openssl: Update to 3.5.6 and associated fixes.

Included fixes:
OpenSSL: update Makefiles to reflect 3.5.1 release
(cherry picked from commit ee6882e6b1287aa910a4f74f5290ae397dbd5054)

crypto/openssl: fix importing new versions from pristine trees
(cherry picked from commit f43d0ac1b0e29bbd77d6b0b1c87dca075cd7b9bf)

openssl: import 3.5.5
(cherry picked from commit f775385affefd7beac0d038d5cd9cbf01bfc4a06)

OpenSSL: update vendor sources to match 3.5.5 content
(cherry picked from commit 12eecb3bcc0be4d7fd35847252c40998806fc551)

OpenSSL: install EVP_CIPHER_CTX_get_app_data.3 once
(cherry picked from commit b0476eea5ef4ab2ccf2479652f486af3d4ab9cc0)

MFV: crypto/openssl: update to 3.5.6
(cherry picked from commit e2fcde7333a515907316cf1a4ee4858edc90419d)

OpenSSL: commit sys/crypto changes for 3.5.5
(cherry picked from commit e6c8997a8958c7aaec8e266d2eeefbfaa137e218)

crypto/openssl: update artifacts to match 3.5.6 release artifacts
(cherry picked from commit 293c738aa45003423f45eb7f0e37f3047e52c502)

crypto/openssl: add new manpage from release 3.5.6
(cherry picked from commit 51a80be04fe63a8d6950a7524b3ca0d511ade131)

Approved by:	so
Security:	FreeBSD-EN-26:15.openssl
Security:	CVE-2026-2673
Security:	CVE-2026-28387
Security:	CVE-2026-28388
Security:	CVE-2026-28389
Security:	CVE-2026-31789
Security:	CVE-2026-31790

108 files changed, 16489 insertions, 16189 deletions

diff --git a/crypto/openssl/ssl/bio_ssl.c b/crypto/openssl/ssl/bio_ssl.c
index d1034814bff2..1123899c9224 100644
--- a/crypto/openssl/ssl/bio_ssl.c
+++ b/crypto/openssl/ssl/bio_ssl.c
@@ -26,7 +26,7 @@ static int ssl_new(BIO *h);
 static int ssl_free(BIO *data);
 static long ssl_callback_ctrl(BIO *h, int cmd, BIO_info_cb *fp);
 typedef struct bio_ssl_st {
-    SSL *ssl;                   /* The ssl handle :-) */
+    SSL *ssl; /* The ssl handle :-) */
     /*
      * Re-negotiate every time the total number of bytes is this size
      * or when timeout expires.
@@ -43,11 +43,11 @@ static const BIO_METHOD methods_sslp = {
     BIO_TYPE_SSL,
     "ssl",
     ssl_write,
-    NULL,                       /* ssl_write_old, */
+    NULL, /* ssl_write_old, */
     ssl_read,
-    NULL,                       /* ssl_read_old,  */
+    NULL, /* ssl_read_old,  */
     ssl_puts,
-    NULL,                       /* ssl_gets,      */
+    NULL, /* ssl_gets,      */
     ssl_ctrl,
     ssl_new,
     ssl_free,
@@ -267,7 +267,7 @@ static long ssl_ctrl(BIO *b, int cmd, long num, void *ptr)
         ret = 0;
         break;
     case BIO_C_SSL_MODE:
-        if (num)                /* client mode */
+        if (num) /* client mode */
             SSL_set_connect_state(ssl);
         else
             SSL_set_accept_state(ssl);
@@ -445,11 +445,11 @@ BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx)
 #ifndef OPENSSL_NO_SOCK
     BIO *ret = NULL, *buf = NULL, *ssl = NULL;
 
-# ifndef OPENSSL_NO_QUIC
+#ifndef OPENSSL_NO_QUIC
     if (ctx != NULL && IS_QUIC_CTX(ctx))
         /* Never use buffering for QUIC. */
         return BIO_new_ssl_connect(ctx);
-# endif
+#endif
 
     if ((buf = BIO_new(BIO_f_buffer())) == NULL)
         return NULL;
@@ -458,7 +458,7 @@ BIO *BIO_new_buffer_ssl_connect(SSL_CTX *ctx)
     if ((ret = BIO_push(buf, ssl)) == NULL)
         goto err;
     return ret;
- err:
+err:
     BIO_free(buf);
     BIO_free(ssl);
 #endif
@@ -473,7 +473,7 @@ BIO *BIO_new_ssl_connect(SSL_CTX *ctx)
     if ((con = BIO_new(BIO_s_connect())) == NULL)
         return NULL;
 
-# ifndef OPENSSL_NO_QUIC
+#ifndef OPENSSL_NO_QUIC
     if (ctx != NULL && IS_QUIC_CTX(ctx))
         if (!BIO_set_sock_type(con, SOCK_DGRAM))
             goto err;
@@ -484,7 +484,7 @@ BIO *BIO_new_ssl_connect(SSL_CTX *ctx)
     if ((ret = BIO_push(ssl, con)) == NULL)
         goto err;
     return ret;
- err:
+err:
     BIO_free(ssl);
     BIO_free(con);
 #endif
diff --git a/crypto/openssl/ssl/d1_lib.c b/crypto/openssl/ssl/d1_lib.c
index a5a52a7ee80e..ad1bc7d8c830 100644
--- a/crypto/openssl/ssl/d1_lib.c
+++ b/crypto/openssl/ssl/d1_lib.c
@@ -8,7 +8,7 @@
  */
 
 #include "internal/e_os.h"
-#include "internal/e_winsock.h"          /* struct timeval for DTLS_CTRL_GET_TIMEOUT */
+#include "internal/e_winsock.h" /* struct timeval for DTLS_CTRL_GET_TIMEOUT */
 #include <stdio.h>
 #include <openssl/objects.h>
 #include <openssl/rand.h>
@@ -134,8 +134,8 @@ void dtls1_clear_sent_buffer(SSL_CONNECTION *s)
         frag = (hm_fragment *)item->data;
 
         if (frag->msg_header.is_ccs
-                && frag->msg_header.saved_retransmit_state.wrlmethod != NULL
-                && s->rlayer.wrl != frag->msg_header.saved_retransmit_state.wrl) {
+            && frag->msg_header.saved_retransmit_state.wrlmethod != NULL
+            && s->rlayer.wrl != frag->msg_header.saved_retransmit_state.wrl) {
             /*
              * If we're freeing the CCS then we're done with the old wrl and it
              * can bee freed
@@ -148,7 +148,6 @@ void dtls1_clear_sent_buffer(SSL_CONNECTION *s)
     }
 }
 
-
 void dtls1_free(SSL *ssl)
 {
     SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
@@ -374,8 +373,7 @@ int dtls1_check_timeout_num(SSL_CONNECTION *s)
     /* Reduce MTU after 2 unsuccessful retransmissions */
     if (s->d1->timeout_num_alerts > 2
         && !(SSL_get_options(ssl) & SSL_OP_NO_QUERY_MTU)) {
-        mtu =
-            BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_GET_FALLBACK_MTU, 0, NULL);
+        mtu = BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_GET_FALLBACK_MTU, 0, NULL);
         if (mtu < s->d1->mtu)
             s->d1->mtu = mtu;
     }
@@ -398,7 +396,7 @@ int dtls1_handle_timeout(SSL_CONNECTION *s)
 
     if (s->d1->timer_cb != NULL)
         s->d1->timeout_duration_us = s->d1->timer_cb(SSL_CONNECTION_GET_USER_SSL(s),
-                                                     s->d1->timeout_duration_us);
+            s->d1->timeout_duration_us);
     else
         dtls1_double_timeout(s);
 
@@ -412,8 +410,8 @@ int dtls1_handle_timeout(SSL_CONNECTION *s)
     return dtls1_retransmit_buffered_messages(s);
 }
 
-#define LISTEN_SUCCESS              2
-#define LISTEN_SEND_VERIFY_REQUEST  1
+#define LISTEN_SUCCESS 2
+#define LISTEN_SEND_VERIFY_REQUEST 1
 
 #ifndef OPENSSL_NO_SOCK
 int DTLSv1_listen(SSL *ssl, BIO_ADDR *client)
@@ -477,8 +475,7 @@ int DTLSv1_listen(SSL *ssl, BIO_ADDR *client)
         /* Get a packet */
 
         clear_sys_error();
-        n = BIO_read(rbio, buf, SSL3_RT_MAX_PLAIN_LENGTH
-                                + DTLS1_RT_HEADER_LENGTH);
+        n = BIO_read(rbio, buf, SSL3_RT_MAX_PLAIN_LENGTH + DTLS1_RT_HEADER_LENGTH);
         if (n <= 0) {
             if (BIO_should_retry(rbio)) {
                 /* Non-blocking IO */
@@ -519,7 +516,7 @@ int DTLSv1_listen(SSL *ssl, BIO_ADDR *client)
 
         if (s->msg_callback)
             s->msg_callback(0, (versmajor << 8) | versminor, SSL3_RT_HEADER, buf,
-                            DTLS1_RT_HEADER_LENGTH, ssl, s->msg_callback_arg);
+                DTLS1_RT_HEADER_LENGTH, ssl, s->msg_callback_arg);
 
         if (rectype != SSL3_RT_HANDSHAKE) {
             ERR_raise(ERR_LIB_SSL, SSL_R_UNEXPECTED_MESSAGE);
@@ -573,7 +570,7 @@ int DTLSv1_listen(SSL *ssl, BIO_ADDR *client)
         }
 
         /* Message sequence number can only be 0 or 1 */
-        if (msgseq > 2) {
+        if (msgseq > 1) {
             ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_SEQUENCE_NUMBER);
             goto end;
         }
@@ -593,8 +590,8 @@ int DTLSv1_listen(SSL *ssl, BIO_ADDR *client)
 
         if (s->msg_callback)
             s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, data,
-                            fraglen + DTLS1_HM_HEADER_LENGTH, ssl,
-                            s->msg_callback_arg);
+                fraglen + DTLS1_HM_HEADER_LENGTH, ssl,
+                s->msg_callback_arg);
 
         if (!PACKET_get_net_2(&msgpayload, &clientvers)) {
             ERR_raise(ERR_LIB_SSL, SSL_R_LENGTH_MISMATCH);
@@ -604,8 +601,7 @@ int DTLSv1_listen(SSL *ssl, BIO_ADDR *client)
         /*
          * Verify client version is supported
          */
-        if (DTLS_VERSION_LT(clientvers, (unsigned int)ssl->method->version) &&
-            ssl->method->version != DTLS_ANY_VERSION) {
+        if (DTLS_VERSION_LT(clientvers, (unsigned int)ssl->method->version) && ssl->method->version != DTLS_ANY_VERSION) {
             ERR_raise(ERR_LIB_SSL, SSL_R_WRONG_VERSION_NUMBER);
             goto end;
         }
@@ -638,7 +634,8 @@ int DTLSv1_listen(SSL *ssl, BIO_ADDR *client)
                 goto end;
             }
             if (ssl->ctx->app_verify_cookie_cb(ssl, PACKET_data(&cookiepkt),
-                    (unsigned int)PACKET_remaining(&cookiepkt)) == 0) {
+                    (unsigned int)PACKET_remaining(&cookiepkt))
+                == 0) {
                 /*
                  * We treat invalid cookies in the same was as no cookie as
                  * per RFC6347
@@ -662,9 +659,7 @@ int DTLSv1_listen(SSL *ssl, BIO_ADDR *client)
              */
 
             /* Generate the cookie */
-            if (ssl->ctx->app_gen_cookie_cb == NULL ||
-                ssl->ctx->app_gen_cookie_cb(ssl, cookie, &cookielen) == 0 ||
-                cookielen > 255) {
+            if (ssl->ctx->app_gen_cookie_cb == NULL || ssl->ctx->app_gen_cookie_cb(ssl, cookie, &cookielen) == 0 || cookielen > 255) {
                 ERR_raise(ERR_LIB_SSL, SSL_R_COOKIE_GEN_CALLBACK_FAILURE);
                 /* This is fatal */
                 ret = -1;
@@ -681,54 +676,54 @@ int DTLSv1_listen(SSL *ssl, BIO_ADDR *client)
 
             /* Construct the record and message headers */
             if (!WPACKET_init_static_len(&wpkt,
-                                         wbuf,
-                                         ssl_get_max_send_fragment(s)
-                                         + DTLS1_RT_HEADER_LENGTH,
-                                         0)
-                    || !WPACKET_put_bytes_u8(&wpkt, SSL3_RT_HANDSHAKE)
-                    || !WPACKET_put_bytes_u16(&wpkt, version)
-                       /*
-                        * Record sequence number is always the same as in the
-                        * received ClientHello
-                        */
-                    || !WPACKET_memcpy(&wpkt, seq, SEQ_NUM_SIZE)
-                       /* End of record, start sub packet for message */
-                    || !WPACKET_start_sub_packet_u16(&wpkt)
-                       /* Message type */
-                    || !WPACKET_put_bytes_u8(&wpkt,
-                                             DTLS1_MT_HELLO_VERIFY_REQUEST)
-                       /*
-                        * Message length - doesn't follow normal TLS convention:
-                        * the length isn't the last thing in the message header.
-                        * We'll need to fill this in later when we know the
-                        * length. Set it to zero for now
-                        */
-                    || !WPACKET_put_bytes_u24(&wpkt, 0)
-                       /*
-                        * Message sequence number is always 0 for a
-                        * HelloVerifyRequest
-                        */
-                    || !WPACKET_put_bytes_u16(&wpkt, 0)
-                       /*
-                        * We never fragment a HelloVerifyRequest, so fragment
-                        * offset is 0
-                        */
-                    || !WPACKET_put_bytes_u24(&wpkt, 0)
-                       /*
-                        * Fragment length is the same as message length, but
-                        * this *is* the last thing in the message header so we
-                        * can just start a sub-packet. No need to come back
-                        * later for this one.
-                        */
-                    || !WPACKET_start_sub_packet_u24(&wpkt)
-                       /* Create the actual HelloVerifyRequest body */
-                    || !dtls_raw_hello_verify_request(&wpkt, cookie, cookielen)
-                       /* Close message body */
-                    || !WPACKET_close(&wpkt)
-                       /* Close record body */
-                    || !WPACKET_close(&wpkt)
-                    || !WPACKET_get_total_written(&wpkt, &wreclen)
-                    || !WPACKET_finish(&wpkt)) {
+                    wbuf,
+                    ssl_get_max_send_fragment(s)
+                        + DTLS1_RT_HEADER_LENGTH,
+                    0)
+                || !WPACKET_put_bytes_u8(&wpkt, SSL3_RT_HANDSHAKE)
+                || !WPACKET_put_bytes_u16(&wpkt, version)
+                /*
+                 * Record sequence number is always the same as in the
+                 * received ClientHello
+                 */
+                || !WPACKET_memcpy(&wpkt, seq, SEQ_NUM_SIZE)
+                /* End of record, start sub packet for message */
+                || !WPACKET_start_sub_packet_u16(&wpkt)
+                /* Message type */
+                || !WPACKET_put_bytes_u8(&wpkt,
+                    DTLS1_MT_HELLO_VERIFY_REQUEST)
+                /*
+                 * Message length - doesn't follow normal TLS convention:
+                 * the length isn't the last thing in the message header.
+                 * We'll need to fill this in later when we know the
+                 * length. Set it to zero for now
+                 */
+                || !WPACKET_put_bytes_u24(&wpkt, 0)
+                /*
+                 * Message sequence number is always 0 for a
+                 * HelloVerifyRequest
+                 */
+                || !WPACKET_put_bytes_u16(&wpkt, 0)
+                /*
+                 * We never fragment a HelloVerifyRequest, so fragment
+                 * offset is 0
+                 */
+                || !WPACKET_put_bytes_u24(&wpkt, 0)
+                /*
+                 * Fragment length is the same as message length, but
+                 * this *is* the last thing in the message header so we
+                 * can just start a sub-packet. No need to come back
+                 * later for this one.
+                 */
+                || !WPACKET_start_sub_packet_u24(&wpkt)
+                /* Create the actual HelloVerifyRequest body */
+                || !dtls_raw_hello_verify_request(&wpkt, cookie, cookielen)
+                /* Close message body */
+                || !WPACKET_close(&wpkt)
+                /* Close record body */
+                || !WPACKET_close(&wpkt)
+                || !WPACKET_get_total_written(&wpkt, &wreclen)
+                || !WPACKET_finish(&wpkt)) {
                 ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
                 WPACKET_cleanup(&wpkt);
                 /* This is fatal */
@@ -744,13 +739,13 @@ int DTLSv1_listen(SSL *ssl, BIO_ADDR *client)
              * last 3 bytes of the message header
              */
             memcpy(&wbuf[DTLS1_RT_HEADER_LENGTH + 1],
-                   &wbuf[DTLS1_RT_HEADER_LENGTH + DTLS1_HM_HEADER_LENGTH - 3],
-                   3);
+                &wbuf[DTLS1_RT_HEADER_LENGTH + DTLS1_HM_HEADER_LENGTH - 3],
+                3);
 
             if (s->msg_callback)
-                s->msg_callback(1, 0, SSL3_RT_HEADER, buf,
-                                DTLS1_RT_HEADER_LENGTH, ssl,
-                                s->msg_callback_arg);
+                s->msg_callback(1, version, SSL3_RT_HEADER, wbuf,
+                    DTLS1_RT_HEADER_LENGTH, ssl,
+                    s->msg_callback_arg);
 
             if ((tmpclient = BIO_ADDR_new()) == NULL) {
                 ERR_raise(ERR_LIB_SSL, ERR_R_BIO_LIB);
@@ -832,18 +827,18 @@ int DTLSv1_listen(SSL *ssl, BIO_ADDR *client)
      * buffered in s->rlayer.rrlnext
      */
     if (!ssl_set_new_record_layer(s,
-                                  DTLS_ANY_VERSION,
-                                  OSSL_RECORD_DIRECTION_READ,
-                                  OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0,
-                                  NULL, 0, NULL, 0, NULL,  0, NULL, 0,
-                                  NID_undef, NULL, NULL, NULL)) {
+            DTLS_ANY_VERSION,
+            OSSL_RECORD_DIRECTION_READ,
+            OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0,
+            NULL, 0, NULL, 0, NULL, 0, NULL, 0,
+            NID_undef, NULL, NULL, NULL)) {
         /* SSLfatal already called */
         ret = -1;
         goto end;
     }
 
     ret = 1;
- end:
+end:
     BIO_ADDR_free(tmpclient);
     OPENSSL_free(buf);
     OPENSSL_free(wbuf);
@@ -867,15 +862,14 @@ int dtls1_shutdown(SSL *s)
         return -1;
 
     wbio = SSL_get_wbio(s);
-    if (wbio != NULL && BIO_dgram_is_sctp(wbio) &&
-        !(sc->shutdown & SSL_SENT_SHUTDOWN)) {
+    if (wbio != NULL && BIO_dgram_is_sctp(wbio) && !(sc->shutdown & SSL_SENT_SHUTDOWN)) {
         ret = BIO_dgram_sctp_wait_for_dry(wbio);
         if (ret < 0)
             return -1;
 
         if (ret == 0)
             BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN, 1,
-                     NULL);
+                NULL);
     }
 #endif
     ret = ssl3_shutdown(s);
@@ -890,16 +884,14 @@ int dtls1_query_mtu(SSL_CONNECTION *s)
     SSL *ssl = SSL_CONNECTION_GET_SSL(s);
 
     if (s->d1->link_mtu) {
-        s->d1->mtu =
-            s->d1->link_mtu - BIO_dgram_get_mtu_overhead(SSL_get_wbio(ssl));
+        s->d1->mtu = s->d1->link_mtu - BIO_dgram_get_mtu_overhead(SSL_get_wbio(ssl));
         s->d1->link_mtu = 0;
     }
 
     /* AHA!  Figure out the MTU, and stick to the right size */
     if (s->d1->mtu < dtls1_min_mtu(s)) {
         if (!(SSL_get_options(ssl) & SSL_OP_NO_QUERY_MTU)) {
-            s->d1->mtu =
-                BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL);
+            s->d1->mtu = BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL);
 
             /*
              * I've seen the kernel return bogus numbers when it doesn't know
@@ -909,7 +901,7 @@ int dtls1_query_mtu(SSL_CONNECTION *s)
                 /* Set to min mtu */
                 s->d1->mtu = dtls1_min_mtu(s);
                 BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SET_MTU,
-                         (long)s->d1->mtu, NULL);
+                    (long)s->d1->mtu, NULL);
             }
         } else
             return 0;
@@ -919,8 +911,7 @@ int dtls1_query_mtu(SSL_CONNECTION *s)
 
 static size_t dtls1_link_min_mtu(void)
 {
-    return (g_probable_mtu[(sizeof(g_probable_mtu) /
-                            sizeof(g_probable_mtu[0])) - 1]);
+    return (g_probable_mtu[(sizeof(g_probable_mtu) / sizeof(g_probable_mtu[0])) - 1]);
 }
 
 size_t dtls1_min_mtu(SSL_CONNECTION *s)
@@ -946,7 +937,7 @@ size_t DTLS_get_data_mtu(const SSL *ssl)
         return 0;
 
     if (!ssl_cipher_get_overhead(ciph, &mac_overhead, &int_overhead,
-                                 &blocksize, &ext_overhead))
+            &blocksize, &ext_overhead))
         return 0;
 
     if (SSL_READ_ETM(s))
diff --git a/crypto/openssl/ssl/d1_msg.c b/crypto/openssl/ssl/d1_msg.c
index 6613f0f4c87a..50676a1cda38 100644
--- a/crypto/openssl/ssl/d1_msg.c
+++ b/crypto/openssl/ssl/d1_msg.c
@@ -11,7 +11,7 @@
 #include "internal/ssl_unwrap.h"
 
 int dtls1_write_app_data_bytes(SSL *s, uint8_t type, const void *buf_,
-                               size_t len, size_t *written)
+    size_t len, size_t *written)
 {
     int i;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
@@ -40,7 +40,7 @@ int dtls1_write_app_data_bytes(SSL *s, uint8_t type, const void *buf_,
 int dtls1_dispatch_alert(SSL *ssl)
 {
     int i, j;
-    void (*cb) (const SSL *ssl, int type, int val) = NULL;
+    void (*cb)(const SSL *ssl, int type, int val) = NULL;
     unsigned char buf[DTLS1_AL_HEADER_LENGTH];
     unsigned char *ptr = &buf[0];
     size_t written;
@@ -64,7 +64,7 @@ int dtls1_dispatch_alert(SSL *ssl)
 
         if (s->msg_callback)
             s->msg_callback(1, s->version, SSL3_RT_ALERT, s->s3.send_alert,
-                            2, ssl, s->msg_callback_arg);
+                2, ssl, s->msg_callback_arg);
 
         if (s->info_callback != NULL)
             cb = s->info_callback;
diff --git a/crypto/openssl/ssl/d1_srtp.c b/crypto/openssl/ssl/d1_srtp.c
index ad926a613dee..d096a056ceda 100644
--- a/crypto/openssl/ssl/d1_srtp.c
+++ b/crypto/openssl/ssl/d1_srtp.c
@@ -22,58 +22,58 @@
 
 static const SRTP_PROTECTION_PROFILE srtp_known_profiles[] = {
     {
-     "SRTP_AES128_CM_SHA1_80",
-     SRTP_AES128_CM_SHA1_80,
-     },
+        "SRTP_AES128_CM_SHA1_80",
+        SRTP_AES128_CM_SHA1_80,
+    },
     {
-     "SRTP_AES128_CM_SHA1_32",
-     SRTP_AES128_CM_SHA1_32,
-     },
+        "SRTP_AES128_CM_SHA1_32",
+        SRTP_AES128_CM_SHA1_32,
+    },
     {
-     "SRTP_AEAD_AES_128_GCM",
-     SRTP_AEAD_AES_128_GCM,
-     },
+        "SRTP_AEAD_AES_128_GCM",
+        SRTP_AEAD_AES_128_GCM,
+    },
     {
-     "SRTP_AEAD_AES_256_GCM",
-     SRTP_AEAD_AES_256_GCM,
-     },
+        "SRTP_AEAD_AES_256_GCM",
+        SRTP_AEAD_AES_256_GCM,
+    },
     {
-     "SRTP_DOUBLE_AEAD_AES_128_GCM_AEAD_AES_128_GCM",
-     SRTP_DOUBLE_AEAD_AES_128_GCM_AEAD_AES_128_GCM,
-     },
+        "SRTP_DOUBLE_AEAD_AES_128_GCM_AEAD_AES_128_GCM",
+        SRTP_DOUBLE_AEAD_AES_128_GCM_AEAD_AES_128_GCM,
+    },
     {
-     "SRTP_DOUBLE_AEAD_AES_256_GCM_AEAD_AES_256_GCM",
-     SRTP_DOUBLE_AEAD_AES_256_GCM_AEAD_AES_256_GCM,
-     },
+        "SRTP_DOUBLE_AEAD_AES_256_GCM_AEAD_AES_256_GCM",
+        SRTP_DOUBLE_AEAD_AES_256_GCM_AEAD_AES_256_GCM,
+    },
     {
-     "SRTP_ARIA_128_CTR_HMAC_SHA1_80",
-     SRTP_ARIA_128_CTR_HMAC_SHA1_80,
-     },
+        "SRTP_ARIA_128_CTR_HMAC_SHA1_80",
+        SRTP_ARIA_128_CTR_HMAC_SHA1_80,
+    },
     {
-     "SRTP_ARIA_128_CTR_HMAC_SHA1_32",
-     SRTP_ARIA_128_CTR_HMAC_SHA1_32,
-     },
+        "SRTP_ARIA_128_CTR_HMAC_SHA1_32",
+        SRTP_ARIA_128_CTR_HMAC_SHA1_32,
+    },
     {
-     "SRTP_ARIA_256_CTR_HMAC_SHA1_80",
-     SRTP_ARIA_256_CTR_HMAC_SHA1_80,
-     },
+        "SRTP_ARIA_256_CTR_HMAC_SHA1_80",
+        SRTP_ARIA_256_CTR_HMAC_SHA1_80,
+    },
     {
-     "SRTP_ARIA_256_CTR_HMAC_SHA1_32",
-     SRTP_ARIA_256_CTR_HMAC_SHA1_32,
-     },
+        "SRTP_ARIA_256_CTR_HMAC_SHA1_32",
+        SRTP_ARIA_256_CTR_HMAC_SHA1_32,
+    },
     {
-     "SRTP_AEAD_ARIA_128_GCM",
-     SRTP_AEAD_ARIA_128_GCM,
-     },
+        "SRTP_AEAD_ARIA_128_GCM",
+        SRTP_AEAD_ARIA_128_GCM,
+    },
     {
-     "SRTP_AEAD_ARIA_256_GCM",
-     SRTP_AEAD_ARIA_256_GCM,
-     },
-    {0}
+        "SRTP_AEAD_ARIA_256_GCM",
+        SRTP_AEAD_ARIA_256_GCM,
+    },
+    { 0 }
 };
 
 static int find_profile_by_name(char *profile_name,
-                                const SRTP_PROTECTION_PROFILE **pptr, size_t len)
+    const SRTP_PROTECTION_PROFILE **pptr, size_t len)
 {
     const SRTP_PROTECTION_PROFILE *p;
 
@@ -92,7 +92,7 @@ static int find_profile_by_name(char *profile_name,
 }
 
 static int ssl_ctx_make_profiles(const char *profiles_string,
-                                 STACK_OF(SRTP_PROTECTION_PROFILE) **out)
+    STACK_OF(SRTP_PROTECTION_PROFILE) **out)
 {
     STACK_OF(SRTP_PROTECTION_PROFILE) *profiles;
 
@@ -108,16 +108,16 @@ static int ssl_ctx_make_profiles(const char *profiles_string,
     do {
         col = strchr(ptr, ':');
 
-        if (!find_profile_by_name(ptr, &p, col ? (size_t)(col - ptr)
-                                               : strlen(ptr))) {
+        if (!find_profile_by_name(ptr, &p, col ? (size_t)(col - ptr) : strlen(ptr))) {
             if (sk_SRTP_PROTECTION_PROFILE_find(profiles,
-                                                (SRTP_PROTECTION_PROFILE *)p) >= 0) {
+                    (SRTP_PROTECTION_PROFILE *)p)
+                >= 0) {
                 ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
                 goto err;
             }
 
             if (!sk_SRTP_PROTECTION_PROFILE_push(profiles,
-                                                 (SRTP_PROTECTION_PROFILE *)p)) {
+                    (SRTP_PROTECTION_PROFILE *)p)) {
                 ERR_raise(ERR_LIB_SSL, SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES);
                 goto err;
             }
@@ -135,7 +135,7 @@ static int ssl_ctx_make_profiles(const char *profiles_string,
     *out = profiles;
 
     return 0;
- err:
+err:
     sk_SRTP_PROTECTION_PROFILE_free(profiles);
     return 1;
 }
diff --git a/crypto/openssl/ssl/methods.c b/crypto/openssl/ssl/methods.c
index 525f59e91231..07098839058d 100644
--- a/crypto/openssl/ssl/methods.c
+++ b/crypto/openssl/ssl/methods.c
@@ -17,29 +17,29 @@
  */
 
 IMPLEMENT_tls_meth_func(TLS_ANY_VERSION, 0, 0,
-                        TLS_method,
-                        ossl_statem_accept,
-                        ossl_statem_connect, TLSv1_2_enc_data)
+    TLS_method,
+    ossl_statem_accept,
+    ossl_statem_connect, TLSv1_2_enc_data)
 IMPLEMENT_tls_meth_func(TLS1_3_VERSION, 0, SSL_OP_NO_TLSv1_3,
-                        tlsv1_3_method,
-                        ossl_statem_accept,
-                        ossl_statem_connect, TLSv1_3_enc_data)
+    tlsv1_3_method,
+    ossl_statem_accept,
+    ossl_statem_connect, TLSv1_3_enc_data)
 #ifndef OPENSSL_NO_TLS1_2_METHOD
 IMPLEMENT_tls_meth_func(TLS1_2_VERSION, 0, SSL_OP_NO_TLSv1_2,
-                        tlsv1_2_method,
-                        ossl_statem_accept,
-                        ossl_statem_connect, TLSv1_2_enc_data)
+    tlsv1_2_method,
+    ossl_statem_accept,
+    ossl_statem_connect, TLSv1_2_enc_data)
 #endif
 #ifndef OPENSSL_NO_TLS1_1_METHOD
 IMPLEMENT_tls_meth_func(TLS1_1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1_1,
-                        tlsv1_1_method,
-                        ossl_statem_accept,
-                        ossl_statem_connect, TLSv1_1_enc_data)
+    tlsv1_1_method,
+    ossl_statem_accept,
+    ossl_statem_connect, TLSv1_1_enc_data)
 #endif
 #ifndef OPENSSL_NO_TLS1_METHOD
 IMPLEMENT_tls_meth_func(TLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1,
-                        tlsv1_method,
-                        ossl_statem_accept, ossl_statem_connect, TLSv1_enc_data)
+    tlsv1_method,
+    ossl_statem_accept, ossl_statem_connect, TLSv1_enc_data)
 #endif
 #ifndef OPENSSL_NO_SSL3_METHOD
 IMPLEMENT_ssl3_meth_func(sslv3_method, ossl_statem_accept, ossl_statem_connect)
@@ -48,133 +48,133 @@ IMPLEMENT_ssl3_meth_func(sslv3_method, ossl_statem_accept, ossl_statem_connect)
  * TLS/SSLv3 server methods
  */
 IMPLEMENT_tls_meth_func(TLS_ANY_VERSION, 0, 0,
-                        TLS_server_method,
-                        ossl_statem_accept,
-                        ssl_undefined_function, TLSv1_2_enc_data)
+    TLS_server_method,
+    ossl_statem_accept,
+    ssl_undefined_function, TLSv1_2_enc_data)
 IMPLEMENT_tls_meth_func(TLS1_3_VERSION, 0, SSL_OP_NO_TLSv1_3,
-                        tlsv1_3_server_method,
-                        ossl_statem_accept,
-                        ssl_undefined_function, TLSv1_3_enc_data)
+    tlsv1_3_server_method,
+    ossl_statem_accept,
+    ssl_undefined_function, TLSv1_3_enc_data)
 #ifndef OPENSSL_NO_TLS1_2_METHOD
 IMPLEMENT_tls_meth_func(TLS1_2_VERSION, 0, SSL_OP_NO_TLSv1_2,
-                        tlsv1_2_server_method,
-                        ossl_statem_accept,
-                        ssl_undefined_function, TLSv1_2_enc_data)
+    tlsv1_2_server_method,
+    ossl_statem_accept,
+    ssl_undefined_function, TLSv1_2_enc_data)
 #endif
 #ifndef OPENSSL_NO_TLS1_1_METHOD
 IMPLEMENT_tls_meth_func(TLS1_1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1_1,
-                        tlsv1_1_server_method,
-                        ossl_statem_accept,
-                        ssl_undefined_function, TLSv1_1_enc_data)
+    tlsv1_1_server_method,
+    ossl_statem_accept,
+    ssl_undefined_function, TLSv1_1_enc_data)
 #endif
 #ifndef OPENSSL_NO_TLS1_METHOD
 IMPLEMENT_tls_meth_func(TLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1,
-                        tlsv1_server_method,
-                        ossl_statem_accept,
-                        ssl_undefined_function, TLSv1_enc_data)
+    tlsv1_server_method,
+    ossl_statem_accept,
+    ssl_undefined_function, TLSv1_enc_data)
 #endif
 #ifndef OPENSSL_NO_SSL3_METHOD
 IMPLEMENT_ssl3_meth_func(sslv3_server_method,
-                         ossl_statem_accept, ssl_undefined_function)
+    ossl_statem_accept, ssl_undefined_function)
 #endif
 /*-
  * TLS/SSLv3 client methods
  */
 IMPLEMENT_tls_meth_func(TLS_ANY_VERSION, 0, 0,
-                        TLS_client_method,
-                        ssl_undefined_function,
-                        ossl_statem_connect, TLSv1_2_enc_data)
+    TLS_client_method,
+    ssl_undefined_function,
+    ossl_statem_connect, TLSv1_2_enc_data)
 IMPLEMENT_tls_meth_func(TLS1_3_VERSION, 0, SSL_OP_NO_TLSv1_3,
-                        tlsv1_3_client_method,
-                        ssl_undefined_function,
-                        ossl_statem_connect, TLSv1_3_enc_data)
+    tlsv1_3_client_method,
+    ssl_undefined_function,
+    ossl_statem_connect, TLSv1_3_enc_data)
 #ifndef OPENSSL_NO_TLS1_2_METHOD
 IMPLEMENT_tls_meth_func(TLS1_2_VERSION, 0, SSL_OP_NO_TLSv1_2,
-                        tlsv1_2_client_method,
-                        ssl_undefined_function,
-                        ossl_statem_connect, TLSv1_2_enc_data)
+    tlsv1_2_client_method,
+    ssl_undefined_function,
+    ossl_statem_connect, TLSv1_2_enc_data)
 #endif
 #ifndef OPENSSL_NO_TLS1_1_METHOD
 IMPLEMENT_tls_meth_func(TLS1_1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1_1,
-                        tlsv1_1_client_method,
-                        ssl_undefined_function,
-                        ossl_statem_connect, TLSv1_1_enc_data)
+    tlsv1_1_client_method,
+    ssl_undefined_function,
+    ossl_statem_connect, TLSv1_1_enc_data)
 #endif
 #ifndef OPENSSL_NO_TLS1_METHOD
 IMPLEMENT_tls_meth_func(TLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_TLSv1,
-                        tlsv1_client_method,
-                        ssl_undefined_function,
-                        ossl_statem_connect, TLSv1_enc_data)
+    tlsv1_client_method,
+    ssl_undefined_function,
+    ossl_statem_connect, TLSv1_enc_data)
 #endif
 #ifndef OPENSSL_NO_SSL3_METHOD
 IMPLEMENT_ssl3_meth_func(sslv3_client_method,
-                         ssl_undefined_function, ossl_statem_connect)
+    ssl_undefined_function, ossl_statem_connect)
 #endif
 /*-
  * DTLS methods
  */
 #ifndef OPENSSL_NO_DTLS1_METHOD
 IMPLEMENT_dtls1_meth_func(DTLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_DTLSv1,
-                          dtlsv1_method,
-                          ossl_statem_accept,
-                          ossl_statem_connect, DTLSv1_enc_data)
+    dtlsv1_method,
+    ossl_statem_accept,
+    ossl_statem_connect, DTLSv1_enc_data)
 #endif
 #ifndef OPENSSL_NO_DTLS1_2_METHOD
 IMPLEMENT_dtls1_meth_func(DTLS1_2_VERSION, 0, SSL_OP_NO_DTLSv1_2,
-                          dtlsv1_2_method,
-                          ossl_statem_accept,
-                          ossl_statem_connect, DTLSv1_2_enc_data)
+    dtlsv1_2_method,
+    ossl_statem_accept,
+    ossl_statem_connect, DTLSv1_2_enc_data)
 #endif
 IMPLEMENT_dtls1_meth_func(DTLS_ANY_VERSION, 0, 0,
-                          DTLS_method,
-                          ossl_statem_accept,
-                          ossl_statem_connect, DTLSv1_2_enc_data)
+    DTLS_method,
+    ossl_statem_accept,
+    ossl_statem_connect, DTLSv1_2_enc_data)
 
 /*-
  * DTLS server methods
  */
 #ifndef OPENSSL_NO_DTLS1_METHOD
 IMPLEMENT_dtls1_meth_func(DTLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_DTLSv1,
-                          dtlsv1_server_method,
-                          ossl_statem_accept,
-                          ssl_undefined_function, DTLSv1_enc_data)
+    dtlsv1_server_method,
+    ossl_statem_accept,
+    ssl_undefined_function, DTLSv1_enc_data)
 #endif
 #ifndef OPENSSL_NO_DTLS1_2_METHOD
 IMPLEMENT_dtls1_meth_func(DTLS1_2_VERSION, 0, SSL_OP_NO_DTLSv1_2,
-                          dtlsv1_2_server_method,
-                          ossl_statem_accept,
-                          ssl_undefined_function, DTLSv1_2_enc_data)
+    dtlsv1_2_server_method,
+    ossl_statem_accept,
+    ssl_undefined_function, DTLSv1_2_enc_data)
 #endif
 IMPLEMENT_dtls1_meth_func(DTLS_ANY_VERSION, 0, 0,
-                          DTLS_server_method,
-                          ossl_statem_accept,
-                          ssl_undefined_function, DTLSv1_2_enc_data)
+    DTLS_server_method,
+    ossl_statem_accept,
+    ssl_undefined_function, DTLSv1_2_enc_data)
 
 /*-
  * DTLS client methods
  */
 #ifndef OPENSSL_NO_DTLS1_METHOD
 IMPLEMENT_dtls1_meth_func(DTLS1_VERSION, SSL_METHOD_NO_SUITEB, SSL_OP_NO_DTLSv1,
-                          dtlsv1_client_method,
-                          ssl_undefined_function,
-                          ossl_statem_connect, DTLSv1_enc_data)
+    dtlsv1_client_method,
+    ssl_undefined_function,
+    ossl_statem_connect, DTLSv1_enc_data)
 IMPLEMENT_dtls1_meth_func(DTLS1_BAD_VER, SSL_METHOD_NO_SUITEB, SSL_OP_NO_DTLSv1,
-                          dtls_bad_ver_client_method,
-                          ssl_undefined_function,
-                          ossl_statem_connect, DTLSv1_enc_data)
+    dtls_bad_ver_client_method,
+    ssl_undefined_function,
+    ossl_statem_connect, DTLSv1_enc_data)
 #endif
 #ifndef OPENSSL_NO_DTLS1_2_METHOD
 IMPLEMENT_dtls1_meth_func(DTLS1_2_VERSION, 0, SSL_OP_NO_DTLSv1_2,
-                          dtlsv1_2_client_method,
-                          ssl_undefined_function,
-                          ossl_statem_connect, DTLSv1_2_enc_data)
+    dtlsv1_2_client_method,
+    ssl_undefined_function,
+    ossl_statem_connect, DTLSv1_2_enc_data)
 #endif
 IMPLEMENT_dtls1_meth_func(DTLS_ANY_VERSION, 0, 0,
-                          DTLS_client_method,
-                          ssl_undefined_function,
-                          ossl_statem_connect, DTLSv1_2_enc_data)
+    DTLS_client_method,
+    ssl_undefined_function,
+    ossl_statem_connect, DTLSv1_2_enc_data)
 #ifndef OPENSSL_NO_DEPRECATED_1_1_0
-# ifndef OPENSSL_NO_TLS1_2_METHOD
+#ifndef OPENSSL_NO_TLS1_2_METHOD
 const SSL_METHOD *TLSv1_2_method(void)
 {
     return tlsv1_2_method();
@@ -189,9 +189,9 @@ const SSL_METHOD *TLSv1_2_client_method(void)
 {
     return tlsv1_2_client_method();
 }
-# endif
+#endif
 
-# ifndef OPENSSL_NO_TLS1_1_METHOD
+#ifndef OPENSSL_NO_TLS1_1_METHOD
 const SSL_METHOD *TLSv1_1_method(void)
 {
     return tlsv1_1_method();
@@ -206,9 +206,9 @@ const SSL_METHOD *TLSv1_1_client_method(void)
 {
     return tlsv1_1_client_method();
 }
-# endif
+#endif
 
-# ifndef OPENSSL_NO_TLS1_METHOD
+#ifndef OPENSSL_NO_TLS1_METHOD
 const SSL_METHOD *TLSv1_method(void)
 {
     return tlsv1_method();
@@ -223,9 +223,9 @@ const SSL_METHOD *TLSv1_client_method(void)
 {
     return tlsv1_client_method();
 }
-# endif
+#endif
 
-# ifndef OPENSSL_NO_SSL3_METHOD
+#ifndef OPENSSL_NO_SSL3_METHOD
 const SSL_METHOD *SSLv3_method(void)
 {
     return sslv3_method();
@@ -240,9 +240,9 @@ const SSL_METHOD *SSLv3_client_method(void)
 {
     return sslv3_client_method();
 }
-# endif
+#endif
 
-# ifndef OPENSSL_NO_DTLS1_2_METHOD
+#ifndef OPENSSL_NO_DTLS1_2_METHOD
 const SSL_METHOD *DTLSv1_2_method(void)
 {
     return dtlsv1_2_method();
@@ -257,9 +257,9 @@ const SSL_METHOD *DTLSv1_2_client_method(void)
 {
     return dtlsv1_2_client_method();
 }
-# endif
+#endif
 
-# ifndef OPENSSL_NO_DTLS1_METHOD
+#ifndef OPENSSL_NO_DTLS1_METHOD
 const SSL_METHOD *DTLSv1_method(void)
 {
     return dtlsv1_method();
@@ -274,6 +274,6 @@ const SSL_METHOD *DTLSv1_client_method(void)
 {
     return dtlsv1_client_method();
 }
-# endif
+#endif
 
 #endif
diff --git a/crypto/openssl/ssl/pqueue.c b/crypto/openssl/ssl/pqueue.c
index db161e25da1f..87918e5e2bc9 100644
--- a/crypto/openssl/ssl/pqueue.c
+++ b/crypto/openssl/ssl/pqueue.c
@@ -55,12 +55,12 @@ pitem *pqueue_insert(pqueue *pq, pitem *item)
     }
 
     for (curr = NULL, next = pq->items;
-         next != NULL; curr = next, next = next->next) {
+        next != NULL; curr = next, next = next->next) {
         /*
          * we can compare 64-bit value in big-endian encoding with memcmp:-)
          */
         int cmp = memcmp(next->priority, item->priority, 8);
-        if (cmp > 0) {          /* next > item */
+        if (cmp > 0) { /* next > item */
             item->next = next;
 
             if (curr == NULL)
@@ -71,7 +71,7 @@ pitem *pqueue_insert(pqueue *pq, pitem *item)
             return item;
         }
 
-        else if (cmp == 0)      /* duplicates not allowed */
+        else if (cmp == 0) /* duplicates not allowed */
             return NULL;
     }
 
diff --git a/crypto/openssl/ssl/priority_queue.c b/crypto/openssl/ssl/priority_queue.c
index ed1d191f2e85..6f1de51b89d4 100644
--- a/crypto/openssl/ssl/priority_queue.c
+++ b/crypto/openssl/ssl/priority_queue.c
@@ -35,14 +35,14 @@ OSSL_SAFE_MATH_UNSIGNED(size_t, size_t)
  */
 
 struct pq_heap_st {
-    void *data;     /* User supplied data pointer */
-    size_t index;   /* Constant index in elements[] */
+    void *data; /* User supplied data pointer */
+    size_t index; /* Constant index in elements[] */
 };
 
 struct pq_elem_st {
-    size_t posn;    /* Current index in heap[] or link in free list */
+    size_t posn; /* Current index in heap[] or link in free list */
 #ifndef NDEBUG
-    int used;       /* Debug flag indicating that this is in use */
+    int used; /* Debug flag indicating that this is in use */
 #endif
 };
 
@@ -50,29 +50,27 @@ struct ossl_pqueue_st {
     struct pq_heap_st *heap;
     struct pq_elem_st *elements;
     int (*compare)(const void *, const void *);
-    size_t htop;        /* Highest used heap element */
-    size_t hmax;        /* Allocated heap & element space */
-    size_t freelist;    /* Index into elements[], start of free element list */
+    size_t htop; /* Highest used heap element */
+    size_t hmax; /* Allocated heap & element space */
+    size_t freelist; /* Index into elements[], start of free element list */
 };
 
 /*
  * The initial and maximum number of elements in the heap.
  */
 static const size_t min_nodes = 8;
-static const size_t max_nodes =
-        SIZE_MAX / (sizeof(struct pq_heap_st) > sizeof(struct pq_elem_st)
-                    ? sizeof(struct pq_heap_st) : sizeof(struct pq_elem_st));
+static const size_t max_nodes = SIZE_MAX / (sizeof(struct pq_heap_st) > sizeof(struct pq_elem_st) ? sizeof(struct pq_heap_st) : sizeof(struct pq_elem_st));
 
 #ifndef NDEBUG
 /* Some basic sanity checking of the data structure */
-# define ASSERT_USED(pq, idx)                                               \
-    assert(pq->elements[pq->heap[idx].index].used);                         \
+#define ASSERT_USED(pq, idx)                        \
+    assert(pq->elements[pq->heap[idx].index].used); \
     assert(pq->elements[pq->heap[idx].index].posn == idx)
-# define ASSERT_ELEM_USED(pq, elem)                                         \
+#define ASSERT_ELEM_USED(pq, elem) \
     assert(pq->elements[elem].used)
 #else
-# define ASSERT_USED(pq, idx)
-# define ASSERT_ELEM_USED(pq, elem)
+#define ASSERT_USED(pq, idx)
+#define ASSERT_ELEM_USED(pq, elem)
 #endif
 
 /*
diff --git a/crypto/openssl/ssl/quic/cc_newreno.c b/crypto/openssl/ssl/quic/cc_newreno.c
index 1fe37c276e58..27708a37577c 100644
--- a/crypto/openssl/ssl/quic/cc_newreno.c
+++ b/crypto/openssl/ssl/quic/cc_newreno.c
@@ -6,54 +6,54 @@ OSSL_SAFE_MATH_UNSIGNED(u64, uint64_t)
 
 typedef struct ossl_cc_newreno_st {
     /* Dependencies. */
-    OSSL_TIME   (*now_cb)(void *arg);
-    void        *now_cb_arg;
+    OSSL_TIME (*now_cb)(void *arg);
+    void *now_cb_arg;
 
     /* 'Constants' (which we allow to be configurable). */
-    uint64_t    k_init_wnd, k_min_wnd;
-    uint32_t    k_loss_reduction_factor_num, k_loss_reduction_factor_den;
-    uint32_t    persistent_cong_thresh;
+    uint64_t k_init_wnd, k_min_wnd;
+    uint32_t k_loss_reduction_factor_num, k_loss_reduction_factor_den;
+    uint32_t persistent_cong_thresh;
 
     /* State. */
-    size_t      max_dgram_size;
-    uint64_t    bytes_in_flight, cong_wnd, slow_start_thresh, bytes_acked;
-    OSSL_TIME   cong_recovery_start_time;
+    size_t max_dgram_size;
+    uint64_t bytes_in_flight, cong_wnd, slow_start_thresh, bytes_acked;
+    OSSL_TIME cong_recovery_start_time;
 
     /* Unflushed state during multiple on-loss calls. */
-    int         processing_loss; /* 1 if not flushed */
-    OSSL_TIME   tx_time_of_last_loss;
+    int processing_loss; /* 1 if not flushed */
+    OSSL_TIME tx_time_of_last_loss;
 
     /* Diagnostic state. */
-    int         in_congestion_recovery;
+    int in_congestion_recovery;
 
     /* Diagnostic output locations. */
-    size_t      *p_diag_max_dgram_payload_len;
-    uint64_t    *p_diag_cur_cwnd_size;
-    uint64_t    *p_diag_min_cwnd_size;
-    uint64_t    *p_diag_cur_bytes_in_flight;
-    uint32_t    *p_diag_cur_state;
+    size_t *p_diag_max_dgram_payload_len;
+    uint64_t *p_diag_cur_cwnd_size;
+    uint64_t *p_diag_min_cwnd_size;
+    uint64_t *p_diag_cur_bytes_in_flight;
+    uint32_t *p_diag_cur_state;
 } OSSL_CC_NEWRENO;
 
-#define MIN_MAX_INIT_WND_SIZE    14720  /* RFC 9002 s. 7.2 */
+#define MIN_MAX_INIT_WND_SIZE 14720 /* RFC 9002 s. 7.2 */
 
 /* TODO(QUIC FUTURE): Pacing support. */
 
 static void newreno_set_max_dgram_size(OSSL_CC_NEWRENO *nr,
-                                       size_t max_dgram_size);
+    size_t max_dgram_size);
 static void newreno_update_diag(OSSL_CC_NEWRENO *nr);
 
 static void newreno_reset(OSSL_CC_DATA *cc);
 
 static OSSL_CC_DATA *newreno_new(OSSL_TIME (*now_cb)(void *arg),
-                                 void *now_cb_arg)
+    void *now_cb_arg)
 {
     OSSL_CC_NEWRENO *nr;
 
     if ((nr = OPENSSL_zalloc(sizeof(*nr))) == NULL)
         return NULL;
 
-    nr->now_cb          = now_cb;
-    nr->now_cb_arg      = now_cb_arg;
+    nr->now_cb = now_cb;
+    nr->now_cb_arg = now_cb_arg;
 
     newreno_set_max_dgram_size(nr, QUIC_MIN_INITIAL_DGRAM_LEN);
     newreno_reset((OSSL_CC_DATA *)nr);
@@ -67,7 +67,7 @@ static void newreno_free(OSSL_CC_DATA *cc)
 }
 
 static void newreno_set_max_dgram_size(OSSL_CC_NEWRENO *nr,
-                                       size_t max_dgram_size)
+    size_t max_dgram_size)
 {
     size_t max_init_wnd;
     int is_reduced = (max_dgram_size < nr->max_dgram_size);
@@ -94,19 +94,19 @@ static void newreno_reset(OSSL_CC_DATA *cc)
 {
     OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc;
 
-    nr->k_loss_reduction_factor_num     = 1;
-    nr->k_loss_reduction_factor_den     = 2;
-    nr->persistent_cong_thresh          = 3;
+    nr->k_loss_reduction_factor_num = 1;
+    nr->k_loss_reduction_factor_den = 2;
+    nr->persistent_cong_thresh = 3;
 
-    nr->cong_wnd                    = nr->k_init_wnd;
-    nr->bytes_in_flight             = 0;
-    nr->bytes_acked                 = 0;
-    nr->slow_start_thresh           = UINT64_MAX;
-    nr->cong_recovery_start_time    = ossl_time_zero();
+    nr->cong_wnd = nr->k_init_wnd;
+    nr->bytes_in_flight = 0;
+    nr->bytes_acked = 0;
+    nr->slow_start_thresh = UINT64_MAX;
+    nr->cong_recovery_start_time = ossl_time_zero();
 
-    nr->processing_loss         = 0;
-    nr->tx_time_of_last_loss    = ossl_time_zero();
-    nr->in_congestion_recovery  = 0;
+    nr->processing_loss = 0;
+    nr->tx_time_of_last_loss = ossl_time_zero();
+    nr->in_congestion_recovery = 0;
 }
 
 static int newreno_set_input_params(OSSL_CC_DATA *cc, const OSSL_PARAM *params)
@@ -129,7 +129,7 @@ static int newreno_set_input_params(OSSL_CC_DATA *cc, const OSSL_PARAM *params)
 }
 
 static int bind_diag(OSSL_PARAM *params, const char *param_name, size_t len,
-                     void **pp)
+    void **pp)
 {
     const OSSL_PARAM *p = OSSL_PARAM_locate_const(params, param_name);
 
@@ -156,15 +156,15 @@ static int newreno_bind_diagnostic(OSSL_CC_DATA *cc, OSSL_PARAM *params)
     uint32_t *new_p_cur_state;
 
     if (!bind_diag(params, OSSL_CC_OPTION_MAX_DGRAM_PAYLOAD_LEN,
-                   sizeof(size_t), (void **)&new_p_max_dgram_payload_len)
+            sizeof(size_t), (void **)&new_p_max_dgram_payload_len)
         || !bind_diag(params, OSSL_CC_OPTION_CUR_CWND_SIZE,
-                      sizeof(uint64_t), (void **)&new_p_cur_cwnd_size)
+            sizeof(uint64_t), (void **)&new_p_cur_cwnd_size)
         || !bind_diag(params, OSSL_CC_OPTION_MIN_CWND_SIZE,
-                      sizeof(uint64_t), (void **)&new_p_min_cwnd_size)
+            sizeof(uint64_t), (void **)&new_p_min_cwnd_size)
         || !bind_diag(params, OSSL_CC_OPTION_CUR_BYTES_IN_FLIGHT,
-                      sizeof(uint64_t), (void **)&new_p_cur_bytes_in_flight)
+            sizeof(uint64_t), (void **)&new_p_cur_bytes_in_flight)
         || !bind_diag(params, OSSL_CC_OPTION_CUR_STATE,
-                      sizeof(uint32_t), (void **)&new_p_cur_state))
+            sizeof(uint32_t), (void **)&new_p_cur_state))
         return 0;
 
     if (new_p_max_dgram_payload_len != NULL)
@@ -187,7 +187,7 @@ static int newreno_bind_diagnostic(OSSL_CC_DATA *cc, OSSL_PARAM *params)
 }
 
 static void unbind_diag(OSSL_PARAM *params, const char *param_name,
-                        void **pp)
+    void **pp)
 {
     const OSSL_PARAM *p = OSSL_PARAM_locate_const(params, param_name);
 
@@ -200,15 +200,15 @@ static int newreno_unbind_diagnostic(OSSL_CC_DATA *cc, OSSL_PARAM *params)
     OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc;
 
     unbind_diag(params, OSSL_CC_OPTION_MAX_DGRAM_PAYLOAD_LEN,
-                (void **)&nr->p_diag_max_dgram_payload_len);
+        (void **)&nr->p_diag_max_dgram_payload_len);
     unbind_diag(params, OSSL_CC_OPTION_CUR_CWND_SIZE,
-                (void **)&nr->p_diag_cur_cwnd_size);
+        (void **)&nr->p_diag_cur_cwnd_size);
     unbind_diag(params, OSSL_CC_OPTION_MIN_CWND_SIZE,
-                (void **)&nr->p_diag_min_cwnd_size);
+        (void **)&nr->p_diag_min_cwnd_size);
     unbind_diag(params, OSSL_CC_OPTION_CUR_BYTES_IN_FLIGHT,
-                (void **)&nr->p_diag_cur_bytes_in_flight);
+        (void **)&nr->p_diag_cur_bytes_in_flight);
     unbind_diag(params, OSSL_CC_OPTION_CUR_STATE,
-                (void **)&nr->p_diag_cur_state);
+        (void **)&nr->p_diag_cur_state);
     return 1;
 }
 
@@ -256,9 +256,9 @@ static void newreno_cong(OSSL_CC_NEWRENO *nr, OSSL_TIME tx_time)
     /* slow_start_thresh = cong_wnd * loss_reduction_factor */
     nr->slow_start_thresh
         = safe_muldiv_u64(nr->cong_wnd,
-                          nr->k_loss_reduction_factor_num,
-                          nr->k_loss_reduction_factor_den,
-                          &err);
+            nr->k_loss_reduction_factor_num,
+            nr->k_loss_reduction_factor_den,
+            &err);
 
     if (err)
         nr->slow_start_thresh = UINT64_MAX;
@@ -276,8 +276,8 @@ static void newreno_flush(OSSL_CC_NEWRENO *nr, uint32_t flags)
     newreno_cong(nr, nr->tx_time_of_last_loss);
 
     if ((flags & OSSL_CC_LOST_FLAG_PERSISTENT_CONGESTION) != 0) {
-        nr->cong_wnd                    = nr->k_min_wnd;
-        nr->cong_recovery_start_time    = ossl_time_zero();
+        nr->cong_wnd = nr->k_min_wnd;
+        nr->cong_recovery_start_time = ossl_time_zero();
     }
 
     nr->processing_loss = 0;
@@ -333,11 +333,11 @@ static int newreno_is_cong_limited(OSSL_CC_NEWRENO *nr)
      * have consumed half of our window.
      */
     return (nr->cong_wnd < nr->slow_start_thresh && wnd_rem <= nr->cong_wnd / 2)
-           || wnd_rem <= 3 * nr->max_dgram_size;
+        || wnd_rem <= 3 * nr->max_dgram_size;
 }
 
 static int newreno_on_data_acked(OSSL_CC_DATA *cc,
-                                 const OSSL_CC_ACK_INFO *info)
+    const OSSL_CC_ACK_INFO *info)
 {
     OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc;
 
@@ -389,7 +389,7 @@ static int newreno_on_data_acked(OSSL_CC_DATA *cc,
          */
         if (nr->bytes_acked >= nr->cong_wnd) {
             nr->bytes_acked -= nr->cong_wnd;
-            nr->cong_wnd    += nr->max_dgram_size;
+            nr->cong_wnd += nr->max_dgram_size;
         }
 
         nr->in_congestion_recovery = 0;
@@ -401,7 +401,7 @@ out:
 }
 
 static int newreno_on_data_lost(OSSL_CC_DATA *cc,
-                                const OSSL_CC_LOSS_INFO *info)
+    const OSSL_CC_LOSS_INFO *info)
 {
     OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc;
 
@@ -446,7 +446,7 @@ static int newreno_on_data_lost_finished(OSSL_CC_DATA *cc, uint32_t flags)
 }
 
 static int newreno_on_data_invalidated(OSSL_CC_DATA *cc,
-                                       uint64_t num_bytes)
+    uint64_t num_bytes)
 {
     OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc;
 
@@ -456,13 +456,13 @@ static int newreno_on_data_invalidated(OSSL_CC_DATA *cc,
 }
 
 static int newreno_on_ecn(OSSL_CC_DATA *cc,
-                          const OSSL_CC_ECN_INFO *info)
+    const OSSL_CC_ECN_INFO *info)
 {
     OSSL_CC_NEWRENO *nr = (OSSL_CC_NEWRENO *)cc;
 
-    nr->processing_loss         = 1;
-    nr->bytes_acked             = 0;
-    nr->tx_time_of_last_loss    = info->largest_acked_time;
+    nr->processing_loss = 1;
+    nr->bytes_acked = 0;
+    nr->tx_time_of_last_loss = info->largest_acked_time;
     newreno_flush(nr, 0);
     return 1;
 }
diff --git a/crypto/openssl/ssl/quic/json_enc.c b/crypto/openssl/ssl/quic/json_enc.c
index 527230137ec2..9e14e821f1cc 100644
--- a/crypto/openssl/ssl/quic/json_enc.c
+++ b/crypto/openssl/ssl/quic/json_enc.c
@@ -24,16 +24,16 @@ static int wbuf_init(struct json_write_buf *wbuf, BIO *bio, size_t alloc)
     if (wbuf->buf == NULL)
         return 0;
 
-    wbuf->cur   = 0;
+    wbuf->cur = 0;
     wbuf->alloc = alloc;
-    wbuf->bio   = bio;
+    wbuf->bio = bio;
     return 1;
 }
 
 static void wbuf_cleanup(struct json_write_buf *wbuf)
 {
     OPENSSL_free(wbuf->buf);
-    wbuf->buf   = NULL;
+    wbuf->buf = NULL;
     wbuf->alloc = 0;
 }
 
@@ -87,12 +87,12 @@ static int wbuf_flush(struct json_write_buf *wbuf, int full)
 
     while (total_written < wbuf->cur) {
         if (!BIO_write_ex(wbuf->bio,
-                          wbuf->buf + total_written,
-                          wbuf->cur - total_written,
-                          &written)) {
+                wbuf->buf + total_written,
+                wbuf->cur - total_written,
+                &written)) {
             memmove(wbuf->buf,
-                    wbuf->buf + total_written,
-                    wbuf->cur - total_written);
+                wbuf->buf + total_written,
+                wbuf->cur - total_written);
             wbuf->cur = 0;
             return 0;
         }
@@ -131,8 +131,8 @@ static int json_ensure_stack_size(OSSL_JSON_ENC *json, size_t num_bytes)
             return 0;
     }
 
-    json->stack         = stack;
-    json->stack_bytes   = num_bytes;
+    json->stack = stack;
+    json->stack_bytes = num_bytes;
     return 1;
 }
 
@@ -193,10 +193,10 @@ static int json_peek(OSSL_JSON_ENC *json)
     size_t obyte, obit;
 
     obyte = json->stack_end_byte;
-    obit  = json->stack_end_bit;
+    obit = json->stack_end_bit;
     if (obit == 0) {
-       if (obyte == 0)
-           return -1;
+        if (obyte == 0)
+            return -1;
 
         --obyte;
         obit = CHAR_BIT - 1;
@@ -236,8 +236,8 @@ static ossl_inline int in_pretty(const OSSL_JSON_ENC *json)
 int ossl_json_init(OSSL_JSON_ENC *json, BIO *bio, uint32_t flags)
 {
     memset(json, 0, sizeof(*json));
-    json->flags     = flags;
-    json->error     = 0;
+    json->flags = flags;
+    json->error = 0;
     if (!wbuf_init(&json->wbuf, bio, 4096))
         return 0;
 
@@ -266,9 +266,9 @@ int ossl_json_flush_cleanup(OSSL_JSON_ENC *json)
 int ossl_json_reset(OSSL_JSON_ENC *json)
 {
     wbuf_clean(&json->wbuf);
-    json->stack_end_byte    = 0;
-    json->stack_end_bit     = 0;
-    json->error             = 0;
+    json->stack_end_byte = 0;
+    json->stack_end_bit = 0;
+    json->error = 0;
     return 1;
 }
 
@@ -605,7 +605,7 @@ static ossl_inline int hex_digit(int v)
 
 static ossl_inline void
 json_write_qstring_inner(OSSL_JSON_ENC *json, const char *str, size_t str_len,
-                         int nul_term)
+    int nul_term)
 {
     char c, *o, obuf[7];
     unsigned char *u_str;
@@ -619,19 +619,33 @@ json_write_qstring_inner(OSSL_JSON_ENC *json, const char *str, size_t str_len,
 
     for (j = nul_term ? strlen(str) : str_len; j > 0; str++, j--) {
         c = *str;
-        u_str = (unsigned char*)str;
+        u_str = (unsigned char *)str;
         switch (c) {
-        case '\n': o = "\\n"; break;
-        case '\r': o = "\\r"; break;
-        case '\t': o = "\\t"; break;
-        case '\b': o = "\\b"; break;
-        case '\f': o = "\\f"; break;
-        case '"': o = "\\\""; break;
-        case '\\': o = "\\\\"; break;
+        case '\n':
+            o = "\\n";
+            break;
+        case '\r':
+            o = "\\r";
+            break;
+        case '\t':
+            o = "\\t";
+            break;
+        case '\b':
+            o = "\\b";
+            break;
+        case '\f':
+            o = "\\f";
+            break;
+        case '"':
+            o = "\\\"";
+            break;
+        case '\\':
+            o = "\\\\";
+            break;
         default:
             /* valid UTF-8 sequences according to RFC-3629 */
             if (u_str[0] >= 0xc2 && u_str[0] <= 0xdf && j >= 2
-                    && u_str[1] >= 0x80 && u_str[1] <= 0xbf) {
+                && u_str[1] >= 0x80 && u_str[1] <= 0xbf) {
                 memcpy(obuf, str, 2);
                 obuf[2] = '\0';
                 str++, j--;
@@ -639,10 +653,10 @@ json_write_qstring_inner(OSSL_JSON_ENC *json, const char *str, size_t str_len,
                 break;
             }
             if (u_str[0] >= 0xe0 && u_str[0] <= 0xef && j >= 3
-                    && u_str[1] >= 0x80 && u_str[1] <= 0xbf
-                    && u_str[2] >= 0x80 && u_str[2] <= 0xbf
-                    && !(u_str[0] == 0xe0 && u_str[1] <= 0x9f)
-                    && !(u_str[0] == 0xed && u_str[1] >= 0xa0)) {
+                && u_str[1] >= 0x80 && u_str[1] <= 0xbf
+                && u_str[2] >= 0x80 && u_str[2] <= 0xbf
+                && !(u_str[0] == 0xe0 && u_str[1] <= 0x9f)
+                && !(u_str[0] == 0xed && u_str[1] >= 0xa0)) {
                 memcpy(obuf, str, 3);
                 obuf[3] = '\0';
                 str += 2;
@@ -651,11 +665,11 @@ json_write_qstring_inner(OSSL_JSON_ENC *json, const char *str, size_t str_len,
                 break;
             }
             if (u_str[0] >= 0xf0 && u_str[0] <= 0xf4 && j >= 4
-                    && u_str[1] >= 0x80 && u_str[1] <= 0xbf
-                    && u_str[2] >= 0x80 && u_str[2] <= 0xbf
-                    && u_str[3] >= 0x80 && u_str[3] <= 0xbf
-                    && !(u_str[0] == 0xf0 && u_str[1] <= 0x8f)
-                    && !(u_str[0] == 0xf4 && u_str[1] >= 0x90)) {
+                && u_str[1] >= 0x80 && u_str[1] <= 0xbf
+                && u_str[2] >= 0x80 && u_str[2] <= 0xbf
+                && u_str[3] >= 0x80 && u_str[3] <= 0xbf
+                && !(u_str[0] == 0xf0 && u_str[1] <= 0x8f)
+                && !(u_str[0] == 0xf4 && u_str[1] >= 0x90)) {
                 memcpy(obuf, str, 4);
                 obuf[4] = '\0';
                 str += 3;
diff --git a/crypto/openssl/ssl/quic/qlog.c b/crypto/openssl/ssl/quic/qlog.c
index 3aadda046f74..41025159ced8 100644
--- a/crypto/openssl/ssl/quic/qlog.c
+++ b/crypto/openssl/ssl/quic/qlog.c
@@ -34,13 +34,13 @@ static ossl_unused ossl_inline void bit_set(size_t *p, uint32_t bit_no, int enab
 struct qlog_st {
     QLOG_TRACE_INFO info;
 
-    BIO             *bio;
-    size_t          enabled[NUM_ENABLED_W];
-    uint32_t        event_type;
-    const char      *event_cat, *event_name, *event_combined_name;
-    OSSL_TIME       event_time, prev_event_time;
-    OSSL_JSON_ENC   json;
-    int             header_done, first_event_done;
+    BIO *bio;
+    size_t enabled[NUM_ENABLED_W];
+    uint32_t event_type;
+    const char *event_cat, *event_name, *event_combined_name;
+    OSSL_TIME event_time, prev_event_time;
+    OSSL_JSON_ENC json;
+    int header_done, first_event_done;
 };
 
 static OSSL_TIME default_now(void *arg)
@@ -59,11 +59,11 @@ QLOG *ossl_qlog_new(const QLOG_TRACE_INFO *info)
     if (qlog == NULL)
         return NULL;
 
-    qlog->info.odcid                = info->odcid;
-    qlog->info.is_server            = info->is_server;
-    qlog->info.now_cb               = info->now_cb;
-    qlog->info.now_cb_arg           = info->now_cb_arg;
-    qlog->info.override_process_id  = info->override_process_id;
+    qlog->info.odcid = info->odcid;
+    qlog->info.is_server = info->is_server;
+    qlog->info.now_cb = info->now_cb;
+    qlog->info.now_cb_arg = info->now_cb_arg;
+    qlog->info.override_process_id = info->override_process_id;
 
     if (info->title != NULL
         && (qlog->info.title = OPENSSL_strdup(info->title)) == NULL)
@@ -79,11 +79,12 @@ QLOG *ossl_qlog_new(const QLOG_TRACE_INFO *info)
 
     if (info->override_impl_name != NULL
         && (qlog->info.override_impl_name
-                = OPENSSL_strdup(info->override_impl_name)) == NULL)
+               = OPENSSL_strdup(info->override_impl_name))
+            == NULL)
         goto err;
 
     if (!ossl_json_init(&qlog->json, NULL,
-                        OSSL_JSON_FLAG_IJSON | OSSL_JSON_FLAG_SEQ))
+            OSSL_JSON_FLAG_IJSON | OSSL_JSON_FLAG_SEQ))
         goto err;
 
     if (qlog->info.now_cb == NULL)
@@ -133,7 +134,7 @@ QLOG *ossl_qlog_new_from_env(const QLOG_TRACE_INFO *info)
         l += BIO_snprintf(filename + l, strl - l, "%02x", info->odcid.id[i]);
 
     l += BIO_snprintf(filename + l, strl - l, "_%s.sqlog",
-                      info->is_server ? "server" : "client");
+        info->is_server ? "server" : "client");
 
     qlog = ossl_qlog_new(info);
     if (qlog == NULL)
@@ -242,7 +243,7 @@ int ossl_qlog_flush(QLOG *qlog)
 }
 
 int ossl_qlog_set_event_type_enabled(QLOG *qlog, uint32_t event_type,
-                                     int enabled)
+    int enabled)
 {
     if (qlog == NULL || event_type >= QLOG_EVENT_TYPE_NUM)
         return 0;
@@ -339,13 +340,13 @@ static void qlog_event_seq_header(QLOG *qlog)
                     p = qlog->info.override_impl_name;
                 } else {
                     BIO_snprintf(buf, sizeof(buf), "OpenSSL/%s (%s)",
-                                 OpenSSL_version(OPENSSL_FULL_VERSION_STRING),
-                                 OpenSSL_version(OPENSSL_PLATFORM) + 10);
+                        OpenSSL_version(OPENSSL_FULL_VERSION_STRING),
+                        OpenSSL_version(OPENSSL_PLATFORM) + 10);
                 }
 
                 ossl_json_key(&qlog->json, "type");
                 ossl_json_str(&qlog->json,
-                              qlog->info.is_server ? "server" : "client");
+                    qlog->info.is_server ? "server" : "client");
 
                 ossl_json_key(&qlog->json, "name");
                 ossl_json_str(&qlog->json, p);
@@ -383,7 +384,7 @@ static void qlog_event_epilogue(QLOG *qlog)
         qlog->first_event_done = 1;
     } else {
         OSSL_TIME delta = ossl_time_subtract(qlog->event_time,
-                                             qlog->prev_event_time);
+            qlog->prev_event_time);
 
         ossl_json_u64(&qlog->json, ossl_time2ms(delta));
         qlog->prev_event_time = qlog->event_time;
@@ -393,10 +394,10 @@ static void qlog_event_epilogue(QLOG *qlog)
 }
 
 int ossl_qlog_event_try_begin(QLOG *qlog,
-                              uint32_t event_type,
-                              const char *event_cat,
-                              const char *event_name,
-                              const char *event_combined_name)
+    uint32_t event_type,
+    const char *event_cat,
+    const char *event_name,
+    const char *event_combined_name)
 {
     if (qlog == NULL)
         return 0;
@@ -405,11 +406,11 @@ int ossl_qlog_event_try_begin(QLOG *qlog,
         || !ossl_qlog_enabled(qlog, event_type))
         return 0;
 
-    qlog->event_type            = event_type;
-    qlog->event_cat             = event_cat;
-    qlog->event_name            = event_name;
-    qlog->event_combined_name   = event_combined_name;
-    qlog->event_time            = qlog->info.now_cb(qlog->info.now_cb_arg);
+    qlog->event_type = event_type;
+    qlog->event_cat = event_cat;
+    qlog->event_name = event_name;
+    qlog->event_combined_name = event_combined_name;
+    qlog->event_time = qlog->info.now_cb(qlog->info.now_cb_arg);
 
     qlog_event_prologue(qlog);
     return 1;
@@ -468,7 +469,7 @@ void ossl_qlog_str(QLOG *qlog, const char *name, const char *value)
 }
 
 void ossl_qlog_str_len(QLOG *qlog, const char *name,
-                       const char *value, size_t value_len)
+    const char *value, size_t value_len)
 {
     if (name != NULL)
         ossl_json_key(&qlog->json, name);
@@ -501,7 +502,7 @@ void ossl_qlog_bool(QLOG *qlog, const char *name, int value)
 }
 
 void ossl_qlog_bin(QLOG *qlog, const char *name,
-                   const void *value, size_t value_len)
+    const void *value, size_t value_len)
 {
     if (name != NULL)
         ossl_json_key(&qlog->json, name);
@@ -532,9 +533,9 @@ static int lex_init(struct lexer *lex, const char *in, size_t in_len)
     if (in == NULL)
         return 0;
 
-    lex->p          = in;
-    lex->term_end   = in;
-    lex->end        = in + in_len;
+    lex->p = in;
+    lex->term_end = in;
+    lex->end = in + in_len;
     return 1;
 }
 
@@ -542,18 +543,20 @@ static int lex_do(struct lexer *lex)
 {
     const char *p = lex->term_end, *end = lex->end, *term_end;
 
-    for (; is_term_sep_ws(*p) && p < end; ++p);
+    for (; is_term_sep_ws(*p) && p < end; ++p)
+        ;
 
     if (p == end) {
-        lex->p          = end;
-        lex->term_end   = end;
+        lex->p = end;
+        lex->term_end = end;
         return 0;
     }
 
-    for (term_end = p; !is_term_sep_ws(*term_end) && term_end < end; ++term_end);
+    for (term_end = p; !is_term_sep_ws(*term_end) && term_end < end; ++term_end)
+        ;
 
-    lex->p          = p;
-    lex->term_end   = term_end;
+    lex->p = p;
+    lex->term_end = term_end;
     return 1;
 }
 
@@ -589,29 +592,30 @@ static int lex_match(struct lexer *lex, const char *s, size_t s_len)
 
 static void lex_get_rest(struct lexer *lex, const char **str, size_t *str_l)
 {
-    *str    = lex->p;
-    *str_l  = lex->term_end - lex->p;
+    *str = lex->p;
+    *str_l = lex->term_end - lex->p;
 }
 
 static int lex_extract_to(struct lexer *lex, char c,
-                          const char **str, size_t *str_l)
+    const char **str, size_t *str_l)
 {
     const char *p = lex->p, *term_end = lex->term_end, *s;
 
-    for (s = p; s < term_end && *s != c; ++s);
+    for (s = p; s < term_end && *s != c; ++s)
+        ;
     if (s == term_end)
         return 0;
 
-    *str    = p;
-    *str_l  = s - p;
-    lex->p  = ++s;
+    *str = p;
+    *str_l = s - p;
+    lex->p = ++s;
     return 1;
 }
 
 static int ossl_unused filter_match_event(const char *cat, size_t cat_l,
-                                          const char *event, size_t event_l,
-                                          const char *expect_cat,
-                                          const char *expect_event)
+    const char *event, size_t event_l,
+    const char *expect_cat,
+    const char *expect_event)
 {
     size_t expect_cat_l = strlen(expect_cat);
     size_t expect_event_l = strlen(expect_event);
@@ -634,16 +638,16 @@ static int ossl_unused filter_match_event(const char *cat, size_t cat_l,
  *        NULL to match any.
  */
 static void filter_apply(size_t *enabled, int add,
-                         const char *cat, size_t cat_l,
-                         const char *event, size_t event_l)
+    const char *cat, size_t cat_l,
+    const char *event, size_t event_l)
 {
     /* Find events which match the given filters. */
-# define QLOG_EVENT(e_cat, e_name)                          \
+#define QLOG_EVENT(e_cat, e_name)                      \
     if (filter_match_event(cat, cat_l, event, event_l, \
-                                #e_cat, #e_name))           \
+            #e_cat, #e_name))                          \
         bit_set(enabled, QLOG_EVENT_TYPE_##e_cat##_##e_name, add);
-# include "internal/qlog_events.h"
-# undef QLOG_EVENT
+#include "internal/qlog_events.h"
+#undef QLOG_EVENT
 }
 
 static int lex_fail(struct lexer *lex, const char *msg)
@@ -679,7 +683,7 @@ static int validate_name(const char **p, size_t *l)
 
 int ossl_qlog_set_filter(QLOG *qlog, const char *filter)
 {
-    struct lexer lex = {0};
+    struct lexer lex = { 0 };
     char c;
     const char *cat, *event;
     size_t cat_l, event_l, enabled[NUM_ENABLED_W];
@@ -699,7 +703,7 @@ int ossl_qlog_set_filter(QLOG *qlog, const char *filter)
             c = lex_peek_char(&lex);
             if (!is_name_char(c) && c != '*')
                 return lex_fail(&lex, "expected alphanumeric name or '*'"
-                                " after +/-");
+                                      " after +/-");
         } else if (!is_name_char(c) && c != '*') {
             return lex_fail(&lex, "expected +/- or alphanumeric name or '*'");
         } else {
diff --git a/crypto/openssl/ssl/quic/qlog_event_helpers.c b/crypto/openssl/ssl/quic/qlog_event_helpers.c
index a4f74e25c800..83eebe82ad4f 100644
--- a/crypto/openssl/ssl/quic/qlog_event_helpers.c
+++ b/crypto/openssl/ssl/quic/qlog_event_helpers.c
@@ -14,20 +14,20 @@
 #include "internal/quic_error.h"
 
 void ossl_qlog_event_connectivity_connection_started(QLOG *qlog,
-                                                     const QUIC_CONN_ID *init_dcid)
+    const QUIC_CONN_ID *init_dcid)
 {
 #ifndef OPENSSL_NO_QLOG
     QLOG_EVENT_BEGIN(qlog, connectivity, connection_started)
-        QLOG_STR("protocol", "quic");
-        QLOG_CID("dst_cid", init_dcid);
+    QLOG_STR("protocol", "quic");
+    QLOG_CID("dst_cid", init_dcid);
     QLOG_EVENT_END()
 #endif
 }
 
 #ifndef OPENSSL_NO_QLOG
 static const char *map_state_to_qlog(uint32_t state,
-                                     int handshake_complete,
-                                     int handshake_confirmed)
+    int handshake_complete,
+    int handshake_confirmed)
 {
     switch (state) {
     default:
@@ -55,21 +55,21 @@ static const char *map_state_to_qlog(uint32_t state,
 #endif
 
 void ossl_qlog_event_connectivity_connection_state_updated(QLOG *qlog,
-                                                           uint32_t old_state,
-                                                           uint32_t new_state,
-                                                           int handshake_complete,
-                                                           int handshake_confirmed)
+    uint32_t old_state,
+    uint32_t new_state,
+    int handshake_complete,
+    int handshake_confirmed)
 {
 #ifndef OPENSSL_NO_QLOG
     const char *state_s;
 
     QLOG_EVENT_BEGIN(qlog, connectivity, connection_state_updated)
-        state_s = map_state_to_qlog(new_state,
-                                    handshake_complete,
-                                    handshake_confirmed);
+    state_s = map_state_to_qlog(new_state,
+        handshake_complete,
+        handshake_confirmed);
 
-        if (state_s != NULL)
-            QLOG_STR("state", state_s);
+    if (state_s != NULL)
+        QLOG_STR("state", state_s);
     QLOG_EVENT_END()
 #endif
 }
@@ -117,32 +117,32 @@ static const char *quic_err_to_qlog(uint64_t error_code)
 #endif
 
 void ossl_qlog_event_connectivity_connection_closed(QLOG *qlog,
-                                                    const QUIC_TERMINATE_CAUSE *tcause)
+    const QUIC_TERMINATE_CAUSE *tcause)
 {
 #ifndef OPENSSL_NO_QLOG
     QLOG_EVENT_BEGIN(qlog, connectivity, connection_closed)
-        QLOG_STR("owner", tcause->remote ? "remote" : "local");
-        if (tcause->app) {
-            QLOG_U64("application_code", tcause->error_code);
-        } else {
-            const char *m = quic_err_to_qlog(tcause->error_code);
-            char ce[32];
+    QLOG_STR("owner", tcause->remote ? "remote" : "local");
+    if (tcause->app) {
+        QLOG_U64("application_code", tcause->error_code);
+    } else {
+        const char *m = quic_err_to_qlog(tcause->error_code);
+        char ce[32];
 
-            if (tcause->error_code >= OSSL_QUIC_ERR_CRYPTO_ERR_BEGIN
-                && tcause->error_code <= OSSL_QUIC_ERR_CRYPTO_ERR_END) {
-                BIO_snprintf(ce, sizeof(ce), "crypto_error_0x%03llx",
-                             (unsigned long long)tcause->error_code);
-                m = ce;
-            }
-            /* TODO(QLOG FUTURE): Consider adding ERR information in the output. */
-
-            if (m != NULL)
-                QLOG_STR("connection_code", m);
-            else
-                QLOG_U64("connection_code", tcause->error_code);
+        if (tcause->error_code >= OSSL_QUIC_ERR_CRYPTO_ERR_BEGIN
+            && tcause->error_code <= OSSL_QUIC_ERR_CRYPTO_ERR_END) {
+            BIO_snprintf(ce, sizeof(ce), "crypto_error_0x%03llx",
+                (unsigned long long)tcause->error_code);
+            m = ce;
         }
+        /* TODO(QLOG FUTURE): Consider adding ERR information in the output. */
+
+        if (m != NULL)
+            QLOG_STR("connection_code", m);
+        else
+            QLOG_U64("connection_code", tcause->error_code);
+    }
 
-        QLOG_STR_LEN("reason", tcause->reason, tcause->reason_len);
+    QLOG_STR_LEN("reason", tcause->reason, tcause->reason_len);
     QLOG_EVENT_END()
 #endif
 }
@@ -170,23 +170,23 @@ static const char *quic_pkt_type_to_qlog(uint32_t pkt_type)
 #endif
 
 void ossl_qlog_event_recovery_packet_lost(QLOG *qlog,
-                                          const QUIC_TXPIM_PKT *tpkt)
+    const QUIC_TXPIM_PKT *tpkt)
 {
 #ifndef OPENSSL_NO_QLOG
     QLOG_EVENT_BEGIN(qlog, recovery, packet_lost)
-        QLOG_BEGIN("header")
-            QLOG_STR("packet_type", quic_pkt_type_to_qlog(tpkt->pkt_type));
-            if (ossl_quic_pkt_type_has_pn(tpkt->pkt_type))
-                QLOG_U64("packet_number", tpkt->ackm_pkt.pkt_num);
-        QLOG_END()
+    QLOG_BEGIN("header")
+    QLOG_STR("packet_type", quic_pkt_type_to_qlog(tpkt->pkt_type));
+    if (ossl_quic_pkt_type_has_pn(tpkt->pkt_type))
+        QLOG_U64("packet_number", tpkt->ackm_pkt.pkt_num);
+    QLOG_END()
     QLOG_EVENT_END()
 #endif
 }
 
 #ifndef OPENSSL_NO_QLOG
-# define MAX_ACK_RANGES 32
+#define MAX_ACK_RANGES 32
 
-static void ignore_res(int x) {}
+static void ignore_res(int x) { }
 
 /*
  * For logging received packets, we need to parse all the frames in the packet
@@ -204,7 +204,7 @@ static void ignore_res(int x) {}
  * data on what frames it contained.
  */
 static int log_frame_actual(QLOG *qlog_instance, PACKET *pkt,
-                            size_t *need_skip)
+    size_t *need_skip)
 {
     uint64_t frame_type;
     OSSL_QUIC_FRAME_ACK ack;
@@ -227,7 +227,7 @@ static int log_frame_actual(QLOG *qlog_instance, PACKET *pkt,
     case OSSL_QUIC_FRAME_TYPE_PADDING:
         QLOG_STR("frame_type", "padding");
         QLOG_U64("payload_length",
-                 ossl_quic_wire_decode_padding(pkt));
+            ossl_quic_wire_decode_padding(pkt));
         break;
     case OSSL_QUIC_FRAME_TYPE_PING:
         if (!ossl_quic_wire_decode_frame_ping(pkt))
@@ -240,8 +240,8 @@ static int log_frame_actual(QLOG *qlog_instance, PACKET *pkt,
         if (!ossl_quic_wire_peek_frame_ack_num_ranges(pkt, &num_ranges))
             goto unknown;
 
-        ack.ack_ranges      = ack_ranges;
-        ack.num_ack_ranges  = OSSL_NELEM(ack_ranges);
+        ack.ack_ranges = ack_ranges;
+        ack.num_ack_ranges = OSSL_NELEM(ack_ranges);
         if (!ossl_quic_wire_decode_frame_ack(pkt, 3, &ack, &total_ranges))
             goto unknown;
 
@@ -255,51 +255,45 @@ static int log_frame_actual(QLOG *qlog_instance, PACKET *pkt,
         QLOG_BEGIN_ARRAY("acked_ranges");
         for (i = 0; i < ack.num_ack_ranges; ++i) {
             QLOG_BEGIN_ARRAY(NULL)
-                QLOG_U64(NULL, ack.ack_ranges[i].start);
-                if (ack.ack_ranges[i].end != ack.ack_ranges[i].start)
-                    QLOG_U64(NULL, ack.ack_ranges[i].end);
+            QLOG_U64(NULL, ack.ack_ranges[i].start);
+            if (ack.ack_ranges[i].end != ack.ack_ranges[i].start)
+                QLOG_U64(NULL, ack.ack_ranges[i].end);
             QLOG_END_ARRAY()
         }
         QLOG_END_ARRAY()
         break;
-    case OSSL_QUIC_FRAME_TYPE_RESET_STREAM:
-        {
-            OSSL_QUIC_FRAME_RESET_STREAM f;
+    case OSSL_QUIC_FRAME_TYPE_RESET_STREAM: {
+        OSSL_QUIC_FRAME_RESET_STREAM f;
 
-            if (!ossl_quic_wire_decode_frame_reset_stream(pkt, &f))
-                goto unknown;
+        if (!ossl_quic_wire_decode_frame_reset_stream(pkt, &f))
+            goto unknown;
 
-            QLOG_STR("frame_type", "reset_stream");
-            QLOG_U64("stream_id", f.stream_id);
-            QLOG_U64("error_code", f.app_error_code);
-            QLOG_U64("final_size", f.final_size);
-        }
-        break;
-    case OSSL_QUIC_FRAME_TYPE_STOP_SENDING:
-        {
-            OSSL_QUIC_FRAME_STOP_SENDING f;
+        QLOG_STR("frame_type", "reset_stream");
+        QLOG_U64("stream_id", f.stream_id);
+        QLOG_U64("error_code", f.app_error_code);
+        QLOG_U64("final_size", f.final_size);
+    } break;
+    case OSSL_QUIC_FRAME_TYPE_STOP_SENDING: {
+        OSSL_QUIC_FRAME_STOP_SENDING f;
 
-            if (!ossl_quic_wire_decode_frame_stop_sending(pkt, &f))
-                goto unknown;
+        if (!ossl_quic_wire_decode_frame_stop_sending(pkt, &f))
+            goto unknown;
 
-            QLOG_STR("frame_type", "stop_sending");
-            QLOG_U64("stream_id", f.stream_id);
-            QLOG_U64("error_code", f.app_error_code);
-        }
-        break;
-    case OSSL_QUIC_FRAME_TYPE_CRYPTO:
-        {
-            OSSL_QUIC_FRAME_CRYPTO f;
+        QLOG_STR("frame_type", "stop_sending");
+        QLOG_U64("stream_id", f.stream_id);
+        QLOG_U64("error_code", f.app_error_code);
+    } break;
+    case OSSL_QUIC_FRAME_TYPE_CRYPTO: {
+        OSSL_QUIC_FRAME_CRYPTO f;
 
-            if (!ossl_quic_wire_decode_frame_crypto(pkt, 1, &f))
-                goto unknown;
+        if (!ossl_quic_wire_decode_frame_crypto(pkt, 1, &f))
+            goto unknown;
 
-            QLOG_STR("frame_type", "crypto");
-            QLOG_U64("offset", f.offset);
-            QLOG_U64("payload_length", f.len);
-            *need_skip += (size_t)f.len;
-        }
-        break;
+        QLOG_STR("frame_type", "crypto");
+        QLOG_U64("offset", f.offset);
+        QLOG_U64("payload_length", f.len);
+        *need_skip += (size_t)f.len;
+    } break;
     case OSSL_QUIC_FRAME_TYPE_STREAM:
     case OSSL_QUIC_FRAME_TYPE_STREAM_FIN:
     case OSSL_QUIC_FRAME_TYPE_STREAM_LEN:
@@ -307,194 +301,169 @@ static int log_frame_actual(QLOG *qlog_instance, PACKET *pkt,
     case OSSL_QUIC_FRAME_TYPE_STREAM_OFF:
     case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_FIN:
     case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN:
-    case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN_FIN:
-        {
-            OSSL_QUIC_FRAME_STREAM f;
+    case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN_FIN: {
+        OSSL_QUIC_FRAME_STREAM f;
 
-            if (!ossl_quic_wire_decode_frame_stream(pkt, 1, &f))
-                goto unknown;
+        if (!ossl_quic_wire_decode_frame_stream(pkt, 1, &f))
+            goto unknown;
 
-            QLOG_STR("frame_type", "stream");
-            QLOG_U64("stream_id", f.stream_id);
-            QLOG_U64("offset", f.offset);
-            QLOG_U64("payload_length", f.len);
-            QLOG_BOOL("explicit_length", f.has_explicit_len);
-            if (f.is_fin)
-                QLOG_BOOL("fin", 1);
-            *need_skip = f.has_explicit_len
-                ? *need_skip + (size_t)f.len : SIZE_MAX;
-        }
-        break;
-    case OSSL_QUIC_FRAME_TYPE_MAX_DATA:
-        {
-            uint64_t x;
+        QLOG_STR("frame_type", "stream");
+        QLOG_U64("stream_id", f.stream_id);
+        QLOG_U64("offset", f.offset);
+        QLOG_U64("payload_length", f.len);
+        QLOG_BOOL("explicit_length", f.has_explicit_len);
+        if (f.is_fin)
+            QLOG_BOOL("fin", 1);
+        *need_skip = f.has_explicit_len
+            ? *need_skip + (size_t)f.len
+            : SIZE_MAX;
+    } break;
+    case OSSL_QUIC_FRAME_TYPE_MAX_DATA: {
+        uint64_t x;
 
-            if (!ossl_quic_wire_decode_frame_max_data(pkt, &x))
-                goto unknown;
+        if (!ossl_quic_wire_decode_frame_max_data(pkt, &x))
+            goto unknown;
 
-            QLOG_STR("frame_type", "max_data");
-            QLOG_U64("maximum", x);
-        }
-        break;
+        QLOG_STR("frame_type", "max_data");
+        QLOG_U64("maximum", x);
+    } break;
     case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI:
-    case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI:
-        {
-            uint64_t x;
+    case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI: {
+        uint64_t x;
 
-            if (!ossl_quic_wire_decode_frame_max_streams(pkt, &x))
-                goto unknown;
+        if (!ossl_quic_wire_decode_frame_max_streams(pkt, &x))
+            goto unknown;
 
-            QLOG_STR("frame_type", "max_streams");
-            QLOG_STR("stream_type",
-                     frame_type == OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI
-                        ? "bidirectional" : "unidirectional");
-            QLOG_U64("maximum", x);
-        }
-        break;
-    case OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA:
-        {
-            uint64_t stream_id, max_data;
+        QLOG_STR("frame_type", "max_streams");
+        QLOG_STR("stream_type",
+            frame_type == OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI
+                ? "bidirectional"
+                : "unidirectional");
+        QLOG_U64("maximum", x);
+    } break;
+    case OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA: {
+        uint64_t stream_id, max_data;
 
-            if (!ossl_quic_wire_decode_frame_max_stream_data(pkt, &stream_id,
-                                                             &max_data))
-                goto unknown;
+        if (!ossl_quic_wire_decode_frame_max_stream_data(pkt, &stream_id,
+                &max_data))
+            goto unknown;
 
-            QLOG_STR("frame_type", "max_stream_data");
-            QLOG_U64("stream_id", stream_id);
-            QLOG_U64("maximum", max_data);
-        }
-        break;
-    case OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE:
-        {
-            uint64_t challenge;
+        QLOG_STR("frame_type", "max_stream_data");
+        QLOG_U64("stream_id", stream_id);
+        QLOG_U64("maximum", max_data);
+    } break;
+    case OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE: {
+        uint64_t challenge;
 
-            if (!ossl_quic_wire_decode_frame_path_challenge(pkt, &challenge))
-                goto unknown;
+        if (!ossl_quic_wire_decode_frame_path_challenge(pkt, &challenge))
+            goto unknown;
 
-            QLOG_STR("frame_type", "path_challenge");
-        }
-        break;
-    case OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE:
-        {
-            uint64_t challenge;
+        QLOG_STR("frame_type", "path_challenge");
+    } break;
+    case OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE: {
+        uint64_t challenge;
 
-            if (!ossl_quic_wire_decode_frame_path_response(pkt, &challenge))
-                goto unknown;
+        if (!ossl_quic_wire_decode_frame_path_response(pkt, &challenge))
+            goto unknown;
 
-            QLOG_STR("frame_type", "path_response");
-        }
-        break;
+        QLOG_STR("frame_type", "path_response");
+    } break;
     case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP:
-    case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT:
-        {
-            OSSL_QUIC_FRAME_CONN_CLOSE f;
+    case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT: {
+        OSSL_QUIC_FRAME_CONN_CLOSE f;
 
-            if (!ossl_quic_wire_decode_frame_conn_close(pkt, &f))
-                goto unknown;
+        if (!ossl_quic_wire_decode_frame_conn_close(pkt, &f))
+            goto unknown;
 
-            QLOG_STR("frame_type", "connection_close");
-            QLOG_STR("error_space", f.is_app ? "application" : "transport");
-            QLOG_U64("error_code_value", f.error_code);
-            if (f.is_app)
-                QLOG_U64("error_code", f.error_code);
-            if (!f.is_app && f.frame_type != 0)
-                QLOG_U64("trigger_frame_type", f.frame_type);
-            QLOG_STR_LEN("reason", f.reason, f.reason_len);
-        }
-        break;
-    case OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE:
-        {
-            if (!ossl_quic_wire_decode_frame_handshake_done(pkt))
-                goto unknown;
+        QLOG_STR("frame_type", "connection_close");
+        QLOG_STR("error_space", f.is_app ? "application" : "transport");
+        QLOG_U64("error_code_value", f.error_code);
+        if (f.is_app)
+            QLOG_U64("error_code", f.error_code);
+        if (!f.is_app && f.frame_type != 0)
+            QLOG_U64("trigger_frame_type", f.frame_type);
+        QLOG_STR_LEN("reason", f.reason, f.reason_len);
+    } break;
+    case OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE: {
+        if (!ossl_quic_wire_decode_frame_handshake_done(pkt))
+            goto unknown;
 
-            QLOG_STR("frame_type", "handshake_done");
-        }
-        break;
-    case OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID:
-        {
-            OSSL_QUIC_FRAME_NEW_CONN_ID f;
+        QLOG_STR("frame_type", "handshake_done");
+    } break;
+    case OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID: {
+        OSSL_QUIC_FRAME_NEW_CONN_ID f;
 
-            if (!ossl_quic_wire_decode_frame_new_conn_id(pkt, &f))
-                goto unknown;
+        if (!ossl_quic_wire_decode_frame_new_conn_id(pkt, &f))
+            goto unknown;
 
-            QLOG_STR("frame_type", "new_connection_id");
-            QLOG_U64("sequence_number", f.seq_num);
-            QLOG_U64("retire_prior_to", f.retire_prior_to);
-            QLOG_CID("connection_id", &f.conn_id);
-            QLOG_BIN("stateless_reset_token",
-                     f.stateless_reset.token,
-                     sizeof(f.stateless_reset.token));
-        }
-        break;
-    case OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID:
-        {
-            uint64_t seq_num;
+        QLOG_STR("frame_type", "new_connection_id");
+        QLOG_U64("sequence_number", f.seq_num);
+        QLOG_U64("retire_prior_to", f.retire_prior_to);
+        QLOG_CID("connection_id", &f.conn_id);
+        QLOG_BIN("stateless_reset_token",
+            f.stateless_reset.token,
+            sizeof(f.stateless_reset.token));
+    } break;
+    case OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID: {
+        uint64_t seq_num;
 
-            if (!ossl_quic_wire_decode_frame_retire_conn_id(pkt, &seq_num))
-                goto unknown;
+        if (!ossl_quic_wire_decode_frame_retire_conn_id(pkt, &seq_num))
+            goto unknown;
 
-            QLOG_STR("frame_type", "retire_connection_id");
-            QLOG_U64("sequence_number", seq_num);
-        }
-        break;
-    case OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED:
-        {
-            uint64_t x;
+        QLOG_STR("frame_type", "retire_connection_id");
+        QLOG_U64("sequence_number", seq_num);
+    } break;
+    case OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED: {
+        uint64_t x;
 
-            if (!ossl_quic_wire_decode_frame_data_blocked(pkt, &x))
-                goto unknown;
+        if (!ossl_quic_wire_decode_frame_data_blocked(pkt, &x))
+            goto unknown;
 
-            QLOG_STR("frame_type", "data_blocked");
-            QLOG_U64("limit", x);
-        }
-        break;
-    case OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED:
-        {
-            uint64_t stream_id, x;
+        QLOG_STR("frame_type", "data_blocked");
+        QLOG_U64("limit", x);
+    } break;
+    case OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED: {
+        uint64_t stream_id, x;
 
-            if (!ossl_quic_wire_decode_frame_stream_data_blocked(pkt,
-                                                                 &stream_id,
-                                                                 &x))
-                goto unknown;
+        if (!ossl_quic_wire_decode_frame_stream_data_blocked(pkt,
+                &stream_id,
+                &x))
+            goto unknown;
 
-            QLOG_STR("frame_type", "stream_data_blocked");
-            QLOG_U64("stream_id", stream_id);
-            QLOG_U64("limit", x);
-        }
-        break;
+        QLOG_STR("frame_type", "stream_data_blocked");
+        QLOG_U64("stream_id", stream_id);
+        QLOG_U64("limit", x);
+    } break;
     case OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI:
-    case OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI:
-        {
-            uint64_t x;
+    case OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI: {
+        uint64_t x;
 
-            if (!ossl_quic_wire_decode_frame_streams_blocked(pkt, &x))
-                goto unknown;
+        if (!ossl_quic_wire_decode_frame_streams_blocked(pkt, &x))
+            goto unknown;
 
-            QLOG_STR("frame_type", "streams_blocked");
-            QLOG_STR("stream_type",
-                     frame_type == OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI
-                        ? "bidirectional" : "unidirectional");
-            QLOG_U64("limit", x);
-        }
-        break;
-    case OSSL_QUIC_FRAME_TYPE_NEW_TOKEN:
-        {
-            const unsigned char *token;
-            size_t token_len;
+        QLOG_STR("frame_type", "streams_blocked");
+        QLOG_STR("stream_type",
+            frame_type == OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI
+                ? "bidirectional"
+                : "unidirectional");
+        QLOG_U64("limit", x);
+    } break;
+    case OSSL_QUIC_FRAME_TYPE_NEW_TOKEN: {
+        const unsigned char *token;
+        size_t token_len;
 
-            if (!ossl_quic_wire_decode_frame_new_token(pkt, &token, &token_len))
-                goto unknown;
+        if (!ossl_quic_wire_decode_frame_new_token(pkt, &token, &token_len))
+            goto unknown;
 
-            QLOG_STR("frame_type", "new_token");
-            QLOG_BEGIN("token");
-                QLOG_BEGIN("raw");
-                    QLOG_BIN("data", token, token_len);
-                QLOG_END();
-            QLOG_END();
-        }
-        break;
+        QLOG_STR("frame_type", "new_token");
+        QLOG_BEGIN("token");
+        QLOG_BEGIN("raw");
+        QLOG_BIN("data", token, token_len);
+        QLOG_END();
+        QLOG_END();
+    } break;
     default:
-unknown:
+    unknown:
         QLOG_STR("frame_type", "unknown");
         QLOG_U64("frame_type_value", frame_type);
 
@@ -504,8 +473,8 @@ unknown:
          * as the raw data of the frame.
          */
         QLOG_BEGIN("raw");
-            QLOG_BIN("data", PACKET_data(&orig_pkt),
-                     PACKET_remaining(&orig_pkt));
+        QLOG_BIN("data", PACKET_data(&orig_pkt),
+            PACKET_remaining(&orig_pkt));
         QLOG_END();
         ignore_res(PACKET_forward(pkt, PACKET_remaining(pkt)));
         break;
@@ -515,7 +484,7 @@ unknown:
 }
 
 static void log_frame(QLOG *qlog_instance, PACKET *pkt,
-                      size_t *need_skip)
+    size_t *need_skip)
 {
     size_t rem_before, rem_after;
 
@@ -529,8 +498,8 @@ static void log_frame(QLOG *qlog_instance, PACKET *pkt,
 }
 
 static int log_frames(QLOG *qlog_instance,
-                      const OSSL_QTX_IOVEC *iovec,
-                      size_t num_iovec)
+    const OSSL_QTX_IOVEC *iovec,
+    size_t num_iovec)
 {
     size_t i;
     PACKET pkt;
@@ -566,41 +535,41 @@ static int log_frames(QLOG *qlog_instance,
 }
 
 static void log_packet(QLOG *qlog_instance,
-                       const QUIC_PKT_HDR *hdr,
-                       QUIC_PN pn,
-                       const OSSL_QTX_IOVEC *iovec,
-                       size_t num_iovec,
-                       uint64_t datagram_id)
+    const QUIC_PKT_HDR *hdr,
+    QUIC_PN pn,
+    const OSSL_QTX_IOVEC *iovec,
+    size_t num_iovec,
+    uint64_t datagram_id)
 {
     const char *type_s;
 
     QLOG_BEGIN("header")
-        type_s = quic_pkt_type_to_qlog(hdr->type);
-        if (type_s == NULL)
-            type_s = "unknown";
+    type_s = quic_pkt_type_to_qlog(hdr->type);
+    if (type_s == NULL)
+        type_s = "unknown";
 
-        QLOG_STR("packet_type", type_s);
-        if (ossl_quic_pkt_type_has_pn(hdr->type))
-            QLOG_U64("packet_number", pn);
+    QLOG_STR("packet_type", type_s);
+    if (ossl_quic_pkt_type_has_pn(hdr->type))
+        QLOG_U64("packet_number", pn);
 
-        QLOG_CID("dcid", &hdr->dst_conn_id);
-        if (ossl_quic_pkt_type_has_scid(hdr->type))
-            QLOG_CID("scid", &hdr->src_conn_id);
+    QLOG_CID("dcid", &hdr->dst_conn_id);
+    if (ossl_quic_pkt_type_has_scid(hdr->type))
+        QLOG_CID("scid", &hdr->src_conn_id);
 
-        if (hdr->token_len > 0) {
-            QLOG_BEGIN("token")
-                QLOG_BEGIN("raw")
-                    QLOG_BIN("data", hdr->token, hdr->token_len);
-                QLOG_END()
-            QLOG_END()
-        }
-        /* TODO(QLOG FUTURE): flags, length */
+    if (hdr->token_len > 0) {
+        QLOG_BEGIN("token")
+        QLOG_BEGIN("raw")
+        QLOG_BIN("data", hdr->token, hdr->token_len);
+        QLOG_END()
+        QLOG_END()
+    }
+    /* TODO(QLOG FUTURE): flags, length */
     QLOG_END()
     QLOG_U64("datagram_id", datagram_id);
 
     if (ossl_quic_pkt_type_is_encrypted(hdr->type)) {
         QLOG_BEGIN_ARRAY("frames")
-            log_frames(qlog_instance, iovec, num_iovec);
+        log_frames(qlog_instance, iovec, num_iovec);
         QLOG_END_ARRAY()
     }
 }
@@ -608,29 +577,29 @@ static void log_packet(QLOG *qlog_instance,
 #endif
 
 void ossl_qlog_event_transport_packet_sent(QLOG *qlog,
-                                           const QUIC_PKT_HDR *hdr,
-                                           QUIC_PN pn,
-                                           const OSSL_QTX_IOVEC *iovec,
-                                           size_t num_iovec,
-                                           uint64_t datagram_id)
+    const QUIC_PKT_HDR *hdr,
+    QUIC_PN pn,
+    const OSSL_QTX_IOVEC *iovec,
+    size_t num_iovec,
+    uint64_t datagram_id)
 {
 #ifndef OPENSSL_NO_QLOG
     QLOG_EVENT_BEGIN(qlog, transport, packet_sent)
-        log_packet(qlog, hdr, pn, iovec, num_iovec, datagram_id);
+    log_packet(qlog, hdr, pn, iovec, num_iovec, datagram_id);
     QLOG_EVENT_END()
 #endif
 }
 
 void ossl_qlog_event_transport_packet_received(QLOG *qlog,
-                                               const QUIC_PKT_HDR *hdr,
-                                               QUIC_PN pn,
-                                               const OSSL_QTX_IOVEC *iovec,
-                                               size_t num_iovec,
-                                               uint64_t datagram_id)
+    const QUIC_PKT_HDR *hdr,
+    QUIC_PN pn,
+    const OSSL_QTX_IOVEC *iovec,
+    size_t num_iovec,
+    uint64_t datagram_id)
 {
 #ifndef OPENSSL_NO_QLOG
     QLOG_EVENT_BEGIN(qlog, transport, packet_received)
-        log_packet(qlog, hdr, pn, iovec, num_iovec, datagram_id);
+    log_packet(qlog, hdr, pn, iovec, num_iovec, datagram_id);
     QLOG_EVENT_END()
 #endif
 }
diff --git a/crypto/openssl/ssl/quic/quic_ackm.c b/crypto/openssl/ssl/quic/quic_ackm.c
index 93c83a36d8fe..503a6eae19ec 100644
--- a/crypto/openssl/ssl/quic/quic_ackm.c
+++ b/crypto/openssl/ssl/quic/quic_ackm.c
@@ -30,7 +30,8 @@ DEFINE_LIST_OF(tx_history, OSSL_ACKM_TX_PKT);
  */
 struct tx_pkt_history_st {
     /* A linked list of all our packets. */
-    OSSL_LIST(tx_history) packets;
+    OSSL_LIST(tx_history)
+    packets;
 
     /*
      * Mapping from packet numbers (uint64_t) to (OSSL_ACKM_TX_PKT *)
@@ -65,7 +66,7 @@ static unsigned long tx_pkt_info_hash(const OSSL_ACKM_TX_PKT *pkt)
 }
 
 static int tx_pkt_info_compare(const OSSL_ACKM_TX_PKT *a,
-                               const OSSL_ACKM_TX_PKT *b)
+    const OSSL_ACKM_TX_PKT *b)
 {
     if (a->pkt_num < b->pkt_num)
         return -1;
@@ -78,7 +79,7 @@ static int
 tx_pkt_history_init(struct tx_pkt_history_st *h)
 {
     ossl_list_tx_history_init(&h->packets);
-    h->watermark    = 0;
+    h->watermark = 0;
     h->highest_sent = 0;
 
     h->map = lh_OSSL_ACKM_TX_PKT_new(tx_pkt_info_hash, tx_pkt_info_compare);
@@ -98,7 +99,7 @@ tx_pkt_history_destroy(struct tx_pkt_history_st *h)
 
 static int
 tx_pkt_history_add_actual(struct tx_pkt_history_st *h,
-                          OSSL_ACKM_TX_PKT *pkt)
+    OSSL_ACKM_TX_PKT *pkt)
 {
     OSSL_ACKM_TX_PKT *existing;
 
@@ -124,7 +125,7 @@ tx_pkt_history_add_actual(struct tx_pkt_history_st *h,
 /* Adds a packet information structure to the history list. */
 static int
 tx_pkt_history_add(struct tx_pkt_history_st *h,
-                   OSSL_ACKM_TX_PKT *pkt)
+    OSSL_ACKM_TX_PKT *pkt)
 {
     if (!ossl_assert(pkt->pkt_num >= h->watermark))
         return 0;
@@ -132,7 +133,7 @@ tx_pkt_history_add(struct tx_pkt_history_st *h,
     if (tx_pkt_history_add_actual(h, pkt) < 1)
         return 0;
 
-    h->watermark    = pkt->pkt_num + 1;
+    h->watermark = pkt->pkt_num + 1;
     h->highest_sent = pkt->pkt_num;
     return 1;
 }
@@ -397,7 +398,7 @@ struct rx_pkt_history_st {
 };
 
 static int rx_pkt_history_bump_watermark(struct rx_pkt_history_st *h,
-                                         QUIC_PN watermark);
+    QUIC_PN watermark);
 
 static void rx_pkt_history_init(struct rx_pkt_history_st *h)
 {
@@ -414,7 +415,7 @@ static void rx_pkt_history_destroy(struct rx_pkt_history_st *h)
  * Limit the number of ACK ranges we store to prevent resource consumption DoS
  * attacks.
  */
-#define MAX_RX_ACK_RANGES   32
+#define MAX_RX_ACK_RANGES 32
 
 static void rx_pkt_history_trim_range_count(struct rx_pkt_history_st *h)
 {
@@ -424,7 +425,8 @@ static void rx_pkt_history_trim_range_count(struct rx_pkt_history_st *h)
         UINT_RANGE r = ossl_list_uint_set_head(&h->set)->range;
 
         highest = (highest == QUIC_PN_INVALID)
-            ? r.end : ossl_quic_pn_max(highest, r.end);
+            ? r.end
+            : ossl_quic_pn_max(highest, r.end);
 
         ossl_uint_set_remove(&h->set, &r);
     }
@@ -438,12 +440,12 @@ static void rx_pkt_history_trim_range_count(struct rx_pkt_history_st *h)
 }
 
 static int rx_pkt_history_add_pn(struct rx_pkt_history_st *h,
-                                 QUIC_PN pn)
+    QUIC_PN pn)
 {
     UINT_RANGE r;
 
     r.start = pn;
-    r.end   = pn;
+    r.end = pn;
 
     if (pn < h->watermark)
         return 1; /* consider this a success case */
@@ -456,7 +458,7 @@ static int rx_pkt_history_add_pn(struct rx_pkt_history_st *h,
 }
 
 static int rx_pkt_history_bump_watermark(struct rx_pkt_history_st *h,
-                                         QUIC_PN watermark)
+    QUIC_PN watermark)
 {
     UINT_RANGE r;
 
@@ -465,7 +467,7 @@ static int rx_pkt_history_bump_watermark(struct rx_pkt_history_st *h,
 
     /* Remove existing PNs below the watermark. */
     r.start = 0;
-    r.end   = watermark - 1;
+    r.end = watermark - 1;
     if (ossl_uint_set_remove(&h->set, &r) != 1)
         return 0;
 
@@ -480,16 +482,16 @@ static int rx_pkt_history_bump_watermark(struct rx_pkt_history_st *h,
  */
 
 /* Constants used by the ACK manager; see RFC 9002. */
-#define K_GRANULARITY           (1 * OSSL_TIME_MS)
-#define K_PKT_THRESHOLD         3
-#define K_TIME_THRESHOLD_NUM    9
-#define K_TIME_THRESHOLD_DEN    8
+#define K_GRANULARITY (1 * OSSL_TIME_MS)
+#define K_PKT_THRESHOLD 3
+#define K_TIME_THRESHOLD_NUM 9
+#define K_TIME_THRESHOLD_DEN 8
 
 /* The maximum number of times we allow PTO to be doubled. */
-#define MAX_PTO_COUNT          16
+#define MAX_PTO_COUNT 16
 
 /* Default maximum amount of time to leave an ACK-eliciting packet un-ACK'd. */
-#define DEFAULT_TX_MAX_ACK_DELAY       ossl_ms2time(QUIC_DEFAULT_MAX_ACK_DELAY)
+#define DEFAULT_TX_MAX_ACK_DELAY ossl_ms2time(QUIC_DEFAULT_MAX_ACK_DELAY)
 
 struct ossl_ackm_st {
     /* Our list of transmitted packets. Corresponds to RFC 9002 sent_packets. */
@@ -499,105 +501,105 @@ struct ossl_ackm_st {
     struct rx_pkt_history_st rx_history[QUIC_PN_SPACE_NUM];
 
     /* Polymorphic dependencies that we consume. */
-    OSSL_TIME             (*now)(void *arg);
-    void                   *now_arg;
-    OSSL_STATM             *statm;
-    const OSSL_CC_METHOD   *cc_method;
-    OSSL_CC_DATA           *cc_data;
+    OSSL_TIME (*now)(void *arg);
+    void *now_arg;
+    OSSL_STATM *statm;
+    const OSSL_CC_METHOD *cc_method;
+    OSSL_CC_DATA *cc_data;
 
     /* RFC 9002 variables. */
-    uint32_t        pto_count;
-    QUIC_PN         largest_acked_pkt[QUIC_PN_SPACE_NUM];
-    OSSL_TIME       time_of_last_ack_eliciting_pkt[QUIC_PN_SPACE_NUM];
-    OSSL_TIME       loss_time[QUIC_PN_SPACE_NUM];
-    OSSL_TIME       loss_detection_deadline;
+    uint32_t pto_count;
+    QUIC_PN largest_acked_pkt[QUIC_PN_SPACE_NUM];
+    OSSL_TIME time_of_last_ack_eliciting_pkt[QUIC_PN_SPACE_NUM];
+    OSSL_TIME loss_time[QUIC_PN_SPACE_NUM];
+    OSSL_TIME loss_detection_deadline;
 
     /* Lowest PN which is still not known to be ACKed. */
-    QUIC_PN         lowest_unacked_pkt[QUIC_PN_SPACE_NUM];
+    QUIC_PN lowest_unacked_pkt[QUIC_PN_SPACE_NUM];
 
     /* Time at which we got our first RTT sample, or 0. */
-    OSSL_TIME       first_rtt_sample;
+    OSSL_TIME first_rtt_sample;
 
     /*
      * A packet's num_bytes are added to this if it is inflight,
      * and removed again once ack'd/lost/discarded.
      */
-    uint64_t        bytes_in_flight;
+    uint64_t bytes_in_flight;
 
     /*
      * A packet's num_bytes are added to this if it is both inflight and
      * ack-eliciting, and removed again once ack'd/lost/discarded.
      */
-    uint64_t        ack_eliciting_bytes_in_flight[QUIC_PN_SPACE_NUM];
+    uint64_t ack_eliciting_bytes_in_flight[QUIC_PN_SPACE_NUM];
 
     /* Count of ECN-CE events. */
-    uint64_t        peer_ecnce[QUIC_PN_SPACE_NUM];
+    uint64_t peer_ecnce[QUIC_PN_SPACE_NUM];
 
     /* Set to 1 when the handshake is confirmed. */
-    char            handshake_confirmed;
+    char handshake_confirmed;
 
     /* Set to 1 when attached to server channel */
-    char            is_server;
+    char is_server;
 
     /* Set to 1 when the peer has completed address validation. */
-    char            peer_completed_addr_validation;
+    char peer_completed_addr_validation;
 
     /* Set to 1 when a PN space has been discarded. */
-    char            discarded[QUIC_PN_SPACE_NUM];
+    char discarded[QUIC_PN_SPACE_NUM];
 
     /* Set to 1 when we think an ACK frame should be generated. */
-    char            rx_ack_desired[QUIC_PN_SPACE_NUM];
+    char rx_ack_desired[QUIC_PN_SPACE_NUM];
 
     /* Set to 1 if an ACK frame has ever been generated. */
-    char            rx_ack_generated[QUIC_PN_SPACE_NUM];
+    char rx_ack_generated[QUIC_PN_SPACE_NUM];
 
     /* Probe request counts for reporting to the user. */
-    OSSL_ACKM_PROBE_INFO    pending_probe;
+    OSSL_ACKM_PROBE_INFO pending_probe;
 
     /* Generated ACK frames for each PN space. */
-    OSSL_QUIC_FRAME_ACK     ack[QUIC_PN_SPACE_NUM];
-    OSSL_QUIC_ACK_RANGE     ack_ranges[QUIC_PN_SPACE_NUM][MAX_RX_ACK_RANGES];
+    OSSL_QUIC_FRAME_ACK ack[QUIC_PN_SPACE_NUM];
+    OSSL_QUIC_ACK_RANGE ack_ranges[QUIC_PN_SPACE_NUM][MAX_RX_ACK_RANGES];
 
     /* Other RX state. */
     /* Largest PN we have RX'd. */
-    QUIC_PN         rx_largest_pn[QUIC_PN_SPACE_NUM];
+    QUIC_PN rx_largest_pn[QUIC_PN_SPACE_NUM];
 
     /* Time at which the PN in rx_largest_pn was RX'd. */
-    OSSL_TIME       rx_largest_time[QUIC_PN_SPACE_NUM];
+    OSSL_TIME rx_largest_time[QUIC_PN_SPACE_NUM];
 
     /*
      * ECN event counters. Each time we receive a packet with a given ECN label,
      * the corresponding ECN counter here is incremented.
      */
-    uint64_t        rx_ect0[QUIC_PN_SPACE_NUM];
-    uint64_t        rx_ect1[QUIC_PN_SPACE_NUM];
-    uint64_t        rx_ecnce[QUIC_PN_SPACE_NUM];
+    uint64_t rx_ect0[QUIC_PN_SPACE_NUM];
+    uint64_t rx_ect1[QUIC_PN_SPACE_NUM];
+    uint64_t rx_ecnce[QUIC_PN_SPACE_NUM];
 
     /*
      * Number of ACK-eliciting packets since last ACK. We use this to defer
      * emitting ACK frames until a threshold number of ACK-eliciting packets
      * have been received.
      */
-    uint32_t        rx_ack_eliciting_pkts_since_last_ack[QUIC_PN_SPACE_NUM];
+    uint32_t rx_ack_eliciting_pkts_since_last_ack[QUIC_PN_SPACE_NUM];
 
     /*
      * The ACK frame coalescing deadline at which we should flush any unsent ACK
      * frames.
      */
-    OSSL_TIME       rx_ack_flush_deadline[QUIC_PN_SPACE_NUM];
+    OSSL_TIME rx_ack_flush_deadline[QUIC_PN_SPACE_NUM];
 
     /*
      * The RX maximum ACK delay (the maximum amount of time our peer might
      * wait to send us an ACK after receiving an ACK-eliciting packet).
      */
-    OSSL_TIME       rx_max_ack_delay;
+    OSSL_TIME rx_max_ack_delay;
 
     /*
      * The TX maximum ACK delay (the maximum amount of time we allow ourselves
      * to wait before generating an ACK after receiving an ACK-eliciting
      * packet).
      */
-    OSSL_TIME       tx_max_ack_delay;
+    OSSL_TIME tx_max_ack_delay;
 
     /* Callbacks for deadline updates. */
     void (*loss_detection_deadline_cb)(OSSL_TIME deadline, void *arg);
@@ -670,8 +672,8 @@ static int range_contains(const OSSL_QUIC_ACK_RANGE *range, QUIC_PN pn)
  * list head (or NULL) if empty.
  */
 static OSSL_ACKM_TX_PKT *ackm_detect_and_remove_newly_acked_pkts(OSSL_ACKM *ackm,
-                                                                 const OSSL_QUIC_FRAME_ACK *ack,
-                                                                 int pkt_space)
+    const OSSL_QUIC_FRAME_ACK *ack,
+    int pkt_space)
 {
     OSSL_ACKM_TX_PKT *acked_pkts = NULL, **fixup = &acked_pkts, *pkt, *pprev;
     struct tx_pkt_history_st *h;
@@ -747,7 +749,7 @@ stop:
  * detected lost. The packets in the list are removed from the TX history list.
  */
 static OSSL_ACKM_TX_PKT *ackm_detect_and_remove_lost_pkts(OSSL_ACKM *ackm,
-                                                          int pkt_space)
+    int pkt_space)
 {
     OSSL_ACKM_TX_PKT *lost_pkts = NULL, **fixup = &lost_pkts, *pkt, *pnext;
     OSSL_TIME loss_delay, lost_send_time, now;
@@ -761,8 +763,8 @@ static OSSL_ACKM_TX_PKT *ackm_detect_and_remove_lost_pkts(OSSL_ACKM *ackm,
     ackm->loss_time[pkt_space] = ossl_time_zero();
 
     loss_delay = ossl_time_multiply(ossl_time_max(rtt.latest_rtt,
-                                                  rtt.smoothed_rtt),
-                                    K_TIME_THRESHOLD_NUM);
+                                        rtt.smoothed_rtt),
+        K_TIME_THRESHOLD_NUM);
     loss_delay = ossl_time_divide(loss_delay, K_TIME_THRESHOLD_DEN);
 
     /* Minimum time of K_GRANULARITY before packets are deemed lost. */
@@ -772,7 +774,7 @@ static OSSL_ACKM_TX_PKT *ackm_detect_and_remove_lost_pkts(OSSL_ACKM *ackm,
     now = ackm->now(ackm->now_arg);
     lost_send_time = ossl_time_subtract(now, loss_delay);
 
-    h   = get_tx_history(ackm, pkt_space);
+    h = get_tx_history(ackm, pkt_space);
     pkt = ossl_list_tx_history_head(&h->packets);
 
     for (; pkt != NULL; pkt = pnext) {
@@ -791,7 +793,7 @@ static OSSL_ACKM_TX_PKT *ackm_detect_and_remove_lost_pkts(OSSL_ACKM *ackm,
          * Mark packet as lost, or set time when it should be marked.
          */
         if (ossl_time_compare(pkt->time, lost_send_time) <= 0
-                || ackm->largest_acked_pkt[pkt_space]
+            || ackm->largest_acked_pkt[pkt_space]
                 >= pkt->pkt_num + K_PKT_THRESHOLD) {
             tx_pkt_history_remove(h, pkt->pkt_num);
 
@@ -800,12 +802,10 @@ static OSSL_ACKM_TX_PKT *ackm_detect_and_remove_lost_pkts(OSSL_ACKM *ackm,
             *fixup = NULL;
         } else {
             if (ossl_time_is_zero(ackm->loss_time[pkt_space]))
-                ackm->loss_time[pkt_space] =
-                    ossl_time_add(pkt->time, loss_delay);
+                ackm->loss_time[pkt_space] = ossl_time_add(pkt->time, loss_delay);
             else
-                ackm->loss_time[pkt_space] =
-                    ossl_time_min(ackm->loss_time[pkt_space],
-                                  ossl_time_add(pkt->time, loss_delay));
+                ackm->loss_time[pkt_space] = ossl_time_min(ackm->loss_time[pkt_space],
+                    ossl_time_add(pkt->time, loss_delay));
         }
     }
 
@@ -820,8 +820,8 @@ static OSSL_TIME ackm_get_loss_time_and_space(OSSL_ACKM *ackm, int *pspace)
     for (i = space + 1; i < QUIC_PN_SPACE_NUM; ++i)
         if (ossl_time_is_zero(time)
             || ossl_time_compare(ackm->loss_time[i], time) == -1) {
-            time    = ackm->loss_time[i];
-            space   = i;
+            time = ackm->loss_time[i];
+            space = i;
         }
 
     *pspace = space;
@@ -839,21 +839,21 @@ static OSSL_TIME ackm_get_pto_time_and_space(OSSL_ACKM *ackm, int *space)
 
     duration
         = ossl_time_add(rtt.smoothed_rtt,
-                        ossl_time_max(ossl_time_multiply(rtt.rtt_variance, 4),
-                                      ossl_ticks2time(K_GRANULARITY)));
+            ossl_time_max(ossl_time_multiply(rtt.rtt_variance, 4),
+                ossl_ticks2time(K_GRANULARITY)));
 
     duration
         = ossl_time_multiply(duration,
-                             (uint64_t)1 << min_u32(ackm->pto_count,
-                                                    MAX_PTO_COUNT));
+            (uint64_t)1 << min_u32(ackm->pto_count,
+                MAX_PTO_COUNT));
 
     /* Anti-deadlock PTO starts from the current time. */
     if (ackm_ack_eliciting_bytes_in_flight(ackm) == 0) {
         assert(!ackm->peer_completed_addr_validation);
 
         *space = ackm->discarded[QUIC_PN_SPACE_INITIAL]
-                    ? QUIC_PN_SPACE_HANDSHAKE
-                    : QUIC_PN_SPACE_INITIAL;
+            ? QUIC_PN_SPACE_HANDSHAKE
+            : QUIC_PN_SPACE_INITIAL;
         return ossl_time_add(ackm->now(ackm->now_arg), duration);
     }
 
@@ -863,8 +863,7 @@ static OSSL_TIME ackm_get_pto_time_and_space(OSSL_ACKM *ackm, int *space)
          * handshake is confirmed (client sees HANDSHAKE_DONE message
          * from server).
          */
-        if (ackm->ack_eliciting_bytes_in_flight[i] == 0 &&
-            (ackm->handshake_confirmed == 1 || ackm->is_server == 1))
+        if (ackm->ack_eliciting_bytes_in_flight[i] == 0 && (ackm->handshake_confirmed == 1 || ackm->is_server == 1))
             continue;
 
         if (i == QUIC_PN_SPACE_APP) {
@@ -879,8 +878,8 @@ static OSSL_TIME ackm_get_pto_time_and_space(OSSL_ACKM *ackm, int *space)
 
                 duration
                     = ossl_time_add(duration,
-                                    ossl_time_multiply(ackm->rx_max_ack_delay,
-                                                       factor));
+                        ossl_time_multiply(ackm->rx_max_ack_delay,
+                            factor));
             }
         }
 
@@ -894,7 +893,7 @@ static OSSL_TIME ackm_get_pto_time_and_space(OSSL_ACKM *ackm, int *space)
             t = ossl_time_add(ackm->time_of_last_ack_eliciting_pkt[i], duration);
             if (ossl_time_compare(t, pto_timeout) < 0) {
                 pto_timeout = t;
-                pto_space   = i;
+                pto_space = i;
             }
         }
     }
@@ -904,13 +903,13 @@ static OSSL_TIME ackm_get_pto_time_and_space(OSSL_ACKM *ackm, int *space)
 }
 
 static void ackm_set_loss_detection_timer_actual(OSSL_ACKM *ackm,
-                                                 OSSL_TIME deadline)
+    OSSL_TIME deadline)
 {
     ackm->loss_detection_deadline = deadline;
 
     if (ackm->loss_detection_deadline_cb != NULL)
         ackm->loss_detection_deadline_cb(deadline,
-                                         ackm->loss_detection_deadline_cb_arg);
+            ackm->loss_detection_deadline_cb_arg);
 }
 
 static int ackm_set_loss_detection_timer(OSSL_ACKM *ackm)
@@ -926,7 +925,7 @@ static int ackm_set_loss_detection_timer(OSSL_ACKM *ackm)
     }
 
     if (ackm_ack_eliciting_bytes_in_flight(ackm) == 0
-            && ackm->peer_completed_addr_validation) {
+        && ackm->peer_completed_addr_validation) {
         /*
          * Nothing to detect lost, so no timer is set. However, the client
          * needs to arm the timer if the server might be blocked by the
@@ -942,19 +941,19 @@ static int ackm_set_loss_detection_timer(OSSL_ACKM *ackm)
 }
 
 static int ackm_in_persistent_congestion(OSSL_ACKM *ackm,
-                                         const OSSL_ACKM_TX_PKT *lpkt)
+    const OSSL_ACKM_TX_PKT *lpkt)
 {
     /* TODO(QUIC FUTURE): Persistent congestion not currently implemented. */
     return 0;
 }
 
 static void ackm_on_pkts_lost(OSSL_ACKM *ackm, int pkt_space,
-                              const OSSL_ACKM_TX_PKT *lpkt, int pseudo)
+    const OSSL_ACKM_TX_PKT *lpkt, int pseudo)
 {
     const OSSL_ACKM_TX_PKT *p, *pnext;
     OSSL_RTT_INFO rtt;
     QUIC_PN largest_pn_lost = 0;
-    OSSL_CC_LOSS_INFO loss_info = {0};
+    OSSL_CC_LOSS_INFO loss_info = { 0 };
     uint32_t flags = 0;
 
     for (p = lpkt; p != NULL; p = pnext) {
@@ -1001,7 +1000,7 @@ static void ackm_on_pkts_acked(OSSL_ACKM *ackm, const OSSL_ACKM_TX_PKT *apkt)
 {
     const OSSL_ACKM_TX_PKT *anext;
     QUIC_PN last_pn_acked = 0;
-    OSSL_CC_ACK_INFO ainfo = {0};
+    OSSL_CC_ACK_INFO ainfo = { 0 };
 
     for (; apkt != NULL; apkt = anext) {
         if (apkt->is_inflight) {
@@ -1019,8 +1018,8 @@ static void ackm_on_pkts_acked(OSSL_ACKM *ackm, const OSSL_ACKM_TX_PKT *apkt)
                  * next time.
                  */
                 rx_pkt_history_bump_watermark(get_rx_history(ackm,
-                                                             apkt->pkt_space),
-                                              apkt->largest_acked + 1);
+                                                  apkt->pkt_space),
+                    apkt->largest_acked + 1);
         }
 
         ainfo.tx_time = apkt->time;
@@ -1035,11 +1034,11 @@ static void ackm_on_pkts_acked(OSSL_ACKM *ackm, const OSSL_ACKM_TX_PKT *apkt)
 }
 
 OSSL_ACKM *ossl_ackm_new(OSSL_TIME (*now)(void *arg),
-                         void *now_arg,
-                         OSSL_STATM *statm,
-                         const OSSL_CC_METHOD *cc_method,
-                         OSSL_CC_DATA *cc_data,
-                         int is_server)
+    void *now_arg,
+    OSSL_STATM *statm,
+    const OSSL_CC_METHOD *cc_method,
+    OSSL_CC_DATA *cc_data,
+    int is_server)
 {
     OSSL_ACKM *ackm;
     int i;
@@ -1058,11 +1057,11 @@ OSSL_ACKM *ossl_ackm_new(OSSL_TIME (*now)(void *arg),
     for (i = 0; i < (int)OSSL_NELEM(ackm->rx_history); ++i)
         rx_pkt_history_init(&ackm->rx_history[i]);
 
-    ackm->now       = now;
-    ackm->now_arg   = now_arg;
-    ackm->statm     = statm;
+    ackm->now = now;
+    ackm->now_arg = now_arg;
+    ackm->statm = statm;
     ackm->cc_method = cc_method;
-    ackm->cc_data   = cc_data;
+    ackm->cc_data = cc_data;
     ackm->is_server = (char)is_server;
 
     ackm->rx_max_ack_delay = ossl_ms2time(QUIC_DEFAULT_MAX_ACK_DELAY);
@@ -1101,7 +1100,8 @@ int ossl_ackm_on_tx_packet(OSSL_ACKM *ackm, OSSL_ACKM_TX_PKT *pkt)
     /* Time must be set and not move backwards. */
     if (ossl_time_is_zero(pkt->time)
         || ossl_time_compare(ackm->time_of_last_ack_eliciting_pkt[pkt->pkt_space],
-                             pkt->time) > 0)
+               pkt->time)
+            > 0)
         return 0;
 
     /* Must have non-zero number of bytes. */
@@ -1138,11 +1138,11 @@ int ossl_ackm_on_rx_datagram(OSSL_ACKM *ackm, size_t num_bytes)
 }
 
 static void ackm_process_ecn(OSSL_ACKM *ackm, const OSSL_QUIC_FRAME_ACK *ack,
-                             int pkt_space)
+    int pkt_space)
 {
     struct tx_pkt_history_st *h;
     OSSL_ACKM_TX_PKT *pkt;
-    OSSL_CC_ECN_INFO ecn_info = {0};
+    OSSL_CC_ECN_INFO ecn_info = { 0 };
 
     /*
      * If the ECN-CE counter reported by the peer has increased, this could
@@ -1162,7 +1162,7 @@ static void ackm_process_ecn(OSSL_ACKM *ackm, const OSSL_QUIC_FRAME_ACK *ack,
 }
 
 int ossl_ackm_on_rx_ack_frame(OSSL_ACKM *ackm, const OSSL_QUIC_FRAME_ACK *ack,
-                              int pkt_space, OSSL_TIME rx_time)
+    int pkt_space, OSSL_TIME rx_time)
 {
     OSSL_ACKM_TX_PKT *na_pkts, *lost_pkts;
     int must_set_timer = 0;
@@ -1172,14 +1172,14 @@ int ossl_ackm_on_rx_ack_frame(OSSL_ACKM *ackm, const OSSL_QUIC_FRAME_ACK *ack,
     else
         ackm->largest_acked_pkt[pkt_space]
             = ossl_quic_pn_max(ackm->largest_acked_pkt[pkt_space],
-                               ack->ack_ranges[0].end);
+                ack->ack_ranges[0].end);
 
     /*
      * If we get an ACK in the handshake space, address validation is completed.
      * Make sure we update the timer, even if no packets were ACK'd.
      */
     if (!ackm->peer_completed_addr_validation
-            && pkt_space == QUIC_PN_SPACE_HANDSHAKE) {
+        && pkt_space == QUIC_PN_SPACE_HANDSHAKE) {
         ackm->peer_completed_addr_validation = 1;
         must_set_timer = 1;
     }
@@ -1201,8 +1201,7 @@ int ossl_ackm_on_rx_ack_frame(OSSL_ACKM *ackm, const OSSL_QUIC_FRAME_ACK *ack,
      *
      * First packet in the list is always the one with the largest PN.
      */
-    if (na_pkts->pkt_num == ack->ack_ranges[0].end &&
-        ack_includes_ack_eliciting(na_pkts)) {
+    if (na_pkts->pkt_num == ack->ack_ranges[0].end && ack_includes_ack_eliciting(na_pkts)) {
         OSSL_TIME now = ackm->now(ackm->now_arg), ack_delay;
         if (ossl_time_is_zero(ackm->first_rtt_sample))
             ackm->first_rtt_sample = now;
@@ -1213,7 +1212,7 @@ int ossl_ackm_on_rx_ack_frame(OSSL_ACKM *ackm, const OSSL_QUIC_FRAME_ACK *ack,
             ack_delay = ossl_time_min(ack_delay, ackm->rx_max_ack_delay);
 
         ossl_statm_update_rtt(ackm->statm, ack_delay,
-                              ossl_time_subtract(now, na_pkts->time));
+            ossl_time_subtract(now, na_pkts->time));
     }
 
     /*
@@ -1256,7 +1255,7 @@ int ossl_ackm_on_pkt_space_discarded(OSSL_ACKM *ackm, int pkt_space)
         ackm->peer_completed_addr_validation = 1;
 
     for (pkt = ossl_list_tx_history_head(&get_tx_history(ackm, pkt_space)->packets);
-            pkt != NULL; pkt = pnext) {
+        pkt != NULL; pkt = pnext) {
         pnext = ossl_list_tx_history_next(pkt);
         if (pkt->is_inflight) {
             ackm->bytes_in_flight -= pkt->num_bytes;
@@ -1271,7 +1270,7 @@ int ossl_ackm_on_pkt_space_discarded(OSSL_ACKM *ackm, int pkt_space)
 
     if (num_bytes_invalidated > 0)
         ackm->cc_method->on_data_invalidated(ackm->cc_data,
-                                             num_bytes_invalidated);
+            num_bytes_invalidated);
 
     ackm->time_of_last_ack_eliciting_pkt[pkt_space] = ossl_time_zero();
     ackm->loss_time[pkt_space] = ossl_time_zero();
@@ -1284,8 +1283,8 @@ int ossl_ackm_on_pkt_space_discarded(OSSL_ACKM *ackm, int pkt_space)
 
 int ossl_ackm_on_handshake_confirmed(OSSL_ACKM *ackm)
 {
-    ackm->handshake_confirmed               = 1;
-    ackm->peer_completed_addr_validation    = 1;
+    ackm->handshake_confirmed = 1;
+    ackm->peer_completed_addr_validation = 1;
     ackm_set_loss_detection_timer(ackm);
     return 1;
 }
@@ -1378,7 +1377,7 @@ int ossl_ackm_get_largest_unacked(OSSL_ACKM *ackm, int pkt_space, QUIC_PN *pn)
 }
 
 /* Number of ACK-eliciting packets RX'd before we always emit an ACK. */
-#define PKTS_BEFORE_ACK     2
+#define PKTS_BEFORE_ACK 2
 
 /*
  * Return 1 if emission of an ACK frame is currently desired.
@@ -1400,7 +1399,8 @@ int ossl_ackm_is_ack_desired(OSSL_ACKM *ackm, int pkt_space)
     return ackm->rx_ack_desired[pkt_space]
         || (!ossl_time_is_infinite(ackm->rx_ack_flush_deadline[pkt_space])
             && ossl_time_compare(ackm->now(ackm->now_arg),
-                                 ackm->rx_ack_flush_deadline[pkt_space]) >= 0);
+                   ackm->rx_ack_flush_deadline[pkt_space])
+                >= 0);
 }
 
 /*
@@ -1459,19 +1459,19 @@ static int ackm_has_newly_missing(OSSL_ACKM *ackm, int pkt_space)
      */
     return ackm->ack[pkt_space].num_ack_ranges > 0
         && ossl_list_uint_set_tail(&h->set)->range.start
-           == ossl_list_uint_set_tail(&h->set)->range.end
+        == ossl_list_uint_set_tail(&h->set)->range.end
         && ossl_list_uint_set_tail(&h->set)->range.start
-            > ackm->ack[pkt_space].ack_ranges[0].end + 1;
+        > ackm->ack[pkt_space].ack_ranges[0].end + 1;
 }
 
 static void ackm_set_flush_deadline(OSSL_ACKM *ackm, int pkt_space,
-                                    OSSL_TIME deadline)
+    OSSL_TIME deadline)
 {
     ackm->rx_ack_flush_deadline[pkt_space] = deadline;
 
     if (ackm->ack_deadline_cb != NULL)
         ackm->ack_deadline_cb(ossl_ackm_get_ack_deadline(ackm, pkt_space),
-                              pkt_space, ackm->ack_deadline_cb_arg);
+            pkt_space, ackm->ack_deadline_cb_arg);
 }
 
 /* Explicitly flags that we want to generate an ACK frame. */
@@ -1484,8 +1484,8 @@ static void ackm_queue_ack(OSSL_ACKM *ackm, int pkt_space)
 }
 
 static void ackm_on_rx_ack_eliciting(OSSL_ACKM *ackm,
-                                     OSSL_TIME rx_time, int pkt_space,
-                                     int was_missing)
+    OSSL_TIME rx_time, int pkt_space,
+    int was_missing)
 {
     OSSL_TIME tx_max_ack_delay;
 
@@ -1496,10 +1496,10 @@ static void ackm_on_rx_ack_eliciting(OSSL_ACKM *ackm,
     ++ackm->rx_ack_eliciting_pkts_since_last_ack[pkt_space];
 
     if (!ackm->rx_ack_generated[pkt_space]
-            || was_missing
-            || ackm->rx_ack_eliciting_pkts_since_last_ack[pkt_space]
-                >= PKTS_BEFORE_ACK
-            || ackm_has_newly_missing(ackm, pkt_space)) {
+        || was_missing
+        || ackm->rx_ack_eliciting_pkts_since_last_ack[pkt_space]
+            >= PKTS_BEFORE_ACK
+        || ackm_has_newly_missing(ackm, pkt_space)) {
         /*
          * Either:
          *
@@ -1542,12 +1542,12 @@ static void ackm_on_rx_ack_eliciting(OSSL_ACKM *ackm,
 
     if (ossl_time_is_infinite(ackm->rx_ack_flush_deadline[pkt_space]))
         ackm_set_flush_deadline(ackm, pkt_space,
-                                ossl_time_add(rx_time, tx_max_ack_delay));
+            ossl_time_add(rx_time, tx_max_ack_delay));
     else
         ackm_set_flush_deadline(ackm, pkt_space,
-                                ossl_time_min(ackm->rx_ack_flush_deadline[pkt_space],
-                                              ossl_time_add(rx_time,
-                                                            tx_max_ack_delay)));
+            ossl_time_min(ackm->rx_ack_flush_deadline[pkt_space],
+                ossl_time_add(rx_time,
+                    tx_max_ack_delay)));
 }
 
 int ossl_ackm_on_rx_packet(OSSL_ACKM *ackm, const OSSL_ACKM_RX_PKT *pkt)
@@ -1564,7 +1564,7 @@ int ossl_ackm_on_rx_packet(OSSL_ACKM *ackm, const OSSL_ACKM_RX_PKT *pkt)
      * We use this to calculate the ACK delay field of ACK frames.
      */
     if (pkt->pkt_num > ackm->rx_largest_pn[pkt->pkt_space]) {
-        ackm->rx_largest_pn[pkt->pkt_space]   = pkt->pkt_num;
+        ackm->rx_largest_pn[pkt->pkt_space] = pkt->pkt_num;
         ackm->rx_largest_time[pkt->pkt_space] = pkt->time;
     }
 
@@ -1610,7 +1610,7 @@ int ossl_ackm_on_rx_packet(OSSL_ACKM *ackm, const OSSL_ACKM_RX_PKT *pkt)
 }
 
 static void ackm_fill_rx_ack_ranges(OSSL_ACKM *ackm, int pkt_space,
-                                    OSSL_QUIC_FRAME_ACK *ack)
+    OSSL_QUIC_FRAME_ACK *ack)
 {
     struct rx_pkt_history_st *h = get_rx_history(ackm, pkt_space);
     UINT_SET_ITEM *x;
@@ -1621,18 +1621,18 @@ static void ackm_fill_rx_ack_ranges(OSSL_ACKM *ackm, int pkt_space,
      * maximum number of ranges.
      */
     for (x = ossl_list_uint_set_tail(&h->set);
-         x != NULL && i < OSSL_NELEM(ackm->ack_ranges);
-         x = ossl_list_uint_set_prev(x), ++i) {
+        x != NULL && i < OSSL_NELEM(ackm->ack_ranges);
+        x = ossl_list_uint_set_prev(x), ++i) {
         ackm->ack_ranges[pkt_space][i].start = x->range.start;
-        ackm->ack_ranges[pkt_space][i].end   = x->range.end;
+        ackm->ack_ranges[pkt_space][i].end = x->range.end;
     }
 
-    ack->ack_ranges     = ackm->ack_ranges[pkt_space];
+    ack->ack_ranges = ackm->ack_ranges[pkt_space];
     ack->num_ack_ranges = i;
 }
 
 const OSSL_QUIC_FRAME_ACK *ossl_ackm_get_ack_frame(OSSL_ACKM *ackm,
-                                                   int pkt_space)
+    int pkt_space)
 {
     OSSL_QUIC_FRAME_ACK *ack = &ackm->ack[pkt_space];
     OSSL_TIME now = ackm->now(ackm->now_arg);
@@ -1640,27 +1640,25 @@ const OSSL_QUIC_FRAME_ACK *ossl_ackm_get_ack_frame(OSSL_ACKM *ackm,
     ackm_fill_rx_ack_ranges(ackm, pkt_space, ack);
 
     if (!ossl_time_is_zero(ackm->rx_largest_time[pkt_space])
-            && ossl_time_compare(now, ackm->rx_largest_time[pkt_space]) > 0
-            && pkt_space == QUIC_PN_SPACE_APP)
-        ack->delay_time =
-            ossl_time_subtract(now, ackm->rx_largest_time[pkt_space]);
+        && ossl_time_compare(now, ackm->rx_largest_time[pkt_space]) > 0
+        && pkt_space == QUIC_PN_SPACE_APP)
+        ack->delay_time = ossl_time_subtract(now, ackm->rx_largest_time[pkt_space]);
     else
         ack->delay_time = ossl_time_zero();
 
-    ack->ect0              = ackm->rx_ect0[pkt_space];
-    ack->ect1              = ackm->rx_ect1[pkt_space];
-    ack->ecnce             = ackm->rx_ecnce[pkt_space];
-    ack->ecn_present       = 1;
+    ack->ect0 = ackm->rx_ect0[pkt_space];
+    ack->ect1 = ackm->rx_ect1[pkt_space];
+    ack->ecnce = ackm->rx_ecnce[pkt_space];
+    ack->ecn_present = 1;
 
     ackm->rx_ack_eliciting_pkts_since_last_ack[pkt_space] = 0;
 
-    ackm->rx_ack_generated[pkt_space]       = 1;
-    ackm->rx_ack_desired[pkt_space]         = 0;
+    ackm->rx_ack_generated[pkt_space] = 1;
+    ackm->rx_ack_desired[pkt_space] = 0;
     ackm_set_flush_deadline(ackm, pkt_space, ossl_time_infinite());
     return ack;
 }
 
-
 OSSL_TIME ossl_ackm_get_ack_deadline(OSSL_ACKM *ackm, int pkt_space)
 {
     if (ackm->rx_ack_desired[pkt_space])
@@ -1678,26 +1676,26 @@ int ossl_ackm_is_rx_pn_processable(OSSL_ACKM *ackm, QUIC_PN pn, int pkt_space)
 }
 
 void ossl_ackm_set_loss_detection_deadline_callback(OSSL_ACKM *ackm,
-                                                    void (*fn)(OSSL_TIME deadline,
-                                                               void *arg),
-                                                    void *arg)
+    void (*fn)(OSSL_TIME deadline,
+        void *arg),
+    void *arg)
 {
-    ackm->loss_detection_deadline_cb      = fn;
-    ackm->loss_detection_deadline_cb_arg  = arg;
+    ackm->loss_detection_deadline_cb = fn;
+    ackm->loss_detection_deadline_cb_arg = arg;
 }
 
 void ossl_ackm_set_ack_deadline_callback(OSSL_ACKM *ackm,
-                                         void (*fn)(OSSL_TIME deadline,
-                                                    int pkt_space,
-                                                    void *arg),
-                                         void *arg)
+    void (*fn)(OSSL_TIME deadline,
+        int pkt_space,
+        void *arg),
+    void *arg)
 {
-    ackm->ack_deadline_cb     = fn;
+    ackm->ack_deadline_cb = fn;
     ackm->ack_deadline_cb_arg = arg;
 }
 
 int ossl_ackm_mark_packet_pseudo_lost(OSSL_ACKM *ackm,
-                                      int pkt_space, QUIC_PN pn)
+    int pkt_space, QUIC_PN pn)
 {
     struct tx_pkt_history_st *h = get_tx_history(ackm, pkt_space);
     OSSL_ACKM_TX_PKT *pkt;
@@ -1720,8 +1718,8 @@ OSSL_TIME ossl_ackm_get_pto_duration(OSSL_ACKM *ackm)
     ossl_statm_get_rtt_info(ackm->statm, &rtt);
 
     duration = ossl_time_add(rtt.smoothed_rtt,
-                             ossl_time_max(ossl_time_multiply(rtt.rtt_variance, 4),
-                                           ossl_ticks2time(K_GRANULARITY)));
+        ossl_time_max(ossl_time_multiply(rtt.rtt_variance, 4),
+            ossl_ticks2time(K_GRANULARITY)));
     if (!ossl_time_is_infinite(ackm->rx_max_ack_delay))
         duration = ossl_time_add(duration, ackm->rx_max_ack_delay);
 
diff --git a/crypto/openssl/ssl/quic/quic_cfq.c b/crypto/openssl/ssl/quic/quic_cfq.c
index fb96e0c68cc1..3c59234ff0ff 100644
--- a/crypto/openssl/ssl/quic/quic_cfq.c
+++ b/crypto/openssl/ssl/quic/quic_cfq.c
@@ -13,15 +13,15 @@
 typedef struct quic_cfq_item_ex_st QUIC_CFQ_ITEM_EX;
 
 struct quic_cfq_item_ex_st {
-    QUIC_CFQ_ITEM           public;
-    QUIC_CFQ_ITEM_EX       *prev, *next;
-    unsigned char          *encoded;
-    cfq_free_cb            *free_cb;
-    void                   *free_cb_arg;
-    uint64_t                frame_type;
-    size_t                  encoded_len;
-    uint32_t                priority, pn_space, flags;
-    int                     state;
+    QUIC_CFQ_ITEM public;
+    QUIC_CFQ_ITEM_EX *prev, *next;
+    unsigned char *encoded;
+    cfq_free_cb *free_cb;
+    void *free_cb_arg;
+    uint64_t frame_type;
+    size_t encoded_len;
+    uint32_t priority, pn_space, flags;
+    int state;
 };
 
 uint64_t ossl_quic_cfq_item_get_frame_type(const QUIC_CFQ_ITEM *item)
@@ -78,7 +78,7 @@ struct quic_cfq_st {
      * Invariant: The list the CFQ item is determined exactly by the state field
      * of the item.
      */
-    QUIC_CFQ_ITEM_LIST                      new_list, tx_list, free_list;
+    QUIC_CFQ_ITEM_LIST new_list, tx_list, free_list;
 };
 
 static int compare(const QUIC_CFQ_ITEM_EX *a, const QUIC_CFQ_ITEM_EX *b)
@@ -132,8 +132,8 @@ static void list_insert_tail(QUIC_CFQ_ITEM_LIST *l, QUIC_CFQ_ITEM_EX *n)
 }
 
 static void list_insert_after(QUIC_CFQ_ITEM_LIST *l,
-                              QUIC_CFQ_ITEM_EX *ref,
-                              QUIC_CFQ_ITEM_EX *n)
+    QUIC_CFQ_ITEM_EX *ref,
+    QUIC_CFQ_ITEM_EX *n)
 {
     n->prev = ref;
     n->next = ref->next;
@@ -145,8 +145,8 @@ static void list_insert_after(QUIC_CFQ_ITEM_LIST *l,
 }
 
 static void list_insert_sorted(QUIC_CFQ_ITEM_LIST *l, QUIC_CFQ_ITEM_EX *n,
-                               int (*cmp)(const QUIC_CFQ_ITEM_EX *a,
-                                          const QUIC_CFQ_ITEM_EX *b))
+    int (*cmp)(const QUIC_CFQ_ITEM_EX *a,
+        const QUIC_CFQ_ITEM_EX *b))
 {
     QUIC_CFQ_ITEM_EX *p = l->head, *pprev = NULL;
 
@@ -156,7 +156,8 @@ static void list_insert_sorted(QUIC_CFQ_ITEM_LIST *l, QUIC_CFQ_ITEM_EX *n,
         return;
     }
 
-    for (; p != NULL && cmp(p, n) < 0; pprev = p, p = p->next);
+    for (; p != NULL && cmp(p, n) < 0; pprev = p, p = p->next)
+        ;
 
     if (p == NULL)
         list_insert_tail(l, n);
@@ -181,9 +182,9 @@ static void clear_item(QUIC_CFQ_ITEM_EX *item)
     if (item->free_cb != NULL) {
         item->free_cb(item->encoded, item->encoded_len, item->free_cb_arg);
 
-        item->free_cb       = NULL;
-        item->encoded       = NULL;
-        item->encoded_len   = 0;
+        item->free_cb = NULL;
+        item->encoded = NULL;
+        item->encoded_len = 0;
     }
 
     item->state = -1;
@@ -227,28 +228,28 @@ static QUIC_CFQ_ITEM_EX *cfq_get_free(QUIC_CFQ *cfq)
     return item;
 }
 
-QUIC_CFQ_ITEM *ossl_quic_cfq_add_frame(QUIC_CFQ            *cfq,
-                                       uint32_t             priority,
-                                       uint32_t             pn_space,
-                                       uint64_t             frame_type,
-                                       uint32_t             flags,
-                                       const unsigned char *encoded,
-                                       size_t               encoded_len,
-                                       cfq_free_cb         *free_cb,
-                                       void                *free_cb_arg)
+QUIC_CFQ_ITEM *ossl_quic_cfq_add_frame(QUIC_CFQ *cfq,
+    uint32_t priority,
+    uint32_t pn_space,
+    uint64_t frame_type,
+    uint32_t flags,
+    const unsigned char *encoded,
+    size_t encoded_len,
+    cfq_free_cb *free_cb,
+    void *free_cb_arg)
 {
     QUIC_CFQ_ITEM_EX *item = cfq_get_free(cfq);
 
     if (item == NULL)
         return NULL;
 
-    item->priority      = priority;
-    item->frame_type    = frame_type;
-    item->pn_space      = pn_space;
-    item->encoded       = (unsigned char *)encoded;
-    item->encoded_len   = encoded_len;
-    item->free_cb       = free_cb;
-    item->free_cb_arg   = free_cb_arg;
+    item->priority = priority;
+    item->frame_type = frame_type;
+    item->pn_space = pn_space;
+    item->encoded = (unsigned char *)encoded;
+    item->encoded_len = encoded_len;
+    item->free_cb = free_cb;
+    item->free_cb_arg = free_cb_arg;
 
     item->state = QUIC_CFQ_STATE_NEW;
     item->flags = flags;
@@ -276,7 +277,7 @@ void ossl_quic_cfq_mark_tx(QUIC_CFQ *cfq, QUIC_CFQ_ITEM *item)
 }
 
 void ossl_quic_cfq_mark_lost(QUIC_CFQ *cfq, QUIC_CFQ_ITEM *item,
-                             uint32_t priority)
+    uint32_t priority)
 {
     QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item;
 
@@ -332,11 +333,12 @@ void ossl_quic_cfq_release(QUIC_CFQ *cfq, QUIC_CFQ_ITEM *item)
 }
 
 QUIC_CFQ_ITEM *ossl_quic_cfq_get_priority_head(const QUIC_CFQ *cfq,
-                                               uint32_t pn_space)
+    uint32_t pn_space)
 {
     QUIC_CFQ_ITEM_EX *item = cfq->new_list.head;
 
-    for (; item != NULL && item->pn_space != pn_space; item = item->next);
+    for (; item != NULL && item->pn_space != pn_space; item = item->next)
+        ;
 
     if (item == NULL)
         return NULL;
@@ -345,19 +347,20 @@ QUIC_CFQ_ITEM *ossl_quic_cfq_get_priority_head(const QUIC_CFQ *cfq,
 }
 
 QUIC_CFQ_ITEM *ossl_quic_cfq_item_get_priority_next(const QUIC_CFQ_ITEM *item,
-                                                    uint32_t pn_space)
+    uint32_t pn_space)
 {
     QUIC_CFQ_ITEM_EX *ex = (QUIC_CFQ_ITEM_EX *)item;
 
     if (ex == NULL)
         return NULL;
 
-     ex = ex->next;
+    ex = ex->next;
 
-     for (; ex != NULL && ex->pn_space != pn_space; ex = ex->next);
+    for (; ex != NULL && ex->pn_space != pn_space; ex = ex->next)
+        ;
 
-     if (ex == NULL)
-         return NULL; /* ubsan */
+    if (ex == NULL)
+        return NULL; /* ubsan */
 
-     return &ex->public;
+    return &ex->public;
 }
diff --git a/crypto/openssl/ssl/quic/quic_channel.c b/crypto/openssl/ssl/quic/quic_channel.c
index 652c653b9120..13692e5bd09e 100644
--- a/crypto/openssl/ssl/quic/quic_channel.c
+++ b/crypto/openssl/ssl/quic/quic_channel.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022-2025 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2022-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy
@@ -24,9 +24,9 @@
 #include "quic_port_local.h"
 #include "quic_engine_local.h"
 
-#define INIT_CRYPTO_RECV_BUF_LEN    16384
-#define INIT_CRYPTO_SEND_BUF_LEN    16384
-#define INIT_APP_BUF_LEN             8192
+#define INIT_CRYPTO_RECV_BUF_LEN 16384
+#define INIT_CRYPTO_SEND_BUF_LEN 16384
+#define INIT_APP_BUF_LEN 8192
 
 /*
  * Interval before we force a PING to ensure NATs don't timeout. This is based
@@ -41,7 +41,7 @@
  * value which determines the value of the maximum ACK delay if the
  * max_ack_delay transport parameter is not set.
  */
-#define DEFAULT_MAX_ACK_DELAY   QUIC_DEFAULT_MAX_ACK_DELAY
+#define DEFAULT_MAX_ACK_DELAY QUIC_DEFAULT_MAX_ACK_DELAY
 
 DEFINE_LIST_OF_IMPL(ch, QUIC_CHANNEL);
 
@@ -52,53 +52,51 @@ static int ch_tick_tls(QUIC_CHANNEL *ch, int channel_only, int *notify_other_thr
 static void ch_rx_handle_packet(QUIC_CHANNEL *ch, int channel_only);
 static OSSL_TIME ch_determine_next_tick_deadline(QUIC_CHANNEL *ch);
 static int ch_retry(QUIC_CHANNEL *ch,
-                    const unsigned char *retry_token,
-                    size_t retry_token_len,
-                    const QUIC_CONN_ID *retry_scid,
-                    int drop_later_pn);
+    const unsigned char *retry_token,
+    size_t retry_token_len,
+    const QUIC_CONN_ID *retry_scid,
+    int drop_later_pn);
 static int ch_restart(QUIC_CHANNEL *ch);
 
 static void ch_cleanup(QUIC_CHANNEL *ch);
 static int ch_generate_transport_params(QUIC_CHANNEL *ch);
 static int ch_on_transport_params(const unsigned char *params,
-                                  size_t params_len,
-                                  void *arg);
+    size_t params_len,
+    void *arg);
 static int ch_on_handshake_alert(void *arg, unsigned char alert_code);
 static int ch_on_handshake_complete(void *arg);
 static int ch_on_handshake_yield_secret(uint32_t prot_level, int direction,
-                                        uint32_t suite_id, EVP_MD *md,
-                                        const unsigned char *secret,
-                                        size_t secret_len,
-                                        void *arg);
+    uint32_t suite_id, EVP_MD *md,
+    const unsigned char *secret,
+    size_t secret_len,
+    void *arg);
 static int ch_on_crypto_recv_record(const unsigned char **buf,
-                                    size_t *bytes_read, void *arg);
+    size_t *bytes_read, void *arg);
 static int ch_on_crypto_release_record(size_t bytes_read, void *arg);
 static int crypto_ensure_empty(QUIC_RSTREAM *rstream);
 static int ch_on_crypto_send(const unsigned char *buf, size_t buf_len,
-                             size_t *consumed, void *arg);
+    size_t *consumed, void *arg);
 static OSSL_TIME get_time(void *arg);
 static uint64_t get_stream_limit(int uni, void *arg);
 static int rx_late_validate(QUIC_PN pn, int pn_space, void *arg);
 static void rxku_detected(QUIC_PN pn, void *arg);
 static int ch_retry(QUIC_CHANNEL *ch,
-                    const unsigned char *retry_token,
-                    size_t retry_token_len,
-                    const QUIC_CONN_ID *retry_scid,
-                    int drop_later_pn);
+    const unsigned char *retry_token,
+    size_t retry_token_len,
+    const QUIC_CONN_ID *retry_scid,
+    int drop_later_pn);
 static void ch_update_idle(QUIC_CHANNEL *ch);
 static int ch_discard_el(QUIC_CHANNEL *ch,
-                         uint32_t enc_level);
+    uint32_t enc_level);
 static void ch_on_idle_timeout(QUIC_CHANNEL *ch);
 static void ch_update_idle(QUIC_CHANNEL *ch);
 static void ch_update_ping_deadline(QUIC_CHANNEL *ch);
 static void ch_on_terminating_timeout(QUIC_CHANNEL *ch);
 static void ch_start_terminating(QUIC_CHANNEL *ch,
-                                 const QUIC_TERMINATE_CAUSE *tcause,
-                                 int force_immediate);
+    const QUIC_TERMINATE_CAUSE *tcause,
+    int force_immediate);
 static void ch_on_txp_ack_tx(const OSSL_QUIC_FRAME_ACK *ack, uint32_t pn_space,
-                             void *arg);
-static void ch_rx_handle_version_neg(QUIC_CHANNEL *ch, OSSL_QRX_PKT *pkt);
-static void ch_raise_version_neg_failure(QUIC_CHANNEL *ch);
+    void *arg);
 static void ch_record_state_transition(QUIC_CHANNEL *ch, uint32_t new_state);
 
 DEFINE_LHASH_OF_EX(QUIC_SRT_ELEM);
@@ -107,7 +105,7 @@ QUIC_NEEDS_LOCK
 static QLOG *ch_get_qlog(QUIC_CHANNEL *ch)
 {
 #ifndef OPENSSL_NO_QLOG
-    QLOG_TRACE_INFO qti = {0};
+    QLOG_TRACE_INFO qti = { 0 };
 
     if (ch->qlog != NULL)
         return ch->qlog;
@@ -118,13 +116,13 @@ static QLOG *ch_get_qlog(QUIC_CHANNEL *ch)
     if (ch->is_server && ch->init_dcid.id_len == 0)
         return NULL;
 
-    qti.odcid       = ch->init_dcid;
-    qti.title       = ch->qlog_title;
+    qti.odcid = ch->init_dcid;
+    qti.title = ch->qlog_title;
     qti.description = NULL;
-    qti.group_id    = NULL;
-    qti.is_server   = ch->is_server;
-    qti.now_cb      = get_time;
-    qti.now_cb_arg  = ch;
+    qti.group_id = NULL;
+    qti.is_server = ch->is_server;
+    qti.now_cb = get_time;
+    qti.now_cb_arg = ch;
     if ((ch->qlog = ossl_qlog_new_from_env(&qti)) == NULL) {
         ch->use_qlog = 0; /* don't try again */
         return NULL;
@@ -148,20 +146,20 @@ static QLOG *ch_get_qlog_cb(void *arg)
  * QUIC Channel Initialization and Teardown
  * ========================================
  */
-#define DEFAULT_INIT_CONN_RXFC_WND      (768 * 1024)
-#define DEFAULT_CONN_RXFC_MAX_WND_MUL   20
+#define DEFAULT_INIT_CONN_RXFC_WND (768 * 1024)
+#define DEFAULT_CONN_RXFC_MAX_WND_MUL 20
 
-#define DEFAULT_INIT_STREAM_RXFC_WND    (512 * 1024)
+#define DEFAULT_INIT_STREAM_RXFC_WND (512 * 1024)
 #define DEFAULT_STREAM_RXFC_MAX_WND_MUL 12
 
-#define DEFAULT_INIT_CONN_MAX_STREAMS           100
+#define DEFAULT_INIT_CONN_MAX_STREAMS 100
 
 static int ch_init(QUIC_CHANNEL *ch)
 {
-    OSSL_QUIC_TX_PACKETISER_ARGS txp_args = {0};
-    OSSL_QTX_ARGS qtx_args = {0};
-    OSSL_QRX_ARGS qrx_args = {0};
-    QUIC_TLS_ARGS tls_args = {0};
+    OSSL_QUIC_TX_PACKETISER_ARGS txp_args = { 0 };
+    OSSL_QTX_ARGS qtx_args = { 0 };
+    OSSL_QRX_ARGS qrx_args = { 0 };
+    QUIC_TLS_ARGS tls_args = { 0 };
     uint32_t pn_space;
     size_t rx_short_dcid_len;
     size_t tx_init_dcid_len;
@@ -175,14 +173,14 @@ static int ch_init(QUIC_CHANNEL *ch)
     /* For clients, generate our initial DCID. */
     if (!ch->is_server
         && !ossl_quic_gen_rand_conn_id(ch->port->engine->libctx, tx_init_dcid_len,
-                                       &ch->init_dcid))
+            &ch->init_dcid))
         goto err;
 
     /* We plug in a network write BIO to the QTX later when we get one. */
-    qtx_args.libctx             = ch->port->engine->libctx;
-    qtx_args.get_qlog_cb        = ch_get_qlog_cb;
-    qtx_args.get_qlog_cb_arg    = ch;
-    qtx_args.mdpl               = QUIC_MIN_INITIAL_DGRAM_LEN;
+    qtx_args.libctx = ch->port->engine->libctx;
+    qtx_args.get_qlog_cb = ch_get_qlog_cb;
+    qtx_args.get_qlog_cb_arg = ch;
+    qtx_args.mdpl = QUIC_MIN_INITIAL_DGRAM_LEN;
     ch->rx_max_udp_payload_size = qtx_args.mdpl;
 
     ch->ping_deadline = ossl_time_infinite();
@@ -206,31 +204,30 @@ static int ch_init(QUIC_CHANNEL *ch)
      * Note: The TP we transmit governs what the peer can transmit and thus
      * applies to the RXFC.
      */
-    ch->tx_init_max_stream_data_bidi_local  = DEFAULT_INIT_STREAM_RXFC_WND;
+    ch->tx_init_max_stream_data_bidi_local = DEFAULT_INIT_STREAM_RXFC_WND;
     ch->tx_init_max_stream_data_bidi_remote = DEFAULT_INIT_STREAM_RXFC_WND;
-    ch->tx_init_max_stream_data_uni         = DEFAULT_INIT_STREAM_RXFC_WND;
+    ch->tx_init_max_stream_data_uni = DEFAULT_INIT_STREAM_RXFC_WND;
 
     if (!ossl_quic_rxfc_init(&ch->conn_rxfc, NULL,
-                             DEFAULT_INIT_CONN_RXFC_WND,
-                             DEFAULT_CONN_RXFC_MAX_WND_MUL *
-                             DEFAULT_INIT_CONN_RXFC_WND,
-                             get_time, ch))
+            DEFAULT_INIT_CONN_RXFC_WND,
+            DEFAULT_CONN_RXFC_MAX_WND_MUL * DEFAULT_INIT_CONN_RXFC_WND,
+            get_time, ch))
         goto err;
 
     for (pn_space = QUIC_PN_SPACE_INITIAL; pn_space < QUIC_PN_SPACE_NUM; ++pn_space)
         if (!ossl_quic_rxfc_init_standalone(&ch->crypto_rxfc[pn_space],
-                                            INIT_CRYPTO_RECV_BUF_LEN,
-                                            get_time, ch))
+                INIT_CRYPTO_RECV_BUF_LEN,
+                get_time, ch))
             goto err;
 
     if (!ossl_quic_rxfc_init_standalone(&ch->max_streams_bidi_rxfc,
-                                        DEFAULT_INIT_CONN_MAX_STREAMS,
-                                        get_time, ch))
+            DEFAULT_INIT_CONN_MAX_STREAMS,
+            get_time, ch))
         goto err;
 
     if (!ossl_quic_rxfc_init_standalone(&ch->max_streams_uni_rxfc,
-                                        DEFAULT_INIT_CONN_MAX_STREAMS,
-                                        get_time, ch))
+            DEFAULT_INIT_CONN_MAX_STREAMS,
+            get_time, ch))
         goto err;
 
     if (!ossl_statm_init(&ch->statm))
@@ -242,14 +239,15 @@ static int ch_init(QUIC_CHANNEL *ch)
         goto err;
 
     if ((ch->ackm = ossl_ackm_new(get_time, ch, &ch->statm,
-                                  ch->cc_method, ch->cc_data,
-                                  ch->is_server)) == NULL)
+             ch->cc_method, ch->cc_data,
+             ch->is_server))
+        == NULL)
         goto err;
 
     if (!ossl_quic_stream_map_init(&ch->qsm, get_stream_limit, ch,
-                                   &ch->max_streams_bidi_rxfc,
-                                   &ch->max_streams_uni_rxfc,
-                                   ch->is_server))
+            &ch->max_streams_bidi_rxfc,
+            &ch->max_streams_uni_rxfc,
+            ch->is_server))
         goto err;
 
     ch->have_qsm = 1;
@@ -258,25 +256,25 @@ static int ch_init(QUIC_CHANNEL *ch)
         && !ossl_quic_lcidm_generate_initial(ch->lcidm, ch, &ch->init_scid))
         goto err;
 
-    txp_args.cur_scid               = ch->init_scid;
-    txp_args.cur_dcid               = ch->init_dcid;
-    txp_args.ack_delay_exponent     = 3;
-    txp_args.qtx                    = ch->qtx;
-    txp_args.txpim                  = ch->txpim;
-    txp_args.cfq                    = ch->cfq;
-    txp_args.ackm                   = ch->ackm;
-    txp_args.qsm                    = &ch->qsm;
-    txp_args.conn_txfc              = &ch->conn_txfc;
-    txp_args.conn_rxfc              = &ch->conn_rxfc;
-    txp_args.max_streams_bidi_rxfc  = &ch->max_streams_bidi_rxfc;
-    txp_args.max_streams_uni_rxfc   = &ch->max_streams_uni_rxfc;
-    txp_args.cc_method              = ch->cc_method;
-    txp_args.cc_data                = ch->cc_data;
-    txp_args.now                    = get_time;
-    txp_args.now_arg                = ch;
-    txp_args.get_qlog_cb            = ch_get_qlog_cb;
-    txp_args.get_qlog_cb_arg        = ch;
-    txp_args.protocol_version       = QUIC_VERSION_1;
+    txp_args.cur_scid = ch->init_scid;
+    txp_args.cur_dcid = ch->init_dcid;
+    txp_args.ack_delay_exponent = 3;
+    txp_args.qtx = ch->qtx;
+    txp_args.txpim = ch->txpim;
+    txp_args.cfq = ch->cfq;
+    txp_args.ackm = ch->ackm;
+    txp_args.qsm = &ch->qsm;
+    txp_args.conn_txfc = &ch->conn_txfc;
+    txp_args.conn_rxfc = &ch->conn_rxfc;
+    txp_args.max_streams_bidi_rxfc = &ch->max_streams_bidi_rxfc;
+    txp_args.max_streams_uni_rxfc = &ch->max_streams_uni_rxfc;
+    txp_args.cc_method = ch->cc_method;
+    txp_args.cc_data = ch->cc_data;
+    txp_args.now = get_time;
+    txp_args.now_arg = ch;
+    txp_args.get_qlog_cb = ch_get_qlog_cb;
+    txp_args.get_qlog_cb_arg = ch;
+    txp_args.protocol_version = QUIC_VERSION_1;
 
     for (pn_space = QUIC_PN_SPACE_INITIAL; pn_space < QUIC_PN_SPACE_NUM; ++pn_space) {
         ch->crypto_send[pn_space] = ossl_quic_sstream_new(INIT_CRYPTO_SEND_BUF_LEN);
@@ -308,10 +306,10 @@ static int ch_init(QUIC_CHANNEL *ch)
      */
     if (ch->qrx == NULL && ch->is_tserver_ch == 0) {
         /* we are regular client, create channel */
-        qrx_args.libctx             = ch->port->engine->libctx;
-        qrx_args.demux              = ch->port->demux;
-        qrx_args.short_conn_id_len  = rx_short_dcid_len;
-        qrx_args.max_deferred       = 32;
+        qrx_args.libctx = ch->port->engine->libctx;
+        qrx_args.demux = ch->port->demux;
+        qrx_args.short_conn_id_len = rx_short_dcid_len;
+        qrx_args.max_deferred = 32;
 
         if ((ch->qrx = ossl_qrx_new(&qrx_args)) == NULL)
             goto err;
@@ -324,17 +322,16 @@ static int ch_init(QUIC_CHANNEL *ch)
          * in port_default_packet_handler()
          */
         if (!ossl_qrx_set_late_validation_cb(ch->qrx,
-                                             rx_late_validate,
-                                             ch))
+                rx_late_validate,
+                ch))
             goto err;
 
         if (!ossl_qrx_set_key_update_cb(ch->qrx,
-                                        rxku_detected,
-                                        ch))
+                rxku_detected,
+                ch))
             goto err;
     }
 
-
     for (pn_space = QUIC_PN_SPACE_INITIAL; pn_space < QUIC_PN_SPACE_NUM; ++pn_space) {
         ch->crypto_recv[pn_space] = ossl_quic_rstream_new(NULL, NULL, 0);
         if (ch->crypto_recv[pn_space] == NULL)
@@ -342,38 +339,38 @@ static int ch_init(QUIC_CHANNEL *ch)
     }
 
     /* Plug in the TLS handshake layer. */
-    tls_args.s                          = ch->tls;
-    tls_args.crypto_send_cb             = ch_on_crypto_send;
-    tls_args.crypto_send_cb_arg         = ch;
-    tls_args.crypto_recv_rcd_cb         = ch_on_crypto_recv_record;
-    tls_args.crypto_recv_rcd_cb_arg     = ch;
-    tls_args.crypto_release_rcd_cb      = ch_on_crypto_release_record;
-    tls_args.crypto_release_rcd_cb_arg  = ch;
-    tls_args.yield_secret_cb            = ch_on_handshake_yield_secret;
-    tls_args.yield_secret_cb_arg        = ch;
-    tls_args.got_transport_params_cb    = ch_on_transport_params;
-    tls_args.got_transport_params_cb_arg= ch;
-    tls_args.handshake_complete_cb      = ch_on_handshake_complete;
-    tls_args.handshake_complete_cb_arg  = ch;
-    tls_args.alert_cb                   = ch_on_handshake_alert;
-    tls_args.alert_cb_arg               = ch;
-    tls_args.is_server                  = ch->is_server;
-    tls_args.ossl_quic                  = 1;
+    tls_args.s = ch->tls;
+    tls_args.crypto_send_cb = ch_on_crypto_send;
+    tls_args.crypto_send_cb_arg = ch;
+    tls_args.crypto_recv_rcd_cb = ch_on_crypto_recv_record;
+    tls_args.crypto_recv_rcd_cb_arg = ch;
+    tls_args.crypto_release_rcd_cb = ch_on_crypto_release_record;
+    tls_args.crypto_release_rcd_cb_arg = ch;
+    tls_args.yield_secret_cb = ch_on_handshake_yield_secret;
+    tls_args.yield_secret_cb_arg = ch;
+    tls_args.got_transport_params_cb = ch_on_transport_params;
+    tls_args.got_transport_params_cb_arg = ch;
+    tls_args.handshake_complete_cb = ch_on_handshake_complete;
+    tls_args.handshake_complete_cb_arg = ch;
+    tls_args.alert_cb = ch_on_handshake_alert;
+    tls_args.alert_cb_arg = ch;
+    tls_args.is_server = ch->is_server;
+    tls_args.ossl_quic = 1;
 
     if ((ch->qtls = ossl_quic_tls_new(&tls_args)) == NULL)
         goto err;
 
-    ch->tx_max_ack_delay        = DEFAULT_MAX_ACK_DELAY;
-    ch->rx_max_ack_delay        = QUIC_DEFAULT_MAX_ACK_DELAY;
-    ch->rx_ack_delay_exp        = QUIC_DEFAULT_ACK_DELAY_EXP;
+    ch->tx_max_ack_delay = DEFAULT_MAX_ACK_DELAY;
+    ch->rx_max_ack_delay = QUIC_DEFAULT_MAX_ACK_DELAY;
+    ch->rx_ack_delay_exp = QUIC_DEFAULT_ACK_DELAY_EXP;
     ch->rx_active_conn_id_limit = QUIC_MIN_ACTIVE_CONN_ID_LIMIT;
-    ch->tx_enc_level            = QUIC_ENC_LEVEL_INITIAL;
-    ch->rx_enc_level            = QUIC_ENC_LEVEL_INITIAL;
+    ch->tx_enc_level = QUIC_ENC_LEVEL_INITIAL;
+    ch->rx_enc_level = QUIC_ENC_LEVEL_INITIAL;
     ch->txku_threshold_override = UINT64_MAX;
 
-    ch->max_idle_timeout_local_req  = QUIC_DEFAULT_IDLE_TIMEOUT;
+    ch->max_idle_timeout_local_req = QUIC_DEFAULT_IDLE_TIMEOUT;
     ch->max_idle_timeout_remote_req = 0;
-    ch->max_idle_timeout            = ch->max_idle_timeout_local_req;
+    ch->max_idle_timeout = ch->max_idle_timeout_local_req;
 
     ossl_ackm_set_tx_max_ack_delay(ch->ackm, ossl_ms2time(ch->tx_max_ack_delay));
     ossl_ackm_set_rx_max_ack_delay(ch->ackm, ossl_ms2time(ch->rx_max_ack_delay));
@@ -394,8 +391,8 @@ static void ch_cleanup(QUIC_CHANNEL *ch)
 
     if (ch->ackm != NULL)
         for (pn_space = QUIC_PN_SPACE_INITIAL;
-             pn_space < QUIC_PN_SPACE_NUM;
-             ++pn_space)
+            pn_space < QUIC_PN_SPACE_NUM;
+            ++pn_space)
             ossl_ackm_on_pkt_space_discarded(ch->ackm, pn_space);
 
     ossl_quic_lcidm_cull(ch->lcidm, ch);
@@ -453,9 +450,9 @@ void ossl_quic_channel_bind_qrx(QUIC_CHANNEL *tserver_ch, OSSL_QRX *qrx)
     if (tserver_ch->qrx == NULL && tserver_ch->is_tserver_ch == 1) {
         tserver_ch->qrx = qrx;
         ossl_qrx_set_late_validation_cb(tserver_ch->qrx, rx_late_validate,
-                                        tserver_ch);
+            tserver_ch);
         ossl_qrx_set_key_update_cb(tserver_ch->qrx, rxku_detected,
-                                   tserver_ch);
+            tserver_ch);
     }
 }
 
@@ -466,15 +463,15 @@ QUIC_CHANNEL *ossl_quic_channel_alloc(const QUIC_CHANNEL_ARGS *args)
     if ((ch = OPENSSL_zalloc(sizeof(*ch))) == NULL)
         return NULL;
 
-    ch->port           = args->port;
-    ch->is_server      = args->is_server;
-    ch->tls            = args->tls;
-    ch->lcidm          = args->lcidm;
-    ch->srtm           = args->srtm;
-    ch->qrx            = args->qrx;
-    ch->is_tserver_ch  = args->is_tserver_ch;
+    ch->port = args->port;
+    ch->is_server = args->is_server;
+    ch->tls = args->tls;
+    ch->lcidm = args->lcidm;
+    ch->srtm = args->srtm;
+    ch->qrx = args->qrx;
+    ch->is_tserver_ch = args->is_tserver_ch;
 #ifndef OPENSSL_NO_QLOG
-    ch->use_qlog    = args->use_qlog;
+    ch->use_qlog = args->use_qlog;
 
     if (ch->use_qlog && args->qlog_title != NULL) {
         if ((ch->qlog_title = OPENSSL_strdup(args->qlog_title)) == NULL) {
@@ -498,9 +495,9 @@ void ossl_quic_channel_free(QUIC_CHANNEL *ch)
 
 /* Set mutator callbacks for test framework support */
 int ossl_quic_channel_set_mutator(QUIC_CHANNEL *ch,
-                                  ossl_mutate_packet_cb mutatecb,
-                                  ossl_finish_mutate_cb finishmutatecb,
-                                  void *mutatearg)
+    ossl_mutate_packet_cb mutatecb,
+    ossl_finish_mutate_cb finishmutatecb,
+    void *mutatearg)
 {
     if (ch->qtx == NULL)
         return 0;
@@ -563,8 +560,8 @@ static void free_buf_mem(unsigned char *buf, size_t buf_len, void *arg)
 }
 
 int ossl_quic_channel_schedule_new_token(QUIC_CHANNEL *ch,
-                                         const unsigned char *token,
-                                         size_t token_len)
+    const unsigned char *token,
+    size_t token_len)
 {
     int rc = 0;
     QUIC_CFQ_ITEM *cfq_item;
@@ -580,7 +577,7 @@ int ossl_quic_channel_schedule_new_token(QUIC_CHANNEL *ch,
         goto err;
 
     if (!ossl_quic_wire_encode_frame_new_token(&wpkt, token,
-                                               token_len)) {
+            token_len)) {
         WPACKET_cleanup(&wpkt);
         goto err;
     }
@@ -591,11 +588,11 @@ int ossl_quic_channel_schedule_new_token(QUIC_CHANNEL *ch,
         goto err;
 
     cfq_item = ossl_quic_cfq_add_frame(ch->cfq, 1,
-                                       QUIC_PN_SPACE_APP,
-                                       OSSL_QUIC_FRAME_TYPE_NEW_TOKEN, 0,
-                                       (unsigned char *)buf_mem->data, l,
-                                       free_buf_mem,
-                                       buf_mem);
+        QUIC_PN_SPACE_APP,
+        OSSL_QUIC_FRAME_TYPE_NEW_TOKEN, 0,
+        (unsigned char *)buf_mem->data, l,
+        free_buf_mem,
+        buf_mem);
     if (cfq_item == NULL)
         goto err;
 
@@ -612,7 +609,7 @@ size_t ossl_quic_channel_get_short_header_conn_id_len(QUIC_CHANNEL *ch)
 }
 
 QUIC_STREAM *ossl_quic_channel_get_stream_by_id(QUIC_CHANNEL *ch,
-                                                uint64_t stream_id)
+    uint64_t stream_id)
 {
     return ossl_quic_stream_map_get_by_id(&ch->qsm, stream_id);
 }
@@ -740,13 +737,13 @@ static void ch_trigger_txku(QUIC_CHANNEL *ch)
     if (!ossl_quic_pn_valid(next_pn)
         || !ossl_qtx_trigger_key_update(ch->qtx)) {
         ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_INTERNAL_ERROR, 0,
-                                               "key update");
+            "key update");
         return;
     }
 
-    ch->txku_in_progress    = 1;
-    ch->txku_pn             = next_pn;
-    ch->rxku_expected       = ch->ku_locally_initiated;
+    ch->txku_in_progress = 1;
+    ch->txku_pn = next_pn;
+    ch->rxku_expected = ch->ku_locally_initiated;
 }
 
 QUIC_NEEDS_LOCK
@@ -765,9 +762,9 @@ static int txku_in_progress(QUIC_CHANNEL *ch)
          * the ack for a TXKU-triggering packet, not when the TXKU is initiated.
          * So we defer TXKU cooldown deadline calculation to this point.
          */
-        ch->txku_in_progress        = 0;
-        ch->txku_cooldown_deadline  = ossl_time_add(get_time(ch),
-                                                    ossl_time_multiply(pto, 3));
+        ch->txku_in_progress = 0;
+        ch->txku_cooldown_deadline = ossl_time_add(get_time(ch),
+            ossl_time_multiply(pto, 3));
     }
 
     return ch->txku_in_progress;
@@ -888,18 +885,18 @@ static void rxku_detected(QUIC_PN pn, void *arg)
 
     if (decision == DECISION_PROTOCOL_VIOLATION) {
         ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_KEY_UPDATE_ERROR,
-                                               0, "RX key update again too soon");
+            0, "RX key update again too soon");
         return;
     }
 
     pto = ossl_ackm_get_pto_duration(ch->ackm);
 
-    ch->ku_locally_initiated        = 0;
-    ch->rxku_in_progress            = 1;
-    ch->rxku_pending_confirm        = 1;
-    ch->rxku_trigger_pn             = pn;
-    ch->rxku_update_end_deadline    = ossl_time_add(get_time(ch), pto);
-    ch->rxku_expected               = 0;
+    ch->ku_locally_initiated = 0;
+    ch->rxku_in_progress = 1;
+    ch->rxku_pending_confirm = 1;
+    ch->rxku_trigger_pn = pn;
+    ch->rxku_update_end_deadline = ossl_time_add(get_time(ch), pto);
+    ch->rxku_expected = 0;
 
     if (decision == DECISION_SOLICITED_TXKU)
         /* NOT gated by usual txku_allowed() */
@@ -931,17 +928,17 @@ static void ch_rxku_tick(QUIC_CHANNEL *ch)
         || ossl_time_compare(get_time(ch), ch->rxku_update_end_deadline) < 0)
         return;
 
-    ch->rxku_update_end_deadline    = ossl_time_infinite();
-    ch->rxku_in_progress            = 0;
+    ch->rxku_update_end_deadline = ossl_time_infinite();
+    ch->rxku_in_progress = 0;
 
     if (!ossl_qrx_key_update_timeout(ch->qrx, /*normal=*/1))
         ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_INTERNAL_ERROR, 0,
-                                               "RXKU cooldown internal error");
+            "RXKU cooldown internal error");
 }
 
 QUIC_NEEDS_LOCK
 static void ch_on_txp_ack_tx(const OSSL_QUIC_FRAME_ACK *ack, uint32_t pn_space,
-                             void *arg)
+    void *arg)
 {
     QUIC_CHANNEL *ch = arg;
 
@@ -961,7 +958,7 @@ static void ch_on_txp_ack_tx(const OSSL_QUIC_FRAME_ACK *ack, uint32_t pn_space,
  * ============================================
  */
 static int ch_on_crypto_send(const unsigned char *buf, size_t buf_len,
-                             size_t *consumed, void *arg)
+    size_t *consumed, void *arg)
 {
     int ret;
     QUIC_CHANNEL *ch = arg;
@@ -991,7 +988,7 @@ static int crypto_ensure_empty(QUIC_RSTREAM *rstream)
 }
 
 static int ch_on_crypto_recv_record(const unsigned char **buf,
-                                    size_t *bytes_read, void *arg)
+    size_t *bytes_read, void *arg)
 {
     QUIC_CHANNEL *ch = arg;
     QUIC_RSTREAM *rstream;
@@ -1012,12 +1009,11 @@ static int ch_on_crypto_recv_record(const unsigned char **buf,
      * bytes at a lower EL.
      */
     for (i = QUIC_ENC_LEVEL_INITIAL; i < ch->rx_enc_level; ++i)
-        if (i != QUIC_ENC_LEVEL_0RTT &&
-            !crypto_ensure_empty(ch->crypto_recv[ossl_quic_enc_level_to_pn_space(i)])) {
+        if (i != QUIC_ENC_LEVEL_0RTT && !crypto_ensure_empty(ch->crypto_recv[ossl_quic_enc_level_to_pn_space(i)])) {
             /* Protocol violation (RFC 9001 s. 4.1.3) */
             ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                   OSSL_QUIC_FRAME_TYPE_CRYPTO,
-                                                   "crypto stream data in wrong EL");
+                OSSL_QUIC_FRAME_TYPE_CRYPTO,
+                "crypto stream data in wrong EL");
             return 0;
         }
 
@@ -1026,7 +1022,7 @@ static int ch_on_crypto_recv_record(const unsigned char **buf,
         return 0;
 
     return ossl_quic_rstream_get_record(rstream, buf, bytes_read,
-                                        &is_fin);
+        &is_fin);
 }
 
 static int ch_on_crypto_release_record(size_t bytes_read, void *arg)
@@ -1042,17 +1038,17 @@ static int ch_on_crypto_release_record(size_t bytes_read, void *arg)
 
     ossl_statm_get_rtt_info(ossl_quic_channel_get_statm(ch), &rtt_info);
     if (!ossl_quic_rxfc_on_retire(&ch->crypto_rxfc[rx_pn_space], bytes_read,
-                                  rtt_info.smoothed_rtt))
+            rtt_info.smoothed_rtt))
         return 0;
 
     return ossl_quic_rstream_release_record(rstream, bytes_read);
 }
 
 static int ch_on_handshake_yield_secret(uint32_t prot_level, int direction,
-                                        uint32_t suite_id, EVP_MD *md,
-                                        const unsigned char *secret,
-                                        size_t secret_len,
-                                        void *arg)
+    uint32_t suite_id, EVP_MD *md,
+    const unsigned char *secret,
+    size_t secret_len,
+    void *arg)
 {
     QUIC_CHANNEL *ch = arg;
     uint32_t i;
@@ -1080,7 +1076,6 @@ static int ch_on_handshake_yield_secret(uint32_t prot_level, int direction,
         /* Invalid EL. */
         return 0;
 
-
     if (direction) {
         /* TX */
         if (enc_level <= ch->tx_enc_level)
@@ -1091,8 +1086,8 @@ static int ch_on_handshake_yield_secret(uint32_t prot_level, int direction,
             return 0;
 
         if (!ossl_qtx_provide_secret(ch->qtx, enc_level,
-                                     suite_id, md,
-                                     secret, secret_len))
+                suite_id, md,
+                secret, secret_len))
             return 0;
 
         ch->tx_enc_level = enc_level;
@@ -1113,14 +1108,14 @@ static int ch_on_handshake_yield_secret(uint32_t prot_level, int direction,
             if (!crypto_ensure_empty(ch->crypto_recv[ossl_quic_enc_level_to_pn_space(i)])) {
                 /* Protocol violation (RFC 9001 s. 4.1.3) */
                 ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                    OSSL_QUIC_FRAME_TYPE_CRYPTO,
-                                                    "crypto stream data in wrong EL");
+                    OSSL_QUIC_FRAME_TYPE_CRYPTO,
+                    "crypto stream data in wrong EL");
                 return 0;
             }
 
         if (!ossl_qrx_provide_secret(ch->qrx, enc_level,
-                                     suite_id, md,
-                                     secret, secret_len))
+                suite_id, md,
+                secret, secret_len))
             return 0;
 
         ch->have_new_rx_secret = 1;
@@ -1153,8 +1148,8 @@ static int ch_on_handshake_complete(void *arg)
          * params.
          */
         ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_CRYPTO_MISSING_EXT,
-                                               OSSL_QUIC_FRAME_TYPE_CRYPTO,
-                                               "no transport parameters received");
+            OSSL_QUIC_FRAME_TYPE_CRYPTO,
+            "no transport parameters received");
         return 0;
     }
 
@@ -1180,8 +1175,8 @@ static int ch_on_handshake_complete(void *arg)
          * new token.  As a result, we don't need to handle any errors here
          */
         ossl_quic_channel_schedule_new_token(ch,
-                                             ch->pending_new_token,
-                                             ch->pending_new_token_len);
+            ch->pending_new_token,
+            ch->pending_new_token_len);
         OPENSSL_free(ch->pending_new_token);
         ch->pending_new_token = NULL;
         ch->pending_new_token_len = 0;
@@ -1210,13 +1205,13 @@ static int ch_on_handshake_alert(void *arg, unsigned char alert_code)
      * messages as a connection error of type PROTOCOL_VIOLATION.
      */
     if (alert_code == SSL_AD_UNEXPECTED_MESSAGE
-            && ch->handshake_complete
-            && ossl_quic_tls_is_cert_request(ch->qtls))
+        && ch->handshake_complete
+        && ossl_quic_tls_is_cert_request(ch->qtls))
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                               0,
-                                               "Post-handshake TLS "
-                                               "CertificateRequest received");
+            OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+            0,
+            "Post-handshake TLS "
+            "CertificateRequest received");
     /*
      * RFC 9001 s. 4.6.1: Servers MUST NOT send the early_data extension with a
      * max_early_data_size field set to any value other than 0xffffffff. A
@@ -1225,17 +1220,17 @@ static int ch_on_handshake_alert(void *arg, unsigned char alert_code)
      * PROTOCOL_VIOLATION.
      */
     else if (alert_code == SSL_AD_ILLEGAL_PARAMETER
-             && ch->handshake_complete
-             && ossl_quic_tls_has_bad_max_early_data(ch->qtls))
+        && ch->handshake_complete
+        && ossl_quic_tls_has_bad_max_early_data(ch->qtls))
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                               0,
-                                               "Bad max_early_data received");
+            OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+            0,
+            "Bad max_early_data received");
     else
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_CRYPTO_ERR_BEGIN
-                                               + alert_code,
-                                               0, "handshake alert");
+            OSSL_QUIC_ERR_CRYPTO_ERR_BEGIN
+                + alert_code,
+            0, "handshake alert");
 
     return 1;
 }
@@ -1301,8 +1296,8 @@ static uint64_t min_u64_ignore_0(uint64_t a, uint64_t b)
 }
 
 static int ch_on_transport_params(const unsigned char *params,
-                                  size_t params_len,
-                                  void *arg)
+    size_t params_len,
+    void *arg)
 {
     QUIC_CHANNEL *ch = arg;
     PACKET pkt;
@@ -1351,7 +1346,7 @@ static int ch_on_transport_params(const unsigned char *params,
 
     if (!PACKET_buf_init(&pkt, params, params_len)) {
         ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_INTERNAL_ERROR, 0,
-                                               "internal error (packet buf init)");
+            "internal error (packet buf init)");
         return 0;
     }
 
@@ -1547,7 +1542,7 @@ static int ch_on_transport_params(const unsigned char *params,
 
             ch->rx_max_ack_delay = v;
             ossl_ackm_set_rx_max_ack_delay(ch->ackm,
-                                           ossl_ms2time(ch->rx_max_ack_delay));
+                ossl_ms2time(ch->rx_max_ack_delay));
 
             got_max_ack_delay = 1;
             break;
@@ -1603,8 +1598,7 @@ static int ch_on_transport_params(const unsigned char *params,
             ch->max_idle_timeout_remote_req = v;
 
             ch->max_idle_timeout = min_u64_ignore_0(ch->max_idle_timeout_local_req,
-                                                    ch->max_idle_timeout_remote_req);
-
+                ch->max_idle_timeout_remote_req);
 
             ch_update_idle(ch);
             got_max_idle_timeout = 1;
@@ -1625,7 +1619,7 @@ static int ch_on_transport_params(const unsigned char *params,
             }
 
             ch->rx_max_udp_payload_size = v;
-            got_max_udp_payload_size    = 1;
+            got_max_udp_payload_size = 1;
             break;
 
         case QUIC_TPARAM_ACTIVE_CONN_ID_LIMIT:
@@ -1666,13 +1660,13 @@ static int ch_on_transport_params(const unsigned char *params,
                 goto malformed;
             }
             if (!ossl_quic_srtm_add(ch->srtm, ch, ch->cur_remote_seq_num,
-                                    (const QUIC_STATELESS_RESET_TOKEN *)body)) {
+                    (const QUIC_STATELESS_RESET_TOKEN *)body)) {
                 reason = TP_REASON_INTERNAL_ERROR("STATELESS_RESET_TOKEN");
                 goto malformed;
             }
 
-            stateless_reset_token_p     = body;
-            got_stateless_reset_token   = 1;
+            stateless_reset_token_p = body;
+            got_stateless_reset_token = 1;
             break;
 
         case QUIC_TPARAM_PREFERRED_ADDR:
@@ -1741,7 +1735,7 @@ static int ch_on_transport_params(const unsigned char *params,
              * maintaining a list of duplicates for anything we don't recognise.
              */
             body = ossl_quic_wire_decode_transport_param_bytes(&pkt, &id,
-                                                               &len);
+                &len);
             if (body == NULL)
                 goto malformed;
 
@@ -1770,60 +1764,60 @@ static int ch_on_transport_params(const unsigned char *params,
 
 #ifndef OPENSSL_NO_QLOG
     QLOG_EVENT_BEGIN(ch_get_qlog(ch), transport, parameters_set)
-        QLOG_STR("owner", "remote");
+    QLOG_STR("owner", "remote");
 
-        if (got_orig_dcid)
-            QLOG_CID("original_destination_connection_id",
-                     &ch->init_dcid);
-        if (got_initial_scid)
-            QLOG_CID("original_source_connection_id",
-                     &ch->init_dcid);
-        if (got_retry_scid)
-            QLOG_CID("retry_source_connection_id",
-                     &ch->retry_scid);
-        if (got_initial_max_data)
-            QLOG_U64("initial_max_data",
-                     ossl_quic_txfc_get_cwm(&ch->conn_txfc));
-        if (got_initial_max_stream_data_bidi_local)
-            QLOG_U64("initial_max_stream_data_bidi_local",
-                     ch->rx_init_max_stream_data_bidi_local);
-        if (got_initial_max_stream_data_bidi_remote)
-            QLOG_U64("initial_max_stream_data_bidi_remote",
-                     ch->rx_init_max_stream_data_bidi_remote);
-        if (got_initial_max_stream_data_uni)
-            QLOG_U64("initial_max_stream_data_uni",
-                     ch->rx_init_max_stream_data_uni);
-        if (got_initial_max_streams_bidi)
-            QLOG_U64("initial_max_streams_bidi",
-                     ch->max_local_streams_bidi);
-        if (got_initial_max_streams_uni)
-            QLOG_U64("initial_max_streams_uni",
-                     ch->max_local_streams_uni);
-        if (got_ack_delay_exp)
-            QLOG_U64("ack_delay_exponent", ch->rx_ack_delay_exp);
-        if (got_max_ack_delay)
-            QLOG_U64("max_ack_delay", ch->rx_max_ack_delay);
-        if (got_max_udp_payload_size)
-            QLOG_U64("max_udp_payload_size", ch->rx_max_udp_payload_size);
-        if (got_max_idle_timeout)
-            QLOG_U64("max_idle_timeout", rx_max_idle_timeout);
-        if (got_active_conn_id_limit)
-            QLOG_U64("active_connection_id_limit", ch->rx_active_conn_id_limit);
-        if (got_stateless_reset_token)
-            QLOG_BIN("stateless_reset_token", stateless_reset_token_p,
-                     QUIC_STATELESS_RESET_TOKEN_LEN);
-        if (got_preferred_addr) {
-            QLOG_BEGIN("preferred_addr")
-                QLOG_U64("port_v4", pfa.ipv4_port);
-                QLOG_U64("port_v6", pfa.ipv6_port);
-                QLOG_BIN("ip_v4", pfa.ipv4, sizeof(pfa.ipv4));
-                QLOG_BIN("ip_v6", pfa.ipv6, sizeof(pfa.ipv6));
-                QLOG_BIN("stateless_reset_token", pfa.stateless_reset.token,
-                         sizeof(pfa.stateless_reset.token));
-                QLOG_CID("connection_id", &pfa.cid);
-            QLOG_END()
-        }
-        QLOG_BOOL("disable_active_migration", got_disable_active_migration);
+    if (got_orig_dcid)
+        QLOG_CID("original_destination_connection_id",
+            &ch->init_dcid);
+    if (got_initial_scid)
+        QLOG_CID("original_source_connection_id",
+            &ch->init_dcid);
+    if (got_retry_scid)
+        QLOG_CID("retry_source_connection_id",
+            &ch->retry_scid);
+    if (got_initial_max_data)
+        QLOG_U64("initial_max_data",
+            ossl_quic_txfc_get_cwm(&ch->conn_txfc));
+    if (got_initial_max_stream_data_bidi_local)
+        QLOG_U64("initial_max_stream_data_bidi_local",
+            ch->rx_init_max_stream_data_bidi_local);
+    if (got_initial_max_stream_data_bidi_remote)
+        QLOG_U64("initial_max_stream_data_bidi_remote",
+            ch->rx_init_max_stream_data_bidi_remote);
+    if (got_initial_max_stream_data_uni)
+        QLOG_U64("initial_max_stream_data_uni",
+            ch->rx_init_max_stream_data_uni);
+    if (got_initial_max_streams_bidi)
+        QLOG_U64("initial_max_streams_bidi",
+            ch->max_local_streams_bidi);
+    if (got_initial_max_streams_uni)
+        QLOG_U64("initial_max_streams_uni",
+            ch->max_local_streams_uni);
+    if (got_ack_delay_exp)
+        QLOG_U64("ack_delay_exponent", ch->rx_ack_delay_exp);
+    if (got_max_ack_delay)
+        QLOG_U64("max_ack_delay", ch->rx_max_ack_delay);
+    if (got_max_udp_payload_size)
+        QLOG_U64("max_udp_payload_size", ch->rx_max_udp_payload_size);
+    if (got_max_idle_timeout)
+        QLOG_U64("max_idle_timeout", rx_max_idle_timeout);
+    if (got_active_conn_id_limit)
+        QLOG_U64("active_connection_id_limit", ch->rx_active_conn_id_limit);
+    if (got_stateless_reset_token)
+        QLOG_BIN("stateless_reset_token", stateless_reset_token_p,
+            QUIC_STATELESS_RESET_TOKEN_LEN);
+    if (got_preferred_addr) {
+        QLOG_BEGIN("preferred_addr")
+        QLOG_U64("port_v4", pfa.ipv4_port);
+        QLOG_U64("port_v6", pfa.ipv6_port);
+        QLOG_BIN("ip_v4", pfa.ipv4, sizeof(pfa.ipv4));
+        QLOG_BIN("ip_v6", pfa.ipv6, sizeof(pfa.ipv6));
+        QLOG_BIN("stateless_reset_token", pfa.stateless_reset.token,
+            sizeof(pfa.stateless_reset.token));
+        QLOG_CID("connection_id", &pfa.cid);
+        QLOG_END()
+    }
+    QLOG_BOOL("disable_active_migration", got_disable_active_migration);
     QLOG_EVENT_END()
 #endif
 
@@ -1838,7 +1832,7 @@ static int ch_on_transport_params(const unsigned char *params,
     /* If we are a server, we now generate our own transport parameters. */
     if (ch->is_server && !ch_generate_transport_params(ch)) {
         ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_INTERNAL_ERROR, 0,
-                                               "internal error");
+            "internal error");
         return 0;
     }
 
@@ -1846,7 +1840,7 @@ static int ch_on_transport_params(const unsigned char *params,
 
 malformed:
     ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_TRANSPORT_PARAMETER_ERROR,
-                                           0, reason);
+        0, reason);
     return 0;
 }
 
@@ -1890,68 +1884,69 @@ static int ch_generate_transport_params(QUIC_CHANNEL *ch)
     wpkt_valid = 1;
 
     if (ossl_quic_wire_encode_transport_param_bytes(&wpkt, QUIC_TPARAM_DISABLE_ACTIVE_MIGRATION,
-                                                    NULL, 0) == NULL)
+            NULL, 0)
+        == NULL)
         goto err;
 
     if (ch->is_server) {
         if (!ossl_quic_wire_encode_transport_param_cid(&wpkt, QUIC_TPARAM_ORIG_DCID,
-                                                       id_to_use))
+                id_to_use))
             goto err;
 
         if (!ossl_quic_wire_encode_transport_param_cid(&wpkt, QUIC_TPARAM_INITIAL_SCID,
-                                                       &ch->cur_local_cid))
+                &ch->cur_local_cid))
             goto err;
         if (ch->odcid.id_len != 0)
             if (!ossl_quic_wire_encode_transport_param_cid(&wpkt,
-                                                           QUIC_TPARAM_RETRY_SCID,
-                                                           &ch->init_dcid))
+                    QUIC_TPARAM_RETRY_SCID,
+                    &ch->init_dcid))
                 goto err;
     } else {
         if (!ossl_quic_wire_encode_transport_param_cid(&wpkt, QUIC_TPARAM_INITIAL_SCID,
-                                                       &ch->init_scid))
+                &ch->init_scid))
             goto err;
     }
 
     if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_MAX_IDLE_TIMEOUT,
-                                                   ch->max_idle_timeout_local_req))
+            ch->max_idle_timeout_local_req))
         goto err;
 
     if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_MAX_UDP_PAYLOAD_SIZE,
-                                                   QUIC_MIN_INITIAL_DGRAM_LEN))
+            QUIC_MIN_INITIAL_DGRAM_LEN))
         goto err;
 
     if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_ACTIVE_CONN_ID_LIMIT,
-                                                   QUIC_MIN_ACTIVE_CONN_ID_LIMIT))
+            QUIC_MIN_ACTIVE_CONN_ID_LIMIT))
         goto err;
 
     if (ch->tx_max_ack_delay != QUIC_DEFAULT_MAX_ACK_DELAY
         && !ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_MAX_ACK_DELAY,
-                                                      ch->tx_max_ack_delay))
+            ch->tx_max_ack_delay))
         goto err;
 
     if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_DATA,
-                                                   ossl_quic_rxfc_get_cwm(&ch->conn_rxfc)))
+            ossl_quic_rxfc_get_cwm(&ch->conn_rxfc)))
         goto err;
 
     /* Send the default CWM for a new RXFC. */
     if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_STREAM_DATA_BIDI_LOCAL,
-                                                   ch->tx_init_max_stream_data_bidi_local))
+            ch->tx_init_max_stream_data_bidi_local))
         goto err;
 
     if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_STREAM_DATA_BIDI_REMOTE,
-                                                   ch->tx_init_max_stream_data_bidi_remote))
+            ch->tx_init_max_stream_data_bidi_remote))
         goto err;
 
     if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_STREAM_DATA_UNI,
-                                                   ch->tx_init_max_stream_data_uni))
+            ch->tx_init_max_stream_data_uni))
         goto err;
 
     if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_STREAMS_BIDI,
-                                                   ossl_quic_rxfc_get_cwm(&ch->max_streams_bidi_rxfc)))
+            ossl_quic_rxfc_get_cwm(&ch->max_streams_bidi_rxfc)))
         goto err;
 
     if (!ossl_quic_wire_encode_transport_param_int(&wpkt, QUIC_TPARAM_INITIAL_MAX_STREAMS_UNI,
-                                                   ossl_quic_rxfc_get_cwm(&ch->max_streams_uni_rxfc)))
+            ossl_quic_rxfc_get_cwm(&ch->max_streams_uni_rxfc)))
         goto err;
 
     if (!WPACKET_finish(&wpkt))
@@ -1966,34 +1961,34 @@ static int ch_generate_transport_params(QUIC_CHANNEL *ch)
     buf_mem->data = NULL;
 
     if (!ossl_quic_tls_set_transport_params(ch->qtls, ch->local_transport_params,
-                                            buf_len))
+            buf_len))
         goto err;
 
 #ifndef OPENSSL_NO_QLOG
     QLOG_EVENT_BEGIN(ch_get_qlog(ch), transport, parameters_set)
-        QLOG_STR("owner", "local");
-        QLOG_BOOL("disable_active_migration", 1);
-        if (ch->is_server) {
-            QLOG_CID("original_destination_connection_id", &ch->init_dcid);
-            QLOG_CID("initial_source_connection_id", &ch->cur_local_cid);
-        } else {
-            QLOG_STR("initial_source_connection_id", "");
-        }
-        QLOG_U64("max_idle_timeout", ch->max_idle_timeout);
-        QLOG_U64("max_udp_payload_size", QUIC_MIN_INITIAL_DGRAM_LEN);
-        QLOG_U64("active_connection_id_limit", QUIC_MIN_ACTIVE_CONN_ID_LIMIT);
-        QLOG_U64("max_ack_delay", ch->tx_max_ack_delay);
-        QLOG_U64("initial_max_data", ossl_quic_rxfc_get_cwm(&ch->conn_rxfc));
-        QLOG_U64("initial_max_stream_data_bidi_local",
-                 ch->tx_init_max_stream_data_bidi_local);
-        QLOG_U64("initial_max_stream_data_bidi_remote",
-                 ch->tx_init_max_stream_data_bidi_remote);
-        QLOG_U64("initial_max_stream_data_uni",
-                 ch->tx_init_max_stream_data_uni);
-        QLOG_U64("initial_max_streams_bidi",
-                 ossl_quic_rxfc_get_cwm(&ch->max_streams_bidi_rxfc));
-        QLOG_U64("initial_max_streams_uni",
-                 ossl_quic_rxfc_get_cwm(&ch->max_streams_uni_rxfc));
+    QLOG_STR("owner", "local");
+    QLOG_BOOL("disable_active_migration", 1);
+    if (ch->is_server) {
+        QLOG_CID("original_destination_connection_id", &ch->init_dcid);
+        QLOG_CID("initial_source_connection_id", &ch->cur_local_cid);
+    } else {
+        QLOG_STR("initial_source_connection_id", "");
+    }
+    QLOG_U64("max_idle_timeout", ch->max_idle_timeout);
+    QLOG_U64("max_udp_payload_size", QUIC_MIN_INITIAL_DGRAM_LEN);
+    QLOG_U64("active_connection_id_limit", QUIC_MIN_ACTIVE_CONN_ID_LIMIT);
+    QLOG_U64("max_ack_delay", ch->tx_max_ack_delay);
+    QLOG_U64("initial_max_data", ossl_quic_rxfc_get_cwm(&ch->conn_rxfc));
+    QLOG_U64("initial_max_stream_data_bidi_local",
+        ch->tx_init_max_stream_data_bidi_local);
+    QLOG_U64("initial_max_stream_data_bidi_remote",
+        ch->tx_init_max_stream_data_bidi_remote);
+    QLOG_U64("initial_max_stream_data_uni",
+        ch->tx_init_max_stream_data_uni);
+    QLOG_U64("initial_max_streams_bidi",
+        ossl_quic_rxfc_get_cwm(&ch->max_streams_bidi_rxfc));
+    QLOG_U64("initial_max_streams_uni",
+        ossl_quic_rxfc_get_cwm(&ch->max_streams_uni_rxfc));
     QLOG_EVENT_END()
 #endif
 
@@ -2018,7 +2013,7 @@ err:
  * "loudly".
  */
 void ossl_quic_channel_subtick(QUIC_CHANNEL *ch, QUIC_TICK_RESULT *res,
-                               uint32_t flags)
+    uint32_t flags)
 {
     OSSL_TIME now, deadline;
     int channel_only = (flags & QUIC_REACTOR_TICK_FLAG_CHANNEL_ONLY) != 0;
@@ -2040,11 +2035,11 @@ void ossl_quic_channel_subtick(QUIC_CHANNEL *ch, QUIC_TICK_RESULT *res,
      * there is nothing to do.
      */
     if (ch->state == QUIC_CHANNEL_STATE_IDLE
-            || ossl_quic_channel_is_terminated(ch)) {
-        res->net_read_desired       = 0;
-        res->net_write_desired      = 0;
-        res->notify_other_threads   = 0;
-        res->tick_deadline          = ossl_time_infinite();
+        || ossl_quic_channel_is_terminated(ch)) {
+        res->net_read_desired = 0;
+        res->net_write_desired = 0;
+        res->notify_other_threads = 0;
+        res->tick_deadline = ossl_time_infinite();
         return;
     }
 
@@ -2057,10 +2052,10 @@ void ossl_quic_channel_subtick(QUIC_CHANNEL *ch, QUIC_TICK_RESULT *res,
 
         if (ossl_time_compare(now, ch->terminate_deadline) >= 0) {
             ch_on_terminating_timeout(ch);
-            res->net_read_desired       = 0;
-            res->net_write_desired      = 0;
-            res->notify_other_threads   = 1;
-            res->tick_deadline          = ossl_time_infinite();
+            res->net_read_desired = 0;
+            res->net_write_desired = 0;
+            res->notify_other_threads = 1;
+            res->tick_deadline = ossl_time_infinite();
             return; /* abort normal processing, nothing to do */
         }
     }
@@ -2071,8 +2066,8 @@ void ossl_quic_channel_subtick(QUIC_CHANNEL *ch, QUIC_TICK_RESULT *res,
 
         do {
             /* Process queued incoming packets. */
-            ch->did_tls_tick        = 0;
-            ch->have_new_rx_secret  = 0;
+            ch->did_tls_tick = 0;
+            ch->have_new_rx_secret = 0;
             ch_rx(ch, channel_only, &notify_other_threads);
 
             /*
@@ -2108,10 +2103,10 @@ void ossl_quic_channel_subtick(QUIC_CHANNEL *ch, QUIC_TICK_RESULT *res,
         if (!ch->port->engine->inhibit_tick)
             ch_on_idle_timeout(ch);
 
-        res->net_read_desired       = 0;
-        res->net_write_desired      = 0;
-        res->notify_other_threads   = 1;
-        res->tick_deadline          = ossl_time_infinite();
+        res->net_read_desired = 0;
+        res->net_write_desired = 0;
+        res->notify_other_threads = 1;
+        res->tick_deadline = ossl_time_infinite();
         return;
     }
 
@@ -2157,7 +2152,7 @@ void ossl_quic_channel_subtick(QUIC_CHANNEL *ch, QUIC_TICK_RESULT *res,
     /* We want to write to the network if we have any data in our TX queue. */
     res->net_write_desired
         = (!ossl_quic_channel_is_terminated(ch)
-           && ossl_qtx_get_queue_len_datagrams(ch->qtx) > 0);
+            && ossl_qtx_get_queue_len_datagrams(ch->qtx) > 0);
 
     res->notify_other_threads = notify_other_threads;
 }
@@ -2175,9 +2170,9 @@ static int ch_tick_tls(QUIC_CHANNEL *ch, int channel_only, int *notify_other_thr
     ossl_quic_tls_tick(ch->qtls);
 
     if (ossl_quic_tls_get_error(ch->qtls, &error_code, &error_msg,
-                                &error_state)) {
+            &error_state)) {
         ossl_quic_channel_raise_protocol_error_state(ch, error_code, 0,
-                                                     error_msg, error_state);
+            error_msg, error_state);
         if (notify_other_threads != NULL)
             *notify_other_threads = 1;
 
@@ -2194,9 +2189,8 @@ static void ch_rx_check_forged_pkt_limit(QUIC_CHANNEL *ch)
     uint64_t limit = UINT64_MAX, l;
 
     for (enc_level = QUIC_ENC_LEVEL_INITIAL;
-         enc_level < QUIC_ENC_LEVEL_NUM;
-         ++enc_level)
-    {
+        enc_level < QUIC_ENC_LEVEL_NUM;
+        ++enc_level) {
         /*
          * Different ELs can have different AEADs which can in turn impose
          * different limits, so use the lowest value of any currently valid EL.
@@ -2216,7 +2210,7 @@ static void ch_rx_check_forged_pkt_limit(QUIC_CHANNEL *ch)
         return;
 
     ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_AEAD_LIMIT_REACHED, 0,
-                                           "forgery limit");
+        "forgery limit");
 }
 
 /* Process queued incoming packets and handle frames, if any. */
@@ -2241,7 +2235,7 @@ static int ch_rx(QUIC_CHANNEL *ch, int channel_only, int *notify_other_threads)
         /* Track the amount of data received while in the closing state */
         if (closing)
             ossl_quic_tx_packetiser_record_received_closing_bytes(
-                    ch->txp, ch->qrx_pkt->hdr->len);
+                ch->txp, ch->qrx_pkt->hdr->len);
 
         if (!handled_any) {
             ch_update_idle(ch);
@@ -2283,20 +2277,20 @@ static int bio_addr_eq(const BIO_ADDR *a, const BIO_ADDR *b)
         return 0;
 
     switch (BIO_ADDR_family(a)) {
-        case AF_INET:
-            return !memcmp(&a->s_in.sin_addr,
-                           &b->s_in.sin_addr,
-                           sizeof(a->s_in.sin_addr))
-                && a->s_in.sin_port == b->s_in.sin_port;
+    case AF_INET:
+        return !memcmp(&a->s_in.sin_addr,
+                   &b->s_in.sin_addr,
+                   sizeof(a->s_in.sin_addr))
+            && a->s_in.sin_port == b->s_in.sin_port;
 #if OPENSSL_USE_IPV6
-        case AF_INET6:
-            return !memcmp(&a->s_in6.sin6_addr,
-                           &b->s_in6.sin6_addr,
-                           sizeof(a->s_in6.sin6_addr))
-                && a->s_in6.sin6_port == b->s_in6.sin6_port;
+    case AF_INET6:
+        return !memcmp(&a->s_in6.sin6_addr,
+                   &b->s_in6.sin6_addr,
+                   sizeof(a->s_in6.sin6_addr))
+            && a->s_in6.sin6_port == b->s_in6.sin6_port;
 #endif
-        default:
-            return 0; /* not supported */
+    default:
+        return 0; /* not supported */
     }
 
     return 1;
@@ -2351,12 +2345,11 @@ static void ch_rx_handle_packet(QUIC_CHANNEL *ch, int channel_only)
      */
     if (!ch->is_server
         && ch->qrx_pkt->peer != NULL
-        && (
-               BIO_ADDR_family(&ch->cur_peer_addr) == AF_INET
+        && (BIO_ADDR_family(&ch->cur_peer_addr) == AF_INET
 #if OPENSSL_USE_IPV6
             || BIO_ADDR_family(&ch->cur_peer_addr) == AF_INET6
 #endif
-        )
+            )
         && !bio_addr_eq(ch->qrx_pkt->peer, &ch->cur_peer_addr))
         return;
 
@@ -2369,7 +2362,7 @@ static void ch_rx_handle_packet(QUIC_CHANNEL *ch, int channel_only)
          * that connection with a different SCID."
          */
         if (!ossl_quic_conn_id_eq(&ch->qrx_pkt->hdr->src_conn_id,
-                                  &ch->init_scid))
+                &ch->init_scid))
             return;
     }
 
@@ -2424,13 +2417,13 @@ static void ch_rx_handle_packet(QUIC_CHANNEL *ch, int channel_only)
          * version
          */
         if (!PACKET_buf_init(&vpkt, ch->qrx_pkt->hdr->data,
-                             ch->qrx_pkt->hdr->len))
+                ch->qrx_pkt->hdr->len))
             return;
 
         while (PACKET_remaining(&vpkt) > 0) {
             /*
              * We only support quic version 1 at the moment, so
-             * look to see if thats offered
+             * look to see if that's offered
              */
             if (!PACKET_get_net_4(&vpkt, &supported_ver))
                 return;
@@ -2443,12 +2436,12 @@ static void ch_rx_handle_packet(QUIC_CHANNEL *ch, int channel_only)
                 ossl_quic_tx_packetiser_set_protocol_version(ch->txp, QUIC_VERSION_1);
 
                 /*
-                 * And then request a restart of the QUIC connection 
+                 * And then request a restart of the QUIC connection
                  */
                 if (!ch_restart(ch))
                     ossl_quic_channel_raise_protocol_error(ch,
-                                                           OSSL_QUIC_ERR_INTERNAL_ERROR,
-                                                           0, "handling ver negotiation packet");
+                        OSSL_QUIC_ERR_INTERNAL_ERROR,
+                        0, "handling ver negotiation packet");
                 return;
             }
         }
@@ -2458,7 +2451,7 @@ static void ch_rx_handle_packet(QUIC_CHANNEL *ch, int channel_only)
          * protocol that we can handle, abandon the connection
          */
         ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_CONNECTION_REFUSED,
-                                               0, "unsupported protocol version");
+            0, "unsupported protocol version");
         return;
     }
 
@@ -2472,15 +2465,15 @@ static void ch_rx_handle_packet(QUIC_CHANNEL *ch, int channel_only)
     if (ossl_quic_pkt_type_is_encrypted(ch->qrx_pkt->hdr->type)
         && ch->qrx_pkt->hdr->reserved != 0) {
         ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                               0, "packet header reserved bits");
+            0, "packet header reserved bits");
         return;
     }
 
-    iovec.buf       = ch->qrx_pkt->hdr->data;
-    iovec.buf_len   = ch->qrx_pkt->hdr->len;
+    iovec.buf = ch->qrx_pkt->hdr->data;
+    iovec.buf_len = ch->qrx_pkt->hdr->len;
     ossl_qlog_event_transport_packet_received(ch_get_qlog(ch), ch->qrx_pkt->hdr,
-                                              ch->qrx_pkt->pn, &iovec, 1,
-                                              ch->qrx_pkt->datagram_id);
+        ch->qrx_pkt->pn, &iovec, 1,
+        ch->qrx_pkt->datagram_id);
 
     /* Handle incoming packet. */
     switch (ch->qrx_pkt->hdr->type) {
@@ -2514,17 +2507,17 @@ static void ch_rx_handle_packet(QUIC_CHANNEL *ch, int channel_only)
          * upper layers. However, special casing this will do for now.
          */
         if (!ossl_quic_validate_retry_integrity_tag(ch->port->engine->libctx,
-                                                    ch->port->engine->propq,
-                                                    ch->qrx_pkt->hdr,
-                                                    &ch->init_dcid))
+                ch->port->engine->propq,
+                ch->qrx_pkt->hdr,
+                &ch->init_dcid))
             /* Malformed retry packet, ignore. */
             return;
 
         if (!ch_retry(ch, ch->qrx_pkt->hdr->data,
-                      ch->qrx_pkt->hdr->len - QUIC_RETRY_INTEGRITY_TAG_LEN,
-                      &ch->qrx_pkt->hdr->src_conn_id, old_have_processed_any_pkt))
+                ch->qrx_pkt->hdr->len - QUIC_RETRY_INTEGRITY_TAG_LEN,
+                &ch->qrx_pkt->hdr->src_conn_id, old_have_processed_any_pkt))
             ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_INTERNAL_ERROR,
-                                                   0, "handling retry packet");
+                0, "handling retry packet");
         break;
 
     case QUIC_PKT_TYPE_0RTT:
@@ -2562,7 +2555,7 @@ static void ch_rx_handle_packet(QUIC_CHANNEL *ch, int channel_only)
              * as a connection error of type KEY_UPDATE_ERROR.
              */
             ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_KEY_UPDATE_ERROR,
-                                                   0, "new packet with old keys");
+                0, "new packet with old keys");
             break;
         }
 
@@ -2587,7 +2580,7 @@ static void ch_rx_handle_packet(QUIC_CHANNEL *ch, int channel_only)
              * I.e. should we drop this packet instead of closing the connection?
              */
             ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                   0, "client received initial token");
+                0, "client received initial token");
             break;
         }
 
@@ -2599,62 +2592,10 @@ static void ch_rx_handle_packet(QUIC_CHANNEL *ch, int channel_only)
 
         break;
 
-    case QUIC_PKT_TYPE_VERSION_NEG:
-        /*
-         * "A client MUST discard any Version Negotiation packet if it has
-         * received and successfully processed any other packet."
-         */
-        if (!old_have_processed_any_pkt)
-            ch_rx_handle_version_neg(ch, ch->qrx_pkt);
-
-        break;
-
     default:
         assert(0);
         break;
     }
-
-}
-
-static void ch_rx_handle_version_neg(QUIC_CHANNEL *ch, OSSL_QRX_PKT *pkt)
-{
-    /*
-     * We do not support version negotiation at this time. As per RFC 9000 s.
-     * 6.2., we MUST abandon the connection attempt if we receive a Version
-     * Negotiation packet, unless we have already successfully processed another
-     * incoming packet, or the packet lists the QUIC version we want to use.
-     */
-    PACKET vpkt;
-    unsigned long v;
-
-    if (!PACKET_buf_init(&vpkt, pkt->hdr->data, pkt->hdr->len))
-        return;
-
-    while (PACKET_remaining(&vpkt) > 0) {
-        if (!PACKET_get_net_4(&vpkt, &v))
-            break;
-
-        if ((uint32_t)v == QUIC_VERSION_1)
-            return;
-    }
-
-    /* No match, this is a failure case. */
-    ch_raise_version_neg_failure(ch);
-}
-
-static void ch_raise_version_neg_failure(QUIC_CHANNEL *ch)
-{
-    QUIC_TERMINATE_CAUSE tcause = {0};
-
-    tcause.error_code = OSSL_QUIC_ERR_CONNECTION_REFUSED;
-    tcause.reason     = "version negotiation failure";
-    tcause.reason_len = strlen(tcause.reason);
-
-    /*
-     * Skip TERMINATING state; this is not considered a protocol error and we do
-     * not send CONNECTION_CLOSE.
-     */
-    ch_start_terminating(ch, &tcause, 1);
 }
 
 /* Try to generate packets and if possible, flush them to the network. */
@@ -2698,33 +2639,33 @@ static int ch_tx(QUIC_CHANNEL *ch, int *notify_other_threads)
     /* Loop until we stop generating packets to send */
     do {
         /*
-        * Send packet, if we need to. Best effort. The TXP consults the CC and
-        * applies any limitations imposed by it, so we don't need to do it here.
-        *
-        * Best effort. In particular if TXP fails for some reason we should
-        * still flush any queued packets which we already generated.
-        */
+         * Send packet, if we need to. Best effort. The TXP consults the CC and
+         * applies any limitations imposed by it, so we don't need to do it here.
+         *
+         * Best effort. In particular if TXP fails for some reason we should
+         * still flush any queued packets which we already generated.
+         */
         res = ossl_quic_tx_packetiser_generate(ch->txp, &status);
         if (status.sent_pkt > 0) {
             ch->have_sent_any_pkt = 1; /* Packet(s) were sent */
             ch->port->have_sent_any_pkt = 1;
 
             /*
-            * RFC 9000 s. 10.1. 'An endpoint also restarts its idle timer when
-            * sending an ack-eliciting packet if no other ack-eliciting packets
-            * have been sent since last receiving and processing a packet.'
-            */
+             * RFC 9000 s. 10.1. 'An endpoint also restarts its idle timer when
+             * sending an ack-eliciting packet if no other ack-eliciting packets
+             * have been sent since last receiving and processing a packet.'
+             */
             if (status.sent_ack_eliciting
-                    && !ch->have_sent_ack_eliciting_since_rx) {
+                && !ch->have_sent_ack_eliciting_since_rx) {
                 ch_update_idle(ch);
                 ch->have_sent_ack_eliciting_since_rx = 1;
             }
 
             if (!ch->is_server && status.sent_handshake)
                 /*
-                * RFC 9001 s. 4.9.1: A client MUST discard Initial keys when it
-                * first sends a Handshake packet.
-                */
+                 * RFC 9001 s. 4.9.1: A client MUST discard Initial keys when it
+                 * first sends a Handshake packet.
+                 */
                 ch_discard_el(ch, QUIC_ENC_LEVEL_INITIAL);
 
             if (ch->rxku_pending_confirm_done)
@@ -2735,20 +2676,20 @@ static int ch_tx(QUIC_CHANNEL *ch, int *notify_other_threads)
 
         if (!res) {
             /*
-            * One case where TXP can fail is if we reach a TX PN of 2**62 - 1.
-            * As per RFC 9000 s. 12.3, if this happens we MUST close the
-            * connection without sending a CONNECTION_CLOSE frame. This is
-            * actually handled as an emergent consequence of our design, as the
-            * TX packetiser will never transmit another packet when the TX PN
-            * reaches the limit.
-            *
-            * Calling the below function terminates the connection; its attempt
-            * to schedule a CONNECTION_CLOSE frame will not actually cause a
-            * packet to be transmitted for this reason.
-            */
+             * One case where TXP can fail is if we reach a TX PN of 2**62 - 1.
+             * As per RFC 9000 s. 12.3, if this happens we MUST close the
+             * connection without sending a CONNECTION_CLOSE frame. This is
+             * actually handled as an emergent consequence of our design, as the
+             * TX packetiser will never transmit another packet when the TX PN
+             * reaches the limit.
+             *
+             * Calling the below function terminates the connection; its attempt
+             * to schedule a CONNECTION_CLOSE frame will not actually cause a
+             * packet to be transmitted for this reason.
+             */
             ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_INTERNAL_ERROR,
-                                                   0,
-                                                   "internal error (txp generate)");
+                0,
+                "internal error (txp generate)");
             break;
         }
     } while (status.sent_pkt > 0);
@@ -2798,8 +2739,8 @@ static OSSL_TIME ch_determine_next_tick_deadline(QUIC_CHANNEL *ch)
     for (i = 0; i < QUIC_ENC_LEVEL_NUM; i++) {
         if (ossl_qtx_is_enc_level_provisioned(ch->qtx, i)) {
             deadline = ossl_time_min(deadline,
-                                     ossl_ackm_get_ack_deadline(ch->ackm,
-                                                                ossl_quic_enc_level_to_pn_space(i)));
+                ossl_ackm_get_ack_deadline(ch->ackm,
+                    ossl_quic_enc_level_to_pn_space(i)));
         }
     }
 
@@ -2812,15 +2753,15 @@ static OSSL_TIME ch_determine_next_tick_deadline(QUIC_CHANNEL *ch)
 
     /* Apply TXP wakeup deadline. */
     deadline = ossl_time_min(deadline,
-                             ossl_quic_tx_packetiser_get_deadline(ch->txp));
+        ossl_quic_tx_packetiser_get_deadline(ch->txp));
 
     /* Is the terminating timer armed? */
     if (ossl_quic_channel_is_terminating(ch))
         deadline = ossl_time_min(deadline,
-                                 ch->terminate_deadline);
+            ch->terminate_deadline);
     else if (!ossl_time_is_infinite(ch->idle_deadline))
         deadline = ossl_time_min(deadline,
-                                 ch->idle_deadline);
+            ch->idle_deadline);
 
     /* When does the RXKU process complete? */
     if (ch->rxku_in_progress)
@@ -2845,14 +2786,14 @@ static void ch_record_state_transition(QUIC_CHANNEL *ch, uint32_t new_state)
     ch->state = new_state;
 
     ossl_qlog_event_connectivity_connection_state_updated(ch_get_qlog(ch),
-                                                          old_state,
-                                                          new_state,
-                                                          ch->handshake_complete,
-                                                          ch->handshake_confirmed);
+        old_state,
+        new_state,
+        ch->handshake_complete,
+        ch->handshake_confirmed);
 }
 
 static void free_peer_token(const unsigned char *token,
-                            size_t token_len, void *arg)
+    size_t token_len, void *arg)
 {
     ossl_quic_free_peer_token((QUIC_TOKEN *)arg);
 }
@@ -2881,20 +2822,20 @@ int ossl_quic_channel_start(QUIC_CHANNEL *ch)
      */
     if (!ch->is_server
         && ossl_quic_get_peer_token(ch->port->channel_ctx,
-                                    &ch->cur_peer_addr,
-                                    &token)
+            &ch->cur_peer_addr,
+            &token)
         && !ossl_quic_tx_packetiser_set_initial_token(ch->txp, token->token,
-                                                      token->token_len,
-                                                      free_peer_token,
-                                                      token))
+            token->token_len,
+            free_peer_token,
+            token))
         free_peer_token(NULL, 0, token);
 
     /* Plug in secrets for the Initial EL. */
     if (!ossl_quic_provide_initial_secret(ch->port->engine->libctx,
-                                          ch->port->engine->propq,
-                                          &ch->init_dcid,
-                                          ch->is_server,
-                                          ch->qrx, ch->qtx))
+            ch->port->engine->propq,
+            &ch->init_dcid,
+            ch->is_server,
+            ch->qrx, ch->qtx))
         return 0;
 
     /*
@@ -2911,7 +2852,7 @@ int ossl_quic_channel_start(QUIC_CHANNEL *ch)
     ch->doing_proactive_ver_neg = 0; /* not currently supported */
 
     ossl_qlog_event_connectivity_connection_started(ch_get_qlog(ch),
-                                                    &ch->init_dcid);
+        &ch->init_dcid);
 
     /* Handshake layer: start (e.g. send CH). */
     if (!ch_tick_tls(ch, /*channel_only=*/0, NULL))
@@ -2928,17 +2869,17 @@ static void free_token(const unsigned char *token, size_t token_len, void *arg)
 
 /* Start a locally initiated connection shutdown. */
 void ossl_quic_channel_local_close(QUIC_CHANNEL *ch, uint64_t app_error_code,
-                                   const char *app_reason)
+    const char *app_reason)
 {
-    QUIC_TERMINATE_CAUSE tcause = {0};
+    QUIC_TERMINATE_CAUSE tcause = { 0 };
 
     if (ossl_quic_channel_is_term_any(ch))
         return;
 
-    tcause.app          = 1;
-    tcause.error_code   = app_error_code;
-    tcause.reason       = app_reason;
-    tcause.reason_len   = app_reason != NULL ? strlen(app_reason) : 0;
+    tcause.app = 1;
+    tcause.error_code = app_error_code;
+    tcause.reason = app_reason;
+    tcause.reason_len = app_reason != NULL ? strlen(app_reason) : 0;
     ch_start_terminating(ch, &tcause, 0);
 }
 
@@ -2957,16 +2898,16 @@ static int ch_restart(QUIC_CHANNEL *ch)
      * Just pretend we lost our initial packet, so it gets
      * regenerated, with our updated protocol version number
      */
-   return ossl_ackm_mark_packet_pseudo_lost(ch->ackm, QUIC_PN_SPACE_INITIAL,
-                                            /* PN= */ 0);
+    return ossl_ackm_mark_packet_pseudo_lost(ch->ackm, QUIC_PN_SPACE_INITIAL,
+        /* PN= */ 0);
 }
 
 /* Called when a server asks us to do a retry. */
 static int ch_retry(QUIC_CHANNEL *ch,
-                    const unsigned char *retry_token,
-                    size_t retry_token_len,
-                    const QUIC_CONN_ID *retry_scid,
-                    int drop_later_pn)
+    const unsigned char *retry_token,
+    size_t retry_token_len,
+    const QUIC_CONN_ID *retry_scid,
+    int drop_later_pn)
 {
     void *buf;
     QUIC_PN pn = 0;
@@ -2990,19 +2931,19 @@ static int ch_retry(QUIC_CHANNEL *ch,
         return 0;
 
     if (!ossl_quic_tx_packetiser_set_initial_token(ch->txp, buf,
-                                                   retry_token_len,
-                                                   free_token, NULL)) {
+            retry_token_len,
+            free_token, NULL)) {
         /*
          * This may fail if the token we receive is too big for us to ever be
          * able to transmit in an outgoing Initial packet.
          */
         ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_INVALID_TOKEN, 0,
-                                               "received oversize token");
+            "received oversize token");
         OPENSSL_free(buf);
         return 0;
     }
 
-    ch->retry_scid  = *retry_scid;
+    ch->retry_scid = *retry_scid;
     ch->doing_retry = 1;
 
     /*
@@ -3023,7 +2964,7 @@ static int ch_retry(QUIC_CHANNEL *ch,
      * repeated retries.
      */
     if (!ossl_ackm_mark_packet_pseudo_lost(ch->ackm, QUIC_PN_SPACE_INITIAL,
-                                           pn))
+            pn))
         return 0;
 
     /*
@@ -3031,10 +2972,10 @@ static int ch_retry(QUIC_CHANNEL *ch,
      * the secrets for an EL after we already provisioned it.
      */
     if (!ossl_quic_provide_initial_secret(ch->port->engine->libctx,
-                                          ch->port->engine->propq,
-                                          &ch->retry_scid,
-                                          /*is_server=*/0,
-                                          ch->qrx, ch->qtx))
+            ch->port->engine->propq,
+            &ch->retry_scid,
+            /*is_server=*/0,
+            ch->qrx, ch->qtx))
         return 0;
 
     return 1;
@@ -3042,7 +2983,7 @@ static int ch_retry(QUIC_CHANNEL *ch,
 
 /* Called when an EL is to be discarded. */
 static int ch_discard_el(QUIC_CHANNEL *ch,
-                         uint32_t enc_level)
+    uint32_t enc_level)
 {
     if (!ossl_assert(enc_level < QUIC_ENC_LEVEL_1RTT))
         return 0;
@@ -3090,9 +3031,9 @@ int ossl_quic_channel_on_handshake_confirmed(QUIC_CHANNEL *ch)
          * completed.
          */
         ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                               OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE,
-                                               "handshake cannot be confirmed "
-                                               "before it is completed");
+            OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE,
+            "handshake cannot be confirmed "
+            "before it is completed");
         return 0;
     }
 
@@ -3149,14 +3090,14 @@ int ossl_quic_channel_on_handshake_confirmed(QUIC_CHANNEL *ch)
  *      frame in response to any UDP datagram that is received.
  */
 static void copy_tcause(QUIC_TERMINATE_CAUSE *dst,
-                        const QUIC_TERMINATE_CAUSE *src)
+    const QUIC_TERMINATE_CAUSE *src)
 {
     dst->error_code = src->error_code;
     dst->frame_type = src->frame_type;
-    dst->app        = src->app;
-    dst->remote     = src->remote;
+    dst->app = src->app;
+    dst->remote = src->remote;
 
-    dst->reason     = NULL;
+    dst->reason = NULL;
     dst->reason_len = 0;
 
     if (src->reason != NULL && src->reason_len > 0) {
@@ -3174,14 +3115,14 @@ static void copy_tcause(QUIC_TERMINATE_CAUSE *dst,
         if (r == NULL)
             return;
 
-        r[l]  = '\0';
+        r[l] = '\0';
         dst->reason_len = l;
     }
 }
 
 static void ch_start_terminating(QUIC_CHANNEL *ch,
-                                 const QUIC_TERMINATE_CAUSE *tcause,
-                                 int force_immediate)
+    const QUIC_TERMINATE_CAUSE *tcause,
+    int force_immediate)
 {
     /* No point sending anything if we haven't sent anything yet. */
     if (!ch->have_sent_any_pkt)
@@ -3200,9 +3141,7 @@ static void ch_start_terminating(QUIC_CHANNEL *ch,
         ossl_qlog_event_connectivity_connection_closed(ch_get_qlog(ch), tcause);
 
         if (!force_immediate) {
-            ch_record_state_transition(ch, tcause->remote
-                                           ? QUIC_CHANNEL_STATE_TERMINATING_DRAINING
-                                           : QUIC_CHANNEL_STATE_TERMINATING_CLOSING);
+            ch_record_state_transition(ch, tcause->remote ? QUIC_CHANNEL_STATE_TERMINATING_DRAINING : QUIC_CHANNEL_STATE_TERMINATING_CLOSING);
             /*
              * RFC 9000 s. 10.2 Immediate Close
              *  These states SHOULD persist for at least three times
@@ -3210,17 +3149,17 @@ static void ch_start_terminating(QUIC_CHANNEL *ch,
              */
             ch->terminate_deadline
                 = ossl_time_add(get_time(ch),
-                                ossl_time_multiply(ossl_ackm_get_pto_duration(ch->ackm),
-                                                   3));
+                    ossl_time_multiply(ossl_ackm_get_pto_duration(ch->ackm),
+                        3));
 
             if (!tcause->remote) {
-                OSSL_QUIC_FRAME_CONN_CLOSE f = {0};
+                OSSL_QUIC_FRAME_CONN_CLOSE f = { 0 };
 
                 /* best effort */
                 f.error_code = ch->terminate_cause.error_code;
                 f.frame_type = ch->terminate_cause.frame_type;
-                f.is_app     = ch->terminate_cause.app;
-                f.reason     = (char *)ch->terminate_cause.reason;
+                f.is_app = ch->terminate_cause.app;
+                f.reason = (char *)ch->terminate_cause.reason;
                 f.reason_len = ch->terminate_cause.reason_len;
                 ossl_quic_tx_packetiser_schedule_conn_close(ch->txp, &f);
                 /*
@@ -3269,18 +3208,18 @@ static void ch_start_terminating(QUIC_CHANNEL *ch,
 
 /* For RXDP use. */
 void ossl_quic_channel_on_remote_conn_close(QUIC_CHANNEL *ch,
-                                            OSSL_QUIC_FRAME_CONN_CLOSE *f)
+    OSSL_QUIC_FRAME_CONN_CLOSE *f)
 {
-    QUIC_TERMINATE_CAUSE tcause = {0};
+    QUIC_TERMINATE_CAUSE tcause = { 0 };
 
     if (!ossl_quic_channel_is_active(ch))
         return;
 
-    tcause.remote     = 1;
-    tcause.app        = f->is_app;
+    tcause.remote = 1;
+    tcause.app = f->is_app;
     tcause.error_code = f->error_code;
     tcause.frame_type = f->frame_type;
-    tcause.reason     = f->reason;
+    tcause.reason = f->reason;
     tcause.reason_len = f->reason_len;
     ch_start_terminating(ch, &tcause, 0);
 }
@@ -3314,9 +3253,10 @@ static int ch_enqueue_retire_conn_id(QUIC_CHANNEL *ch, uint64_t seq_num)
         goto err;
 
     if (ossl_quic_cfq_add_frame(ch->cfq, 1, QUIC_PN_SPACE_APP,
-                                OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID, 0,
-                                (unsigned char *)buf_mem->data, l,
-                                free_frame_data, NULL) == NULL)
+            OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID, 0,
+            (unsigned char *)buf_mem->data, l,
+            free_frame_data, NULL)
+        == NULL)
         goto err;
 
     buf_mem->data = NULL;
@@ -3325,15 +3265,15 @@ static int ch_enqueue_retire_conn_id(QUIC_CHANNEL *ch, uint64_t seq_num)
 
 err:
     ossl_quic_channel_raise_protocol_error(ch,
-                                           OSSL_QUIC_ERR_INTERNAL_ERROR,
-                                           OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
-                                           "internal error enqueueing retire conn id");
+        OSSL_QUIC_ERR_INTERNAL_ERROR,
+        OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
+        "internal error enqueueing retire conn id");
     BUF_MEM_free(buf_mem);
     return 0;
 }
 
 void ossl_quic_channel_on_new_conn_id(QUIC_CHANNEL *ch,
-                                      OSSL_QUIC_FRAME_NEW_CONN_ID *f)
+    OSSL_QUIC_FRAME_NEW_CONN_ID *f)
 {
     uint64_t new_remote_seq_num = ch->cur_remote_seq_num;
     uint64_t new_retire_prior_to = ch->cur_retire_prior_to;
@@ -3345,9 +3285,9 @@ void ossl_quic_channel_on_new_conn_id(QUIC_CHANNEL *ch,
     if (ch->cur_remote_dcid.id_len == 0) {
         /* Changing from 0 length connection id is disallowed */
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                               OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
-                                               "zero length connection id in use");
+            OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+            OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
+            "zero length connection id in use");
 
         return;
     }
@@ -3369,9 +3309,9 @@ void ossl_quic_channel_on_new_conn_id(QUIC_CHANNEL *ch,
      */
     if (new_remote_seq_num - new_retire_prior_to > 1) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_CONNECTION_ID_LIMIT_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
-                                               "active_connection_id limit violated");
+            OSSL_QUIC_ERR_CONNECTION_ID_LIMIT_ERROR,
+            OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
+            "active_connection_id limit violated");
         return;
     }
 
@@ -3392,9 +3332,9 @@ void ossl_quic_channel_on_new_conn_id(QUIC_CHANNEL *ch,
      */
     if (new_retire_prior_to - ch->cur_retire_prior_to > 10) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_CONNECTION_ID_LIMIT_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
-                                               "retiring connection id limit violated");
+            OSSL_QUIC_ERR_CONNECTION_ID_LIMIT_ERROR,
+            OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
+            "retiring connection id limit violated");
 
         return;
     }
@@ -3402,11 +3342,11 @@ void ossl_quic_channel_on_new_conn_id(QUIC_CHANNEL *ch,
     if (new_remote_seq_num > ch->cur_remote_seq_num) {
         /* Add new stateless reset token */
         if (!ossl_quic_srtm_add(ch->srtm, ch, new_remote_seq_num,
-                                &f->stateless_reset)) {
+                &f->stateless_reset)) {
             ossl_quic_channel_raise_protocol_error(
-                    ch, OSSL_QUIC_ERR_CONNECTION_ID_LIMIT_ERROR,
-                    OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
-                    "unable to store stateless reset token");
+                ch, OSSL_QUIC_ERR_CONNECTION_ID_LIMIT_ERROR,
+                OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
+                "unable to store stateless reset token");
 
             return;
         }
@@ -3465,16 +3405,16 @@ void ossl_quic_channel_inject_pkt(QUIC_CHANNEL *ch, OSSL_QRX_PKT *qpkt)
 
 void ossl_quic_channel_on_stateless_reset(QUIC_CHANNEL *ch)
 {
-    QUIC_TERMINATE_CAUSE tcause = {0};
+    QUIC_TERMINATE_CAUSE tcause = { 0 };
 
-    tcause.error_code   = OSSL_QUIC_ERR_NO_ERROR;
-    tcause.remote       = 1;
+    tcause.error_code = OSSL_QUIC_ERR_NO_ERROR;
+    tcause.remote = 1;
     ch_start_terminating(ch, &tcause, 0);
 }
 
 void ossl_quic_channel_raise_net_error(QUIC_CHANNEL *ch)
 {
-    QUIC_TERMINATE_CAUSE tcause = {0};
+    QUIC_TERMINATE_CAUSE tcause = { 0 };
 
     if (ch->net_error)
         return;
@@ -3482,7 +3422,7 @@ void ossl_quic_channel_raise_net_error(QUIC_CHANNEL *ch)
     ch->net_error = 1;
 
     tcause.error_code = OSSL_QUIC_ERR_INTERNAL_ERROR;
-    tcause.reason     = "network BIO I/O error";
+    tcause.reason = "network BIO I/O error";
     tcause.reason_len = strlen(tcause.reason);
 
     /*
@@ -3509,17 +3449,18 @@ void ossl_quic_channel_restore_err_state(QUIC_CHANNEL *ch)
 }
 
 void ossl_quic_channel_raise_protocol_error_loc(QUIC_CHANNEL *ch,
-                                                uint64_t error_code,
-                                                uint64_t frame_type,
-                                                const char *reason,
-                                                ERR_STATE *err_state,
-                                                const char *src_file,
-                                                int src_line,
-                                                const char *src_func)
+    uint64_t error_code,
+    uint64_t frame_type,
+    const char *reason,
+    ERR_STATE *err_state,
+    const char *src_file,
+    int src_line,
+    const char *src_func)
 {
-    QUIC_TERMINATE_CAUSE tcause = {0};
+    QUIC_TERMINATE_CAUSE tcause = { 0 };
     int err_reason = error_code == OSSL_QUIC_ERR_INTERNAL_ERROR
-                     ? ERR_R_INTERNAL_ERROR : SSL_R_QUIC_PROTOCOL_ERROR;
+        ? ERR_R_INTERNAL_ERROR
+        : SSL_R_QUIC_PROTOCOL_ERROR;
     const char *err_str = ossl_quic_err_to_string(error_code);
     const char *err_str_pfx = " (", *err_str_sfx = ")";
     const char *ft_str = NULL;
@@ -3530,7 +3471,7 @@ void ossl_quic_channel_raise_protocol_error_loc(QUIC_CHANNEL *ch,
         return;
 
     if (err_str == NULL) {
-        err_str     = "";
+        err_str = "";
         err_str_pfx = "";
         err_str_sfx = "";
     }
@@ -3545,25 +3486,25 @@ void ossl_quic_channel_raise_protocol_error_loc(QUIC_CHANNEL *ch,
     if (frame_type != 0) {
         ft_str = ossl_quic_frame_type_to_string(frame_type);
         if (ft_str == NULL) {
-            ft_str      = "";
-            ft_str_pfx  = "";
-            ft_str_sfx  = "";
+            ft_str = "";
+            ft_str_pfx = "";
+            ft_str_sfx = "";
         }
 
         ERR_raise_data(ERR_LIB_SSL, err_reason,
-                       "QUIC error code: 0x%llx%s%s%s "
-                       "(triggered by frame type: 0x%llx%s%s%s), reason: \"%s\"",
-                       (unsigned long long) error_code,
-                       err_str_pfx, err_str, err_str_sfx,
-                       (unsigned long long) frame_type,
-                       ft_str_pfx, ft_str, ft_str_sfx,
-                       reason);
+            "QUIC error code: 0x%llx%s%s%s "
+            "(triggered by frame type: 0x%llx%s%s%s), reason: \"%s\"",
+            (unsigned long long)error_code,
+            err_str_pfx, err_str, err_str_sfx,
+            (unsigned long long)frame_type,
+            ft_str_pfx, ft_str, ft_str_sfx,
+            reason);
     } else {
         ERR_raise_data(ERR_LIB_SSL, err_reason,
-                       "QUIC error code: 0x%llx%s%s%s, reason: \"%s\"",
-                       (unsigned long long) error_code,
-                       err_str_pfx, err_str, err_str_sfx,
-                       reason);
+            "QUIC error code: 0x%llx%s%s%s, reason: \"%s\"",
+            (unsigned long long)error_code,
+            err_str_pfx, err_str, err_str_sfx,
+            reason);
     }
 
     if (src_file != NULL)
@@ -3573,7 +3514,7 @@ void ossl_quic_channel_raise_protocol_error_loc(QUIC_CHANNEL *ch,
 
     tcause.error_code = error_code;
     tcause.frame_type = frame_type;
-    tcause.reason     = reason;
+    tcause.reason = reason;
     tcause.reason_len = strlen(reason);
 
     ch->protocol_error = 1;
@@ -3611,7 +3552,7 @@ static OSSL_TIME ch_get_effective_idle_timeout_duration(QUIC_CHANNEL *ch)
      */
     pto = ossl_ackm_get_pto_duration(ch->ackm);
     return ossl_time_max(ossl_ms2time(ch->max_idle_timeout),
-                                      ossl_time_multiply(pto, 3));
+        ossl_time_multiply(pto, 3));
 }
 
 /*
@@ -3621,7 +3562,7 @@ static OSSL_TIME ch_get_effective_idle_timeout_duration(QUIC_CHANNEL *ch)
 static void ch_update_idle(QUIC_CHANNEL *ch)
 {
     ch->idle_deadline = ossl_time_add(get_time(ch),
-                                      ch_get_effective_idle_timeout_duration(ch));
+        ch_get_effective_idle_timeout_duration(ch));
 }
 
 /*
@@ -3657,9 +3598,9 @@ static void ch_on_idle_timeout(QUIC_CHANNEL *ch)
      * CONN_CLOSE is never sent for it. We shouldn't use this data once we reach
      * TERMINATED anyway.
      */
-    ch->terminate_cause.app         = 0;
-    ch->terminate_cause.error_code  = OSSL_QUIC_LOCAL_ERR_IDLE_TIMEOUT;
-    ch->terminate_cause.frame_type  = 0;
+    ch->terminate_cause.app = 0;
+    ch->terminate_cause.error_code = OSSL_QUIC_LOCAL_ERR_IDLE_TIMEOUT;
+    ch->terminate_cause.frame_type = 0;
 
     ch_record_state_transition(ch, QUIC_CHANNEL_STATE_TERMINATED);
 }
@@ -3681,15 +3622,15 @@ static void ch_on_idle_timeout(QUIC_CHANNEL *ch)
  * @return         1 on success, 0 on failure to set required elements.
  */
 static int ch_on_new_conn_common(QUIC_CHANNEL *ch, const BIO_ADDR *peer,
-                                 const QUIC_CONN_ID *peer_scid,
-                                 const QUIC_CONN_ID *peer_dcid,
-                                 const QUIC_CONN_ID *peer_odcid)
+    const QUIC_CONN_ID *peer_scid,
+    const QUIC_CONN_ID *peer_dcid,
+    const QUIC_CONN_ID *peer_odcid)
 {
     /* Note our newly learnt peer address and CIDs. */
     if (!BIO_ADDR_copy(&ch->cur_peer_addr, peer))
         return 0;
 
-    ch->init_dcid       = *peer_dcid;
+    ch->init_dcid = *peer_dcid;
     ch->cur_remote_dcid = *peer_scid;
     ch->odcid.id_len = 0;
 
@@ -3716,16 +3657,14 @@ static int ch_on_new_conn_common(QUIC_CHANNEL *ch, const BIO_ADDR *peer,
      * port_default_packet_handler() already.
      */
     if (!ossl_quic_provide_initial_secret(ch->port->engine->libctx,
-                                          ch->port->engine->propq,
-                                          &ch->init_dcid,
-                                          /*is_server=*/1,
-                                          NULL, ch->qtx))
+            ch->port->engine->propq,
+            &ch->init_dcid,
+            /*is_server=*/1,
+            NULL, ch->qtx))
         return 0;
 
     /* Register the peer ODCID in the LCIDM. */
-    if (!ossl_quic_lcidm_enrol_odcid(ch->lcidm, ch, peer_odcid == NULL ?
-                                     &ch->init_dcid :
-                                     peer_odcid))
+    if (!ossl_quic_lcidm_enrol_odcid(ch->lcidm, ch, peer_odcid == NULL ? &ch->init_dcid : peer_odcid))
         return 0;
 
     /* Change state. */
@@ -3736,8 +3675,8 @@ static int ch_on_new_conn_common(QUIC_CHANNEL *ch, const BIO_ADDR *peer,
 
 /* Called when we, as a server, get a new incoming connection. */
 int ossl_quic_channel_on_new_conn(QUIC_CHANNEL *ch, const BIO_ADDR *peer,
-                                  const QUIC_CONN_ID *peer_scid,
-                                  const QUIC_CONN_ID *peer_dcid)
+    const QUIC_CONN_ID *peer_scid,
+    const QUIC_CONN_ID *peer_dcid)
 {
     if (!ossl_assert(ch->state == QUIC_CHANNEL_STATE_IDLE && ch->is_server))
         return 0;
@@ -3773,9 +3712,9 @@ int ossl_quic_channel_on_new_conn(QUIC_CHANNEL *ch, const BIO_ADDR *peer,
  *         met (e.g., channel is not idle or not a server, or binding fails).
  */
 int ossl_quic_bind_channel(QUIC_CHANNEL *ch, const BIO_ADDR *peer,
-                           const QUIC_CONN_ID *peer_scid,
-                           const QUIC_CONN_ID *peer_dcid,
-                           const QUIC_CONN_ID *peer_odcid)
+    const QUIC_CONN_ID *peer_scid,
+    const QUIC_CONN_ID *peer_dcid,
+    const QUIC_CONN_ID *peer_odcid)
 {
     if (peer_dcid == NULL)
         return 0;
@@ -3800,7 +3739,7 @@ SSL *ossl_quic_channel_get0_ssl(QUIC_CHANNEL *ch)
 }
 
 static int ch_init_new_stream(QUIC_CHANNEL *ch, QUIC_STREAM *qs,
-                              int can_send, int can_recv)
+    int can_send, int can_recv)
 {
     uint64_t rxfc_wnd;
     int server_init = ossl_quic_stream_is_server_init(qs);
@@ -3850,9 +3789,9 @@ static int ch_init_new_stream(QUIC_CHANNEL *ch, QUIC_STREAM *qs,
         rxfc_wnd = ch->tx_init_max_stream_data_bidi_remote;
 
     if (!ossl_quic_rxfc_init(&qs->rxfc, &ch->conn_rxfc,
-                             rxfc_wnd,
-                             DEFAULT_STREAM_RXFC_MAX_WND_MUL * rxfc_wnd,
-                             get_time, ch))
+            rxfc_wnd,
+            DEFAULT_STREAM_RXFC_MAX_WND_MUL * rxfc_wnd,
+            get_time, ch))
         goto err;
 
     return 1;
@@ -3866,50 +3805,50 @@ err:
 }
 
 static uint64_t *ch_get_local_stream_next_ordinal_ptr(QUIC_CHANNEL *ch,
-                                                      int is_uni)
+    int is_uni)
 {
     return is_uni ? &ch->next_local_stream_ordinal_uni
                   : &ch->next_local_stream_ordinal_bidi;
 }
 
 static const uint64_t *ch_get_local_stream_max_ptr(const QUIC_CHANNEL *ch,
-                                                   int is_uni)
+    int is_uni)
 {
     return is_uni ? &ch->max_local_streams_uni
                   : &ch->max_local_streams_bidi;
 }
 
 static const QUIC_RXFC *ch_get_remote_stream_count_rxfc(const QUIC_CHANNEL *ch,
-                                                        int is_uni)
+    int is_uni)
 {
     return is_uni ? &ch->max_streams_uni_rxfc
                   : &ch->max_streams_bidi_rxfc;
 }
 
 int ossl_quic_channel_is_new_local_stream_admissible(QUIC_CHANNEL *ch,
-                                                     int is_uni)
+    int is_uni)
 {
     const uint64_t *p_next_ordinal = ch_get_local_stream_next_ordinal_ptr(ch, is_uni);
 
     return ossl_quic_stream_map_is_local_allowed_by_stream_limit(&ch->qsm,
-                                                                 *p_next_ordinal,
-                                                                 is_uni);
+        *p_next_ordinal,
+        is_uni);
 }
 
 uint64_t ossl_quic_channel_get_local_stream_count_avail(const QUIC_CHANNEL *ch,
-                                                        int is_uni)
+    int is_uni)
 {
     const uint64_t *p_next_ordinal, *p_max;
 
-    p_next_ordinal  = ch_get_local_stream_next_ordinal_ptr((QUIC_CHANNEL *)ch,
-                                                           is_uni);
-    p_max           = ch_get_local_stream_max_ptr(ch, is_uni);
+    p_next_ordinal = ch_get_local_stream_next_ordinal_ptr((QUIC_CHANNEL *)ch,
+        is_uni);
+    p_max = ch_get_local_stream_max_ptr(ch, is_uni);
 
     return *p_max - *p_next_ordinal;
 }
 
 uint64_t ossl_quic_channel_get_remote_stream_count_avail(const QUIC_CHANNEL *ch,
-                                                         int is_uni)
+    int is_uni)
 {
     return ossl_quic_rxfc_get_credit(ch_get_remote_stream_count_rxfc(ch, is_uni));
 }
@@ -3952,7 +3891,7 @@ err:
 }
 
 QUIC_STREAM *ossl_quic_channel_new_stream_remote(QUIC_CHANNEL *ch,
-                                                 uint64_t stream_id)
+    uint64_t stream_id)
 {
     uint64_t peer_role;
     int is_uni;
@@ -3968,8 +3907,7 @@ QUIC_STREAM *ossl_quic_channel_new_stream_remote(QUIC_CHANNEL *ch,
     is_uni = ((stream_id & QUIC_STREAM_DIR_MASK) == QUIC_STREAM_DIR_UNI);
 
     qs = ossl_quic_stream_map_alloc(&ch->qsm, stream_id,
-                                    stream_id & (QUIC_STREAM_INITIATOR_MASK
-                                                 | QUIC_STREAM_DIR_MASK));
+        stream_id & (QUIC_STREAM_INITIATOR_MASK | QUIC_STREAM_DIR_MASK));
     if (qs == NULL)
         return NULL;
 
@@ -3989,20 +3927,20 @@ err:
 }
 
 void ossl_quic_channel_set_incoming_stream_auto_reject(QUIC_CHANNEL *ch,
-                                                       int enable,
-                                                       uint64_t aec)
+    int enable,
+    uint64_t aec)
 {
-    ch->incoming_stream_auto_reject     = (enable != 0);
+    ch->incoming_stream_auto_reject = (enable != 0);
     ch->incoming_stream_auto_reject_aec = aec;
 }
 
 void ossl_quic_channel_reject_stream(QUIC_CHANNEL *ch, QUIC_STREAM *qs)
 {
     ossl_quic_stream_map_stop_sending_recv_part(&ch->qsm, qs,
-                                                ch->incoming_stream_auto_reject_aec);
+        ch->incoming_stream_auto_reject_aec);
 
     ossl_quic_stream_map_reset_stream_send_part(&ch->qsm, qs,
-                                                ch->incoming_stream_auto_reject_aec);
+        ch->incoming_stream_auto_reject_aec);
     qs->deleted = 1;
 
     ossl_quic_stream_map_update_state(&ch->qsm, qs);
@@ -4010,7 +3948,7 @@ void ossl_quic_channel_reject_stream(QUIC_CHANNEL *ch, QUIC_STREAM *qs)
 
 /* Replace local connection ID in TXP and DEMUX for testing purposes. */
 int ossl_quic_channel_replace_local_cid(QUIC_CHANNEL *ch,
-                                        const QUIC_CONN_ID *conn_id)
+    const QUIC_CONN_ID *conn_id)
 {
     /* Remove the current LCID from the LCIDM. */
     if (!ossl_quic_lcidm_debug_remove(ch->lcidm, &ch->cur_local_cid))
@@ -4021,20 +3959,20 @@ int ossl_quic_channel_replace_local_cid(QUIC_CHANNEL *ch,
         return 0;
     /* Add the new LCID to the LCIDM. */
     if (!ossl_quic_lcidm_debug_add(ch->lcidm, ch, &ch->cur_local_cid,
-                                   100))
+            100))
         return 0;
     return 1;
 }
 
 void ossl_quic_channel_set_msg_callback(QUIC_CHANNEL *ch,
-                                        ossl_msg_cb msg_callback,
-                                        SSL *msg_callback_ssl)
+    ossl_msg_cb msg_callback,
+    SSL *msg_callback_ssl)
 {
     ch->msg_callback = msg_callback;
     ch->msg_callback_ssl = msg_callback_ssl;
     ossl_qtx_set_msg_callback(ch->qtx, msg_callback, msg_callback_ssl);
     ossl_quic_tx_packetiser_set_msg_callback(ch->txp, msg_callback,
-                                             msg_callback_ssl);
+        msg_callback_ssl);
     /*
      * postpone msg callback setting for tserver until port calls
      * port_bind_channel().
@@ -4044,7 +3982,7 @@ void ossl_quic_channel_set_msg_callback(QUIC_CHANNEL *ch,
 }
 
 void ossl_quic_channel_set_msg_callback_arg(QUIC_CHANNEL *ch,
-                                            void *msg_callback_arg)
+    void *msg_callback_arg)
 {
     ch->msg_callback_arg = msg_callback_arg;
     ossl_qtx_set_msg_callback_arg(ch->qtx, msg_callback_arg);
@@ -4059,7 +3997,7 @@ void ossl_quic_channel_set_msg_callback_arg(QUIC_CHANNEL *ch,
 }
 
 void ossl_quic_channel_set_txku_threshold_override(QUIC_CHANNEL *ch,
-                                                   uint64_t tx_pkt_threshold)
+    uint64_t tx_pkt_threshold)
 {
     ch->txku_threshold_override = tx_pkt_threshold;
 }
diff --git a/crypto/openssl/ssl/quic/quic_channel_local.h b/crypto/openssl/ssl/quic/quic_channel_local.h
index 816ccf694b8f..ae443fccca1e 100644
--- a/crypto/openssl/ssl/quic/quic_channel_local.h
+++ b/crypto/openssl/ssl/quic/quic_channel_local.h
@@ -1,16 +1,16 @@
 #ifndef OSSL_QUIC_CHANNEL_LOCAL_H
-# define OSSL_QUIC_CHANNEL_LOCAL_H
+#define OSSL_QUIC_CHANNEL_LOCAL_H
 
-# include "internal/quic_channel.h"
+#include "internal/quic_channel.h"
 
-# ifndef OPENSSL_NO_QUIC
+#ifndef OPENSSL_NO_QUIC
 
-#  include <openssl/lhash.h>
-#  include "internal/list.h"
-#  include "internal/quic_predef.h"
-#  include "internal/quic_fc.h"
-#  include "internal/quic_stream_map.h"
-#  include "internal/quic_tls.h"
+#include <openssl/lhash.h>
+#include "internal/list.h"
+#include "internal/quic_predef.h"
+#include "internal/quic_fc.h"
+#include "internal/quic_stream_map.h"
+#include "internal/quic_tls.h"
 
 /*
  * QUIC Channel Structure
@@ -29,14 +29,14 @@
  * Other components should not include this header.
  */
 struct quic_channel_st {
-    QUIC_PORT                       *port;
+    QUIC_PORT *port;
 
     /*
      * QUIC_PORT keeps the channels which belong to it on a list for bookkeeping
      * purposes.
      */
-    OSSL_LIST_MEMBER(ch,            QUIC_CHANNEL);
-    OSSL_LIST_MEMBER(incoming_ch,   QUIC_CHANNEL);
+    OSSL_LIST_MEMBER(ch, QUIC_CHANNEL);
+    OSSL_LIST_MEMBER(incoming_ch, QUIC_CHANNEL);
 
     /*
      * The associated TLS 1.3 connection data. Used to provide the handshake
@@ -46,68 +46,68 @@ struct quic_channel_st {
      * to be valid for the lifetime of the channel. Therefore we do not free it
      * when we free the channel.
      */
-    QUIC_TLS                        *qtls;
-    SSL                             *tls;
+    QUIC_TLS *qtls;
+    SSL *tls;
 
     /* Port LCIDM we use to register LCIDs. */
-    QUIC_LCIDM                      *lcidm;
+    QUIC_LCIDM *lcidm;
     /* SRTM we register SRTs with. */
-    QUIC_SRTM                       *srtm;
+    QUIC_SRTM *srtm;
 
     /* Optional QLOG instance (or NULL). */
-    QLOG                            *qlog;
+    QLOG *qlog;
 
     /*
      * The transport parameter block we will send or have sent.
      * Freed after sending or when connection is freed.
      */
-    unsigned char                   *local_transport_params;
+    unsigned char *local_transport_params;
 
     /*
      * Pending new token to send once handshake is complete
      */
-    uint8_t                         *pending_new_token;
-    size_t                          pending_new_token_len;
+    uint8_t *pending_new_token;
+    size_t pending_new_token_len;
 
     /* Our current L4 peer address, if any. */
-    BIO_ADDR                        cur_peer_addr;
+    BIO_ADDR cur_peer_addr;
 
     /*
      * Subcomponents of the connection. All of these components are instantiated
      * and owned by us.
      */
-    OSSL_QUIC_TX_PACKETISER         *txp;
-    QUIC_TXPIM                      *txpim;
-    QUIC_CFQ                        *cfq;
+    OSSL_QUIC_TX_PACKETISER *txp;
+    QUIC_TXPIM *txpim;
+    QUIC_CFQ *cfq;
     /*
      * Connection level FC. The stream_count RXFCs is used to manage
      * MAX_STREAMS signalling.
      */
-    QUIC_TXFC                       conn_txfc;
-    QUIC_RXFC                       conn_rxfc, crypto_rxfc[QUIC_PN_SPACE_NUM];
-    QUIC_RXFC                       max_streams_bidi_rxfc, max_streams_uni_rxfc;
-    QUIC_STREAM_MAP                 qsm;
-    OSSL_STATM                      statm;
-    OSSL_CC_DATA                    *cc_data;
-    const OSSL_CC_METHOD            *cc_method;
-    OSSL_ACKM                       *ackm;
+    QUIC_TXFC conn_txfc;
+    QUIC_RXFC conn_rxfc, crypto_rxfc[QUIC_PN_SPACE_NUM];
+    QUIC_RXFC max_streams_bidi_rxfc, max_streams_uni_rxfc;
+    QUIC_STREAM_MAP qsm;
+    OSSL_STATM statm;
+    OSSL_CC_DATA *cc_data;
+    const OSSL_CC_METHOD *cc_method;
+    OSSL_ACKM *ackm;
 
     /* Record layers in the TX and RX directions. */
-    OSSL_QTX                        *qtx;
-    OSSL_QRX                        *qrx;
+    OSSL_QTX *qtx;
+    OSSL_QRX *qrx;
 
     /* Message callback related arguments */
-    ossl_msg_cb                     msg_callback;
-    void                            *msg_callback_arg;
-    SSL                             *msg_callback_ssl;
+    ossl_msg_cb msg_callback;
+    void *msg_callback_arg;
+    SSL *msg_callback_ssl;
 
     /*
      * Send and receive parts of the crypto streams.
      * crypto_send[QUIC_PN_SPACE_APP] is the 1-RTT crypto stream. There is no
      * 0-RTT crypto stream.
      */
-    QUIC_SSTREAM                    *crypto_send[QUIC_PN_SPACE_NUM];
-    QUIC_RSTREAM                    *crypto_recv[QUIC_PN_SPACE_NUM];
+    QUIC_SSTREAM *crypto_send[QUIC_PN_SPACE_NUM];
+    QUIC_RSTREAM *crypto_recv[QUIC_PN_SPACE_NUM];
 
     /* Internal state. */
     /*
@@ -115,89 +115,89 @@ struct quic_channel_st {
      * Server: The DCID used in the first Initial packet the client transmitted.
      * Randomly generated and required by RFC to be at least 8 bytes.
      */
-    QUIC_CONN_ID                    init_dcid;
+    QUIC_CONN_ID init_dcid;
 
     /*
      * Server: If this channel is created in response to an init packet sent
      * after the server has sent a retry packet to do address validation, this
      * field stores the original connection id from the first init packet sent
      */
-    QUIC_CONN_ID                    odcid;
+    QUIC_CONN_ID odcid;
 
     /*
      * Client: The SCID found in the first Initial packet from the server.
      * Not valid for servers.
      * Valid if have_received_enc_pkt is set.
      */
-    QUIC_CONN_ID                    init_scid;
+    QUIC_CONN_ID init_scid;
 
     /*
      * Client only: The SCID found in an incoming Retry packet we handled.
      * Not valid for servers.
      */
-    QUIC_CONN_ID                    retry_scid;
+    QUIC_CONN_ID retry_scid;
 
     /* Server only: The DCID we currently expect the peer to use to talk to us. */
-    QUIC_CONN_ID                    cur_local_cid;
+    QUIC_CONN_ID cur_local_cid;
 
     /*
      * The DCID we currently use to talk to the peer and its sequence num.
      */
-    QUIC_CONN_ID                    cur_remote_dcid;
-    uint64_t                        cur_remote_seq_num;
-    uint64_t                        cur_retire_prior_to;
+    QUIC_CONN_ID cur_remote_dcid;
+    uint64_t cur_remote_seq_num;
+    uint64_t cur_retire_prior_to;
 
     /* Transport parameter values we send to our peer. */
-    uint64_t                        tx_init_max_stream_data_bidi_local;
-    uint64_t                        tx_init_max_stream_data_bidi_remote;
-    uint64_t                        tx_init_max_stream_data_uni;
-    uint64_t                        tx_max_ack_delay; /* ms */
+    uint64_t tx_init_max_stream_data_bidi_local;
+    uint64_t tx_init_max_stream_data_bidi_remote;
+    uint64_t tx_init_max_stream_data_uni;
+    uint64_t tx_max_ack_delay; /* ms */
 
     /* Transport parameter values received from server. */
-    uint64_t                        rx_init_max_stream_data_bidi_local;
-    uint64_t                        rx_init_max_stream_data_bidi_remote;
-    uint64_t                        rx_init_max_stream_data_uni;
-    uint64_t                        rx_max_ack_delay; /* ms */
-    unsigned char                   rx_ack_delay_exp;
+    uint64_t rx_init_max_stream_data_bidi_local;
+    uint64_t rx_init_max_stream_data_bidi_remote;
+    uint64_t rx_init_max_stream_data_uni;
+    uint64_t rx_max_ack_delay; /* ms */
+    unsigned char rx_ack_delay_exp;
 
     /* Diagnostic counters for testing purposes only. May roll over. */
-    uint16_t                        diag_num_rx_ack; /* Number of ACK frames received */
+    uint16_t diag_num_rx_ack; /* Number of ACK frames received */
 
     /*
      * Temporary staging area to store information about the incoming packet we
      * are currently processing.
      */
-    OSSL_QRX_PKT                    *qrx_pkt;
+    OSSL_QRX_PKT *qrx_pkt;
 
     /*
      * Current limit on number of streams we may create. Set by transport
      * parameters initially and then by MAX_STREAMS frames.
      */
-    uint64_t                        max_local_streams_bidi;
-    uint64_t                        max_local_streams_uni;
+    uint64_t max_local_streams_bidi;
+    uint64_t max_local_streams_uni;
 
     /* The idle timeout values we and our peer requested. */
-    uint64_t                        max_idle_timeout_local_req;
-    uint64_t                        max_idle_timeout_remote_req;
+    uint64_t max_idle_timeout_local_req;
+    uint64_t max_idle_timeout_remote_req;
 
     /* The negotiated maximum idle timeout in milliseconds. */
-    uint64_t                        max_idle_timeout;
+    uint64_t max_idle_timeout;
 
     /*
      * Maximum payload size in bytes for datagrams sent to our peer, as
      * negotiated by transport parameters.
      */
-    uint64_t                        rx_max_udp_payload_size;
+    uint64_t rx_max_udp_payload_size;
     /* Maximum active CID limit, as negotiated by transport parameters. */
-    uint64_t                        rx_active_conn_id_limit;
+    uint64_t rx_active_conn_id_limit;
 
     /*
      * Used to allocate stream IDs. This is a stream ordinal, i.e., a stream ID
      * without the low two bits designating type and initiator. Shift and or in
      * the type bits to convert to a stream ID.
      */
-    uint64_t                        next_local_stream_ordinal_bidi;
-    uint64_t                        next_local_stream_ordinal_uni;
+    uint64_t next_local_stream_ordinal_bidi;
+    uint64_t next_local_stream_ordinal_uni;
 
     /*
      * Used to track which stream ordinals within a given stream type have been
@@ -205,14 +205,14 @@ struct quic_channel_st {
      * which streams should be implicitly created due to usage of a higher
      * stream ordinal.
      */
-    uint64_t                        next_remote_stream_ordinal_bidi;
-    uint64_t                        next_remote_stream_ordinal_uni;
+    uint64_t next_remote_stream_ordinal_bidi;
+    uint64_t next_remote_stream_ordinal_uni;
 
     /*
      * Application error code to be used for STOP_SENDING/RESET_STREAM frames
      * used to autoreject incoming streams.
      */
-    uint64_t                        incoming_stream_auto_reject_aec;
+    uint64_t incoming_stream_auto_reject_aec;
 
     /*
      * Override packet count threshold at which we do a spontaneous TXKU.
@@ -220,41 +220,41 @@ struct quic_channel_st {
      * limit advice from the QRL utility functions. This is intended for testing
      * use only. Usually set to UINT64_MAX.
      */
-    uint64_t                        txku_threshold_override;
+    uint64_t txku_threshold_override;
 
     /* Valid if we are in the TERMINATING or TERMINATED states. */
-    QUIC_TERMINATE_CAUSE            terminate_cause;
+    QUIC_TERMINATE_CAUSE terminate_cause;
 
     /*
      * Deadline at which we move to TERMINATING state. Valid if in the
      * TERMINATING state.
      */
-    OSSL_TIME                       terminate_deadline;
+    OSSL_TIME terminate_deadline;
 
     /*
      * Deadline at which connection dies due to idle timeout if no further
      * events occur.
      */
-    OSSL_TIME                       idle_deadline;
+    OSSL_TIME idle_deadline;
 
     /*
      * Deadline at which we should send an ACK-eliciting packet to ensure
      * idle timeout does not occur.
      */
-    OSSL_TIME                       ping_deadline;
+    OSSL_TIME ping_deadline;
 
     /*
      * The deadline at which the period in which it is RECOMMENDED that we not
      * initiate any spontaneous TXKU ends. This is zero if no such deadline
      * applies.
      */
-    OSSL_TIME                       txku_cooldown_deadline;
+    OSSL_TIME txku_cooldown_deadline;
 
     /*
      * The deadline at which we take the QRX out of UPDATING and back to NORMAL.
      * Valid if rxku_in_progress in 1.
      */
-    OSSL_TIME                       rxku_update_end_deadline;
+    OSSL_TIME rxku_update_end_deadline;
 
     /*
      * The first (application space) PN sent with a new key phase. Valid if the
@@ -263,13 +263,13 @@ struct quic_channel_st {
      * becomes 0. For sanity's sake, such a PN p should also be <= the highest
      * PN we have ever sent, of course.
      */
-    QUIC_PN                         txku_pn;
+    QUIC_PN txku_pn;
 
     /*
      * The (application space) PN which triggered RXKU detection. Valid if
      * rxku_pending_confirm.
      */
-    QUIC_PN                         rxku_trigger_pn;
+    QUIC_PN rxku_trigger_pn;
 
     /*
      * State tracking. QUIC connection-level state is best represented based on
@@ -281,37 +281,37 @@ struct quic_channel_st {
      * state if the state is QUIC_CHANNEL_STATE_ACTIVE and handshake_confirmed is
      * set.
      */
-    unsigned int                    state                   : 3;
+    unsigned int state : 3;
 
     /*
      * Have we received at least one encrypted packet from the peer?
      * (If so, Retry and Version Negotiation messages should no longer
      *  be received and should be ignored if they do occur.)
      */
-    unsigned int                    have_received_enc_pkt   : 1;
+    unsigned int have_received_enc_pkt : 1;
 
     /*
      * Have we successfully processed any packet, including a Version
      * Negotiation packet? If so, further Version Negotiation packets should be
      * ignored.
      */
-    unsigned int                    have_processed_any_pkt  : 1;
+    unsigned int have_processed_any_pkt : 1;
 
     /*
      * Have we sent literally any packet yet? If not, there is no point polling
      * RX.
      */
-    unsigned int                    have_sent_any_pkt       : 1;
+    unsigned int have_sent_any_pkt : 1;
 
     /*
      * Are we currently doing proactive version negotiation?
      */
-    unsigned int                    doing_proactive_ver_neg : 1;
+    unsigned int doing_proactive_ver_neg : 1;
 
     /* We have received transport parameters from the peer. */
-    unsigned int                    got_remote_transport_params    : 1;
+    unsigned int got_remote_transport_params : 1;
     /* We have generated our local transport parameters. */
-    unsigned int                    got_local_transport_params     : 1;
+    unsigned int got_local_transport_params : 1;
 
     /*
      * This monotonically transitions to 1 once the TLS state machine is
@@ -322,7 +322,7 @@ struct quic_channel_st {
      * Handshake completion is not the same as handshake confirmation (see
      * below).
      */
-    unsigned int                    handshake_complete      : 1;
+    unsigned int handshake_complete : 1;
 
     /*
      * This monotonically transitions to 1 once the handshake is confirmed.
@@ -330,13 +330,13 @@ struct quic_channel_st {
      * At our option, we may also take acknowledgement of any 1-RTT packet
      * we sent as a handshake confirmation.
      */
-    unsigned int                    handshake_confirmed     : 1;
+    unsigned int handshake_confirmed : 1;
 
     /*
      * We are sending Initial packets based on a Retry. This means we definitely
      * should not receive another Retry, and if we do it is an error.
      */
-    unsigned int                    doing_retry             : 1;
+    unsigned int doing_retry : 1;
 
     /*
      * We don't store the current EL here; the TXP asks the QTX which ELs
@@ -344,8 +344,8 @@ struct quic_channel_st {
      */
 
     /* Have statm, qsm been initialised? Used to track cleanup. */
-    unsigned int                    have_statm              : 1;
-    unsigned int                    have_qsm                : 1;
+    unsigned int have_statm : 1;
+    unsigned int have_qsm : 1;
 
     /*
      * Preferred ELs for transmission and reception. This is not strictly needed
@@ -355,41 +355,41 @@ struct quic_channel_st {
      * easier for interoperation with the handshake layer, which likes to invoke
      * the yield secret callback at different times for TX and RX.
      */
-    unsigned int                    tx_enc_level            : 3;
-    unsigned int                    rx_enc_level            : 3;
+    unsigned int tx_enc_level : 3;
+    unsigned int rx_enc_level : 3;
 
     /* If bit n is set, EL n has been discarded. */
-    unsigned int                    el_discarded            : 4;
+    unsigned int el_discarded : 4;
 
     /*
      * While in TERMINATING - CLOSING, set when we should generate a connection
      * close frame.
      */
-    unsigned int                    conn_close_queued       : 1;
+    unsigned int conn_close_queued : 1;
 
     /* Are we in server mode? Never changes after instantiation. */
-    unsigned int                    is_server               : 1;
+    unsigned int is_server : 1;
 
     /*
      * Set temporarily when the handshake layer has given us a new RX secret.
      * Used to determine if we need to check our RX queues again.
      */
-    unsigned int                    have_new_rx_secret      : 1;
+    unsigned int have_new_rx_secret : 1;
 
     /* Have we ever called QUIC_TLS yet during RX processing? */
-    unsigned int                    did_tls_tick            : 1;
+    unsigned int did_tls_tick : 1;
     /* Has any CRYPTO frame been processed during this tick? */
-    unsigned int                    did_crypto_frame        : 1;
+    unsigned int did_crypto_frame : 1;
 
     /*
      * Have we sent an ack-eliciting packet since the last successful packet
      * reception? Used to determine when to bump idle timer (see RFC 9000 s.
      * 10.1).
      */
-    unsigned int                    have_sent_ack_eliciting_since_rx    : 1;
+    unsigned int have_sent_ack_eliciting_since_rx : 1;
 
     /* Should incoming streams automatically be rejected? */
-    unsigned int                    incoming_stream_auto_reject         : 1;
+    unsigned int incoming_stream_auto_reject : 1;
 
     /*
      * 1 if a key update sequence was locally initiated, meaning we sent the
@@ -397,7 +397,7 @@ struct quic_channel_st {
      * another TXKU. 0 if a key update sequence was initiated by the peer,
      * meaning we detect a RXKU first and have to generate a TXKU in response.
      */
-    unsigned int                    ku_locally_initiated                : 1;
+    unsigned int ku_locally_initiated : 1;
 
     /*
      * 1 if we have triggered TXKU (whether spontaneous or solicited) but are
@@ -405,7 +405,7 @@ struct quic_channel_st {
      * are not allowed to trigger spontaneous TXKU (but solicited TXKU is
      * potentially still possible).
      */
-    unsigned int                    txku_in_progress                    : 1;
+    unsigned int txku_in_progress : 1;
 
     /*
      * We have received an RXKU event and currently are going through
@@ -416,7 +416,7 @@ struct quic_channel_st {
      * active so we know when to take the QRX out of UPDATING and back to
      * NORMAL.
      */
-    unsigned int                    rxku_in_progress                    : 1;
+    unsigned int rxku_in_progress : 1;
 
     /*
      * We have received an RXKU but have yet to send an ACK for it, which means
@@ -425,18 +425,18 @@ struct quic_channel_st {
      * this restriction comes into play if we take more than PTO time to send
      * an ACK for it (not likely).
      */
-    unsigned int                    rxku_pending_confirm                : 1;
+    unsigned int rxku_pending_confirm : 1;
 
     /* Temporary variable indicating rxku_pending_confirm is to become 0. */
-    unsigned int                    rxku_pending_confirm_done           : 1;
+    unsigned int rxku_pending_confirm_done : 1;
 
     /*
      * If set, RXKU is expected (because we initiated a spontaneous TXKU).
      */
-    unsigned int                    rxku_expected                       : 1;
+    unsigned int rxku_expected : 1;
 
     /* Permanent net error encountered */
-    unsigned int                    net_error                           : 1;
+    unsigned int net_error : 1;
 
     /*
      * Protocol error encountered. Note that you should refer to the state field
@@ -444,31 +444,31 @@ struct quic_channel_st {
      * after the first protocol error, but still record the first protocol error
      * if it happens during the TERMINATING state.
      */
-    unsigned int                    protocol_error                      : 1;
+    unsigned int protocol_error : 1;
 
     /* Are we using addressed mode? */
-    unsigned int                    addressed_mode                      : 1;
+    unsigned int addressed_mode : 1;
 
     /* Are we on the QUIC_PORT linked list of channels? */
-    unsigned int                    on_port_list                        : 1;
+    unsigned int on_port_list : 1;
 
     /* Has qlog been requested? */
-    unsigned int                    use_qlog                            : 1;
+    unsigned int use_qlog : 1;
 
     /* Has qlog been requested? */
-    unsigned int                    is_tserver_ch                       : 1;
+    unsigned int is_tserver_ch : 1;
 
     /* Saved error stack in case permanent error was encountered */
-    ERR_STATE                       *err_state;
+    ERR_STATE *err_state;
 
     /* Scratch area for use by RXDP to store decoded ACK ranges. */
-    OSSL_QUIC_ACK_RANGE             *ack_range_scratch;
-    size_t                          num_ack_range_scratch;
+    OSSL_QUIC_ACK_RANGE *ack_range_scratch;
+    size_t num_ack_range_scratch;
 
     /* Title for qlog purposes. We own this copy. */
-    char                            *qlog_title;
+    char *qlog_title;
 };
 
-# endif
+#endif
 
 #endif
diff --git a/crypto/openssl/ssl/quic/quic_demux.c b/crypto/openssl/ssl/quic/quic_demux.c
index a84a44c6e9fb..8fb4adb8c1db 100644
--- a/crypto/openssl/ssl/quic/quic_demux.c
+++ b/crypto/openssl/ssl/quic/quic_demux.c
@@ -13,47 +13,47 @@
 #include <openssl/lhash.h>
 #include <openssl/err.h>
 
-#define URXE_DEMUX_STATE_FREE       0 /* on urx_free list */
-#define URXE_DEMUX_STATE_PENDING    1 /* on urx_pending list */
-#define URXE_DEMUX_STATE_ISSUED     2 /* on neither list */
+#define URXE_DEMUX_STATE_FREE 0 /* on urx_free list */
+#define URXE_DEMUX_STATE_PENDING 1 /* on urx_pending list */
+#define URXE_DEMUX_STATE_ISSUED 2 /* on neither list */
 
-#define DEMUX_MAX_MSGS_PER_CALL    32
+#define DEMUX_MAX_MSGS_PER_CALL 32
 
-#define DEMUX_DEFAULT_MTU        1500
+#define DEMUX_DEFAULT_MTU 1500
 
 struct quic_demux_st {
     /* The underlying transport BIO with datagram semantics. */
-    BIO                        *net_bio;
+    BIO *net_bio;
 
     /*
      * QUIC short packets do not contain the length of the connection ID field,
      * therefore it must be known contextually. The demuxer requires connection
      * IDs of the same length to be used for all incoming packets.
      */
-    size_t                      short_conn_id_len;
+    size_t short_conn_id_len;
 
     /*
      * Our current understanding of the upper bound on an incoming datagram size
      * in bytes.
      */
-    size_t                      mtu;
+    size_t mtu;
 
     /* The datagram_id to use for the next datagram we receive. */
-    uint64_t                    next_datagram_id;
+    uint64_t next_datagram_id;
 
     /* Time retrieval callback. */
-    OSSL_TIME                 (*now)(void *arg);
-    void                       *now_arg;
+    OSSL_TIME (*now)(void *arg);
+    void *now_arg;
 
     /* The default packet handler, if any. */
-    ossl_quic_demux_cb_fn      *default_cb;
-    void                       *default_cb_arg;
+    ossl_quic_demux_cb_fn *default_cb;
+    void *default_cb_arg;
 
     /*
      * List of URXEs which are not currently in use (i.e., not filled with
      * unconsumed data). These are moved to the pending list as they are filled.
      */
-    QUIC_URXE_LIST              urx_free;
+    QUIC_URXE_LIST urx_free;
 
     /*
      * List of URXEs which are filled with received encrypted data. These are
@@ -62,16 +62,16 @@ struct quic_demux_st {
      * user calls ossl_quic_demux_release_urxe to return the URXE to us, at
      * which point we add it to the free list.
      */
-    QUIC_URXE_LIST              urx_pending;
+    QUIC_URXE_LIST urx_pending;
 
     /* Whether to use local address support. */
-    char                        use_local_addr;
+    char use_local_addr;
 };
 
 QUIC_DEMUX *ossl_quic_demux_new(BIO *net_bio,
-                                size_t short_conn_id_len,
-                                OSSL_TIME (*now)(void *arg),
-                                void *now_arg)
+    size_t short_conn_id_len,
+    OSSL_TIME (*now)(void *arg),
+    void *now_arg)
 {
     QUIC_DEMUX *demux;
 
@@ -79,12 +79,12 @@ QUIC_DEMUX *ossl_quic_demux_new(BIO *net_bio,
     if (demux == NULL)
         return NULL;
 
-    demux->net_bio                  = net_bio;
-    demux->short_conn_id_len        = short_conn_id_len;
+    demux->net_bio = net_bio;
+    demux->short_conn_id_len = short_conn_id_len;
     /* We update this if possible when we get a BIO. */
-    demux->mtu                      = DEMUX_DEFAULT_MTU;
-    demux->now                      = now;
-    demux->now_arg                  = now_arg;
+    demux->mtu = DEMUX_DEFAULT_MTU;
+    demux->now = now;
+    demux->now_arg = now_arg;
 
     if (net_bio != NULL
         && BIO_dgram_get_local_addr_cap(net_bio)
@@ -145,11 +145,11 @@ int ossl_quic_demux_set_mtu(QUIC_DEMUX *demux, unsigned int mtu)
 }
 
 void ossl_quic_demux_set_default_handler(QUIC_DEMUX *demux,
-                                         ossl_quic_demux_cb_fn *cb,
-                                         void *cb_arg)
+    ossl_quic_demux_cb_fn *cb,
+    void *cb_arg)
 {
-    demux->default_cb       = cb;
-    demux->default_cb_arg   = cb_arg;
+    demux->default_cb = cb;
+    demux->default_cb_arg = cb_arg;
 }
 
 static QUIC_URXE *demux_alloc_urxe(size_t alloc_len)
@@ -164,13 +164,13 @@ static QUIC_URXE *demux_alloc_urxe(size_t alloc_len)
         return NULL;
 
     ossl_list_urxe_init_elem(e);
-    e->alloc_len   = alloc_len;
-    e->data_len    = 0;
+    e->alloc_len = alloc_len;
+    e->data_len = 0;
     return e;
 }
 
 static QUIC_URXE *demux_resize_urxe(QUIC_DEMUX *demux, QUIC_URXE *e,
-                                    size_t new_alloc_len)
+    size_t new_alloc_len)
 {
     QUIC_URXE *e2, *prev;
 
@@ -181,6 +181,9 @@ static QUIC_URXE *demux_resize_urxe(QUIC_DEMUX *demux, QUIC_URXE *e,
     prev = ossl_list_urxe_prev(e);
     ossl_list_urxe_remove(&demux->urx_free, e);
 
+    if (new_alloc_len >= SIZE_MAX - sizeof(QUIC_URXE))
+        return NULL;
+
     e2 = OPENSSL_realloc(e, sizeof(QUIC_URXE) + new_alloc_len);
     if (e2 == NULL) {
         /* Failed to resize, abort. */
@@ -202,7 +205,7 @@ static QUIC_URXE *demux_resize_urxe(QUIC_DEMUX *demux, QUIC_URXE *e,
 }
 
 static QUIC_URXE *demux_reserve_urxe(QUIC_DEMUX *demux, QUIC_URXE *e,
-                                     size_t alloc_len)
+    size_t alloc_len)
 {
     return e->alloc_len < alloc_len ? demux_resize_urxe(demux, e, alloc_len) : e;
 }
@@ -253,7 +256,7 @@ static int demux_recv(QUIC_DEMUX *demux)
      * syscall, determined by how many free URXEs are available.
      */
     for (i = 0; i < (ossl_ssize_t)OSSL_NELEM(msg);
-            ++i, urxe = ossl_list_urxe_next(urxe)) {
+        ++i, urxe = ossl_list_urxe_next(urxe)) {
         if (urxe == NULL) {
             /* We need at least one URXE to receive into. */
             if (!ossl_assert(i > 0))
@@ -270,9 +273,9 @@ static int demux_recv(QUIC_DEMUX *demux)
 
         /* Ensure we zero any fields added to BIO_MSG at a later date. */
         memset(&msg[i], 0, sizeof(BIO_MSG));
-        msg[i].data     = ossl_quic_urxe_data(urxe);
+        msg[i].data = ossl_quic_urxe_data(urxe);
         msg[i].data_len = urxe->alloc_len;
-        msg[i].peer     = &urxe->peer;
+        msg[i].peer = &urxe->peer;
         BIO_ADDR_clear(&urxe->peer);
         if (demux->use_local_addr)
             msg[i].local = &urxe->local;
@@ -300,10 +303,10 @@ static int demux_recv(QUIC_DEMUX *demux)
     for (i = 0; i < rd; ++i, urxe = unext) {
         unext = ossl_list_urxe_next(urxe);
         /* Set URXE with actual length of received datagram. */
-        urxe->data_len      = msg[i].data_len;
+        urxe->data_len = msg[i].data_len;
         /* Time we received datagram. */
-        urxe->time          = now;
-        urxe->datagram_id   = demux->next_datagram_id++;
+        urxe->time = now;
+        urxe->datagram_id = demux->next_datagram_id++;
         /* Move from free list to pending list. */
         ossl_list_urxe_remove(&demux->urx_free, urxe);
         ossl_list_urxe_insert_tail(&demux->urx_pending, urxe);
@@ -315,13 +318,13 @@ static int demux_recv(QUIC_DEMUX *demux)
 
 /* Extract destination connection ID from the first packet in a datagram. */
 static int demux_identify_conn_id(QUIC_DEMUX *demux,
-                                  QUIC_URXE *e,
-                                  QUIC_CONN_ID *dst_conn_id)
+    QUIC_URXE *e,
+    QUIC_CONN_ID *dst_conn_id)
 {
     return ossl_quic_wire_get_pkt_hdr_dst_conn_id(ossl_quic_urxe_data(e),
-                                                  e->data_len,
-                                                  demux->short_conn_id_len,
-                                                  dst_conn_id);
+        e->data_len,
+        demux->short_conn_id_len,
+        dst_conn_id);
 }
 
 /*
@@ -350,7 +353,7 @@ static int demux_process_pending_urxe(QUIC_DEMUX *demux, QUIC_URXE *e)
          */
         e->demux_state = URXE_DEMUX_STATE_ISSUED;
         demux->default_cb(e, demux->default_cb_arg,
-                          dst_conn_id_ok ? &dst_conn_id : NULL);
+            dst_conn_id_ok ? &dst_conn_id : NULL);
     } else {
         /* Discard. */
         ossl_list_urxe_insert_tail(&demux->urx_free, e);
@@ -404,10 +407,10 @@ int ossl_quic_demux_pump(QUIC_DEMUX *demux)
 
 /* Artificially inject a packet into the demuxer for testing purposes. */
 int ossl_quic_demux_inject(QUIC_DEMUX *demux,
-                           const unsigned char *buf,
-                           size_t buf_len,
-                           const BIO_ADDR *peer,
-                           const BIO_ADDR *local)
+    const unsigned char *buf,
+    size_t buf_len,
+    const BIO_ADDR *peer,
+    const BIO_ADDR *local)
 {
     int ret;
     QUIC_URXE *urxe;
@@ -451,7 +454,7 @@ int ossl_quic_demux_inject(QUIC_DEMUX *demux,
 
 /* Called by our user to return a URXE to the free list. */
 void ossl_quic_demux_release_urxe(QUIC_DEMUX *demux,
-                                  QUIC_URXE *e)
+    QUIC_URXE *e)
 {
     assert(ossl_list_urxe_prev(e) == NULL && ossl_list_urxe_next(e) == NULL);
     assert(e->demux_state == URXE_DEMUX_STATE_ISSUED);
@@ -460,7 +463,7 @@ void ossl_quic_demux_release_urxe(QUIC_DEMUX *demux,
 }
 
 void ossl_quic_demux_reinject_urxe(QUIC_DEMUX *demux,
-                                   QUIC_URXE *e)
+    QUIC_URXE *e)
 {
     assert(ossl_list_urxe_prev(e) == NULL && ossl_list_urxe_next(e) == NULL);
     assert(e->demux_state == URXE_DEMUX_STATE_ISSUED);
diff --git a/crypto/openssl/ssl/quic/quic_engine.c b/crypto/openssl/ssl/quic/quic_engine.c
index e933d8548f47..370b9c3987f1 100644
--- a/crypto/openssl/ssl/quic/quic_engine.c
+++ b/crypto/openssl/ssl/quic/quic_engine.c
@@ -30,9 +30,9 @@ QUIC_ENGINE *ossl_quic_engine_new(const QUIC_ENGINE_ARGS *args)
     if ((qeng = OPENSSL_zalloc(sizeof(QUIC_ENGINE))) == NULL)
         return NULL;
 
-    qeng->libctx            = args->libctx;
-    qeng->propq             = args->propq;
-    qeng->mutex             = args->mutex;
+    qeng->libctx = args->libctx;
+    qeng->propq = args->propq;
+    qeng->mutex = args->mutex;
 
     if (!qeng_init(qeng, args->reactor_flags)) {
         OPENSSL_free(qeng);
@@ -54,8 +54,8 @@ void ossl_quic_engine_free(QUIC_ENGINE *qeng)
 static int qeng_init(QUIC_ENGINE *qeng, uint64_t reactor_flags)
 {
     return ossl_quic_reactor_init(&qeng->rtor, qeng_tick, qeng,
-                                  qeng->mutex,
-                                  ossl_time_zero(), reactor_flags);
+        qeng->mutex,
+        ossl_time_zero(), reactor_flags);
 }
 
 static void qeng_cleanup(QUIC_ENGINE *qeng)
@@ -87,8 +87,8 @@ OSSL_TIME ossl_quic_engine_make_real_time(QUIC_ENGINE *qeng, OSSL_TIME tm)
     OSSL_TIME offset;
 
     if (qeng->now_cb != NULL
-            && !ossl_time_is_zero(tm)
-            && !ossl_time_is_infinite(tm)) {
+        && !ossl_time_is_zero(tm)
+        && !ossl_time_is_infinite(tm)) {
 
         offset = qeng->now_cb(qeng->now_cb_arg);
 
@@ -100,8 +100,8 @@ OSSL_TIME ossl_quic_engine_make_real_time(QUIC_ENGINE *qeng, OSSL_TIME tm)
 }
 
 void ossl_quic_engine_set_time_cb(QUIC_ENGINE *qeng,
-                                  OSSL_TIME (*now_cb)(void *arg),
-                                  void *now_cb_arg)
+    OSSL_TIME (*now_cb)(void *arg),
+    void *now_cb_arg)
 {
     qeng->now_cb = now_cb;
     qeng->now_cb_arg = now_cb_arg;
@@ -137,7 +137,7 @@ void ossl_quic_engine_update_poll_descriptors(QUIC_ENGINE *qeng, int force)
      * important currently as the port list has a single entry.
      */
     OSSL_LIST_FOREACH(port, port, &qeng->port_list)
-        ossl_quic_port_update_poll_descriptors(port, force);
+    ossl_quic_port_update_poll_descriptors(port, force);
 }
 
 /*
@@ -146,7 +146,7 @@ void ossl_quic_engine_update_poll_descriptors(QUIC_ENGINE *qeng, int force)
  */
 
 QUIC_PORT *ossl_quic_engine_create_port(QUIC_ENGINE *qeng,
-                                        const QUIC_PORT_ARGS *args)
+    const QUIC_PORT_ARGS *args)
 {
     QUIC_PORT_ARGS largs = *args;
 
@@ -176,17 +176,18 @@ static void qeng_tick(QUIC_TICK_RESULT *res, void *arg, uint32_t flags)
     QUIC_ENGINE *qeng = arg;
     QUIC_PORT *port;
 
-    res->net_read_desired     = 0;
-    res->net_write_desired    = 0;
+    res->net_read_desired = 0;
+    res->net_write_desired = 0;
     res->notify_other_threads = 0;
-    res->tick_deadline        = ossl_time_infinite();
+    res->tick_deadline = ossl_time_infinite();
 
     if (qeng->inhibit_tick)
         return;
 
     /* Iterate through all ports and service them. */
-    OSSL_LIST_FOREACH(port, port, &qeng->port_list) {
-        QUIC_TICK_RESULT subr = {0};
+    OSSL_LIST_FOREACH(port, port, &qeng->port_list)
+    {
+        QUIC_TICK_RESULT subr = { 0 };
 
         ossl_quic_port_subtick(port, &subr, flags);
         ossl_quic_tick_result_merge_into(res, &subr);
diff --git a/crypto/openssl/ssl/quic/quic_engine_local.h b/crypto/openssl/ssl/quic/quic_engine_local.h
index 280fd31dd7c1..476a884f648c 100644
--- a/crypto/openssl/ssl/quic/quic_engine_local.h
+++ b/crypto/openssl/ssl/quic/quic_engine_local.h
@@ -8,12 +8,12 @@
  */
 
 #ifndef OSSL_QUIC_ENGINE_LOCAL_H
-# define OSSL_QUIC_ENGINE_LOCAL_H
+#define OSSL_QUIC_ENGINE_LOCAL_H
 
-# include "internal/quic_engine.h"
-# include "internal/quic_reactor.h"
+#include "internal/quic_engine.h"
+#include "internal/quic_reactor.h"
 
-# ifndef OPENSSL_NO_QUIC
+#ifndef OPENSSL_NO_QUIC
 
 /*
  * QUIC Engine Structure
@@ -29,8 +29,8 @@ DECLARE_LIST_OF(port, QUIC_PORT);
 
 struct quic_engine_st {
     /* All objects in a QUIC event domain share the same (libctx, propq). */
-    OSSL_LIB_CTX                    *libctx;
-    const char                      *propq;
+    OSSL_LIB_CTX *libctx;
+    const char *propq;
 
     /*
      * Master synchronisation mutex for the entire QUIC event domain. Used for
@@ -38,22 +38,23 @@ struct quic_engine_st {
      * of the engine passes it to us and is responsible for freeing it after
      * engine destruction.
      */
-    CRYPTO_MUTEX                    *mutex;
+    CRYPTO_MUTEX *mutex;
 
     /* Callback used to get the current time. */
-    OSSL_TIME                       (*now_cb)(void *arg);
-    void                            *now_cb_arg;
+    OSSL_TIME (*now_cb)(void *arg);
+    void *now_cb_arg;
 
     /* Asynchronous I/O reactor. */
-    QUIC_REACTOR                    rtor;
+    QUIC_REACTOR rtor;
 
     /* List of all child ports. */
-    OSSL_LIST(port)                 port_list;
+    OSSL_LIST(port)
+    port_list;
 
     /* Inhibit tick for testing purposes? */
-    unsigned int                    inhibit_tick                    : 1;
+    unsigned int inhibit_tick : 1;
 };
 
-# endif
+#endif
 
 #endif
diff --git a/crypto/openssl/ssl/quic/quic_fc.c b/crypto/openssl/ssl/quic/quic_fc.c
index 64ef31780c22..1691d4d69efa 100644
--- a/crypto/openssl/ssl/quic/quic_fc.c
+++ b/crypto/openssl/ssl/quic/quic_fc.c
@@ -25,10 +25,10 @@ int ossl_quic_txfc_init(QUIC_TXFC *txfc, QUIC_TXFC *conn_txfc)
     if (conn_txfc != NULL && conn_txfc->parent != NULL)
         return 0;
 
-    txfc->swm                   = 0;
-    txfc->cwm                   = 0;
-    txfc->parent                = conn_txfc;
-    txfc->has_become_blocked    = 0;
+    txfc->swm = 0;
+    txfc->cwm = 0;
+    txfc->parent = conn_txfc;
+    txfc->has_become_blocked = 0;
     return 1;
 }
 
@@ -124,40 +124,40 @@ uint64_t ossl_quic_txfc_get_swm(QUIC_TXFC *txfc)
  */
 
 int ossl_quic_rxfc_init(QUIC_RXFC *rxfc, QUIC_RXFC *conn_rxfc,
-                        uint64_t initial_window_size,
-                        uint64_t max_window_size,
-                        OSSL_TIME (*now)(void *now_arg),
-                        void *now_arg)
+    uint64_t initial_window_size,
+    uint64_t max_window_size,
+    OSSL_TIME (*now)(void *now_arg),
+    void *now_arg)
 {
     if (conn_rxfc != NULL && conn_rxfc->parent != NULL)
         return 0;
 
-    rxfc->swm               = 0;
-    rxfc->cwm               = initial_window_size;
-    rxfc->rwm               = 0;
-    rxfc->esrwm             = 0;
-    rxfc->hwm               = 0;
-    rxfc->cur_window_size   = initial_window_size;
-    rxfc->max_window_size   = max_window_size;
-    rxfc->parent            = conn_rxfc;
-    rxfc->error_code        = 0;
-    rxfc->has_cwm_changed   = 0;
-    rxfc->epoch_start       = ossl_time_zero();
-    rxfc->now               = now;
-    rxfc->now_arg           = now_arg;
-    rxfc->is_fin            = 0;
-    rxfc->standalone        = 0;
+    rxfc->swm = 0;
+    rxfc->cwm = initial_window_size;
+    rxfc->rwm = 0;
+    rxfc->esrwm = 0;
+    rxfc->hwm = 0;
+    rxfc->cur_window_size = initial_window_size;
+    rxfc->max_window_size = max_window_size;
+    rxfc->parent = conn_rxfc;
+    rxfc->error_code = 0;
+    rxfc->has_cwm_changed = 0;
+    rxfc->epoch_start = ossl_time_zero();
+    rxfc->now = now;
+    rxfc->now_arg = now_arg;
+    rxfc->is_fin = 0;
+    rxfc->standalone = 0;
     return 1;
 }
 
 int ossl_quic_rxfc_init_standalone(QUIC_RXFC *rxfc,
-                                   uint64_t initial_window_size,
-                                   OSSL_TIME (*now)(void *arg),
-                                   void *now_arg)
+    uint64_t initial_window_size,
+    OSSL_TIME (*now)(void *arg),
+    void *now_arg)
 {
     if (!ossl_quic_rxfc_init(rxfc, NULL,
-                             initial_window_size, initial_window_size,
-                             now, now_arg))
+            initial_window_size, initial_window_size,
+            now, now_arg))
         return 0;
 
     rxfc->standalone = 1;
@@ -170,15 +170,15 @@ QUIC_RXFC *ossl_quic_rxfc_get_parent(QUIC_RXFC *rxfc)
 }
 
 void ossl_quic_rxfc_set_max_window_size(QUIC_RXFC *rxfc,
-                                        size_t max_window_size)
+    size_t max_window_size)
 {
     rxfc->max_window_size = max_window_size;
 }
 
 static void rxfc_start_epoch(QUIC_RXFC *rxfc)
 {
-    rxfc->epoch_start   = rxfc->now(rxfc->now_arg);
-    rxfc->esrwm         = rxfc->rwm;
+    rxfc->epoch_start = rxfc->now(rxfc->now_arg);
+    rxfc->esrwm = rxfc->rwm;
 }
 
 static int on_rx_controlled_bytes(QUIC_RXFC *rxfc, uint64_t num_bytes)
@@ -216,7 +216,7 @@ int ossl_quic_rxfc_on_rx_stream_frame(QUIC_RXFC *rxfc, uint64_t end, int is_fin)
         delta = end - rxfc->hwm;
         rxfc->hwm = end;
 
-        on_rx_controlled_bytes(rxfc, delta);             /* result ignored */
+        on_rx_controlled_bytes(rxfc, delta); /* result ignored */
         if (rxfc->parent != NULL)
             on_rx_controlled_bytes(rxfc->parent, delta); /* result ignored */
     } else if (end < rxfc->hwm && is_fin) {
@@ -237,7 +237,7 @@ static int rxfc_cwm_bump_desired(QUIC_RXFC *rxfc)
     uint64_t window_rem = rxfc->cwm - rxfc->rwm;
     uint64_t threshold
         = safe_muldiv_uint64_t(rxfc->cur_window_size,
-                               WINDOW_THRESHOLD_NUM, WINDOW_THRESHOLD_DEN, &err);
+            WINDOW_THRESHOLD_NUM, WINDOW_THRESHOLD_DEN, &err);
 
     if (err)
         /*
@@ -274,21 +274,21 @@ static int rxfc_should_bump_window_size(QUIC_RXFC *rxfc, OSSL_TIME rtt)
      * our 64-bit nanosecond representation, which will afford plenty of
      * precision left over after the division anyway.
      */
-    uint64_t  b = rxfc->rwm - rxfc->esrwm;
+    uint64_t b = rxfc->rwm - rxfc->esrwm;
     OSSL_TIME now, dt, t_window;
 
     if (b == 0)
         return 0;
 
-    now      = rxfc->now(rxfc->now_arg);
-    dt       = ossl_time_subtract(now, rxfc->epoch_start);
+    now = rxfc->now(rxfc->now_arg);
+    dt = ossl_time_subtract(now, rxfc->epoch_start);
     t_window = ossl_time_muldiv(dt, rxfc->cur_window_size, b);
 
     return ossl_time_compare(t_window, ossl_time_multiply(rtt, 4)) < 0;
 }
 
 static void rxfc_adjust_window_size(QUIC_RXFC *rxfc, uint64_t min_window_size,
-                                    OSSL_TIME rtt)
+    OSSL_TIME rtt)
 {
     /* Are we sending updates too often? */
     uint64_t new_window_size;
@@ -308,7 +308,7 @@ static void rxfc_adjust_window_size(QUIC_RXFC *rxfc, uint64_t min_window_size,
 }
 
 static void rxfc_update_cwm(QUIC_RXFC *rxfc, uint64_t min_window_size,
-                            OSSL_TIME rtt)
+    OSSL_TIME rtt)
 {
     uint64_t new_cwm;
 
@@ -325,8 +325,8 @@ static void rxfc_update_cwm(QUIC_RXFC *rxfc, uint64_t min_window_size,
 }
 
 static int rxfc_on_retire(QUIC_RXFC *rxfc, uint64_t num_bytes,
-                          uint64_t min_window_size,
-                          OSSL_TIME rtt)
+    uint64_t min_window_size,
+    OSSL_TIME rtt)
 {
     if (ossl_time_is_zero(rxfc->epoch_start))
         /* This happens when we retire our first ever bytes. */
@@ -338,8 +338,8 @@ static int rxfc_on_retire(QUIC_RXFC *rxfc, uint64_t num_bytes,
 }
 
 int ossl_quic_rxfc_on_retire(QUIC_RXFC *rxfc,
-                             uint64_t num_bytes,
-                             OSSL_TIME rtt)
+    uint64_t num_bytes,
+    OSSL_TIME rtt)
 {
     if (rxfc->parent == NULL && !rxfc->standalone)
         return 0;
diff --git a/crypto/openssl/ssl/quic/quic_fifd.c b/crypto/openssl/ssl/quic/quic_fifd.c
index 1d1bcc11ce63..03b8cebd3057 100644
--- a/crypto/openssl/ssl/quic/quic_fifd.c
+++ b/crypto/openssl/ssl/quic/quic_fifd.c
@@ -14,48 +14,48 @@
 DEFINE_LIST_OF(tx_history, OSSL_ACKM_TX_PKT);
 
 int ossl_quic_fifd_init(QUIC_FIFD *fifd,
-                        QUIC_CFQ *cfq,
-                        OSSL_ACKM *ackm,
-                        QUIC_TXPIM *txpim,
-                        /* stream_id is UINT64_MAX for the crypto stream */
-                        QUIC_SSTREAM *(*get_sstream_by_id)(uint64_t stream_id,
-                                                           uint32_t pn_space,
-                                                           void *arg),
-                        void *get_sstream_by_id_arg,
-                        /* stream_id is UINT64_MAX if not applicable */
-                        void (*regen_frame)(uint64_t frame_type,
-                                            uint64_t stream_id,
-                                            QUIC_TXPIM_PKT *pkt,
-                                            void *arg),
-                        void *regen_frame_arg,
-                        void (*confirm_frame)(uint64_t frame_type,
-                                              uint64_t stream_id,
-                                              QUIC_TXPIM_PKT *pkt,
-                                              void *arg),
-                        void *confirm_frame_arg,
-                        void (*sstream_updated)(uint64_t stream_id,
-                                                void *arg),
-                        void *sstream_updated_arg,
-                        QLOG *(*get_qlog_cb)(void *arg),
-                        void *get_qlog_cb_arg)
+    QUIC_CFQ *cfq,
+    OSSL_ACKM *ackm,
+    QUIC_TXPIM *txpim,
+    /* stream_id is UINT64_MAX for the crypto stream */
+    QUIC_SSTREAM *(*get_sstream_by_id)(uint64_t stream_id,
+        uint32_t pn_space,
+        void *arg),
+    void *get_sstream_by_id_arg,
+    /* stream_id is UINT64_MAX if not applicable */
+    void (*regen_frame)(uint64_t frame_type,
+        uint64_t stream_id,
+        QUIC_TXPIM_PKT *pkt,
+        void *arg),
+    void *regen_frame_arg,
+    void (*confirm_frame)(uint64_t frame_type,
+        uint64_t stream_id,
+        QUIC_TXPIM_PKT *pkt,
+        void *arg),
+    void *confirm_frame_arg,
+    void (*sstream_updated)(uint64_t stream_id,
+        void *arg),
+    void *sstream_updated_arg,
+    QLOG *(*get_qlog_cb)(void *arg),
+    void *get_qlog_cb_arg)
 {
     if (cfq == NULL || ackm == NULL || txpim == NULL
         || get_sstream_by_id == NULL || regen_frame == NULL)
         return 0;
 
-    fifd->cfq                   = cfq;
-    fifd->ackm                  = ackm;
-    fifd->txpim                 = txpim;
-    fifd->get_sstream_by_id     = get_sstream_by_id;
+    fifd->cfq = cfq;
+    fifd->ackm = ackm;
+    fifd->txpim = txpim;
+    fifd->get_sstream_by_id = get_sstream_by_id;
     fifd->get_sstream_by_id_arg = get_sstream_by_id_arg;
-    fifd->regen_frame           = regen_frame;
-    fifd->regen_frame_arg       = regen_frame_arg;
-    fifd->confirm_frame         = confirm_frame;
-    fifd->confirm_frame_arg     = confirm_frame_arg;
-    fifd->sstream_updated       = sstream_updated;
-    fifd->sstream_updated_arg   = sstream_updated_arg;
-    fifd->get_qlog_cb           = get_qlog_cb;
-    fifd->get_qlog_cb_arg       = get_qlog_cb_arg;
+    fifd->regen_frame = regen_frame;
+    fifd->regen_frame_arg = regen_frame_arg;
+    fifd->confirm_frame = confirm_frame;
+    fifd->confirm_frame_arg = confirm_frame_arg;
+    fifd->sstream_updated = sstream_updated;
+    fifd->sstream_updated_arg = sstream_updated_arg;
+    fifd->get_qlog_cb = get_qlog_cb;
+    fifd->get_qlog_cb_arg = get_qlog_cb_arg;
     return 1;
 }
 
@@ -76,28 +76,28 @@ static void on_acked(void *arg)
     /* STREAM and CRYPTO stream chunks, FINs and stream FC frames */
     for (i = 0; i < num_chunks; ++i) {
         sstream = fifd->get_sstream_by_id(chunks[i].stream_id,
-                                          pkt->ackm_pkt.pkt_space,
-                                          fifd->get_sstream_by_id_arg);
+            pkt->ackm_pkt.pkt_space,
+            fifd->get_sstream_by_id_arg);
         if (sstream == NULL)
             continue;
 
         if (chunks[i].end >= chunks[i].start)
             /* coverity[check_return]: Best effort - we cannot fail here. */
             ossl_quic_sstream_mark_acked(sstream,
-                                         chunks[i].start, chunks[i].end);
+                chunks[i].start, chunks[i].end);
 
         if (chunks[i].has_fin && chunks[i].stream_id != UINT64_MAX)
             ossl_quic_sstream_mark_acked_fin(sstream);
 
         if (chunks[i].has_stop_sending && chunks[i].stream_id != UINT64_MAX)
             fifd->confirm_frame(OSSL_QUIC_FRAME_TYPE_STOP_SENDING,
-                                chunks[i].stream_id, pkt,
-                                fifd->confirm_frame_arg);
+                chunks[i].stream_id, pkt,
+                fifd->confirm_frame_arg);
 
         if (chunks[i].has_reset_stream && chunks[i].stream_id != UINT64_MAX)
             fifd->confirm_frame(OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
-                                chunks[i].stream_id, pkt,
-                                fifd->confirm_frame_arg);
+                chunks[i].stream_id, pkt,
+                fifd->confirm_frame_arg);
 
         if (ossl_quic_sstream_is_totally_acked(sstream))
             fifd->sstream_updated(chunks[i].stream_id, fifd->sstream_updated_arg);
@@ -135,8 +135,8 @@ static void on_lost(void *arg)
     /* STREAM and CRYPTO stream chunks, FIN and stream FC frames */
     for (i = 0; i < num_chunks; ++i) {
         sstream = fifd->get_sstream_by_id(chunks[i].stream_id,
-                                          pkt->ackm_pkt.pkt_space,
-                                          fifd->get_sstream_by_id_arg);
+            pkt->ackm_pkt.pkt_space,
+            fifd->get_sstream_by_id_arg);
         if (sstream == NULL)
             continue;
 
@@ -150,7 +150,7 @@ static void on_lost(void *arg)
              * and our call to get_sstream_by_id above will return NULL.
              */
             ossl_quic_sstream_mark_lost(sstream,
-                                        chunks[i].start, chunks[i].end);
+                chunks[i].start, chunks[i].end);
             sstream_updated = 1;
         }
 
@@ -161,13 +161,13 @@ static void on_lost(void *arg)
 
         if (chunks[i].has_stop_sending && chunks[i].stream_id != UINT64_MAX)
             fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_STOP_SENDING,
-                              chunks[i].stream_id, pkt,
-                              fifd->regen_frame_arg);
+                chunks[i].stream_id, pkt,
+                fifd->regen_frame_arg);
 
         if (chunks[i].has_reset_stream && chunks[i].stream_id != UINT64_MAX)
             fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
-                              chunks[i].stream_id, pkt,
-                              fifd->regen_frame_arg);
+                chunks[i].stream_id, pkt,
+                fifd->regen_frame_arg);
 
         /*
          * Inform caller that stream needs an FC frame.
@@ -180,13 +180,13 @@ static void on_lost(void *arg)
          * handling loss.
          */
         fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA,
-                          chunks[i].stream_id,
-                          pkt,
-                          fifd->regen_frame_arg);
+            chunks[i].stream_id,
+            pkt,
+            fifd->regen_frame_arg);
 
         if (sstream_updated && chunks[i].stream_id != UINT64_MAX)
             fifd->sstream_updated(chunks[i].stream_id,
-                                  fifd->sstream_updated_arg);
+                fifd->sstream_updated_arg);
     }
 
     /* GCR */
@@ -198,23 +198,23 @@ static void on_lost(void *arg)
     /* Regenerate flag frames */
     if (pkt->had_handshake_done_frame)
         fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE,
-                          UINT64_MAX, pkt,
-                          fifd->regen_frame_arg);
+            UINT64_MAX, pkt,
+            fifd->regen_frame_arg);
 
     if (pkt->had_max_data_frame)
         fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_MAX_DATA,
-                          UINT64_MAX, pkt,
-                          fifd->regen_frame_arg);
+            UINT64_MAX, pkt,
+            fifd->regen_frame_arg);
 
     if (pkt->had_max_streams_bidi_frame)
         fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI,
-                          UINT64_MAX, pkt,
-                          fifd->regen_frame_arg);
+            UINT64_MAX, pkt,
+            fifd->regen_frame_arg);
 
     if (pkt->had_max_streams_uni_frame)
         fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI,
-                          UINT64_MAX, pkt,
-                          fifd->regen_frame_arg);
+            UINT64_MAX, pkt,
+            fifd->regen_frame_arg);
 
     if (pkt->had_ack_frame)
         /*
@@ -223,8 +223,8 @@ static void on_lost(void *arg)
          * whether it wants to send ECN data or not.
          */
         fifd->regen_frame(OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN,
-                          UINT64_MAX, pkt,
-                          fifd->regen_frame_arg);
+            UINT64_MAX, pkt,
+            fifd->regen_frame_arg);
 
     ossl_quic_txpim_pkt_release(fifd->txpim, pkt);
 }
@@ -256,12 +256,12 @@ int ossl_quic_fifd_pkt_commit(QUIC_FIFD *fifd, QUIC_TXPIM_PKT *pkt)
     size_t i, num_chunks;
     QUIC_SSTREAM *sstream;
 
-    pkt->fifd                   = fifd;
+    pkt->fifd = fifd;
 
-    pkt->ackm_pkt.on_lost       = on_lost;
-    pkt->ackm_pkt.on_acked      = on_acked;
-    pkt->ackm_pkt.on_discarded  = on_discarded;
-    pkt->ackm_pkt.cb_arg        = pkt;
+    pkt->ackm_pkt.on_lost = on_lost;
+    pkt->ackm_pkt.on_acked = on_acked;
+    pkt->ackm_pkt.on_discarded = on_discarded;
+    pkt->ackm_pkt.cb_arg = pkt;
 
     ossl_list_tx_history_init_elem(&pkt->ackm_pkt);
     pkt->ackm_pkt.anext = pkt->ackm_pkt.lnext = NULL;
@@ -271,8 +271,8 @@ int ossl_quic_fifd_pkt_commit(QUIC_FIFD *fifd, QUIC_TXPIM_PKT *pkt)
      * transmitted.
      */
     for (cfq_item = pkt->retx_head;
-         cfq_item != NULL;
-         cfq_item = cfq_item->pkt_next)
+        cfq_item != NULL;
+        cfq_item = cfq_item->pkt_next)
         ossl_quic_cfq_mark_tx(fifd->cfq, cfq_item);
 
     /*
@@ -283,21 +283,21 @@ int ossl_quic_fifd_pkt_commit(QUIC_FIFD *fifd, QUIC_TXPIM_PKT *pkt)
     num_chunks = ossl_quic_txpim_pkt_get_num_chunks(pkt);
     for (i = 0; i < num_chunks; ++i) {
         sstream = fifd->get_sstream_by_id(chunks[i].stream_id,
-                                          pkt->ackm_pkt.pkt_space,
-                                          fifd->get_sstream_by_id_arg);
+            pkt->ackm_pkt.pkt_space,
+            fifd->get_sstream_by_id_arg);
         if (sstream == NULL)
             continue;
 
         if (chunks[i].end >= chunks[i].start
             && !ossl_quic_sstream_mark_transmitted(sstream,
-                                                   chunks[i].start,
-                                                   chunks[i].end))
+                chunks[i].start,
+                chunks[i].end))
             return 0;
 
         if (chunks[i].has_fin
             && !ossl_quic_sstream_mark_transmitted_fin(sstream,
-                                                       chunks[i].end + 1))
-                return 0;
+                chunks[i].end + 1))
+            return 0;
     }
 
     /* Inform the ACKM. */
@@ -305,8 +305,8 @@ int ossl_quic_fifd_pkt_commit(QUIC_FIFD *fifd, QUIC_TXPIM_PKT *pkt)
 }
 
 void ossl_quic_fifd_set_qlog_cb(QUIC_FIFD *fifd, QLOG *(*get_qlog_cb)(void *arg),
-                                void *get_qlog_cb_arg)
+    void *get_qlog_cb_arg)
 {
-    fifd->get_qlog_cb       = get_qlog_cb;
-    fifd->get_qlog_cb_arg   = get_qlog_cb_arg;
+    fifd->get_qlog_cb = get_qlog_cb;
+    fifd->get_qlog_cb_arg = get_qlog_cb_arg;
 }
diff --git a/crypto/openssl/ssl/quic/quic_impl.c b/crypto/openssl/ssl/quic/quic_impl.c
index 0c15ef05236c..a8f9ac92c2a4 100644
--- a/crypto/openssl/ssl/quic/quic_impl.c
+++ b/crypto/openssl/ssl/quic/quic_impl.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022-2025 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2022-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy
@@ -39,7 +39,7 @@ static void qc_update_reject_policy(QUIC_CONNECTION *qc);
 static void qc_touch_default_xso(QUIC_CONNECTION *qc);
 static void qc_set_default_xso(QUIC_CONNECTION *qc, QUIC_XSO *xso, int touch);
 static void qc_set_default_xso_keep_ref(QUIC_CONNECTION *qc, QUIC_XSO *xso,
-                                        int touch, QUIC_XSO **old_xso);
+    int touch, QUIC_XSO **old_xso);
 static SSL *quic_conn_stream_new(QCTX *ctx, uint64_t flags, int need_lock);
 static int quic_validate_for_write(QUIC_XSO *xso, int *err);
 static int quic_mutation_allowed(QUIC_CONNECTION *qc, int req_active);
@@ -67,12 +67,12 @@ static int qctx_should_autotick(QCTX *ctx);
  *     of SSL_get_error.
  */
 struct qctx_st {
-    QUIC_OBJ        *obj;
-    QUIC_DOMAIN     *qd;
-    QUIC_LISTENER   *ql;
+    QUIC_OBJ *obj;
+    QUIC_DOMAIN *qd;
+    QUIC_LISTENER *ql;
     QUIC_CONNECTION *qc;
-    QUIC_XSO        *xso;
-    int             is_stream, is_listener, is_domain, in_io;
+    QUIC_XSO *xso;
+    int is_stream, is_listener, is_domain, in_io;
 };
 
 QUIC_NEEDS_LOCK
@@ -94,7 +94,7 @@ static void quic_set_last_error(QCTX *ctx, int last_error)
  */
 QUIC_NEEDS_LOCK
 static int quic_raise_normal_error(QCTX *ctx,
-                                   int err)
+    int err)
 {
     assert(ctx->in_io);
     quic_set_last_error(ctx, err);
@@ -114,12 +114,12 @@ static int quic_raise_normal_error(QCTX *ctx,
  * ctx should be NULL if the connection lock is not held.
  */
 static int quic_raise_non_normal_error(QCTX *ctx,
-                                       const char *file,
-                                       int line,
-                                       const char *func,
-                                       int reason,
-                                       const char *fmt,
-                                       ...)
+    const char *file,
+    int line,
+    const char *func,
+    int reason,
+    const char *fmt,
+    ...)
 {
     va_list args;
 
@@ -140,15 +140,15 @@ static int quic_raise_non_normal_error(QCTX *ctx,
     return 0;
 }
 
-#define QUIC_RAISE_NORMAL_ERROR(ctx, err)                       \
+#define QUIC_RAISE_NORMAL_ERROR(ctx, err) \
     quic_raise_normal_error((ctx), (err))
 
-#define QUIC_RAISE_NON_NORMAL_ERROR(ctx, reason, msg)           \
-    quic_raise_non_normal_error((ctx),                          \
-                                OPENSSL_FILE, OPENSSL_LINE,     \
-                                OPENSSL_FUNC,                   \
-                                (reason),                       \
-                                (msg))
+#define QUIC_RAISE_NON_NORMAL_ERROR(ctx, reason, msg) \
+    quic_raise_non_normal_error((ctx),                \
+        OPENSSL_FILE, OPENSSL_LINE,                   \
+        OPENSSL_FUNC,                                 \
+        (reason),                                     \
+        (msg))
 /*
  * Flags for expect_quic_as:
  *
@@ -191,15 +191,15 @@ static int quic_raise_non_normal_error(QCTX *ctx,
  *      conjunction with any flags that may raise errors not related to a wrong
  *      object type.
  */
-#define QCTX_C              (1U << 0)
-#define QCTX_S              (1U << 1)
-#define QCTX_L              (1U << 2)
-#define QCTX_AUTO_S         (1U << 3)
-#define QCTX_REMOTE_INIT    (1U << 4)
-#define QCTX_LOCK           (1U << 5)
-#define QCTX_IO             (1U << 6)
-#define QCTX_D              (1U << 7)
-#define QCTX_NO_ERROR       (1U << 8)
+#define QCTX_C (1U << 0)
+#define QCTX_S (1U << 1)
+#define QCTX_L (1U << 2)
+#define QCTX_AUTO_S (1U << 3)
+#define QCTX_REMOTE_INIT (1U << 4)
+#define QCTX_LOCK (1U << 5)
+#define QCTX_IO (1U << 6)
+#define QCTX_D (1U << 7)
+#define QCTX_NO_ERROR (1U << 8)
 
 /*
  * Called when expect_quic failed. Used to diagnose why such a call failed and
@@ -219,7 +219,7 @@ static int wrong_type(const SSL *s, uint32_t flags)
     else if ((flags & mask) == QCTX_C)
         code = SSL_R_CONN_USE_ONLY;
     else if ((flags & mask) == QCTX_S
-             || (flags & mask) == (QCTX_C | QCTX_S))
+        || (flags & mask) == (QCTX_C | QCTX_S))
         code = SSL_R_NO_STREAM;
 
     return QUIC_RAISE_NON_NORMAL_ERROR(NULL, code, NULL);
@@ -263,15 +263,15 @@ static int expect_quic_as(const SSL *s, QCTX *ctx, uint32_t flags)
     if ((flags & QCTX_AUTO_S) != 0)
         flags |= QCTX_S;
 
-    ctx->obj            = NULL;
-    ctx->qd             = NULL;
-    ctx->ql             = NULL;
-    ctx->qc             = NULL;
-    ctx->xso            = NULL;
-    ctx->is_stream      = 0;
-    ctx->is_listener    = 0;
-    ctx->is_domain      = 0;
-    ctx->in_io          = ((flags & QCTX_IO) != 0);
+    ctx->obj = NULL;
+    ctx->qd = NULL;
+    ctx->ql = NULL;
+    ctx->qc = NULL;
+    ctx->xso = NULL;
+    ctx->is_stream = 0;
+    ctx->is_listener = 0;
+    ctx->is_domain = 0;
+    ctx->in_io = ((flags & QCTX_IO) != 0);
 
     if (s == NULL) {
         QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_PASSED_NULL_PARAMETER, NULL);
@@ -285,10 +285,10 @@ static int expect_quic_as(const SSL *s, QCTX *ctx, uint32_t flags)
             goto err;
         }
 
-        qd                  = (QUIC_DOMAIN *)s;
-        ctx->obj            = &qd->obj;
-        ctx->qd             = qd;
-        ctx->is_domain      = 1;
+        qd = (QUIC_DOMAIN *)s;
+        ctx->obj = &qd->obj;
+        ctx->qd = qd;
+        ctx->is_domain = 1;
         break;
 
     case SSL_TYPE_QUIC_LISTENER:
@@ -297,19 +297,19 @@ static int expect_quic_as(const SSL *s, QCTX *ctx, uint32_t flags)
             goto err;
         }
 
-        ql                  = (QUIC_LISTENER *)s;
-        ctx->obj            = &ql->obj;
-        ctx->qd             = ql->domain;
-        ctx->ql             = ql;
-        ctx->is_listener    = 1;
+        ql = (QUIC_LISTENER *)s;
+        ctx->obj = &ql->obj;
+        ctx->qd = ql->domain;
+        ctx->ql = ql;
+        ctx->is_listener = 1;
         break;
 
     case SSL_TYPE_QUIC_CONNECTION:
-        qc                  = (QUIC_CONNECTION *)s;
-        ctx->obj            = &qc->obj;
-        ctx->qd             = qc->domain;
-        ctx->ql             = qc->listener; /* never changes, so can be read without lock */
-        ctx->qc             = qc;
+        qc = (QUIC_CONNECTION *)s;
+        ctx->obj = &qc->obj;
+        ctx->qd = qc->domain;
+        ctx->ql = qc->listener; /* never changes, so can be read without lock */
+        ctx->qc = qc;
 
         if ((flags & QCTX_AUTO_S) != 0) {
             if ((flags & QCTX_IO) != 0)
@@ -346,7 +346,7 @@ static int expect_quic_as(const SSL *s, QCTX *ctx, uint32_t flags)
             goto err;
         }
 
-        ctx->xso            = qc->default_xso;
+        ctx->xso = qc->default_xso;
         break;
 
     case SSL_TYPE_QUIC_XSO:
@@ -355,13 +355,13 @@ static int expect_quic_as(const SSL *s, QCTX *ctx, uint32_t flags)
             goto err;
         }
 
-        xso                 = (QUIC_XSO *)s;
-        ctx->obj            = &xso->obj;
-        ctx->qd             = xso->conn->domain;
-        ctx->ql             = xso->conn->listener;
-        ctx->qc             = xso->conn;
-        ctx->xso            = xso;
-        ctx->is_stream      = 1;
+        xso = (QUIC_XSO *)s;
+        ctx->obj = &xso->obj;
+        ctx->qd = xso->conn->domain;
+        ctx->ql = xso->conn->listener;
+        ctx->qc = xso->conn;
+        ctx->xso = xso;
+        ctx->is_stream = 1;
         break;
 
     default:
@@ -444,7 +444,7 @@ static int expect_quic_domain(const SSL *s, QCTX *ctx)
  */
 QUIC_ACQUIRES_LOCK
 static int ossl_unused expect_quic_with_stream_lock(const SSL *s, int remote_init,
-                                                    int in_io, QCTX *ctx)
+    int in_io, QCTX *ctx)
 {
     uint32_t flags = QCTX_S | QCTX_LOCK;
 
@@ -546,8 +546,8 @@ static int qctx_blocking(QCTX *ctx)
  */
 QUIC_NEEDS_LOCK
 static int block_until_pred(QCTX *ctx,
-                            int (*pred)(void *arg), void *pred_arg,
-                            uint32_t flags)
+    int (*pred)(void *arg), void *pred_arg,
+    uint32_t flags)
 {
     QUIC_ENGINE *qeng;
     QUIC_REACTOR *rtor;
@@ -631,7 +631,7 @@ SSL *ossl_quic_new(SSL_CTX *ctx)
         = ((ctx->domain_flags & SSL_DOMAIN_FLAG_THREAD_ASSISTED) != 0);
 #endif
 
-    qc->as_server       = 0;
+    qc->as_server = 0;
     qc->as_server_state = qc->as_server;
 
     if (!create_channel(qc, ctx))
@@ -642,17 +642,17 @@ SSL *ossl_quic_new(SSL_CTX *ctx)
 
     /* Initialise the QUIC_CONNECTION's QUIC_OBJ base. */
     if (!ossl_quic_obj_init(&qc->obj, ctx, SSL_TYPE_QUIC_CONNECTION, NULL,
-                            qc->engine, qc->port)) {
+            qc->engine, qc->port)) {
         QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_INTERNAL_ERROR, NULL);
         goto err;
     }
 
     /* Initialise libssl APL-related state. */
-    qc->default_stream_mode     = SSL_DEFAULT_STREAM_MODE_AUTO_BIDI;
-    qc->default_ssl_mode        = qc->obj.ssl.ctx->mode;
-    qc->default_ssl_options     = qc->obj.ssl.ctx->options & OSSL_QUIC_PERMITTED_OPTIONS;
-    qc->incoming_stream_policy  = SSL_INCOMING_STREAM_POLICY_AUTO;
-    qc->last_error              = SSL_ERROR_NONE;
+    qc->default_stream_mode = SSL_DEFAULT_STREAM_MODE_AUTO_BIDI;
+    qc->default_ssl_mode = qc->obj.ssl.ctx->mode;
+    qc->default_ssl_options = qc->obj.ssl.ctx->options & OSSL_QUIC_PERMITTED_OPTIONS;
+    qc->incoming_stream_policy = SSL_INCOMING_STREAM_POLICY_AUTO;
+    qc->last_error = SSL_ERROR_NONE;
 
     qc_update_reject_policy(qc);
 
@@ -778,22 +778,22 @@ void ossl_quic_free(SSL *s)
         --ctx.qc->num_xso;
 
         /* If a stream's send part has not been finished, auto-reset it. */
-        if ((   ctx.xso->stream->send_state == QUIC_SSTREAM_STATE_READY
-             || ctx.xso->stream->send_state == QUIC_SSTREAM_STATE_SEND)
+        if ((ctx.xso->stream->send_state == QUIC_SSTREAM_STATE_READY
+                || ctx.xso->stream->send_state == QUIC_SSTREAM_STATE_SEND)
             && !ossl_quic_sstream_get_final_size(ctx.xso->stream->sstream, NULL))
             ossl_quic_stream_map_reset_stream_send_part(ossl_quic_channel_get_qsm(ctx.qc->ch),
-                                                        ctx.xso->stream, 0);
+                ctx.xso->stream, 0);
 
         /* Do STOP_SENDING for the receive part, if applicable. */
-        if (   ctx.xso->stream->recv_state == QUIC_RSTREAM_STATE_RECV
+        if (ctx.xso->stream->recv_state == QUIC_RSTREAM_STATE_RECV
             || ctx.xso->stream->recv_state == QUIC_RSTREAM_STATE_SIZE_KNOWN)
             ossl_quic_stream_map_stop_sending_recv_part(ossl_quic_channel_get_qsm(ctx.qc->ch),
-                                                        ctx.xso->stream, 0);
+                ctx.xso->stream, 0);
 
         /* Update stream state. */
         ctx.xso->stream->deleted = 1;
         ossl_quic_stream_map_update_state(ossl_quic_channel_get_qsm(ctx.qc->ch),
-                                          ctx.xso->stream);
+            ctx.xso->stream);
 
         is_default = (ctx.xso == ctx.qc->default_xso);
         qctx_unlock(&ctx);
@@ -886,8 +886,8 @@ int ossl_quic_clear(SSL *s)
 }
 
 int ossl_quic_set_override_now_cb(SSL *s,
-                                  OSSL_TIME (*now_cb)(void *arg),
-                                  void *now_cb_arg)
+    OSSL_TIME (*now_cb)(void *arg),
+    void *now_cb_arg)
 {
     QCTX ctx;
 
@@ -928,8 +928,8 @@ static void qc_touch_default_xso(QUIC_CONNECTION *qc)
  */
 QUIC_NEEDS_LOCK
 static void qc_set_default_xso_keep_ref(QUIC_CONNECTION *qc, QUIC_XSO *xso,
-                                        int touch,
-                                        QUIC_XSO **old_xso)
+    int touch,
+    QUIC_XSO **old_xso)
 {
     int refs;
 
@@ -1024,7 +1024,7 @@ static uint64_t quic_mask_or_options(SSL *ssl, uint64_t mask_value, uint64_t or_
          * changes.
          */
         hs_mask_value = (mask_value & OSSL_QUIC_PERMITTED_OPTIONS_CONN);
-        hs_or_value   = (or_value   & OSSL_QUIC_PERMITTED_OPTIONS_CONN);
+        hs_or_value = (or_value & OSSL_QUIC_PERMITTED_OPTIONS_CONN);
 
         SSL_clear_options(ctx.qc->tls, hs_mask_value);
         SSL_set_options(ctx.qc->tls, hs_or_value);
@@ -1032,7 +1032,7 @@ static uint64_t quic_mask_or_options(SSL *ssl, uint64_t mask_value, uint64_t or_
         /* Update defaults for new streams. */
         ctx.qc->default_ssl_options
             = ((ctx.qc->default_ssl_options & ~mask_value) | or_value)
-              & OSSL_QUIC_PERMITTED_OPTIONS;
+            & OSSL_QUIC_PERMITTED_OPTIONS;
     }
 
     ret = ctx.qc->default_ssl_options;
@@ -1280,7 +1280,7 @@ out:
 }
 
 int ossl_quic_conn_set_initial_peer_addr(SSL *s,
-                                         const BIO_ADDR *peer_addr)
+    const BIO_ADDR *peer_addr)
 {
     QCTX ctx;
 
@@ -1289,7 +1289,7 @@ int ossl_quic_conn_set_initial_peer_addr(SSL *s,
 
     if (ctx.qc->started)
         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED,
-                                       NULL);
+            NULL);
 
     if (peer_addr == NULL) {
         BIO_ADDR_clear(&ctx.qc->init_peer_addr);
@@ -1355,7 +1355,7 @@ int ossl_quic_get_event_timeout(SSL *s, struct timeval *tv, int *is_infinite)
          * Robustness against faulty applications that don't check *is_infinite;
          * harmless long timeout.
          */
-        tv->tv_sec  = 1000000;
+        tv->tv_sec = 1000000;
         tv->tv_usec = 0;
         return 1;
     }
@@ -1384,7 +1384,7 @@ int ossl_quic_get_rpoll_descriptor(SSL *s, BIO_POLL_DESCRIPTOR *desc)
     net_rbio = ossl_quic_port_get_net_rbio(port);
     if (desc == NULL || net_rbio == NULL)
         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_PASSED_INVALID_ARGUMENT,
-                                       NULL);
+            NULL);
 
     return BIO_get_rpoll_descriptor(net_rbio, desc);
 }
@@ -1403,7 +1403,7 @@ int ossl_quic_get_wpoll_descriptor(SSL *s, BIO_POLL_DESCRIPTOR *desc)
     net_wbio = ossl_quic_port_get_net_wbio(port);
     if (desc == NULL || net_wbio == NULL)
         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_PASSED_INVALID_ARGUMENT,
-                                       NULL);
+            NULL);
 
     return BIO_get_wpoll_descriptor(net_wbio, desc);
 }
@@ -1503,8 +1503,8 @@ static int quic_shutdown_peer_wait(void *arg)
 
 QUIC_TAKES_LOCK
 int ossl_quic_conn_shutdown(SSL *s, uint64_t flags,
-                            const SSL_SHUTDOWN_EX_ARGS *args,
-                            size_t args_len)
+    const SSL_SHUTDOWN_EX_ARGS *args,
+    size_t args_len)
 {
     int ret;
     QCTX ctx;
@@ -1580,8 +1580,8 @@ int ossl_quic_conn_shutdown(SSL *s, uint64_t flags,
      * affect the wait_peer case.
      */
     ossl_quic_channel_local_close(ctx.qc->ch,
-                                  args != NULL ? args->quic_error_code : 0,
-                                  args != NULL ? args->quic_reason : NULL);
+        args != NULL ? args->quic_error_code : 0,
+        args != NULL ? args->quic_reason : NULL);
 
     SSL_set_shutdown(ctx.qc->tls, SSL_SENT_SHUTDOWN);
 
@@ -1662,14 +1662,14 @@ long ossl_quic_ctrl(SSL *s, int cmd, long larg, void *parg)
         return SSL_ctrl(ctx.qc->tls, cmd, larg, parg);
 
     case DTLS_CTRL_GET_TIMEOUT: /* DTLSv1_get_timeout */
-        {
-            int is_infinite;
+    {
+        int is_infinite;
 
-            if (!ossl_quic_get_event_timeout(s, parg, &is_infinite))
-                return 0;
+        if (!ossl_quic_get_event_timeout(s, parg, &is_infinite))
+            return 0;
 
-            return !is_infinite;
-        }
+        return !is_infinite;
+    }
     case DTLS_CTRL_HANDLE_TIMEOUT: /* DTLSv1_handle_timeout */
         /* For legacy compatibility with DTLS calls. */
         return ossl_quic_handle_events(s) == 1 ? 1 : -1;
@@ -1744,7 +1744,7 @@ int ossl_quic_set_accept_state(SSL *s, int raiseerrs)
 
 /* SSL_do_handshake */
 struct quic_handshake_wait_args {
-    QUIC_CONNECTION     *qc;
+    QUIC_CONNECTION *qc;
 };
 
 static int tls_wants_non_io_retry(QUIC_CONNECTION *qc)
@@ -1752,8 +1752,8 @@ static int tls_wants_non_io_retry(QUIC_CONNECTION *qc)
     int want = SSL_want(qc->tls);
 
     if (want == SSL_X509_LOOKUP
-            || want == SSL_CLIENT_HELLO_CB
-            || want == SSL_RETRY_VERIFY)
+        || want == SSL_CLIENT_HELLO_CB
+        || want == SSL_RETRY_VERIFY)
         return 1;
 
     return 0;
@@ -1795,13 +1795,13 @@ static int need_notifier_for_domain_flags(uint64_t domain_flags)
 QUIC_NEEDS_LOCK
 static int create_channel(QUIC_CONNECTION *qc, SSL_CTX *ctx)
 {
-    QUIC_ENGINE_ARGS engine_args = {0};
-    QUIC_PORT_ARGS port_args = {0};
+    QUIC_ENGINE_ARGS engine_args = { 0 };
+    QUIC_PORT_ARGS port_args = { 0 };
 
-    engine_args.libctx        = ctx->libctx;
-    engine_args.propq         = ctx->propq;
+    engine_args.libctx = ctx->libctx;
+    engine_args.propq = ctx->propq;
 #if defined(OPENSSL_THREADS)
-    engine_args.mutex         = qc->mutex;
+    engine_args.mutex = qc->mutex;
 #endif
 
     if (need_notifier_for_domain_flags(ctx->domain_flags))
@@ -1844,14 +1844,14 @@ static int ensure_channel_started(QCTX *ctx)
     if (!qc->started) {
         if (!configure_channel(qc)) {
             QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR,
-                                        "failed to configure channel");
+                "failed to configure channel");
             return 0;
         }
 
         if (!ossl_quic_channel_start(qc->ch)) {
             ossl_quic_channel_restore_err_state(qc->ch);
             QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR,
-                                        "failed to start channel");
+                "failed to start channel");
             return 0;
         }
 
@@ -1859,7 +1859,7 @@ static int ensure_channel_started(QCTX *ctx)
         if (qc->is_thread_assisted)
             if (!ossl_quic_thread_assist_init_start(&qc->thread_assist, qc->ch)) {
                 QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR,
-                                            "failed to start assist thread");
+                    "failed to start assist thread");
                 return 0;
             }
 #endif
@@ -1971,7 +1971,7 @@ static int quic_do_handshake(QCTX *ctx)
         /* In blocking mode, wait for the handshake to complete. */
         struct quic_handshake_wait_args args;
 
-        args.qc     = qc;
+        args.qc = qc;
 
         ret = block_until_pred(ctx, quic_handshake_wait, &args, 0);
         if (!quic_mutation_allowed(qc, /*req_active=*/1)) {
@@ -2074,8 +2074,8 @@ static int qc_try_create_default_xso_for_write(QCTX *ctx)
         flags |= SSL_STREAM_FLAG_UNI;
 
     qc_set_default_xso(qc, (QUIC_XSO *)quic_conn_stream_new(ctx, flags,
-                                                            /*needs_lock=*/0),
-                       /*touch=*/0);
+                               /*needs_lock=*/0),
+        /*touch=*/0);
     if (qc->default_xso == NULL)
         return QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR, NULL);
 
@@ -2085,9 +2085,9 @@ static int qc_try_create_default_xso_for_write(QCTX *ctx)
 
 struct quic_wait_for_stream_args {
     QUIC_CONNECTION *qc;
-    QUIC_STREAM     *qs;
-    QCTX            *ctx;
-    uint64_t        expect_id;
+    QUIC_STREAM *qs;
+    QCTX *ctx;
+    uint64_t expect_id;
 };
 
 QUIC_NEEDS_LOCK
@@ -2102,10 +2102,10 @@ static int quic_wait_for_stream(void *arg)
     }
 
     args->qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(args->qc->ch),
-                                              args->expect_id | QUIC_STREAM_DIR_BIDI);
+        args->expect_id | QUIC_STREAM_DIR_BIDI);
     if (args->qs == NULL)
         args->qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(args->qc->ch),
-                                                  args->expect_id | QUIC_STREAM_DIR_UNI);
+            args->expect_id | QUIC_STREAM_DIR_UNI);
 
     if (args->qs != NULL)
         return 1; /* stream now exists */
@@ -2143,16 +2143,16 @@ static int qc_wait_for_default_xso_for_read(QCTX *ctx, int peek)
         : QUIC_STREAM_INITIATOR_SERVER;
 
     qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(qc->ch),
-                                        expect_id | QUIC_STREAM_DIR_BIDI);
+        expect_id | QUIC_STREAM_DIR_BIDI);
     if (qs == NULL)
         qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(qc->ch),
-                                            expect_id | QUIC_STREAM_DIR_UNI);
+            expect_id | QUIC_STREAM_DIR_UNI);
 
     if (qs == NULL) {
         qctx_maybe_autotick(ctx);
 
         qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(qc->ch),
-                                            expect_id);
+            expect_id);
     }
 
     if (qs == NULL) {
@@ -2167,9 +2167,9 @@ static int qc_wait_for_default_xso_for_read(QCTX *ctx, int peek)
         }
 
         /* Block until we have a stream. */
-        wargs.qc        = qc;
-        wargs.qs        = NULL;
-        wargs.ctx       = ctx;
+        wargs.qc = qc;
+        wargs.qs = NULL;
+        wargs.ctx = ctx;
         wargs.expect_id = expect_id;
 
         res = block_until_pred(ctx, quic_wait_for_stream, &wargs, 0);
@@ -2188,7 +2188,7 @@ static int qc_wait_for_default_xso_for_read(QCTX *ctx, int peek)
      */
     ossl_statm_get_rtt_info(ossl_quic_channel_get_statm(qc->ch), &rtt_info);
     ossl_quic_stream_map_remove_from_accept_queue(ossl_quic_channel_get_qsm(qc->ch),
-                                                  qs, rtt_info.smoothed_rtt);
+        qs, rtt_info.smoothed_rtt);
 
     /*
      * Now make qs the default stream, creating the necessary XSO.
@@ -2212,7 +2212,7 @@ static QUIC_XSO *create_xso_from_stream(QUIC_CONNECTION *qc, QUIC_STREAM *qs)
     }
 
     if (!ossl_quic_obj_init(&xso->obj, qc->obj.ssl.ctx, SSL_TYPE_QUIC_XSO,
-                            &qc->obj.ssl, NULL, NULL)) {
+            &qc->obj.ssl, NULL, NULL)) {
         QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_INTERNAL_ERROR, NULL);
         goto err;
     }
@@ -2223,13 +2223,13 @@ static QUIC_XSO *create_xso_from_stream(QUIC_CONNECTION *qc, QUIC_STREAM *qs)
         goto err;
     }
 
-    xso->conn       = qc;
-    xso->ssl_mode   = qc->default_ssl_mode;
+    xso->conn = qc;
+    xso->ssl_mode = qc->default_ssl_mode;
     xso->ssl_options
         = qc->default_ssl_options & OSSL_QUIC_PERMITTED_OPTIONS_STREAM;
     xso->last_error = SSL_ERROR_NONE;
 
-    xso->stream     = qs;
+    xso->stream = qs;
 
     ++qc->num_xso;
     xso_update_options(xso);
@@ -2291,7 +2291,7 @@ static SSL *quic_conn_stream_new(QCTX *ctx, uint64_t flags, int need_lock)
             goto err;
         }
 
-        args.qc     = qc;
+        args.qc = qc;
         args.is_uni = is_uni;
 
         /* Blocking mode - wait until we can get a stream. */
@@ -2328,7 +2328,6 @@ err:
         qctx_unlock(ctx);
 
     return NULL;
-
 }
 
 QUIC_TAKES_LOCK
@@ -2388,7 +2387,7 @@ static int error_to_want(int error)
 {
     switch (error) {
     case SSL_ERROR_WANT_CONNECT: /* never used - UDP is connectionless */
-    case SSL_ERROR_WANT_ACCEPT:  /* never used - UDP is connectionless */
+    case SSL_ERROR_WANT_ACCEPT: /* never used - UDP is connectionless */
     case SSL_ERROR_ZERO_RETURN:
     default:
         return SSL_NOTHING;
@@ -2444,8 +2443,8 @@ int ossl_quic_want(const SSL *s)
  */
 QUIC_NEEDS_LOCK
 static void quic_post_write(QUIC_XSO *xso, int did_append,
-                            int did_append_all, uint64_t flags,
-                            int do_tick)
+    int did_append_all, uint64_t flags,
+    int do_tick)
 {
     /*
      * We have appended at least one byte to the stream.
@@ -2453,7 +2452,7 @@ static void quic_post_write(QUIC_XSO *xso, int did_append,
      */
     if (did_append)
         ossl_quic_stream_map_update_state(ossl_quic_channel_get_qsm(xso->conn->ch),
-                                          xso->stream);
+            xso->stream);
 
     if (did_append_all && (flags & SSL_WRITE_FLAG_CONCLUDE) != 0)
         ossl_quic_sstream_fin(xso->stream->sstream);
@@ -2469,12 +2468,12 @@ static void quic_post_write(QUIC_XSO *xso, int did_append,
 }
 
 struct quic_write_again_args {
-    QUIC_XSO            *xso;
+    QUIC_XSO *xso;
     const unsigned char *buf;
-    size_t              len;
-    size_t              total_written;
-    int                 err;
-    uint64_t            flags;
+    size_t len;
+    size_t total_written;
+    int err;
+    uint64_t flags;
 };
 
 /*
@@ -2482,7 +2481,7 @@ struct quic_write_again_args {
  * deliberately inducing DoS. This has been chosen based on the optimal buffer
  * size for an RTT of 500ms and a bandwidth of 100 Mb/s.
  */
-#define MAX_WRITE_BUF_SIZE      (6 * 1024 * 1024)
+#define MAX_WRITE_BUF_SIZE (6 * 1024 * 1024)
 
 /*
  * Ensure spare buffer space available (up until a limit, at least).
@@ -2513,7 +2512,7 @@ static int sstream_ensure_spare(QUIC_SSTREAM *sstream, uint64_t spare)
  */
 QUIC_NEEDS_LOCK
 static int xso_sstream_append(QUIC_XSO *xso, const unsigned char *buf,
-                              size_t len, size_t *actual_written)
+    size_t len, size_t *actual_written)
 {
     QUIC_SSTREAM *sstream = xso->stream->sstream;
     uint64_t cur = ossl_quic_sstream_get_cur_size(sstream);
@@ -2551,10 +2550,10 @@ static int quic_write_again(void *arg)
         return -2;
 
     quic_post_write(args->xso, actual_written > 0,
-                    args->len == actual_written, args->flags, 0);
+        args->len == actual_written, args->flags, 0);
 
-    args->buf           += actual_written;
-    args->len           -= actual_written;
+    args->buf += actual_written;
+    args->len -= actual_written;
     args->total_written += actual_written;
 
     if (args->len == 0)
@@ -2567,7 +2566,7 @@ static int quic_write_again(void *arg)
 
 QUIC_NEEDS_LOCK
 static int quic_write_blocking(QCTX *ctx, const void *buf, size_t len,
-                               uint64_t flags, size_t *written)
+    uint64_t flags, size_t *written)
 {
     int res;
     QUIC_XSO *xso = ctx->xso;
@@ -2598,12 +2597,12 @@ static int quic_write_blocking(QCTX *ctx, const void *buf, size_t len,
      * buffer has probably filled up. This means we need to block until some of
      * it is freed up.
      */
-    args.xso            = xso;
-    args.buf            = (const unsigned char *)buf + actual_written;
-    args.len            = len - actual_written;
-    args.total_written  = 0;
-    args.err            = ERR_R_INTERNAL_ERROR;
-    args.flags          = flags;
+    args.xso = xso;
+    args.buf = (const unsigned char *)buf + actual_written;
+    args.len = len - actual_written;
+    args.total_written = 0;
+    args.err = ERR_R_INTERNAL_ERROR;
+    args.flags = flags;
 
     res = block_until_pred(ctx, quic_write_again, &args, 0);
     if (res <= 0) {
@@ -2629,28 +2628,28 @@ static int quic_write_blocking(QCTX *ctx, const void *buf, size_t len,
  * write semantics.
  */
 static void aon_write_begin(QUIC_XSO *xso, const unsigned char *buf,
-                            size_t buf_len, size_t already_sent)
+    size_t buf_len, size_t already_sent)
 {
     assert(!xso->aon_write_in_progress);
 
     xso->aon_write_in_progress = 1;
-    xso->aon_buf_base          = buf;
-    xso->aon_buf_pos           = already_sent;
-    xso->aon_buf_len           = buf_len;
+    xso->aon_buf_base = buf;
+    xso->aon_buf_pos = already_sent;
+    xso->aon_buf_len = buf_len;
 }
 
 static void aon_write_finish(QUIC_XSO *xso)
 {
-    xso->aon_write_in_progress   = 0;
-    xso->aon_buf_base            = NULL;
-    xso->aon_buf_pos             = 0;
-    xso->aon_buf_len             = 0;
+    xso->aon_write_in_progress = 0;
+    xso->aon_buf_base = NULL;
+    xso->aon_buf_pos = 0;
+    xso->aon_buf_len = 0;
 }
 
 QUIC_NEEDS_LOCK
 static int quic_write_nonblocking_aon(QCTX *ctx, const void *buf,
-                                      size_t len, uint64_t flags,
-                                      size_t *written)
+    size_t len, uint64_t flags,
+    size_t *written)
 {
     QUIC_XSO *xso = ctx->xso;
     const void *actual_buf;
@@ -2688,7 +2687,7 @@ static int quic_write_nonblocking_aon(QCTX *ctx, const void *buf,
     }
 
     quic_post_write(xso, actual_written > 0, actual_written == actual_len,
-                    flags, qctx_should_autotick(ctx));
+        flags, qctx_should_autotick(ctx));
 
     if (actual_written == actual_len) {
         /* We have sent everything. */
@@ -2738,7 +2737,7 @@ static int quic_write_nonblocking_aon(QCTX *ctx, const void *buf,
 
 QUIC_NEEDS_LOCK
 static int quic_write_nonblocking_epw(QCTX *ctx, const void *buf, size_t len,
-                                      uint64_t flags, size_t *written)
+    uint64_t flags, size_t *written)
 {
     QUIC_XSO *xso = ctx->xso;
 
@@ -2750,7 +2749,7 @@ static int quic_write_nonblocking_epw(QCTX *ctx, const void *buf, size_t len,
     }
 
     quic_post_write(xso, *written > 0, *written == len, flags,
-                    qctx_should_autotick(ctx));
+        qctx_should_autotick(ctx));
 
     if (*written == 0)
         /* SSL_write_ex returns 0 if it didn't write anything. */
@@ -2805,7 +2804,7 @@ static int quic_validate_for_write(QUIC_XSO *xso, int *err)
 
 QUIC_TAKES_LOCK
 int ossl_quic_write_flags(SSL *s, const void *buf, size_t len,
-                          uint64_t flags, size_t *written)
+    uint64_t flags, size_t *written)
 {
     int ret;
     QCTX ctx;
@@ -2825,7 +2824,8 @@ int ossl_quic_write_flags(SSL *s, const void *buf, size_t len,
     }
 
     partial_write = ((ctx.xso != NULL)
-        ? ((ctx.xso->ssl_mode & SSL_MODE_ENABLE_PARTIAL_WRITE) != 0) : 0);
+            ? ((ctx.xso->ssl_mode & SSL_MODE_ENABLE_PARTIAL_WRITE) != 0)
+            : 0);
 
     if ((flags & ~SSL_WRITE_FLAG_CONCLUDE) != 0) {
         ret = QUIC_RAISE_NON_NORMAL_ERROR(&ctx, SSL_R_UNSUPPORTED_WRITE_FLAG, NULL);
@@ -2855,7 +2855,7 @@ int ossl_quic_write_flags(SSL *s, const void *buf, size_t len,
     if (len == 0) {
         if ((flags & SSL_WRITE_FLAG_CONCLUDE) != 0)
             quic_post_write(ctx.xso, 0, 1, flags,
-                            qctx_should_autotick(&ctx));
+                qctx_should_autotick(&ctx));
 
         ret = 1;
         goto out;
@@ -2884,12 +2884,12 @@ int ossl_quic_write(SSL *s, const void *buf, size_t len, size_t *written)
  * --------
  */
 struct quic_read_again_args {
-    QCTX            *ctx;
-    QUIC_STREAM     *stream;
-    void            *buf;
-    size_t          len;
-    size_t          *bytes_read;
-    int             peek;
+    QCTX *ctx;
+    QUIC_STREAM *stream;
+    void *buf;
+    size_t len;
+    size_t *bytes_read;
+    int peek;
 };
 
 QUIC_NEEDS_LOCK
@@ -2932,10 +2932,10 @@ static int quic_validate_for_read(QUIC_XSO *xso, int *err, int *eos)
 
 QUIC_NEEDS_LOCK
 static int quic_read_actual(QCTX *ctx,
-                            QUIC_STREAM *stream,
-                            void *buf, size_t buf_len,
-                            size_t *bytes_read,
-                            int peek)
+    QUIC_STREAM *stream,
+    void *buf, size_t buf_len,
+    size_t *bytes_read,
+    int peek)
 {
     int is_fin = 0, err, eos;
     QUIC_CONNECTION *qc = ctx->qc;
@@ -2951,12 +2951,12 @@ static int quic_read_actual(QCTX *ctx,
 
     if (peek) {
         if (!ossl_quic_rstream_peek(stream->rstream, buf, buf_len,
-                                    bytes_read, &is_fin))
+                bytes_read, &is_fin))
             return QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR, NULL);
 
     } else {
         if (!ossl_quic_rstream_read(stream->rstream, buf, buf_len,
-                                    bytes_read, &is_fin))
+                bytes_read, &is_fin))
             return QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR, NULL);
     }
 
@@ -2973,7 +2973,7 @@ static int quic_read_actual(QCTX *ctx,
             ossl_statm_get_rtt_info(ossl_quic_channel_get_statm(qc->ch), &rtt_info);
 
             if (!ossl_quic_rxfc_on_retire(&stream->rxfc, *bytes_read,
-                                          rtt_info.smoothed_rtt))
+                    rtt_info.smoothed_rtt))
                 return QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_INTERNAL_ERROR, NULL);
         }
 
@@ -2985,7 +2985,7 @@ static int quic_read_actual(QCTX *ctx,
 
         if (*bytes_read > 0)
             ossl_quic_stream_map_update_state(ossl_quic_channel_get_qsm(qc->ch),
-                                              stream);
+                stream);
     }
 
     if (*bytes_read == 0 && is_fin) {
@@ -3008,8 +3008,8 @@ static int quic_read_again(void *arg)
     }
 
     if (!quic_read_actual(args->ctx, args->stream,
-                          args->buf, args->len, args->bytes_read,
-                          args->peek))
+            args->buf, args->len, args->bytes_read,
+            args->peek))
         return -1;
 
     if (*args->bytes_read > 0)
@@ -3077,12 +3077,12 @@ static int quic_read(SSL *s, void *buf, size_t len, size_t *bytes_read, int peek
          * buffer is empty. This means we need to block until we get
          * at least one byte.
          */
-        args.ctx        = &ctx;
-        args.stream     = ctx.xso->stream;
-        args.buf        = buf;
-        args.len        = len;
+        args.ctx = &ctx;
+        args.stream = ctx.xso->stream;
+        args.buf = buf;
+        args.len = len;
         args.bytes_read = bytes_read;
-        args.peek       = peek;
+        args.peek = peek;
 
         res = block_until_pred(&ctx, quic_read_again, &args, 0);
         if (res == 0) {
@@ -3164,12 +3164,12 @@ static size_t ossl_quic_pending_int(const SSL *s, int check_channel)
 
     if (check_channel)
         avail = ossl_quic_stream_recv_pending(ctx.xso->stream,
-                                              /*include_fin=*/1)
-             || ossl_quic_channel_has_pending(ctx.qc->ch)
-             || ossl_quic_channel_is_term_any(ctx.qc->ch);
+                    /*include_fin=*/1)
+            || ossl_quic_channel_has_pending(ctx.qc->ch)
+            || ossl_quic_channel_is_term_any(ctx.qc->ch);
     else
         avail = ossl_quic_stream_recv_pending(ctx.xso->stream,
-                                              /*include_fin=*/0);
+            /*include_fin=*/0);
 
 out:
     qctx_unlock(&ctx);
@@ -3233,9 +3233,9 @@ int ossl_quic_conn_stream_conclude(SSL *s)
  */
 QUIC_TAKES_LOCK
 int SSL_inject_net_dgram(SSL *s, const unsigned char *buf,
-                         size_t buf_len,
-                         const BIO_ADDR *peer,
-                         const BIO_ADDR *local)
+    size_t buf_len,
+    const BIO_ADDR *peer,
+    const BIO_ADDR *local)
 {
     int ret = 0;
     QCTX ctx;
@@ -3410,7 +3410,7 @@ int ossl_quic_set_default_stream_mode(SSL *s, uint32_t mode)
     if (ctx.qc->default_xso_created) {
         qctx_unlock(&ctx);
         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED,
-                                       "too late to change default stream mode");
+            "too late to change default stream mode");
     }
 
     switch (mode) {
@@ -3422,7 +3422,7 @@ int ossl_quic_set_default_stream_mode(SSL *s, uint32_t mode)
     default:
         qctx_unlock(&ctx);
         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_PASSED_INVALID_ARGUMENT,
-                                       "bad default stream type");
+            "bad default stream type");
     }
 
     qctx_unlock(&ctx);
@@ -3469,7 +3469,7 @@ int ossl_quic_attach_stream(SSL *conn, SSL *stream)
 
     if (stream == NULL || stream->type != SSL_TYPE_QUIC_XSO)
         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_PASSED_NULL_PARAMETER,
-                                       "stream to attach must be a valid QUIC stream");
+            "stream to attach must be a valid QUIC stream");
 
     xso = (QUIC_XSO *)stream;
 
@@ -3478,7 +3478,7 @@ int ossl_quic_attach_stream(SSL *conn, SSL *stream)
     if (ctx.qc->default_xso != NULL) {
         qctx_unlock(&ctx);
         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED,
-                                       "connection already has a default stream");
+            "connection already has a default stream");
     }
 
     /*
@@ -3488,14 +3488,14 @@ int ossl_quic_attach_stream(SSL *conn, SSL *stream)
     if (!CRYPTO_GET_REF(&xso->obj.ssl.references, &nref)) {
         qctx_unlock(&ctx);
         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_INTERNAL_ERROR,
-                                       "ref");
+            "ref");
     }
 
     if (nref != 1) {
         qctx_unlock(&ctx);
         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx, ERR_R_PASSED_INVALID_ARGUMENT,
-                                       "stream being attached must have "
-                                       "only 1 reference");
+            "stream being attached must have "
+            "only 1 reference");
     }
 
     /* Caller's reference to the XSO is transferred to us. */
@@ -3514,15 +3514,15 @@ QUIC_NEEDS_LOCK
 static int qc_get_effective_incoming_stream_policy(QUIC_CONNECTION *qc)
 {
     switch (qc->incoming_stream_policy) {
-        case SSL_INCOMING_STREAM_POLICY_AUTO:
-            if ((qc->default_xso == NULL && !qc->default_xso_created)
-                || qc->default_stream_mode == SSL_DEFAULT_STREAM_MODE_NONE)
-                return SSL_INCOMING_STREAM_POLICY_ACCEPT;
-            else
-                return SSL_INCOMING_STREAM_POLICY_REJECT;
+    case SSL_INCOMING_STREAM_POLICY_AUTO:
+        if ((qc->default_xso == NULL && !qc->default_xso_created)
+            || qc->default_stream_mode == SSL_DEFAULT_STREAM_MODE_NONE)
+            return SSL_INCOMING_STREAM_POLICY_ACCEPT;
+        else
+            return SSL_INCOMING_STREAM_POLICY_REJECT;
 
-        default:
-            return qc->incoming_stream_policy;
+    default:
+        return qc->incoming_stream_policy;
     }
 }
 
@@ -3533,13 +3533,13 @@ static void qc_update_reject_policy(QUIC_CONNECTION *qc)
     int enable_reject = (policy == SSL_INCOMING_STREAM_POLICY_REJECT);
 
     ossl_quic_channel_set_incoming_stream_auto_reject(qc->ch,
-                                                      enable_reject,
-                                                      qc->incoming_stream_aec);
+        enable_reject,
+        qc->incoming_stream_aec);
 }
 
 QUIC_TAKES_LOCK
 int ossl_quic_set_incoming_stream_policy(SSL *s, int policy,
-                                         uint64_t aec)
+    uint64_t aec)
 {
     int ret = 1;
     QCTX ctx;
@@ -3554,7 +3554,7 @@ int ossl_quic_set_incoming_stream_policy(SSL *s, int policy,
     case SSL_INCOMING_STREAM_POLICY_ACCEPT:
     case SSL_INCOMING_STREAM_POLICY_REJECT:
         ctx.qc->incoming_stream_policy = policy;
-        ctx.qc->incoming_stream_aec    = aec;
+        ctx.qc->incoming_stream_aec = aec;
         break;
 
     default:
@@ -3574,7 +3574,7 @@ int ossl_quic_set_incoming_stream_policy(SSL *s, int policy,
  */
 QUIC_TAKES_LOCK
 static int qc_getset_idle_timeout(QCTX *ctx, uint32_t class_,
-                                  uint64_t *p_value_out, uint64_t *p_value_in)
+    uint64_t *p_value_out, uint64_t *p_value_in)
 {
     int ret = 0;
     uint64_t value_out = 0, value_in;
@@ -3589,13 +3589,13 @@ static int qc_getset_idle_timeout(QCTX *ctx, uint32_t class_,
             value_in = *p_value_in;
             if (value_in > OSSL_QUIC_VLINT_MAX) {
                 QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_PASSED_INVALID_ARGUMENT,
-                                            NULL);
+                    NULL);
                 goto err;
             }
 
             if (ossl_quic_channel_have_generated_transport_params(ctx->qc->ch)) {
                 QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_FEATURE_NOT_RENEGOTIABLE,
-                                            NULL);
+                    NULL);
                 goto err;
             }
 
@@ -3607,13 +3607,13 @@ static int qc_getset_idle_timeout(QCTX *ctx, uint32_t class_,
     case SSL_VALUE_CLASS_FEATURE_NEGOTIATED:
         if (p_value_in != NULL) {
             QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_UNSUPPORTED_CONFIG_VALUE_OP,
-                                        NULL);
+                NULL);
             goto err;
         }
 
         if (!ossl_quic_channel_is_handshake_complete(ctx->qc->ch)) {
             QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_FEATURE_NEGOTIATION_NOT_COMPLETE,
-                                        NULL);
+                NULL);
             goto err;
         }
 
@@ -3624,7 +3624,7 @@ static int qc_getset_idle_timeout(QCTX *ctx, uint32_t class_,
 
     default:
         QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_UNSUPPORTED_CONFIG_VALUE_CLASS,
-                                    NULL);
+            NULL);
         goto err;
     }
 
@@ -3639,14 +3639,14 @@ err:
 
 QUIC_TAKES_LOCK
 static int qc_get_stream_avail(QCTX *ctx, uint32_t class_,
-                               int is_uni, int is_remote,
-                               uint64_t *value)
+    int is_uni, int is_remote,
+    uint64_t *value)
 {
     int ret = 0;
 
     if (class_ != SSL_VALUE_CLASS_GENERIC) {
         QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_UNSUPPORTED_CONFIG_VALUE_CLASS,
-                                    NULL);
+            NULL);
         return 0;
     }
 
@@ -3668,7 +3668,9 @@ static int qctx_should_autotick(QCTX *ctx)
     QUIC_OBJ *obj = ctx->obj;
 
     for (; (event_handling_mode = obj->event_handling_mode) == SSL_VALUE_EVENT_HANDLING_MODE_INHERIT
-           && obj->parent_obj != NULL; obj = obj->parent_obj);
+        && obj->parent_obj != NULL;
+        obj = obj->parent_obj)
+        ;
 
     return event_handling_mode != SSL_VALUE_EVENT_HANDLING_MODE_EXPLICIT;
 }
@@ -3684,8 +3686,8 @@ static void qctx_maybe_autotick(QCTX *ctx)
 
 QUIC_TAKES_LOCK
 static int qc_getset_event_handling(QCTX *ctx, uint32_t class_,
-                                    uint64_t *p_value_out,
-                                    uint64_t *p_value_in)
+    uint64_t *p_value_out,
+    uint64_t *p_value_in)
 {
     int ret = 0;
     uint64_t value_out = 0;
@@ -3694,7 +3696,7 @@ static int qc_getset_event_handling(QCTX *ctx, uint32_t class_,
 
     if (class_ != SSL_VALUE_CLASS_GENERIC) {
         QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_UNSUPPORTED_CONFIG_VALUE_CLASS,
-                                    NULL);
+            NULL);
         goto err;
     }
 
@@ -3706,7 +3708,7 @@ static int qc_getset_event_handling(QCTX *ctx, uint32_t class_,
             break;
         default:
             QUIC_RAISE_NON_NORMAL_ERROR(ctx, ERR_R_PASSED_INVALID_ARGUMENT,
-                                        NULL);
+                NULL);
             goto err;
         }
 
@@ -3727,8 +3729,8 @@ err:
 
 QUIC_TAKES_LOCK
 static int qc_get_stream_write_buf_stat(QCTX *ctx, uint32_t class_,
-                                        uint64_t *p_value_out,
-                                        size_t (*getter)(QUIC_SSTREAM *sstream))
+    uint64_t *p_value_out,
+    size_t (*getter)(QUIC_SSTREAM *sstream))
 {
     int ret = 0;
     size_t value = 0;
@@ -3737,7 +3739,7 @@ static int qc_get_stream_write_buf_stat(QCTX *ctx, uint32_t class_,
 
     if (class_ != SSL_VALUE_CLASS_GENERIC) {
         QUIC_RAISE_NON_NORMAL_ERROR(ctx, SSL_R_UNSUPPORTED_CONFIG_VALUE_CLASS,
-                                    NULL);
+            NULL);
         goto err;
     }
 
@@ -3777,7 +3779,7 @@ static int expect_quic_for_value(SSL *s, QCTX *ctx, uint32_t id)
 
 QUIC_TAKES_LOCK
 int ossl_quic_get_value_uint(SSL *s, uint32_t class_, uint32_t id,
-                             uint64_t *value)
+    uint64_t *value)
 {
     QCTX ctx;
 
@@ -3786,7 +3788,7 @@ int ossl_quic_get_value_uint(SSL *s, uint32_t class_, uint32_t id,
 
     if (value == NULL)
         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx,
-                                           ERR_R_PASSED_INVALID_ARGUMENT, NULL);
+            ERR_R_PASSED_INVALID_ARGUMENT, NULL);
 
     switch (id) {
     case SSL_VALUE_QUIC_IDLE_TIMEOUT:
@@ -3806,17 +3808,17 @@ int ossl_quic_get_value_uint(SSL *s, uint32_t class_, uint32_t id,
 
     case SSL_VALUE_STREAM_WRITE_BUF_SIZE:
         return qc_get_stream_write_buf_stat(&ctx, class_, value,
-                                            ossl_quic_sstream_get_buffer_size);
+            ossl_quic_sstream_get_buffer_size);
     case SSL_VALUE_STREAM_WRITE_BUF_USED:
         return qc_get_stream_write_buf_stat(&ctx, class_, value,
-                                            ossl_quic_sstream_get_buffer_used);
+            ossl_quic_sstream_get_buffer_used);
     case SSL_VALUE_STREAM_WRITE_BUF_AVAIL:
         return qc_get_stream_write_buf_stat(&ctx, class_, value,
-                                            ossl_quic_sstream_get_buffer_avail);
+            ossl_quic_sstream_get_buffer_avail);
 
     default:
         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx,
-                                           SSL_R_UNSUPPORTED_CONFIG_VALUE, NULL);
+            SSL_R_UNSUPPORTED_CONFIG_VALUE, NULL);
     }
 
     return 1;
@@ -3824,7 +3826,7 @@ int ossl_quic_get_value_uint(SSL *s, uint32_t class_, uint32_t id,
 
 QUIC_TAKES_LOCK
 int ossl_quic_set_value_uint(SSL *s, uint32_t class_, uint32_t id,
-                             uint64_t value)
+    uint64_t value)
 {
     QCTX ctx;
 
@@ -3840,7 +3842,7 @@ int ossl_quic_set_value_uint(SSL *s, uint32_t class_, uint32_t id,
 
     default:
         return QUIC_RAISE_NON_NORMAL_ERROR(&ctx,
-                                           SSL_R_UNSUPPORTED_CONFIG_VALUE, NULL);
+            SSL_R_UNSUPPORTED_CONFIG_VALUE, NULL);
     }
 
     return 1;
@@ -3851,8 +3853,8 @@ int ossl_quic_set_value_uint(SSL *s, uint32_t class_, uint32_t id,
  * -----------------
  */
 struct wait_for_incoming_stream_args {
-    QCTX            *ctx;
-    QUIC_STREAM     *qs;
+    QCTX *ctx;
+    QUIC_STREAM *qs;
 };
 
 QUIC_NEEDS_LOCK
@@ -3928,7 +3930,7 @@ SSL *ossl_quic_accept_stream(SSL *s, uint64_t flags)
 
     ossl_statm_get_rtt_info(ossl_quic_channel_get_statm(ctx.qc->ch), &rtt_info);
     ossl_quic_stream_map_remove_from_accept_queue(qsm, qs,
-                                                  rtt_info.smoothed_rtt);
+        rtt_info.smoothed_rtt);
     new_s = &xso->obj.ssl;
 
     /* Calling this function inhibits default XSO autocreation. */
@@ -3965,8 +3967,8 @@ size_t ossl_quic_get_accept_stream_queue_len(SSL *s)
  * ----------------
  */
 int ossl_quic_stream_reset(SSL *ssl,
-                           const SSL_STREAM_RESET_ARGS *args,
-                           size_t args_len)
+    const SSL_STREAM_RESET_ARGS *args,
+    size_t args_len)
 {
     QCTX ctx;
     QUIC_STREAM_MAP *qsm;
@@ -3977,9 +3979,9 @@ int ossl_quic_stream_reset(SSL *ssl,
     if (!expect_quic_with_stream_lock(ssl, /*remote_init=*/0, /*io=*/0, &ctx))
         return 0;
 
-    qsm         = ossl_quic_channel_get_qsm(ctx.qc->ch);
-    qs          = ctx.xso->stream;
-    error_code  = (args != NULL ? args->quic_error_code : 0);
+    qsm = ossl_quic_channel_get_qsm(ctx.qc->ch);
+    qs = ctx.xso->stream;
+    error_code = (args != NULL ? args->quic_error_code : 0);
 
     if (!quic_validate_for_write(ctx.xso, &err)) {
         ok = QUIC_RAISE_NON_NORMAL_ERROR(&ctx, err, NULL);
@@ -4000,10 +4002,10 @@ err:
  * -------------------------
  */
 static void quic_classify_stream(QUIC_CONNECTION *qc,
-                                 QUIC_STREAM *qs,
-                                 int is_write,
-                                 int *state,
-                                 uint64_t *app_error_code)
+    QUIC_STREAM *qs,
+    int is_write,
+    int *state,
+    uint64_t *app_error_code)
 {
     int local_init;
     uint64_t final_size;
@@ -4028,26 +4030,25 @@ static void quic_classify_stream(QUIC_CONNECTION *qc,
         /* Application has read a FIN. */
         *state = SSL_STREAM_STATE_FINISHED;
     } else if ((!is_write && qs->stop_sending)
-               || (is_write && ossl_quic_stream_send_is_reset(qs))) {
+        || (is_write && ossl_quic_stream_send_is_reset(qs))) {
         /*
          * Stream has been reset locally. FIN takes precedence over this for the
          * read case as the application need not care if the stream is reset
          * after a FIN has been successfully processed.
          */
-        *state          = SSL_STREAM_STATE_RESET_LOCAL;
+        *state = SSL_STREAM_STATE_RESET_LOCAL;
         *app_error_code = !is_write
             ? qs->stop_sending_aec
             : qs->reset_stream_aec;
     } else if ((!is_write && ossl_quic_stream_recv_is_reset(qs))
-               || (is_write && qs->peer_stop_sending)) {
+        || (is_write && qs->peer_stop_sending)) {
         /*
          * Stream has been reset remotely. */
-        *state          = SSL_STREAM_STATE_RESET_REMOTE;
+        *state = SSL_STREAM_STATE_RESET_REMOTE;
         *app_error_code = !is_write
             ? qs->peer_reset_stream_aec
             : qs->peer_stop_sending_aec;
-    } else if (is_write && ossl_quic_sstream_get_final_size(qs->sstream,
-                                                            &final_size)) {
+    } else if (is_write && ossl_quic_sstream_get_final_size(qs->sstream, &final_size)) {
         /*
          * Stream has been finished. Stream reset takes precedence over this for
          * the write case as peer may not have received all data.
@@ -4091,7 +4092,7 @@ int ossl_quic_get_stream_write_state(SSL *ssl)
  * ------------------------------
  */
 static int quic_get_stream_error_code(SSL *ssl, int is_write,
-                                      uint64_t *app_error_code)
+    uint64_t *app_error_code)
 {
     QCTX ctx;
     int state;
@@ -4099,18 +4100,18 @@ static int quic_get_stream_error_code(SSL *ssl, int is_write,
     if (!expect_quic_with_stream_lock(ssl, /*remote_init=*/-1, /*io=*/0, &ctx))
         return -1;
 
-    quic_classify_stream(ctx.qc, ctx.xso->stream, /*is_write=*/0,
-                         &state, app_error_code);
+    quic_classify_stream(ctx.qc, ctx.xso->stream, is_write,
+        &state, app_error_code);
 
     qctx_unlock(&ctx);
     switch (state) {
-        case SSL_STREAM_STATE_FINISHED:
-             return 0;
-        case SSL_STREAM_STATE_RESET_LOCAL:
-        case SSL_STREAM_STATE_RESET_REMOTE:
-             return 1;
-        default:
-             return -1;
+    case SSL_STREAM_STATE_FINISHED:
+        return 0;
+    case SSL_STREAM_STATE_RESET_LOCAL:
+    case SSL_STREAM_STATE_RESET_REMOTE:
+        return 1;
+    default:
+        return -1;
     }
 }
 
@@ -4172,8 +4173,8 @@ out:
  * -----------------------
  */
 int ossl_quic_get_conn_close_info(SSL *ssl,
-                                  SSL_CONN_CLOSE_INFO *info,
-                                  size_t info_len)
+    SSL_CONN_CLOSE_INFO *info,
+    size_t info_len)
 {
     QCTX ctx;
     const QUIC_TERMINATE_CAUSE *tc;
@@ -4185,11 +4186,11 @@ int ossl_quic_get_conn_close_info(SSL *ssl,
     if (tc == NULL)
         return 0;
 
-    info->error_code    = tc->error_code;
-    info->frame_type    = tc->frame_type;
-    info->reason        = tc->reason;
-    info->reason_len    = tc->reason_len;
-    info->flags         = 0;
+    info->error_code = tc->error_code;
+    info->frame_type = tc->frame_type;
+    info->reason = tc->reason;
+    info->reason_len = tc->reason_len;
+    info->flags = 0;
     if (!tc->remote)
         info->flags |= SSL_CONN_CLOSE_FLAG_LOCAL;
     if (!tc->app)
@@ -4286,8 +4287,8 @@ static SSL *alloc_port_user_ssl(QUIC_CHANNEL *ch, void *arg)
 SSL *ossl_quic_new_listener(SSL_CTX *ctx, uint64_t flags)
 {
     QUIC_LISTENER *ql = NULL;
-    QUIC_ENGINE_ARGS engine_args = {0};
-    QUIC_PORT_ARGS port_args = {0};
+    QUIC_ENGINE_ARGS engine_args = { 0 };
+    QUIC_PORT_ARGS port_args = { 0 };
 
     if ((ql = OPENSSL_zalloc(sizeof(*ql))) == NULL) {
         QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_CRYPTO_LIB, NULL);
@@ -4301,10 +4302,10 @@ SSL *ossl_quic_new_listener(SSL_CTX *ctx, uint64_t flags)
     }
 #endif
 
-    engine_args.libctx  = ctx->libctx;
-    engine_args.propq   = ctx->propq;
+    engine_args.libctx = ctx->libctx;
+    engine_args.propq = ctx->propq;
 #if defined(OPENSSL_THREADS)
-    engine_args.mutex   = ql->mutex;
+    engine_args.mutex = ql->mutex;
 #endif
 
     if (need_notifier_for_domain_flags(ctx->domain_flags))
@@ -4315,8 +4316,8 @@ SSL *ossl_quic_new_listener(SSL_CTX *ctx, uint64_t flags)
         goto err;
     }
 
-    port_args.channel_ctx       = ctx;
-    port_args.is_multi_conn     = 1;
+    port_args.channel_ctx = ctx;
+    port_args.is_multi_conn = 1;
     port_args.get_conn_user_ssl = alloc_port_user_ssl;
     port_args.user_ssl_arg = ql;
     if ((flags & SSL_LISTENER_FLAG_NO_VALIDATE) == 0)
@@ -4333,7 +4334,7 @@ SSL *ossl_quic_new_listener(SSL_CTX *ctx, uint64_t flags)
 
     /* Initialise the QUIC_LISTENER's object header. */
     if (!ossl_quic_obj_init(&ql->obj, ctx, SSL_TYPE_QUIC_LISTENER, NULL,
-                            ql->engine, ql->port))
+            ql->engine, ql->port))
         goto err;
 
     return &ql->obj.ssl;
@@ -4357,7 +4358,7 @@ SSL *ossl_quic_new_listener_from(SSL *ssl, uint64_t flags)
 {
     QCTX ctx;
     QUIC_LISTENER *ql = NULL;
-    QUIC_PORT_ARGS port_args = {0};
+    QUIC_PORT_ARGS port_args = { 0 };
 
     if (!expect_quic_domain(ssl, &ctx))
         return NULL;
@@ -4372,8 +4373,8 @@ SSL *ossl_quic_new_listener_from(SSL *ssl, uint64_t flags)
         goto err;
     }
 
-    port_args.channel_ctx       = ssl->ctx;
-    port_args.is_multi_conn     = 1;
+    port_args.channel_ctx = ssl->ctx;
+    port_args.is_multi_conn = 1;
     port_args.get_conn_user_ssl = alloc_port_user_ssl;
     port_args.user_ssl_arg = ql;
     if ((flags & SSL_LISTENER_FLAG_NO_VALIDATE) == 0)
@@ -4384,10 +4385,10 @@ SSL *ossl_quic_new_listener_from(SSL *ssl, uint64_t flags)
         goto err;
     }
 
-    ql->domain  = ctx.qd;
-    ql->engine  = ctx.qd->engine;
+    ql->domain = ctx.qd;
+    ql->engine = ctx.qd->engine;
 #if defined(OPENSSL_THREADS)
-    ql->mutex   = ctx.qd->mutex;
+    ql->mutex = ctx.qd->mutex;
 #endif
 
     /*
@@ -4403,7 +4404,7 @@ SSL *ossl_quic_new_listener_from(SSL *ssl, uint64_t flags)
 
     /* Initialise the QUIC_LISTENER's object header. */
     if (!ossl_quic_obj_init(&ql->obj, ssl->ctx, SSL_TYPE_QUIC_LISTENER,
-                            &ctx.qd->obj.ssl, NULL, ql->port))
+            &ctx.qd->obj.ssl, NULL, ql->port))
         goto err;
 
     qctx_unlock(&ctx);
@@ -4483,7 +4484,7 @@ SSL *ossl_quic_new_from_listener(SSL *ssl, uint64_t flags)
 #endif
 #if !defined(OPENSSL_NO_QUIC_THREAD_ASSIST)
     qc->is_thread_assisted
-    = ((ql->obj.domain_flags & SSL_DOMAIN_FLAG_THREAD_ASSISTED) != 0);
+        = ((ql->obj.domain_flags & SSL_DOMAIN_FLAG_THREAD_ASSISTED) != 0);
 #endif
 
     /* Create the handshake layer. */
@@ -4503,6 +4504,10 @@ SSL *ossl_quic_new_from_listener(SSL *ssl, uint64_t flags)
      * to grab reference for qc.
      */
     qc->ch = ossl_quic_port_create_outgoing(qc->port, qc->tls);
+    if (qc->ch == NULL) {
+        QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_INTERNAL_ERROR, NULL);
+        goto err;
+    }
 
     ossl_quic_channel_set_msg_callback(qc->ch, ql->obj.ssl.ctx->msg_callback, &qc->obj.ssl);
     ossl_quic_channel_set_msg_callback_arg(qc->ch, ql->obj.ssl.ctx->msg_callback_arg);
@@ -4514,8 +4519,8 @@ SSL *ossl_quic_new_from_listener(SSL *ssl, uint64_t flags)
      * to create a new QCSO here.
      */
     if (!ossl_quic_obj_init(&qc->obj, ql->obj.ssl.ctx,
-                            SSL_TYPE_QUIC_CONNECTION,
-                            &ql->obj.ssl, NULL, NULL)) {
+            SSL_TYPE_QUIC_CONNECTION,
+            &ql->obj.ssl, NULL, NULL)) {
         QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_INTERNAL_ERROR, NULL);
         goto err;
     }
@@ -4599,9 +4604,10 @@ SSL *ossl_quic_accept_connection(SSL *ssl, uint64_t flags)
     int ret;
     QCTX ctx;
     SSL *conn_ssl = NULL;
+    SSL *conn_ssl_tmp = NULL;
     SSL_CONNECTION *conn = NULL;
     QUIC_CHANNEL *new_ch = NULL;
-    QUIC_CONNECTION *qc;
+    QUIC_CONNECTION *qc = NULL;
     int no_block = ((flags & SSL_ACCEPT_CONNECTION_NO_BLOCK) != 0);
 
     if (!expect_quic_listener(ssl, &ctx))
@@ -4617,7 +4623,7 @@ SSL *ossl_quic_accept_connection(SSL *ssl, uint64_t flags)
     if (new_ch == NULL && ossl_quic_port_is_running(ctx.ql->port)) {
         if (!no_block && qctx_blocking(&ctx)) {
             ret = block_until_pred(&ctx, quic_accept_connection_wait,
-                                   ctx.ql->port, 0);
+                ctx.ql->port, 0);
             if (ret < 1)
                 goto out;
         } else {
@@ -4642,22 +4648,46 @@ SSL *ossl_quic_accept_connection(SSL *ssl, uint64_t flags)
      * created channel, so once we pop the new channel from the port above
      * we just need to extract it
      */
-    if (new_ch == NULL
-        || (conn_ssl = ossl_quic_channel_get0_tls(new_ch)) == NULL
-        || (conn = SSL_CONNECTION_FROM_SSL(conn_ssl)) == NULL
-        || (conn_ssl = SSL_CONNECTION_GET_USER_SSL(conn)) == NULL)
+    if (new_ch == NULL)
         goto out;
-    qc = (QUIC_CONNECTION *)conn_ssl;
-    qc->listener = ctx.ql;
-    qc->pending = 0;
-    if (!SSL_up_ref(&ctx.ql->obj.ssl)) {
-        SSL_free(conn_ssl);
-        SSL_free(ossl_quic_channel_get0_tls(new_ch));
-        conn_ssl = NULL;
+
+    /*
+     * All objects below must exist, because new_ch != NULL. The objects are
+     * bound to new_ch. If channel constructor fails to create any item here
+     * it just fails to create channel.
+     */
+    if (!ossl_assert((conn_ssl_tmp = ossl_quic_channel_get0_tls(new_ch)) != NULL)
+        || !ossl_assert((conn = SSL_CONNECTION_FROM_SSL(conn_ssl_tmp)) != NULL)
+        || !ossl_assert((conn_ssl_tmp = SSL_CONNECTION_GET_USER_SSL(conn)) != NULL))
+        goto out;
+
+    qc = (QUIC_CONNECTION *)conn_ssl_tmp;
+    if (SSL_up_ref(&ctx.ql->obj.ssl)) {
+        qc->listener = ctx.ql;
+        conn_ssl = conn_ssl_tmp;
+        conn_ssl_tmp = NULL;
+        qc->pending = 0;
     }
 
 out:
+
     qctx_unlock(&ctx);
+    /*
+     * You might expect ossl_quic_channel_free() to be called here. Be
+     * assured it happens, The process goes as follows:
+     *    - The SSL_free() here is being handled by ossl_quic_free().
+     *    - The very last step of ossl_quic_free() is call to qc_cleanup()
+     *      where channel gets freed.
+     * NOTE: We defer this SSL_free until after the call to qctx_unlock above
+     * to avoid the deadlock that would occur when ossl_quic_free attempts to
+     * re-acquire this mutex.  We also do the gymnastics with conn_ssl and
+     * conn_ssl_tmp above so that we only actually do the free on the SSL
+     * object if the up-ref above fails, in such a way that we don't unbalance
+     * the listener refcount (i.e. if the up-ref fails above, we don't set the
+     * listener pointer so that we don't then drop the ref-count erroneously
+     * during the free operation.
+     */
+    SSL_free(conn_ssl_tmp);
     return conn_ssl;
 }
 
@@ -4671,28 +4701,28 @@ static QUIC_CONNECTION *create_qc_from_incoming_conn(QUIC_LISTENER *ql, QUIC_CHA
     }
 
     if (!ossl_quic_obj_init(&qc->obj, ql->obj.ssl.ctx,
-                            SSL_TYPE_QUIC_CONNECTION,
-                            &ql->obj.ssl, NULL, NULL)) {
+            SSL_TYPE_QUIC_CONNECTION,
+            &ql->obj.ssl, NULL, NULL)) {
         QUIC_RAISE_NON_NORMAL_ERROR(NULL, ERR_R_INTERNAL_ERROR, NULL);
         goto err;
     }
 
     ossl_quic_channel_get_peer_addr(ch, &qc->init_peer_addr); /* best effort */
-    qc->pending                 = 1;
-    qc->engine                  = ql->engine;
-    qc->port                    = ql->port;
-    qc->ch                      = ch;
+    qc->pending = 1;
+    qc->engine = ql->engine;
+    qc->port = ql->port;
+    qc->ch = ch;
 #if defined(OPENSSL_THREADS)
-    qc->mutex                   = ql->mutex;
+    qc->mutex = ql->mutex;
 #endif
-    qc->tls                     = ossl_quic_channel_get0_tls(ch);
-    qc->started                 = 1;
-    qc->as_server               = 1;
-    qc->as_server_state         = 1;
-    qc->default_stream_mode     = SSL_DEFAULT_STREAM_MODE_AUTO_BIDI;
-    qc->default_ssl_options     = ql->obj.ssl.ctx->options & OSSL_QUIC_PERMITTED_OPTIONS;
-    qc->incoming_stream_policy  = SSL_INCOMING_STREAM_POLICY_AUTO;
-    qc->last_error              = SSL_ERROR_NONE;
+    qc->tls = ossl_quic_channel_get0_tls(ch);
+    qc->started = 1;
+    qc->as_server = 1;
+    qc->as_server_state = 1;
+    qc->default_stream_mode = SSL_DEFAULT_STREAM_MODE_AUTO_BIDI;
+    qc->default_ssl_options = ql->obj.ssl.ctx->options & OSSL_QUIC_PERMITTED_OPTIONS;
+    qc->incoming_stream_policy = SSL_INCOMING_STREAM_POLICY_AUTO;
+    qc->last_error = SSL_ERROR_NONE;
     qc_update_reject_policy(qc);
     return qc;
 
@@ -4805,7 +4835,7 @@ void ossl_quic_free_token_store(SSL_TOKEN_STORE *hdl)
  * @returns a QUIC_TOKEN pointer or NULL on error
  */
 static QUIC_TOKEN *ossl_quic_build_new_token(BIO_ADDR *peer, uint8_t *token,
-                                             size_t token_len)
+    size_t token_len)
 {
     QUIC_TOKEN *new_token;
     size_t hashkey_len = 0;
@@ -4858,7 +4888,7 @@ static QUIC_TOKEN *ossl_quic_build_new_token(BIO_ADDR *peer, uint8_t *token,
 }
 
 int ossl_quic_set_peer_token(SSL_CTX *ctx, BIO_ADDR *peer,
-                             const uint8_t *token, size_t token_len)
+    const uint8_t *token, size_t token_len)
 {
     SSL_TOKEN_STORE *c = ctx->tokencache;
     QUIC_TOKEN *tok, *old = NULL;
@@ -4885,7 +4915,7 @@ int ossl_quic_set_peer_token(SSL_CTX *ctx, BIO_ADDR *peer,
 }
 
 int ossl_quic_get_peer_token(SSL_CTX *ctx, BIO_ADDR *peer,
-                             QUIC_TOKEN **token)
+    QUIC_TOKEN **token)
 {
     SSL_TOKEN_STORE *c = ctx->tokencache;
     QUIC_TOKEN *key = NULL;
@@ -4960,13 +4990,11 @@ size_t ossl_quic_get_accept_connection_queue_len(SSL *ssl)
 SSL *ossl_quic_new_domain(SSL_CTX *ctx, uint64_t flags)
 {
     QUIC_DOMAIN *qd = NULL;
-    QUIC_ENGINE_ARGS engine_args = {0};
+    QUIC_ENGINE_ARGS engine_args = { 0 };
     uint64_t domain_flags;
 
     domain_flags = ctx->domain_flags;
-    if ((flags & (SSL_DOMAIN_FLAG_SINGLE_THREAD
-                  | SSL_DOMAIN_FLAG_MULTI_THREAD
-                  | SSL_DOMAIN_FLAG_THREAD_ASSISTED)) != 0)
+    if ((flags & (SSL_DOMAIN_FLAG_SINGLE_THREAD | SSL_DOMAIN_FLAG_MULTI_THREAD | SSL_DOMAIN_FLAG_THREAD_ASSISTED)) != 0)
         domain_flags = flags;
     else
         domain_flags = ctx->domain_flags | flags;
@@ -4986,10 +5014,10 @@ SSL *ossl_quic_new_domain(SSL_CTX *ctx, uint64_t flags)
     }
 #endif
 
-    engine_args.libctx  = ctx->libctx;
-    engine_args.propq   = ctx->propq;
+    engine_args.libctx = ctx->libctx;
+    engine_args.propq = ctx->propq;
 #if defined(OPENSSL_THREADS)
-    engine_args.mutex   = qd->mutex;
+    engine_args.mutex = qd->mutex;
 #endif
 
     if (need_notifier_for_domain_flags(domain_flags))
@@ -5002,7 +5030,7 @@ SSL *ossl_quic_new_domain(SSL_CTX *ctx, uint64_t flags)
 
     /* Initialise the QUIC_DOMAIN's object header. */
     if (!ossl_quic_obj_init(&qd->obj, ctx, SSL_TYPE_QUIC_DOMAIN, NULL,
-                            qd->engine, NULL))
+            qd->engine, NULL))
         goto err;
 
     ossl_quic_obj_set_domain_flags(&qd->obj, domain_flags);
@@ -5030,7 +5058,7 @@ long ossl_quic_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
     }
 }
 
-long ossl_quic_callback_ctrl(SSL *s, int cmd, void (*fp) (void))
+long ossl_quic_callback_ctrl(SSL *s, int cmd, void (*fp)(void))
 {
     QCTX ctx;
 
@@ -5040,9 +5068,10 @@ long ossl_quic_callback_ctrl(SSL *s, int cmd, void (*fp) (void))
     switch (cmd) {
     case SSL_CTRL_SET_MSG_CALLBACK:
         ossl_quic_channel_set_msg_callback(ctx.qc->ch, (ossl_msg_cb)fp,
-                                           &ctx.qc->obj.ssl);
+            &ctx.qc->obj.ssl);
         /* This callback also needs to be set on the internal SSL object */
-        return ssl3_callback_ctrl(ctx.qc->tls, cmd, fp);;
+        return ssl3_callback_ctrl(ctx.qc->tls, cmd, fp);
+        ;
 
     default:
         /* Probably a TLS related ctrl. Defer to our internal SSL object */
@@ -5050,7 +5079,7 @@ long ossl_quic_callback_ctrl(SSL *s, int cmd, void (*fp) (void))
     }
 }
 
-long ossl_quic_ctx_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void))
+long ossl_quic_ctx_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)(void))
 {
     return ssl3_ctx_callback_ctrl(ctx, cmd, fp);
 }
@@ -5160,7 +5189,7 @@ static int test_poll_event_w(QUIC_XSO *xso)
         && ossl_quic_sstream_get_buffer_avail(xso->stream->sstream)
         && !ossl_quic_sstream_get_final_size(xso->stream->sstream, NULL)
         && ossl_quic_txfc_get_cwm(&xso->stream->txfc)
-           > ossl_quic_sstream_get_cur_size(xso->stream->sstream)
+        > ossl_quic_sstream_get_cur_size(xso->stream->sstream)
         && quic_mutation_allowed(xso->conn, /*req_active=*/1);
 }
 
@@ -5193,7 +5222,7 @@ QUIC_NEEDS_LOCK
 static int test_poll_event_is(QUIC_CONNECTION *qc, int is_uni)
 {
     return ossl_quic_stream_map_get_accept_queue_len(ossl_quic_channel_get_qsm(qc->ch),
-                                                     is_uni);
+        is_uni);
 }
 
 /* Do we have the OS (outgoing: stream) condition? */
@@ -5221,7 +5250,7 @@ static int test_poll_event_ic(QUIC_LISTENER *ql)
 
 QUIC_TAKES_LOCK
 int ossl_quic_conn_poll_events(SSL *ssl, uint64_t events, int do_tick,
-                               uint64_t *p_revents)
+    uint64_t *p_revents)
 {
     QCTX ctx;
     uint64_t revents = 0;
@@ -5297,7 +5326,7 @@ int ossl_quic_conn_poll_events(SSL *ssl, uint64_t events, int do_tick,
             revents |= SSL_POLL_EVENT_IC;
     }
 
- end:
+end:
     qctx_unlock(&ctx);
     *p_revents = revents;
     return 1;
@@ -5321,7 +5350,7 @@ int ossl_quic_get_notifier_fd(SSL *ssl)
         goto end;
     nfd = ossl_rio_notifier_as_fd(nfy);
 
- end:
+end:
     qctx_unlock(&ctx);
     return nfd;
 }
diff --git a/crypto/openssl/ssl/quic/quic_lcidm.c b/crypto/openssl/ssl/quic/quic_lcidm.c
index f31fd101a1f3..89ee95055dc1 100644
--- a/crypto/openssl/ssl/quic/quic_lcidm.c
+++ b/crypto/openssl/ssl/quic/quic_lcidm.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2023-2025 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2023-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy
@@ -24,63 +24,71 @@
 typedef struct quic_lcidm_conn_st QUIC_LCIDM_CONN;
 
 enum {
-    LCID_TYPE_ODCID,        /* This LCID is the ODCID from the peer */
-    LCID_TYPE_INITIAL,      /* This is our Initial SCID */
-    LCID_TYPE_NCID          /* This LCID was issued via a NCID frame */
+    LCID_TYPE_ODCID, /* This LCID is the ODCID from the peer */
+    LCID_TYPE_INITIAL, /* This is our Initial SCID */
+    LCID_TYPE_NCID /* This LCID was issued via a NCID frame */
 };
 
 typedef struct quic_lcid_st {
-    QUIC_CONN_ID                cid;
-    uint64_t                    seq_num;
+    QUIC_CONN_ID cid;
+    uint64_t seq_num;
 
     /* copy of the hash key from lcidm */
-    uint64_t                    *hash_key;
+    uint64_t *hash_key;
 
     /* Back-pointer to the owning QUIC_LCIDM_CONN structure. */
-    QUIC_LCIDM_CONN             *conn;
+    QUIC_LCIDM_CONN *conn;
 
     /* LCID_TYPE_* */
-    unsigned int                type                : 2;
+    unsigned int type : 2;
 } QUIC_LCID;
 
 DEFINE_LHASH_OF_EX(QUIC_LCID);
 DEFINE_LHASH_OF_EX(QUIC_LCIDM_CONN);
 
 struct quic_lcidm_conn_st {
-    size_t              num_active_lcid;
+    size_t num_active_lcid;
     LHASH_OF(QUIC_LCID) *lcids;
-    void                *opaque;
-    QUIC_LCID           *odcid_lcid_obj;
-    uint64_t            next_seq_num;
+    void *opaque;
+    QUIC_LCID *odcid_lcid_obj;
+    uint64_t next_seq_num;
 
     /* Have we enrolled an ODCID? */
-    unsigned int        done_odcid          : 1;
+    unsigned int done_odcid : 1;
 };
 
 struct quic_lcidm_st {
-    OSSL_LIB_CTX                *libctx;
-    uint64_t                    hash_key[2]; /* random key for siphash */
-    LHASH_OF(QUIC_LCID)         *lcids; /* (QUIC_CONN_ID) -> (QUIC_LCID *)  */
-    LHASH_OF(QUIC_LCIDM_CONN)   *conns; /* (void *opaque) -> (QUIC_LCIDM_CONN *) */
-    size_t                      lcid_len; /* Length in bytes for all LCIDs */
+    OSSL_LIB_CTX *libctx;
+    uint64_t hash_key[2]; /* random key for siphash */
+    LHASH_OF(QUIC_LCID) *lcids; /* (QUIC_CONN_ID) -> (QUIC_LCID *)  */
+    LHASH_OF(QUIC_LCIDM_CONN) *conns; /* (void *opaque) -> (QUIC_LCIDM_CONN *) */
+    size_t lcid_len; /* Length in bytes for all LCIDs */
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    QUIC_CONN_ID                next_lcid;
+    QUIC_CONN_ID next_lcid;
 #endif
 };
 
 static unsigned long lcid_hash(const QUIC_LCID *lcid_obj)
 {
-    SIPHASH siphash = {0, };
+    SIPHASH siphash = {
+        0,
+    };
     unsigned long hashval = 0;
+    unsigned char digest[SIPHASH_MIN_DIGEST_SIZE];
 
-    if (!SipHash_set_hash_size(&siphash, sizeof(unsigned long)))
+    /* Use a supported SipHash digest size (8 or 16); 8 is sufficient here. */
+    if (!SipHash_set_hash_size(&siphash, SIPHASH_MIN_DIGEST_SIZE))
         goto out;
     if (!SipHash_Init(&siphash, (uint8_t *)lcid_obj->hash_key, 0, 0))
         goto out;
     SipHash_Update(&siphash, lcid_obj->cid.id, lcid_obj->cid.id_len);
-    if (!SipHash_Final(&siphash, (unsigned char *)&hashval,
-                       sizeof(unsigned long)))
+    if (!SipHash_Final(&siphash, digest, SIPHASH_MIN_DIGEST_SIZE))
         goto out;
+
+    /*
+     * Truncate the 64-bit SipHash digest into an unsigned long.
+     */
+    memcpy(&hashval, digest, sizeof(hashval) < sizeof(digest) ? sizeof(hashval) : sizeof(digest));
 out:
     return hashval;
 }
@@ -112,17 +120,18 @@ QUIC_LCIDM *ossl_quic_lcidm_new(OSSL_LIB_CTX *libctx, size_t lcid_len)
 
     /* generate a random key for the hash tables hash function */
     if (!RAND_bytes_ex(libctx, (unsigned char *)&lcidm->hash_key,
-                       sizeof(uint64_t) * 2, 0))
+            sizeof(uint64_t) * 2, 0))
         goto err;
 
     if ((lcidm->lcids = lh_QUIC_LCID_new(lcid_hash, lcid_comp)) == NULL)
         goto err;
 
     if ((lcidm->conns = lh_QUIC_LCIDM_CONN_new(lcidm_conn_hash,
-                                               lcidm_conn_comp)) == NULL)
+             lcidm_conn_comp))
+        == NULL)
         goto err;
 
-    lcidm->libctx   = libctx;
+    lcidm->libctx = libctx;
     lcidm->lcid_len = lcid_len;
     return lcidm;
 
@@ -251,7 +260,7 @@ static void lcidm_delete_conn(QUIC_LCIDM *lcidm, QUIC_LCIDM_CONN *conn)
 }
 
 static QUIC_LCID *lcidm_conn_new_lcid(QUIC_LCIDM *lcidm, QUIC_LCIDM_CONN *conn,
-                                      const QUIC_CONN_ID *lcid)
+    const QUIC_CONN_ID *lcid)
 {
     QUIC_LCID *lcid_obj = NULL;
 
@@ -289,7 +298,7 @@ size_t ossl_quic_lcidm_get_lcid_len(const QUIC_LCIDM *lcidm)
 }
 
 size_t ossl_quic_lcidm_get_num_active_lcid(const QUIC_LCIDM *lcidm,
-                                           void *opaque)
+    void *opaque)
 {
     QUIC_LCIDM_CONN *conn;
 
@@ -301,7 +310,7 @@ size_t ossl_quic_lcidm_get_num_active_lcid(const QUIC_LCIDM *lcidm,
 }
 
 static int lcidm_generate_cid(QUIC_LCIDM *lcidm,
-                              QUIC_CONN_ID *cid)
+    QUIC_CONN_ID *cid)
 {
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     int i;
@@ -320,10 +329,10 @@ static int lcidm_generate_cid(QUIC_LCIDM *lcidm,
 }
 
 static int lcidm_generate(QUIC_LCIDM *lcidm,
-                          void *opaque,
-                          unsigned int type,
-                          QUIC_CONN_ID *lcid_out,
-                          uint64_t *seq_num)
+    void *opaque,
+    unsigned int type,
+    QUIC_CONN_ID *lcid_out,
+    uint64_t *seq_num)
 {
     QUIC_LCIDM_CONN *conn;
     QUIC_LCID key, *lcid_obj;
@@ -358,8 +367,8 @@ static int lcidm_generate(QUIC_LCIDM *lcidm,
     if ((lcid_obj = lcidm_conn_new_lcid(lcidm, conn, lcid_out)) == NULL)
         return 0;
 
-    lcid_obj->seq_num   = conn->next_seq_num;
-    lcid_obj->type      = type;
+    lcid_obj->seq_num = conn->next_seq_num;
+    lcid_obj->type = type;
 
     if (seq_num != NULL)
         *seq_num = lcid_obj->seq_num;
@@ -369,8 +378,8 @@ static int lcidm_generate(QUIC_LCIDM *lcidm,
 }
 
 int ossl_quic_lcidm_enrol_odcid(QUIC_LCIDM *lcidm,
-                                void *opaque,
-                                const QUIC_CONN_ID *initial_odcid)
+    void *opaque,
+    const QUIC_CONN_ID *initial_odcid)
 {
     QUIC_LCIDM_CONN *conn;
     QUIC_LCID key, *lcid_obj;
@@ -393,24 +402,24 @@ int ossl_quic_lcidm_enrol_odcid(QUIC_LCIDM *lcidm,
     if ((lcid_obj = lcidm_conn_new_lcid(lcidm, conn, initial_odcid)) == NULL)
         return 0;
 
-    lcid_obj->seq_num       = LCIDM_ODCID_SEQ_NUM;
-    lcid_obj->type          = LCID_TYPE_ODCID;
+    lcid_obj->seq_num = LCIDM_ODCID_SEQ_NUM;
+    lcid_obj->type = LCID_TYPE_ODCID;
 
-    conn->odcid_lcid_obj    = lcid_obj;
-    conn->done_odcid        = 1;
+    conn->odcid_lcid_obj = lcid_obj;
+    conn->done_odcid = 1;
     return 1;
 }
 
 int ossl_quic_lcidm_generate_initial(QUIC_LCIDM *lcidm,
-                                     void *opaque,
-                                     QUIC_CONN_ID *initial_lcid)
+    void *opaque,
+    QUIC_CONN_ID *initial_lcid)
 {
     return lcidm_generate(lcidm, opaque, LCID_TYPE_INITIAL,
-                          initial_lcid, NULL);
+        initial_lcid, NULL);
 }
 
 int ossl_quic_lcidm_bind_channel(QUIC_LCIDM *lcidm, void *opaque,
-                                 const QUIC_CONN_ID *lcid)
+    const QUIC_CONN_ID *lcid)
 {
     QUIC_LCIDM_CONN *conn;
     QUIC_LCID *lcid_obj;
@@ -440,15 +449,15 @@ int ossl_quic_lcidm_bind_channel(QUIC_LCIDM *lcidm, void *opaque,
 }
 
 int ossl_quic_lcidm_generate(QUIC_LCIDM *lcidm,
-                             void *opaque,
-                             OSSL_QUIC_FRAME_NEW_CONN_ID *ncid_frame)
+    void *opaque,
+    OSSL_QUIC_FRAME_NEW_CONN_ID *ncid_frame)
 {
-    ncid_frame->seq_num         = 0;
+    ncid_frame->seq_num = 0;
     ncid_frame->retire_prior_to = 0;
 
     return lcidm_generate(lcidm, opaque, LCID_TYPE_NCID,
-                          &ncid_frame->conn_id,
-                          &ncid_frame->seq_num);
+        &ncid_frame->conn_id,
+        &ncid_frame->seq_num);
 }
 
 int ossl_quic_lcidm_retire_odcid(QUIC_LCIDM *lcidm, void *opaque)
@@ -467,8 +476,8 @@ int ossl_quic_lcidm_retire_odcid(QUIC_LCIDM *lcidm, void *opaque)
 }
 
 struct retire_args {
-    QUIC_LCID           *earliest_seq_num_lcid_obj;
-    uint64_t            earliest_seq_num, retire_prior_to;
+    QUIC_LCID *earliest_seq_num_lcid_obj;
+    uint64_t earliest_seq_num, retire_prior_to;
 };
 
 static void retire_for_conn(QUIC_LCID *lcid_obj, void *arg)
@@ -481,21 +490,21 @@ static void retire_for_conn(QUIC_LCID *lcid_obj, void *arg)
         return;
 
     if (lcid_obj->seq_num < args->earliest_seq_num) {
-        args->earliest_seq_num          = lcid_obj->seq_num;
+        args->earliest_seq_num = lcid_obj->seq_num;
         args->earliest_seq_num_lcid_obj = lcid_obj;
     }
 }
 
 int ossl_quic_lcidm_retire(QUIC_LCIDM *lcidm,
-                           void *opaque,
-                           uint64_t retire_prior_to,
-                           const QUIC_CONN_ID *containing_pkt_dcid,
-                           QUIC_CONN_ID *retired_lcid,
-                           uint64_t *retired_seq_num,
-                           int *did_retire)
+    void *opaque,
+    uint64_t retire_prior_to,
+    const QUIC_CONN_ID *containing_pkt_dcid,
+    QUIC_CONN_ID *retired_lcid,
+    uint64_t *retired_seq_num,
+    int *did_retire)
 {
     QUIC_LCIDM_CONN key, *conn;
-    struct retire_args args = {0};
+    struct retire_args args = { 0 };
 
     key.opaque = opaque;
 
@@ -506,8 +515,8 @@ int ossl_quic_lcidm_retire(QUIC_LCIDM *lcidm,
     if ((conn = lh_QUIC_LCIDM_CONN_retrieve(lcidm->conns, &key)) == NULL)
         return 1;
 
-    args.retire_prior_to    = retire_prior_to;
-    args.earliest_seq_num   = UINT64_MAX;
+    args.retire_prior_to = retire_prior_to;
+    args.earliest_seq_num = UINT64_MAX;
 
     lh_QUIC_LCID_doall_arg(conn->lcids, retire_for_conn, &args);
     if (args.earliest_seq_num_lcid_obj == NULL)
@@ -515,7 +524,7 @@ int ossl_quic_lcidm_retire(QUIC_LCIDM *lcidm,
 
     if (containing_pkt_dcid != NULL
         && ossl_quic_conn_id_eq(&args.earliest_seq_num_lcid_obj->cid,
-                                containing_pkt_dcid))
+            containing_pkt_dcid))
         return 0;
 
     *did_retire = 1;
@@ -542,9 +551,9 @@ int ossl_quic_lcidm_cull(QUIC_LCIDM *lcidm, void *opaque)
 }
 
 int ossl_quic_lcidm_lookup(QUIC_LCIDM *lcidm,
-                           const QUIC_CONN_ID *lcid,
-                           uint64_t *seq_num,
-                           void **opaque)
+    const QUIC_CONN_ID *lcid,
+    uint64_t *seq_num,
+    void **opaque)
 {
     QUIC_LCID *lcid_obj;
 
@@ -555,16 +564,16 @@ int ossl_quic_lcidm_lookup(QUIC_LCIDM *lcidm,
         return 0;
 
     if (seq_num != NULL)
-        *seq_num        = lcid_obj->seq_num;
+        *seq_num = lcid_obj->seq_num;
 
     if (opaque != NULL)
-        *opaque         = lcid_obj->conn->opaque;
+        *opaque = lcid_obj->conn->opaque;
 
     return 1;
 }
 
 int ossl_quic_lcidm_debug_remove(QUIC_LCIDM *lcidm,
-                                 const QUIC_CONN_ID *lcid)
+    const QUIC_CONN_ID *lcid)
 {
     QUIC_LCID key, *lcid_obj;
 
@@ -578,8 +587,8 @@ int ossl_quic_lcidm_debug_remove(QUIC_LCIDM *lcidm,
 }
 
 int ossl_quic_lcidm_debug_add(QUIC_LCIDM *lcidm, void *opaque,
-                              const QUIC_CONN_ID *lcid,
-                              uint64_t seq_num)
+    const QUIC_CONN_ID *lcid,
+    uint64_t seq_num)
 {
     QUIC_LCIDM_CONN *conn;
     QUIC_LCID key, *lcid_obj;
@@ -598,8 +607,8 @@ int ossl_quic_lcidm_debug_add(QUIC_LCIDM *lcidm, void *opaque,
     if ((lcid_obj = lcidm_conn_new_lcid(lcidm, conn, lcid)) == NULL)
         return 0;
 
-    lcid_obj->seq_num   = seq_num;
-    lcid_obj->type      = LCID_TYPE_NCID;
+    lcid_obj->seq_num = seq_num;
+    lcid_obj->type = LCID_TYPE_NCID;
     return 1;
 }
 
diff --git a/crypto/openssl/ssl/quic/quic_local.h b/crypto/openssl/ssl/quic/quic_local.h
index 97029ae9c482..0c8594b3150e 100644
--- a/crypto/openssl/ssl/quic/quic_local.h
+++ b/crypto/openssl/ssl/quic/quic_local.h
@@ -8,24 +8,24 @@
  */
 
 #ifndef OSSL_QUIC_LOCAL_H
-# define OSSL_QUIC_LOCAL_H
+#define OSSL_QUIC_LOCAL_H
 
-# include <openssl/ssl.h>
-# include "internal/quic_ssl.h"       /* QUIC_CONNECTION */
-# include "internal/quic_txp.h"
-# include "internal/quic_statm.h"
-# include "internal/quic_demux.h"
-# include "internal/quic_record_rx.h"
-# include "internal/quic_tls.h"
-# include "internal/quic_fc.h"
-# include "internal/quic_stream.h"
-# include "internal/quic_channel.h"
-# include "internal/quic_reactor.h"
-# include "internal/quic_thread_assist.h"
-# include "../ssl_local.h"
-# include "quic_obj_local.h"
+#include <openssl/ssl.h>
+#include "internal/quic_ssl.h" /* QUIC_CONNECTION */
+#include "internal/quic_txp.h"
+#include "internal/quic_statm.h"
+#include "internal/quic_demux.h"
+#include "internal/quic_record_rx.h"
+#include "internal/quic_tls.h"
+#include "internal/quic_fc.h"
+#include "internal/quic_stream.h"
+#include "internal/quic_channel.h"
+#include "internal/quic_reactor.h"
+#include "internal/quic_thread_assist.h"
+#include "../ssl_local.h"
+#include "quic_obj_local.h"
 
-# ifndef OPENSSL_NO_QUIC
+#ifndef OPENSSL_NO_QUIC
 
 /*
  * QUIC stream SSL object (QSSO) type. This implements the API personality layer
@@ -34,22 +34,22 @@
  */
 struct quic_xso_st {
     /* QUIC_OBJ common header, including SSL object common header. */
-    QUIC_OBJ                        obj;
+    QUIC_OBJ obj;
 
     /* The connection this stream is associated with. Always non-NULL. */
-    QUIC_CONNECTION                 *conn;
+    QUIC_CONNECTION *conn;
 
     /* The stream object. Always non-NULL for as long as the XSO exists. */
-    QUIC_STREAM                     *stream;
+    QUIC_STREAM *stream;
 
     /* The application has retired a FIN (i.e. SSL_ERROR_ZERO_RETURN). */
-    unsigned int                    retired_fin             : 1;
+    unsigned int retired_fin : 1;
 
     /*
      * The application has requested a reset. Not set for reflexive
      * STREAM_RESETs caused by peer STOP_SENDING.
      */
-    unsigned int                    requested_reset         : 1;
+    unsigned int requested_reset : 1;
 
     /*
      * This state tracks SSL_write all-or-nothing (AON) write semantics
@@ -70,7 +70,7 @@ struct quic_xso_st {
      *
      */
     /* Is an AON write in progress? */
-    unsigned int                    aon_write_in_progress   : 1;
+    unsigned int aon_write_in_progress : 1;
 
     /*
      * The base buffer pointer the caller passed us for the initial AON write
@@ -81,27 +81,27 @@ struct quic_xso_st {
      * (but identical) buffer if using ACCEPT_MOVING_WRITE_BUFFER. It is for
      * validation by pointer comparison only.
      */
-    const unsigned char             *aon_buf_base;
+    const unsigned char *aon_buf_base;
     /* The total length of the AON buffer being sent, in bytes. */
-    size_t                          aon_buf_len;
+    size_t aon_buf_len;
     /*
      * The position in the AON buffer up to which we have successfully sent data
      * so far.
      */
-    size_t                          aon_buf_pos;
+    size_t aon_buf_pos;
 
     /* SSL_set_mode */
-    uint32_t                        ssl_mode;
+    uint32_t ssl_mode;
 
     /* SSL_set_options */
-    uint64_t                        ssl_options;
+    uint64_t ssl_options;
 
     /*
      * Last 'normal' error during an app-level I/O operation, used by
      * SSL_get_error(); used to track data-path errors like SSL_ERROR_WANT_READ
      * and SSL_ERROR_WANT_WRITE.
      */
-    int                             last_error;
+    int last_error;
 };
 
 /*
@@ -116,21 +116,21 @@ struct quic_conn_st {
      *
      * Note: This must come first in the QUIC_CONNECTION structure.
      */
-    QUIC_OBJ                        obj;
+    QUIC_OBJ obj;
 
-    SSL                             *tls;
+    SSL *tls;
 
     /* The QLSO this connection belongs to, if any. */
-    QUIC_LISTENER                   *listener;
+    QUIC_LISTENER *listener;
 
     /* The QDSO this connection belongs to, if any. */
-    QUIC_DOMAIN                     *domain;
+    QUIC_DOMAIN *domain;
 
     /* The QUIC engine representing the QUIC event domain. */
-    QUIC_ENGINE                     *engine;
+    QUIC_ENGINE *engine;
 
     /* The QUIC port representing the QUIC listener and socket. */
-    QUIC_PORT                       *port;
+    QUIC_PORT *port;
 
     /*
      * The QUIC channel providing the core QUIC connection implementation. Note
@@ -143,90 +143,90 @@ struct quic_conn_st {
      * The channel remains available after connection termination until the SSL
      * object is freed, thus (ch != NULL) iff (started == 1).
      */
-    QUIC_CHANNEL                    *ch;
+    QUIC_CHANNEL *ch;
 
     /*
      * The mutex used to synchronise access to the QUIC_CHANNEL. We own this but
      * provide it to the channel.
      */
 #if defined(OPENSSL_THREADS)
-    CRYPTO_MUTEX                    *mutex;
+    CRYPTO_MUTEX *mutex;
 #endif
 
     /*
      * If we have a default stream attached, this is the internal XSO
      * object. If there is no default stream, this is NULL.
      */
-    QUIC_XSO                        *default_xso;
+    QUIC_XSO *default_xso;
 
     /* Initial peer L4 address. */
-    BIO_ADDR                        init_peer_addr;
+    BIO_ADDR init_peer_addr;
 
-#  ifndef OPENSSL_NO_QUIC_THREAD_ASSIST
+#ifndef OPENSSL_NO_QUIC_THREAD_ASSIST
     /* Manages thread for QUIC thread assisted mode. */
-    QUIC_THREAD_ASSIST              thread_assist;
-#  endif
+    QUIC_THREAD_ASSIST thread_assist;
+#endif
 
     /* Number of XSOs allocated. Includes the default XSO, if any. */
-    size_t                          num_xso;
+    size_t num_xso;
 
     /* Have we started? */
-    unsigned int                    started                 : 1;
+    unsigned int started : 1;
 
     /*
      * This is 1 if we were instantiated using a QUIC server method
      * (for future use).
      */
-    unsigned int                    as_server               : 1;
+    unsigned int as_server : 1;
 
     /*
      * Has the application called SSL_set_accept_state? We require this to be
      * congruent with the value of as_server.
      */
-    unsigned int                    as_server_state         : 1;
+    unsigned int as_server_state : 1;
 
     /* Are we using thread assisted mode? Never changes after init. */
-    unsigned int                    is_thread_assisted      : 1;
+    unsigned int is_thread_assisted : 1;
 
     /* Have we created a default XSO yet? */
-    unsigned int                    default_xso_created     : 1;
+    unsigned int default_xso_created : 1;
 
     /*
      * Pre-TERMINATING shutdown phase in which we are flushing streams.
      * Monotonically transitions to 1.
      * New streams cannot be created in this state.
      */
-    unsigned int                    shutting_down           : 1;
+    unsigned int shutting_down : 1;
 
     /* Have we probed the BIOs for addressing support? */
-    unsigned int                    addressing_probe_done   : 1;
+    unsigned int addressing_probe_done : 1;
 
     /* Are we using addressed mode (BIO_sendmmsg with non-NULL peer)? */
-    unsigned int                    addressed_mode_w        : 1;
-    unsigned int                    addressed_mode_r        : 1;
+    unsigned int addressed_mode_w : 1;
+    unsigned int addressed_mode_r : 1;
 
     /* Flag to indicate waiting on accept queue */
-    unsigned int                    pending                 : 1;
+    unsigned int pending : 1;
 
     /* Default stream type. Defaults to SSL_DEFAULT_STREAM_MODE_AUTO_BIDI. */
-    uint32_t                        default_stream_mode;
+    uint32_t default_stream_mode;
 
     /* SSL_set_mode. This is not used directly but inherited by new XSOs. */
-    uint32_t                        default_ssl_mode;
+    uint32_t default_ssl_mode;
 
     /* SSL_set_options. This is not used directly but inherited by new XSOs. */
-    uint64_t                        default_ssl_options;
+    uint64_t default_ssl_options;
 
     /* SSL_set_incoming_stream_policy. */
-    int                             incoming_stream_policy;
-    uint64_t                        incoming_stream_aec;
+    int incoming_stream_policy;
+    uint64_t incoming_stream_aec;
 
     /*
      * Last 'normal' error during an app-level I/O operation, used by
      * SSL_get_error(); used to track data-path errors like SSL_ERROR_WANT_READ
      * and SSL_ERROR_WANT_WRITE.
      */
-    int                             last_error;
+    int last_error;
 };
 
 /*
@@ -235,27 +235,27 @@ struct quic_conn_st {
  */
 struct quic_listener_st {
     /* QUIC_OBJ common header, including SSL object common header. */
-    QUIC_OBJ                        obj;
+    QUIC_OBJ obj;
 
     /* The QDSO this connection belongs to, if any. */
-    QUIC_DOMAIN                     *domain;
+    QUIC_DOMAIN *domain;
 
     /* The QUIC engine representing the QUIC event domain. */
-    QUIC_ENGINE                     *engine;
+    QUIC_ENGINE *engine;
 
     /* The QUIC port representing the QUIC listener and socket. */
-    QUIC_PORT                       *port;
+    QUIC_PORT *port;
 
 #if defined(OPENSSL_THREADS)
     /*
      * The mutex used to synchronise access to the QUIC_ENGINE. We own this but
      * provide it to the engine.
      */
-    CRYPTO_MUTEX                    *mutex;
+    CRYPTO_MUTEX *mutex;
 #endif
 
     /* Have we started listening yet? */
-    unsigned int                    listening               : 1;
+    unsigned int listening : 1;
 };
 
 /*
@@ -263,18 +263,18 @@ struct quic_listener_st {
  * for QDSO objects, wrapping the QUIC-native QUIC_ENGINE object.
  */
 struct quic_domain_st {
-     /* QUIC_OBJ common header, including SSL object common header. */
-    QUIC_OBJ                        obj;
+    /* QUIC_OBJ common header, including SSL object common header. */
+    QUIC_OBJ obj;
 
     /* The QUIC engine representing the QUIC event domain. */
-    QUIC_ENGINE                     *engine;
+    QUIC_ENGINE *engine;
 
 #if defined(OPENSSL_THREADS)
     /*
      * The mutex used to synchronise access to the QUIC_ENGINE. We own this but
      * provide it to the engine.
      */
-    CRYPTO_MUTEX                    *mutex;
+    CRYPTO_MUTEX *mutex;
 #endif
 };
 
@@ -288,55 +288,55 @@ int ossl_quic_conn_on_handshake_confirmed(QUIC_CONNECTION *qc);
  * applicable.
  */
 void ossl_quic_conn_raise_protocol_error(QUIC_CONNECTION *qc,
-                                         uint64_t error_code,
-                                         uint64_t frame_type,
-                                         const char *reason);
+    uint64_t error_code,
+    uint64_t frame_type,
+    const char *reason);
 
 void ossl_quic_conn_on_remote_conn_close(QUIC_CONNECTION *qc,
-                                         OSSL_QUIC_FRAME_CONN_CLOSE *f);
+    OSSL_QUIC_FRAME_CONN_CLOSE *f);
 
-#  define OSSL_QUIC_ANY_VERSION 0xFFFFF
-# endif
+#define OSSL_QUIC_ANY_VERSION 0xFFFFF
+#endif
 
-# define IMPLEMENT_quic_meth_func(version, func_name, q_accept, \
-                                 q_connect, enc_data) \
-const SSL_METHOD *func_name(void)  \
-        { \
-        static const SSL_METHOD func_name##_data= { \
-                version, \
-                0, \
-                0, \
-                ossl_quic_new, \
-                ossl_quic_free, \
-                ossl_quic_reset, \
-                ossl_quic_init, \
-                NULL /* clear */, \
-                ossl_quic_deinit, \
-                q_accept, \
-                q_connect, \
-                ossl_quic_read, \
-                ossl_quic_peek, \
-                ossl_quic_write, \
-                NULL /* shutdown */, \
-                NULL /* renegotiate */, \
-                ossl_quic_renegotiate_check, \
-                NULL /* read_bytes */, \
-                NULL /* write_bytes */, \
-                NULL /* dispatch_alert */, \
-                ossl_quic_ctrl, \
-                ossl_quic_ctx_ctrl, \
-                ossl_quic_get_cipher_by_char, \
-                NULL /* put_cipher_by_char */, \
-                ossl_quic_pending, \
-                ossl_quic_num_ciphers, \
-                ossl_quic_get_cipher, \
-                tls1_default_timeout, \
-                &enc_data, \
-                ssl_undefined_void_function, \
-                ossl_quic_callback_ctrl, \
-                ossl_quic_ctx_callback_ctrl, \
-        }; \
-        return &func_name##_data; \
-        }
+#define IMPLEMENT_quic_meth_func(version, func_name, q_accept, \
+    q_connect, enc_data)                                       \
+    const SSL_METHOD *func_name(void)                          \
+    {                                                          \
+        static const SSL_METHOD func_name##_data = {           \
+            version,                                           \
+            0,                                                 \
+            0,                                                 \
+            ossl_quic_new,                                     \
+            ossl_quic_free,                                    \
+            ossl_quic_reset,                                   \
+            ossl_quic_init,                                    \
+            NULL /* clear */,                                  \
+            ossl_quic_deinit,                                  \
+            q_accept,                                          \
+            q_connect,                                         \
+            ossl_quic_read,                                    \
+            ossl_quic_peek,                                    \
+            ossl_quic_write,                                   \
+            NULL /* shutdown */,                               \
+            NULL /* renegotiate */,                            \
+            ossl_quic_renegotiate_check,                       \
+            NULL /* read_bytes */,                             \
+            NULL /* write_bytes */,                            \
+            NULL /* dispatch_alert */,                         \
+            ossl_quic_ctrl,                                    \
+            ossl_quic_ctx_ctrl,                                \
+            ossl_quic_get_cipher_by_char,                      \
+            NULL /* put_cipher_by_char */,                     \
+            ossl_quic_pending,                                 \
+            ossl_quic_num_ciphers,                             \
+            ossl_quic_get_cipher,                              \
+            tls1_default_timeout,                              \
+            &enc_data,                                         \
+            ssl_undefined_void_function,                       \
+            ossl_quic_callback_ctrl,                           \
+            ossl_quic_ctx_callback_ctrl,                       \
+        };                                                     \
+        return &func_name##_data;                              \
+    }
 
 #endif
diff --git a/crypto/openssl/ssl/quic/quic_method.c b/crypto/openssl/ssl/quic/quic_method.c
index 8092855efc61..55d7824e336a 100644
--- a/crypto/openssl/ssl/quic/quic_method.c
+++ b/crypto/openssl/ssl/quic/quic_method.c
@@ -12,16 +12,16 @@
 #include "quic_local.h"
 
 IMPLEMENT_quic_meth_func(OSSL_QUIC_ANY_VERSION,
-                         OSSL_QUIC_client_method,
-                         ssl_undefined_function,
-                         ossl_quic_connect, ssl3_undef_enc_method)
+    OSSL_QUIC_client_method,
+    ssl_undefined_function,
+    ossl_quic_connect, ssl3_undef_enc_method)
 
 IMPLEMENT_quic_meth_func(OSSL_QUIC_ANY_VERSION,
-                         OSSL_QUIC_client_thread_method,
-                         ssl_undefined_function,
-                         ossl_quic_connect, ssl3_undef_enc_method)
+    OSSL_QUIC_client_thread_method,
+    ssl_undefined_function,
+    ossl_quic_connect, ssl3_undef_enc_method)
 
 IMPLEMENT_quic_meth_func(OSSL_QUIC_ANY_VERSION,
-                         OSSL_QUIC_server_method,
-                         ossl_quic_accept,
-                         ssl_undefined_function, ssl3_undef_enc_method)
+    OSSL_QUIC_server_method,
+    ossl_quic_accept,
+    ssl_undefined_function, ssl3_undef_enc_method)
diff --git a/crypto/openssl/ssl/quic/quic_obj.c b/crypto/openssl/ssl/quic/quic_obj.c
index 6c31c8c93314..0c0a3faa2ee5 100644
--- a/crypto/openssl/ssl/quic/quic_obj.c
+++ b/crypto/openssl/ssl/quic/quic_obj.c
@@ -14,17 +14,17 @@
 static int obj_update_cache(QUIC_OBJ *obj);
 
 int ossl_quic_obj_init(QUIC_OBJ *obj,
-                       SSL_CTX *ctx,
-                       int type,
-                       SSL *parent_obj,
-                       QUIC_ENGINE *engine,
-                       QUIC_PORT *port)
+    SSL_CTX *ctx,
+    int type,
+    SSL *parent_obj,
+    QUIC_ENGINE *engine,
+    QUIC_PORT *port)
 {
     int is_event_leader = (engine != NULL);
-    int is_port_leader  = (port != NULL);
+    int is_port_leader = (port != NULL);
 
     if (!ossl_assert(obj != NULL && !obj->init_done && SSL_TYPE_IS_QUIC(type)
-                     && (parent_obj == NULL || IS_QUIC(parent_obj))))
+            && (parent_obj == NULL || IS_QUIC(parent_obj))))
         return 0;
 
     /* Event leader is always the root object. */
@@ -34,22 +34,22 @@ int ossl_quic_obj_init(QUIC_OBJ *obj,
     if (!ossl_ssl_init(&obj->ssl, ctx, ctx->method, type))
         goto err;
 
-    obj->domain_flags       = ctx->domain_flags;
-    obj->parent_obj         = (QUIC_OBJ *)parent_obj;
-    obj->is_event_leader    = is_event_leader;
-    obj->is_port_leader     = is_port_leader;
-    obj->engine             = engine;
-    obj->port               = port;
-    obj->req_blocking_mode  = QUIC_BLOCKING_MODE_INHERIT;
+    obj->domain_flags = ctx->domain_flags;
+    obj->parent_obj = (QUIC_OBJ *)parent_obj;
+    obj->is_event_leader = is_event_leader;
+    obj->is_port_leader = is_port_leader;
+    obj->engine = engine;
+    obj->port = port;
+    obj->req_blocking_mode = QUIC_BLOCKING_MODE_INHERIT;
     if (!obj_update_cache(obj))
         goto err;
 
-    obj->init_done          = 1;
+    obj->init_done = 1;
     return 1;
 
 err:
     obj->is_event_leader = 0;
-    obj->is_port_leader  = 0;
+    obj->is_port_leader = 0;
     return 0;
 }
 
@@ -58,7 +58,7 @@ static int obj_update_cache(QUIC_OBJ *obj)
     QUIC_OBJ *p;
 
     for (p = obj; p != NULL && !p->is_event_leader;
-         p = p->parent_obj)
+        p = p->parent_obj)
         if (!ossl_assert(p == obj || p->init_done))
             return 0;
 
@@ -69,14 +69,15 @@ static int obj_update_cache(QUIC_OBJ *obj)
      * Offset of ->ssl is guaranteed to be 0 but the NULL check makes ubsan
      * happy.
      */
-    obj->cached_event_leader    = p;
-    obj->engine                 = p->engine;
+    obj->cached_event_leader = p;
+    obj->engine = p->engine;
 
     for (p = obj; p != NULL && !p->is_port_leader;
-         p = p->parent_obj);
+        p = p->parent_obj)
+        ;
 
-    obj->cached_port_leader     = p;
-    obj->port                   = (p != NULL) ? p->port : NULL;
+    obj->cached_port_leader = p;
+    obj->port = (p != NULL) ? p->port : NULL;
     return 1;
 }
 
@@ -99,7 +100,8 @@ int ossl_quic_obj_can_support_blocking(const QUIC_OBJ *obj)
     rtor = ossl_quic_obj_get0_reactor(obj);
 
     if ((obj->domain_flags
-            & (SSL_DOMAIN_FLAG_LEGACY_BLOCKING | SSL_DOMAIN_FLAG_BLOCKING)) == 0)
+            & (SSL_DOMAIN_FLAG_LEGACY_BLOCKING | SSL_DOMAIN_FLAG_BLOCKING))
+        == 0)
         return 0;
 
     return ossl_quic_reactor_can_poll_r(rtor)
@@ -112,7 +114,9 @@ int ossl_quic_obj_desires_blocking(const QUIC_OBJ *obj)
 
     assert(obj != NULL);
     for (; (req_blocking_mode = obj->req_blocking_mode) == QUIC_BLOCKING_MODE_INHERIT
-           && obj->parent_obj != NULL; obj = obj->parent_obj);
+        && obj->parent_obj != NULL;
+        obj = obj->parent_obj)
+        ;
 
     return req_blocking_mode != QUIC_BLOCKING_MODE_NONBLOCKING;
 }
@@ -125,7 +129,7 @@ int ossl_quic_obj_blocking(const QUIC_OBJ *obj)
         return 0;
 
     ossl_quic_engine_update_poll_descriptors(ossl_quic_obj_get0_engine(obj),
-                                             /*force=*/0);
+        /*force=*/0);
     return ossl_quic_obj_can_support_blocking(obj);
 }
 
diff --git a/crypto/openssl/ssl/quic/quic_obj_local.h b/crypto/openssl/ssl/quic/quic_obj_local.h
index 9f8729d32590..d454ade330bb 100644
--- a/crypto/openssl/ssl/quic/quic_obj_local.h
+++ b/crypto/openssl/ssl/quic/quic_obj_local.h
@@ -8,14 +8,14 @@
  */
 
 #ifndef OSSL_QUIC_OBJ_LOCAL_H
-# define OSSL_QUIC_OBJ_LOCAL_H
+#define OSSL_QUIC_OBJ_LOCAL_H
 
-# include <openssl/ssl.h>
-# include "internal/quic_predef.h"
-# include "internal/quic_engine.h"
-# include "../ssl_local.h"
+#include <openssl/ssl.h>
+#include "internal/quic_predef.h"
+#include "internal/quic_engine.h"
+#include "../ssl_local.h"
 
-# ifndef OPENSSL_NO_QUIC
+#ifndef OPENSSL_NO_QUIC
 
 /*
  * QUIC Object Structure.
@@ -69,18 +69,18 @@
  */
 struct quic_obj_st {
     /* SSL object common header. */
-    struct ssl_st           ssl;
+    struct ssl_st ssl;
 
     /*
      * Pointer to a parent APL object in a QUIC APL object hierarchy, or NULL if
      * this is the root object.
      */
-    QUIC_OBJ                *parent_obj;
+    QUIC_OBJ *parent_obj;
 
     /* invariant: != NULL */
-    QUIC_OBJ                *cached_event_leader;
+    QUIC_OBJ *cached_event_leader;
     /* invariant: != NULL iff this is a port leader or subsidiary object */
-    QUIC_OBJ                *cached_port_leader;
+    QUIC_OBJ *cached_port_leader;
 
     /*
      * Points to the QUIC_ENGINE instance. Always equals
@@ -89,7 +89,7 @@ struct quic_obj_st {
      * reference cached for convenience. Unlike port this is never NULL because
      * a QUIC domain is always rooted in an event leader.
      */
-    QUIC_ENGINE             *engine;
+    QUIC_ENGINE *engine;
 
     /*
      * Points to the QUIC_PORT instance applicable to the containing_obj APL
@@ -98,23 +98,23 @@ struct quic_obj_st {
      * instance iff is_port_leader is set, otherwise it is an additional
      * reference cached for convenience.
      */
-    QUIC_PORT               *port;
+    QUIC_PORT *port;
 
     /* SSL_DOMAIN_FLAG values taken from SSL_CTX at construction time. */
-    uint64_t                domain_flags;
+    uint64_t domain_flags;
 
-    unsigned int            init_done       : 1;
-    unsigned int            is_event_leader : 1;
-    unsigned int            is_port_leader  : 1;
+    unsigned int init_done : 1;
+    unsigned int is_event_leader : 1;
+    unsigned int is_port_leader : 1;
 
     /*
      * Blocking mode configuration is handled generically through QUIC_OBJ as it
      * by default inherits from the parent SSL object.
      */
-    unsigned int            req_blocking_mode       : 2; /* QUIC_BLOCKING_MODE */
+    unsigned int req_blocking_mode : 2; /* QUIC_BLOCKING_MODE */
 
     /* Event handling mode. One of SSL_QUIC_VALUE_EVENT_HANDLING. */
-    unsigned int            event_handling_mode     : 2;
+    unsigned int event_handling_mode : 2;
 };
 
 enum {
@@ -149,11 +149,11 @@ enum {
  * ancestors to find the Port Leader.
  */
 int ossl_quic_obj_init(QUIC_OBJ *obj,
-                       SSL_CTX *ctx,
-                       int type,
-                       SSL *parent_obj,
-                       QUIC_ENGINE *engine,
-                       QUIC_PORT *port);
+    SSL_CTX *ctx,
+    int type,
+    SSL *parent_obj,
+    QUIC_ENGINE *engine,
+    QUIC_PORT *port);
 
 /*
  * Returns a pointer to the handshake layer object which should be accessible on
@@ -216,7 +216,8 @@ static ossl_inline ossl_unused QUIC_ENGINE *
 ossl_quic_obj_get0_engine_local(const QUIC_OBJ *obj)
 {
     return ossl_quic_obj_is_event_leader(obj)
-        ? ossl_quic_obj_get0_engine(obj) : NULL;
+        ? ossl_quic_obj_get0_engine(obj)
+        : NULL;
 }
 
 /* Returns 1 iff this leader structure represents a port leader. */
@@ -234,7 +235,8 @@ static ossl_inline ossl_unused QUIC_PORT *
 ossl_quic_obj_get0_port_local(const QUIC_OBJ *obj)
 {
     return ossl_quic_obj_is_port_leader(obj)
-        ? ossl_quic_obj_get0_port(obj) : NULL;
+        ? ossl_quic_obj_get0_port(obj)
+        : NULL;
 }
 
 /*
@@ -337,5 +339,5 @@ ossl_quic_obj_set_domain_flags(QUIC_OBJ *obj, uint64_t domain_flags)
     obj->domain_flags = domain_flags;
 }
 
-# endif
+#endif
 #endif
diff --git a/crypto/openssl/ssl/quic/quic_port.c b/crypto/openssl/ssl/quic/quic_port.c
index d6e6d4d25cb5..1e247e1ec624 100644
--- a/crypto/openssl/ssl/quic/quic_port.c
+++ b/crypto/openssl/ssl/quic/quic_port.c
@@ -24,13 +24,13 @@
  * QUIC Port Structure
  * ===================
  */
-#define INIT_DCID_LEN                   8
+#define INIT_DCID_LEN 8
 
 static int port_init(QUIC_PORT *port);
 static void port_cleanup(QUIC_PORT *port);
 static OSSL_TIME get_time(void *arg);
 static void port_default_packet_handler(QUIC_URXE *e, void *arg,
-                                        const QUIC_CONN_ID *dcid);
+    const QUIC_CONN_ID *dcid);
 static void port_rx_pre(QUIC_PORT *port);
 
 /**
@@ -104,8 +104,8 @@ QUIC_PORT *ossl_quic_port_new(const QUIC_PORT_ARGS *args)
     if ((port = OPENSSL_zalloc(sizeof(QUIC_PORT))) == NULL)
         return NULL;
 
-    port->engine        = args->engine;
-    port->channel_ctx   = args->channel_ctx;
+    port->engine = args->engine;
+    port->channel_ctx = args->channel_ctx;
     port->is_multi_conn = args->is_multi_conn;
     port->validate_addr = args->do_addr_validation;
     port->get_conn_user_ssl = args->get_conn_user_ssl;
@@ -143,34 +143,38 @@ static int port_init(QUIC_PORT *port)
         goto err;
 
     if ((port->demux = ossl_quic_demux_new(/*BIO=*/NULL,
-                                           /*Short CID Len=*/rx_short_dcid_len,
-                                           get_time, port)) == NULL)
+             /*Short CID Len=*/rx_short_dcid_len,
+             get_time, port))
+        == NULL)
         goto err;
 
     ossl_quic_demux_set_default_handler(port->demux,
-                                        port_default_packet_handler,
-                                        port);
+        port_default_packet_handler,
+        port);
 
     if ((port->srtm = ossl_quic_srtm_new(port->engine->libctx,
-                                         port->engine->propq)) == NULL)
+             port->engine->propq))
+        == NULL)
         goto err;
 
     if ((port->lcidm = ossl_quic_lcidm_new(port->engine->libctx,
-                                           rx_short_dcid_len)) == NULL)
+             rx_short_dcid_len))
+        == NULL)
         goto err;
 
     port->rx_short_dcid_len = (unsigned char)rx_short_dcid_len;
-    port->tx_init_dcid_len  = INIT_DCID_LEN;
-    port->state             = QUIC_PORT_STATE_RUNNING;
+    port->tx_init_dcid_len = INIT_DCID_LEN;
+    port->state = QUIC_PORT_STATE_RUNNING;
 
     ossl_list_port_insert_tail(&port->engine->port_list, port);
-    port->on_engine_list    = 1;
-    port->bio_changed       = 1;
+    port->on_engine_list = 1;
+    port->bio_changed = 1;
 
     /* Generate random key for token encryption */
     if ((port->token_ctx = EVP_CIPHER_CTX_new()) == NULL
         || (cipher = EVP_CIPHER_fetch(port->engine->libctx,
-                                      "AES-256-GCM", NULL)) == NULL
+                "AES-256-GCM", NULL))
+            == NULL
         || !EVP_EncryptInit_ex(port->token_ctx, cipher, NULL, NULL, NULL)
         || (key_len = EVP_CIPHER_CTX_get_key_length(port->token_ctx)) <= 0
         || (token_key = OPENSSL_malloc(key_len)) == NULL
@@ -298,7 +302,7 @@ BIO *ossl_quic_port_get_net_wbio(QUIC_PORT *port)
 
 static int port_update_poll_desc(QUIC_PORT *port, BIO *net_bio, int for_write)
 {
-    BIO_POLL_DESCRIPTOR d = {0};
+    BIO_POLL_DESCRIPTOR d = { 0 };
 
     if (net_bio == NULL
         || (!for_write && !BIO_get_rpoll_descriptor(net_bio, &d))
@@ -433,7 +437,7 @@ int ossl_quic_port_set_net_wbio(QUIC_PORT *port, BIO *net_wbio)
         return 0;
 
     OSSL_LIST_FOREACH(ch, ch, &port->channel_list)
-        ossl_qtx_set_bio(ch->qtx, net_wbio);
+    ossl_qtx_set_bio(ch->qtx, net_wbio);
 
     port->net_wbio = net_wbio;
     port_update_addressing_mode(port);
@@ -488,38 +492,38 @@ static SSL *port_new_handshake_layer(QUIC_PORT *port, QUIC_CHANNEL *ch)
 
     if (ql != NULL && ql->obj.ssl.ctx->new_pending_conn_cb != NULL)
         if (!ql->obj.ssl.ctx->new_pending_conn_cb(ql->obj.ssl.ctx, user_ssl,
-                                                  ql->obj.ssl.ctx->new_pending_conn_arg)) {
+                ql->obj.ssl.ctx->new_pending_conn_arg)) {
             SSL_free(user_ssl);
             return NULL;
         }
 
     /* Override the user_ssl of the inner connection. */
-    tls_conn->s3.flags      |= TLS1_FLAGS_QUIC | TLS1_FLAGS_QUIC_INTERNAL;
+    tls_conn->s3.flags |= TLS1_FLAGS_QUIC | TLS1_FLAGS_QUIC_INTERNAL;
 
     /* Restrict options derived from the SSL_CTX. */
-    tls_conn->options       &= OSSL_QUIC_PERMITTED_OPTIONS_CONN;
-    tls_conn->pha_enabled   = 0;
+    tls_conn->options &= OSSL_QUIC_PERMITTED_OPTIONS_CONN;
+    tls_conn->pha_enabled = 0;
     return tls;
 }
 
 static QUIC_CHANNEL *port_make_channel(QUIC_PORT *port, SSL *tls, OSSL_QRX *qrx,
-                                       int is_server, int is_tserver)
+    int is_server, int is_tserver)
 {
-    QUIC_CHANNEL_ARGS args = {0};
+    QUIC_CHANNEL_ARGS args = { 0 };
     QUIC_CHANNEL *ch;
 
-    args.port          = port;
-    args.is_server     = is_server;
-    args.lcidm         = port->lcidm;
-    args.srtm          = port->srtm;
-    args.qrx           = qrx;
+    args.port = port;
+    args.is_server = is_server;
+    args.lcidm = port->lcidm;
+    args.srtm = port->srtm;
+    args.qrx = qrx;
     args.is_tserver_ch = is_tserver;
 
     /*
      * Creating a a new channel is made a bit tricky here as there is a
-     * bit of a circular dependency.  Initalizing a channel requires that
+     * bit of a circular dependency.  Initializing a channel requires that
      * the ch->tls and optionally the qlog_title be configured prior to
-     * initalization, but we need the channel at least partially configured
+     * initialization, but we need the channel at least partially configured
      * to create the new handshake layer, so we have to do this in a few steps.
      */
 
@@ -568,7 +572,7 @@ static QUIC_CHANNEL *port_make_channel(QUIC_PORT *port, SSL *tls, OSSL_QRX *qrx,
 QUIC_CHANNEL *ossl_quic_port_create_outgoing(QUIC_PORT *port, SSL *tls)
 {
     return port_make_channel(port, tls, NULL, /* is_server= */ 0,
-                             /* is_tserver= */ 0);
+        /* is_tserver= */ 0);
 }
 
 QUIC_CHANNEL *ossl_quic_port_create_incoming(QUIC_PORT *port, SSL *tls)
@@ -582,7 +586,7 @@ QUIC_CHANNEL *ossl_quic_port_create_incoming(QUIC_PORT *port, SSL *tls)
      * later in port_default_packet_handler() when calling port_bind_channel().
      */
     ch = port_make_channel(port, tls, NULL, /* is_server= */ 1,
-                           /* is_tserver_ch */ 1);
+        /* is_tserver_ch */ 1);
     port->tserver_ch = ch;
     port->allow_incoming = 1;
     return ch;
@@ -655,14 +659,14 @@ void ossl_quic_port_set_allow_incoming(QUIC_PORT *port, int allow_incoming)
  * this port's network BIOs, and services child channels.
  */
 void ossl_quic_port_subtick(QUIC_PORT *port, QUIC_TICK_RESULT *res,
-                            uint32_t flags)
+    uint32_t flags)
 {
     QUIC_CHANNEL *ch;
 
-    res->net_read_desired       = ossl_quic_port_is_running(port);
-    res->net_write_desired      = 0;
-    res->notify_other_threads   = 0;
-    res->tick_deadline          = ossl_time_infinite();
+    res->net_read_desired = ossl_quic_port_is_running(port);
+    res->net_write_desired = 0;
+    res->notify_other_threads = 0;
+    res->tick_deadline = ossl_time_infinite();
 
     if (!port->engine->inhibit_tick) {
         /* Handle any incoming data from network. */
@@ -670,8 +674,9 @@ void ossl_quic_port_subtick(QUIC_PORT *port, QUIC_TICK_RESULT *res,
             port_rx_pre(port);
 
         /* Iterate through all channels and service them. */
-        OSSL_LIST_FOREACH(ch, ch, &port->channel_list) {
-            QUIC_TICK_RESULT subr = {0};
+        OSSL_LIST_FOREACH(ch, ch, &port->channel_list)
+        {
+            QUIC_TICK_RESULT subr = { 0 };
 
             ossl_quic_channel_subtick(ch, &subr, flags);
             ossl_quic_tick_result_merge_into(res, &subr);
@@ -724,9 +729,9 @@ static void port_rx_pre(QUIC_PORT *port)
  * to *new_ch.
  */
 static void port_bind_channel(QUIC_PORT *port, const BIO_ADDR *peer,
-                              const QUIC_CONN_ID *scid, const QUIC_CONN_ID *dcid,
-                              const QUIC_CONN_ID *odcid, OSSL_QRX *qrx,
-                              QUIC_CHANNEL **new_ch)
+    const QUIC_CONN_ID *scid, const QUIC_CONN_ID *dcid,
+    const QUIC_CONN_ID *odcid, OSSL_QRX *qrx,
+    QUIC_CHANNEL **new_ch)
 {
     QUIC_CHANNEL *ch;
 
@@ -739,11 +744,11 @@ static void port_bind_channel(QUIC_PORT *port, const BIO_ADDR *peer,
         port->tserver_ch = NULL;
         ossl_quic_channel_bind_qrx(ch, qrx);
         ossl_qrx_set_msg_callback(ch->qrx, ch->msg_callback,
-                                  ch->msg_callback_ssl);
+            ch->msg_callback_ssl);
         ossl_qrx_set_msg_callback_arg(ch->qrx, ch->msg_callback_arg);
     } else {
         ch = port_make_channel(port, NULL, qrx, /* is_server= */ 1,
-                               /* is_tserver */ 0);
+            /* is_tserver */ 0);
     }
 
     if (ch == NULL)
@@ -759,9 +764,9 @@ static void port_bind_channel(QUIC_PORT *port, const BIO_ADDR *peer,
      */
     if (qrx == NULL)
         if (!ossl_quic_provide_initial_secret(ch->port->engine->libctx,
-                                              ch->port->engine->propq,
-                                              dcid, /* is_server */ 1,
-                                              ch->qrx, NULL))
+                ch->port->engine->propq,
+                dcid, /* is_server */ 1,
+                ch->qrx, NULL))
             return;
 
     if (odcid->id_len != 0) {
@@ -824,9 +829,9 @@ static int port_try_handle_stateless_reset(QUIC_PORT *port, const QUIC_URXE *e)
 
     for (i = 0;; ++i) {
         if (!ossl_quic_srtm_lookup(port->srtm,
-                                   (QUIC_STATELESS_RESET_TOKEN *)(data + e->data_len
-                                   - sizeof(QUIC_STATELESS_RESET_TOKEN)),
-                                   i, &opaque, NULL))
+                (QUIC_STATELESS_RESET_TOKEN *)(data + e->data_len
+                    - sizeof(QUIC_STATELESS_RESET_TOKEN)),
+                i, &opaque, NULL))
             break;
 
         assert(opaque != NULL);
@@ -853,8 +858,8 @@ static void cleanup_validation_token(QUIC_VALIDATION_TOKEN *token)
  * @return 1 if validation token is filled successfully, 0 otherwise.
  */
 static int generate_token(BIO_ADDR *peer, QUIC_CONN_ID odcid,
-                          QUIC_CONN_ID rscid, QUIC_VALIDATION_TOKEN *token,
-                          int is_retry)
+    QUIC_CONN_ID rscid, QUIC_VALIDATION_TOKEN *token,
+    int is_retry)
 {
     token->is_retry = is_retry;
     token->timestamp = ossl_time_now();
@@ -866,7 +871,7 @@ static int generate_token(BIO_ADDR *peer, QUIC_CONN_ID odcid,
         || token->remote_addr_len == 0
         || (token->remote_addr = OPENSSL_malloc(token->remote_addr_len)) == NULL
         || !BIO_ADDR_rawaddress(peer, token->remote_addr,
-                                &token->remote_addr_len)) {
+            &token->remote_addr_len)) {
         cleanup_validation_token(token);
         return 0;
     }
@@ -885,9 +890,9 @@ static int generate_token(BIO_ADDR *peer, QUIC_CONN_ID odcid,
  * @param buffer_len Size of data stored in |buffer|.
  */
 static int marshal_validation_token(QUIC_VALIDATION_TOKEN *token,
-                                    unsigned char *buffer, size_t *buffer_len)
+    unsigned char *buffer, size_t *buffer_len)
 {
-    WPACKET wpkt = {0};
+    WPACKET wpkt = { 0 };
     BUF_MEM *buf_mem = BUF_MEM_new();
 
     if (buffer == NULL || buf_mem == NULL
@@ -899,12 +904,12 @@ static int marshal_validation_token(QUIC_VALIDATION_TOKEN *token,
     if (!WPACKET_init(&wpkt, buf_mem)
         || !WPACKET_memset(&wpkt, token->is_retry, 1)
         || !WPACKET_memcpy(&wpkt, &token->timestamp,
-                           sizeof(token->timestamp))
+            sizeof(token->timestamp))
         || (token->is_retry
             && (!WPACKET_sub_memcpy_u8(&wpkt, &token->odcid.id,
-                                       token->odcid.id_len)
+                    token->odcid.id_len)
                 || !WPACKET_sub_memcpy_u8(&wpkt, &token->rscid.id,
-                                          token->rscid.id_len)))
+                    token->rscid.id_len)))
         || !WPACKET_sub_memcpy_u8(&wpkt, token->remote_addr, token->remote_addr_len)
         || !WPACKET_get_total_written(&wpkt, buffer_len)
         || *buffer_len > MARSHALLED_TOKEN_MAX_LEN
@@ -937,10 +942,10 @@ static int marshal_validation_token(QUIC_VALIDATION_TOKEN *token,
  * [EVP_GCM_IV_LEN bytes IV][encrypted data][EVP_GCM_TAG_LEN bytes tag]
  */
 static int encrypt_validation_token(const QUIC_PORT *port,
-                                    const unsigned char *plaintext,
-                                    size_t pt_len,
-                                    unsigned char *ciphertext,
-                                    size_t *ct_len)
+    const unsigned char *plaintext,
+    size_t pt_len,
+    unsigned char *ciphertext,
+    size_t *ct_len)
 {
     int iv_len, len, ret = 0;
     size_t tag_len;
@@ -987,10 +992,10 @@ err:
  * [EVP_GCM_IV_LEN bytes IV][encrypted data][EVP_GCM_TAG_LEN bytes tag]
  */
 static int decrypt_validation_token(const QUIC_PORT *port,
-                                    const unsigned char *ciphertext,
-                                    size_t ct_len,
-                                    unsigned char *plaintext,
-                                    size_t *pt_len)
+    const unsigned char *ciphertext,
+    size_t ct_len,
+    unsigned char *plaintext,
+    size_t *pt_len)
 {
     int iv_len, len = 0, ret = 0;
     size_t tag_len;
@@ -1015,9 +1020,9 @@ static int decrypt_validation_token(const QUIC_PORT *port,
 
     if (!EVP_DecryptInit_ex(port->token_ctx, NULL, NULL, NULL, iv)
         || !EVP_DecryptUpdate(port->token_ctx, plaintext, &len, data,
-                              ct_len - iv_len - tag_len)
+            ct_len - iv_len - tag_len)
         || !EVP_CIPHER_CTX_ctrl(port->token_ctx, EVP_CTRL_GCM_SET_TAG, tag_len,
-                                (void *)tag)
+            (void *)tag)
         || !EVP_DecryptFinal_ex(port->token_ctx, plaintext + len, &len))
         goto err;
 
@@ -1030,14 +1035,14 @@ err:
 /**
  * @brief Parses contents of a buffer into a validation token.
  *
- * VALIDATION_TOKEN should already be initalized. Does some basic sanity checks.
+ * VALIDATION_TOKEN should already be initialized. Does some basic sanity checks.
  *
  * @param token   Validation token to fill data in.
  * @param buf     Buffer of previously marshaled validation token.
  * @param buf_len Length of |buf|.
  */
 static int parse_validation_token(QUIC_VALIDATION_TOKEN *token,
-                                  const unsigned char *buf, size_t buf_len)
+    const unsigned char *buf, size_t buf_len)
 {
     PACKET pkt, subpkt;
 
@@ -1050,19 +1055,19 @@ static int parse_validation_token(QUIC_VALIDATION_TOKEN *token,
         || !PACKET_copy_bytes(&pkt, &token->is_retry, sizeof(token->is_retry))
         || !(token->is_retry == 0 || token->is_retry == 1)
         || !PACKET_copy_bytes(&pkt, (unsigned char *)&token->timestamp,
-                              sizeof(token->timestamp))
+            sizeof(token->timestamp))
         || (token->is_retry
             && (!PACKET_get_length_prefixed_1(&pkt, &subpkt)
                 || (token->odcid.id_len = (unsigned char)PACKET_remaining(&subpkt))
                     > QUIC_MAX_CONN_ID_LEN
                 || !PACKET_copy_bytes(&subpkt,
-                                      (unsigned char *)&token->odcid.id,
-                                      token->odcid.id_len)
+                    (unsigned char *)&token->odcid.id,
+                    token->odcid.id_len)
                 || !PACKET_get_length_prefixed_1(&pkt, &subpkt)
                 || (token->rscid.id_len = (unsigned char)PACKET_remaining(&subpkt))
                     > QUIC_MAX_CONN_ID_LEN
                 || !PACKET_copy_bytes(&subpkt, (unsigned char *)&token->rscid.id,
-                                      token->rscid.id_len)))
+                    token->rscid.id_len)))
         || !PACKET_get_length_prefixed_1(&pkt, &subpkt)
         || (token->remote_addr_len = PACKET_remaining(&subpkt)) == 0
         || (token->remote_addr = OPENSSL_malloc(token->remote_addr_len)) == NULL
@@ -1098,8 +1103,8 @@ static int parse_validation_token(QUIC_VALIDATION_TOKEN *token,
  * network transmiss
  */
 static void port_send_retry(QUIC_PORT *port,
-                            BIO_ADDR *peer,
-                            QUIC_PKT_HDR *client_hdr)
+    BIO_ADDR *peer,
+    QUIC_PKT_HDR *client_hdr)
 {
     BIO_MSG msg[1];
     /*
@@ -1111,8 +1116,8 @@ static void port_send_retry(QUIC_PORT *port,
     unsigned char ct_buf[ENCRYPTED_TOKEN_MAX_LEN];
     WPACKET wpkt;
     size_t written, token_buf_len, ct_len;
-    QUIC_PKT_HDR hdr = {0};
-    QUIC_VALIDATION_TOKEN token = {0};
+    QUIC_PKT_HDR hdr = { 0 };
+    QUIC_VALIDATION_TOKEN token = { 0 };
     int ok;
 
     if (!ossl_assert(sizeof(buffer) >= MARSHALLED_TOKEN_MAX_LEN))
@@ -1137,13 +1142,13 @@ static void port_send_retry(QUIC_PORT *port,
 
     /* Generate retry validation token */
     if (!generate_token(peer, client_hdr->dst_conn_id,
-                        hdr.src_conn_id, &token, 1)
+            hdr.src_conn_id, &token, 1)
         || !marshal_validation_token(&token, buffer, &token_buf_len)
         || !encrypt_validation_token(port, buffer, token_buf_len, NULL,
-                                     &ct_len)
+            &ct_len)
         || ct_len > ENCRYPTED_TOKEN_MAX_LEN
         || !encrypt_validation_token(port, buffer, token_buf_len, ct_buf,
-                                     &ct_len)
+            &ct_len)
         || !ossl_assert(ct_len >= QUIC_RETRY_INTEGRITY_TAG_LEN))
         goto err;
 
@@ -1154,10 +1159,10 @@ static void port_send_retry(QUIC_PORT *port,
     hdr.len = ct_len;
     hdr.data = ct_buf;
     ok = ossl_quic_calculate_retry_integrity_tag(port->engine->libctx,
-                                                 port->engine->propq, &hdr,
-                                                 &client_hdr->dst_conn_id,
-                                                 ct_buf + ct_len
-                                                 - QUIC_RETRY_INTEGRITY_TAG_LEN);
+        port->engine->propq, &hdr,
+        &client_hdr->dst_conn_id,
+        ct_buf + ct_len
+            - QUIC_RETRY_INTEGRITY_TAG_LEN);
     if (ok == 0)
         goto err;
 
@@ -1174,7 +1179,7 @@ static void port_send_retry(QUIC_PORT *port,
         goto err;
 
     ok = ossl_quic_wire_encode_pkt_hdr(&wpkt, client_hdr->dst_conn_id.id_len,
-                                       &hdr, NULL);
+        &hdr, NULL);
     if (ok == 0)
         goto err;
 
@@ -1192,7 +1197,7 @@ static void port_send_retry(QUIC_PORT *port,
      */
     if (!BIO_sendmmsg(port->net_wbio, msg, sizeof(BIO_MSG), 1, 0, &written))
         ERR_raise_data(ERR_LIB_SSL, SSL_R_QUIC_NETWORK_ERROR,
-                       "port retry send failed due to network BIO I/O error");
+            "port retry send failed due to network BIO I/O error");
 
 err:
     cleanup_validation_token(&token);
@@ -1216,7 +1221,7 @@ err:
  * @note The function will raise an error if sending the message fails.
  */
 static void port_send_version_negotiation(QUIC_PORT *port, BIO_ADDR *peer,
-                                          QUIC_PKT_HDR *client_hdr)
+    QUIC_PKT_HDR *client_hdr)
 {
     BIO_MSG msg[1];
     unsigned char buffer[1024];
@@ -1260,7 +1265,7 @@ static void port_send_version_negotiation(QUIC_PORT *port, BIO_ADDR *peer,
         return;
 
     if (!ossl_quic_wire_encode_pkt_hdr(&wpkt, client_hdr->dst_conn_id.id_len,
-                                       &hdr, NULL))
+            &hdr, NULL))
         return;
 
     /*
@@ -1284,11 +1289,11 @@ static void port_send_version_negotiation(QUIC_PORT *port, BIO_ADDR *peer,
      */
     if (!BIO_sendmmsg(port->net_wbio, msg, sizeof(BIO_MSG), 1, 0, &written))
         ERR_raise_data(ERR_LIB_SSL, SSL_R_QUIC_NETWORK_ERROR,
-                       "port version negotiation send failed");
+            "port version negotiation send failed");
 }
 
 /**
- * @brief defintions of token lifetimes
+ * @brief definitions of token lifetimes
  *
  * RETRY tokens are only valid for 10 seconds
  * NEW_TOKEN tokens have a lifetime of 3600 sec (1 hour)
@@ -1327,8 +1332,8 @@ static void port_send_version_negotiation(QUIC_PORT *port, BIO_ADDR *peer,
  *   configurable in the future.
  */
 static int port_validate_token(QUIC_PKT_HDR *hdr, QUIC_PORT *port,
-                               BIO_ADDR *peer, QUIC_CONN_ID *odcid,
-                               QUIC_CONN_ID *scid, uint8_t *gen_new_token)
+    BIO_ADDR *peer, QUIC_CONN_ID *odcid,
+    QUIC_CONN_ID *scid, uint8_t *gen_new_token)
 {
     int ret = 0;
     QUIC_VALIDATION_TOKEN token = { 0 };
@@ -1340,10 +1345,10 @@ static int port_validate_token(QUIC_PKT_HDR *hdr, QUIC_PORT *port,
     *gen_new_token = 0;
 
     if (!decrypt_validation_token(port, hdr->token, hdr->token_len, NULL,
-                                  &dec_token_len)
+            &dec_token_len)
         || dec_token_len > MARSHALLED_TOKEN_MAX_LEN
         || !decrypt_validation_token(port, hdr->token, hdr->token_len,
-                                     dec_token, &dec_token_len)
+            dec_token, &dec_token_len)
         || !parse_validation_token(&token, dec_token, dec_token_len))
         goto err;
 
@@ -1354,7 +1359,7 @@ static int port_validate_token(QUIC_PKT_HDR *hdr, QUIC_PORT *port,
     if (ossl_time_compare(now, token.timestamp) < 0)
         goto err;
     time_diff = ossl_time2seconds(ossl_time_abs_difference(token.timestamp,
-                                                           now));
+        now));
     if ((token.is_retry && time_diff > RETRY_LIFETIME)
         || (!token.is_retry && time_diff > NEW_TOKEN_LIFETIME))
         goto err;
@@ -1384,7 +1389,8 @@ static int port_validate_token(QUIC_PKT_HDR *hdr, QUIC_PORT *port,
          */
         if (token.rscid.id_len != hdr->dst_conn_id.id_len
             || memcmp(&token.rscid.id, &hdr->dst_conn_id.id,
-                      token.rscid.id_len) != 0)
+                   token.rscid.id_len)
+                != 0)
             goto err;
         *odcid = token.odcid;
         *scid = token.rscid;
@@ -1453,10 +1459,10 @@ static void generate_new_token(QUIC_CHANNEL *ch, BIO_ADDR *peer)
     if (!generate_token(peer, ch->init_dcid, rscid, &token, 0)
         || !marshal_validation_token(&token, buffer, &token_buf_len)
         || !encrypt_validation_token(ch->port, buffer, token_buf_len, NULL,
-                                     &ct_len)
+            &ct_len)
         || ct_len > ENCRYPTED_TOKEN_MAX_LEN
         || !encrypt_validation_token(ch->port, buffer, token_buf_len, ct_buf,
-                                     &ct_len)
+            &ct_len)
         || !ossl_assert(ct_len >= QUIC_RETRY_INTEGRITY_TAG_LEN)) {
         OPENSSL_free(ct_buf);
         cleanup_validation_token(&token);
@@ -1474,7 +1480,7 @@ static void generate_new_token(QUIC_CHANNEL *ch, BIO_ADDR *peer)
  * DCID.
  */
 static void port_default_packet_handler(QUIC_URXE *e, void *arg,
-                                        const QUIC_CONN_ID *dcid)
+    const QUIC_CONN_ID *dcid)
 {
     QUIC_PORT *port = arg;
     PACKET pkt;
@@ -1484,7 +1490,7 @@ static void port_default_packet_handler(QUIC_URXE *e, void *arg,
     uint8_t gen_new_token = 0;
     OSSL_QRX *qrx = NULL;
     OSSL_QRX *qrx_src = NULL;
-    OSSL_QRX_ARGS qrx_args = {0};
+    OSSL_QRX_ARGS qrx_args = { 0 };
     uint64_t cause_flags = 0;
     OSSL_QRX_PKT *qrx_pkt = NULL;
 
@@ -1497,7 +1503,7 @@ static void port_default_packet_handler(QUIC_URXE *e, void *arg,
 
     if (dcid != NULL
         && ossl_quic_lcidm_lookup(port->lcidm, dcid, NULL,
-                                  (void **)&ch)) {
+            (void **)&ch)) {
         assert(ch != NULL);
         ossl_quic_channel_inject(ch, e);
         return;
@@ -1526,7 +1532,7 @@ static void port_default_packet_handler(QUIC_URXE *e, void *arg,
      * care about Initial packets.
      */
     if (!ossl_quic_wire_decode_pkt_hdr(&pkt, SIZE_MAX, 1, 0, &hdr, NULL,
-                                       &cause_flags)) {
+            &cause_flags)) {
         /*
          * If we fail due to a bad version, we know the packet up to the version
          * number was decoded, and we use it below to send a version
@@ -1574,10 +1580,10 @@ static void port_default_packet_handler(QUIC_URXE *e, void *arg,
      * Create qrx now so we can check integrity of packet
      * which does not belong to any channel.
      */
-    qrx_args.libctx             = port->engine->libctx;
-    qrx_args.demux              = port->demux;
-    qrx_args.short_conn_id_len  = dcid->id_len;
-    qrx_args.max_deferred       = 32;
+    qrx_args.libctx = port->engine->libctx;
+    qrx_args.demux = port->demux;
+    qrx_args.short_conn_id_len = dcid->id_len;
+    qrx_args.max_deferred = 32;
     qrx = ossl_qrx_new(&qrx_args);
     if (qrx == NULL)
         goto undesirable;
@@ -1586,10 +1592,10 @@ static void port_default_packet_handler(QUIC_URXE *e, void *arg,
      * Derive secrets for qrx only.
      */
     if (!ossl_quic_provide_initial_secret(port->engine->libctx,
-                                          port->engine->propq,
-                                          &hdr.dst_conn_id,
-                                          /* is_server */ 1,
-                                          qrx, NULL))
+            port->engine->propq,
+            &hdr.dst_conn_id,
+            /* is_server */ 1,
+            qrx, NULL))
         goto undesirable;
 
     if (ossl_qrx_validate_initial_packet(qrx, e, (const QUIC_CONN_ID *)dcid) == 0)
@@ -1609,8 +1615,8 @@ static void port_default_packet_handler(QUIC_URXE *e, void *arg,
          * going to create. We use qrx_src alias so we can read packets from
          * qrx and inject them to channel.
          */
-         qrx_src = qrx;
-         qrx = NULL;
+        qrx_src = qrx;
+        qrx = NULL;
     }
     /*
      * TODO(QUIC FUTURE): there should be some logic similar to accounting half-open
@@ -1630,8 +1636,9 @@ static void port_default_packet_handler(QUIC_URXE *e, void *arg,
      */
     if (hdr.token != NULL
         && port_validate_token(&hdr, port, &e->peer,
-                               &odcid, &scid,
-                               &gen_new_token) == 0) {
+               &odcid, &scid,
+               &gen_new_token)
+            == 0) {
         /*
          * RFC 9000 s 8.1.3
          * When a server receives an Initial packet with an address
@@ -1664,7 +1671,7 @@ static void port_default_packet_handler(QUIC_URXE *e, void *arg,
     }
 
     port_bind_channel(port, &e->peer, &scid, &hdr.dst_conn_id,
-                      &odcid, qrx, &new_ch);
+        &odcid, qrx, &new_ch);
 
     /*
      * if packet validates it gets moved to channel, we've just bound
@@ -1714,7 +1721,7 @@ undesirable:
 }
 
 void ossl_quic_port_raise_net_error(QUIC_PORT *port,
-                                    QUIC_CHANNEL *triggering_ch)
+    QUIC_CHANNEL *triggering_ch)
 {
     QUIC_CHANNEL *ch;
 
@@ -1726,7 +1733,7 @@ void ossl_quic_port_raise_net_error(QUIC_PORT *port,
      * cover error.
      */
     ERR_raise_data(ERR_LIB_SSL, SSL_R_QUIC_NETWORK_ERROR,
-                   "port failed due to network BIO I/O error");
+        "port failed due to network BIO I/O error");
     OSSL_ERR_STATE_save(port->err_state);
 
     port_transition_failed(port);
@@ -1736,8 +1743,8 @@ void ossl_quic_port_raise_net_error(QUIC_PORT *port,
         ossl_quic_channel_raise_net_error(triggering_ch);
 
     OSSL_LIST_FOREACH(ch, ch, &port->channel_list)
-        if (ch != triggering_ch)
-            ossl_quic_channel_raise_net_error(ch);
+    if (ch != triggering_ch)
+        ossl_quic_channel_raise_net_error(ch);
 }
 
 void ossl_quic_port_restore_err_state(const QUIC_PORT *port)
diff --git a/crypto/openssl/ssl/quic/quic_port_local.h b/crypto/openssl/ssl/quic/quic_port_local.h
index e36272a94d61..3bad3fc3a3aa 100644
--- a/crypto/openssl/ssl/quic/quic_port_local.h
+++ b/crypto/openssl/ssl/quic/quic_port_local.h
@@ -8,13 +8,13 @@
  */
 
 #ifndef OSSL_QUIC_PORT_LOCAL_H
-# define OSSL_QUIC_PORT_LOCAL_H
+#define OSSL_QUIC_PORT_LOCAL_H
 
-# include "internal/quic_port.h"
-# include "internal/quic_reactor.h"
-# include "internal/list.h"
+#include "internal/quic_port.h"
+#include "internal/quic_reactor.h"
+#include "internal/list.h"
 
-# ifndef OPENSSL_NO_QUIC
+#ifndef OPENSSL_NO_QUIC
 
 /*
  * QUIC Port Structure
@@ -43,7 +43,7 @@ enum {
 
 struct quic_port_st {
     /* The engine which this port is a child of. */
-    QUIC_ENGINE                     *engine;
+    QUIC_ENGINE *engine;
 
     /*
      * QUIC_ENGINE keeps the ports which belong to it on a list for bookkeeping
@@ -51,73 +51,75 @@ struct quic_port_st {
      */
     OSSL_LIST_MEMBER(port, QUIC_PORT);
 
-    SSL * (*get_conn_user_ssl)(QUIC_CHANNEL *ch, void *arg);
+    SSL *(*get_conn_user_ssl)(QUIC_CHANNEL *ch, void *arg);
     void *user_ssl_arg;
 
     /* Used to create handshake layer objects inside newly created channels. */
-    SSL_CTX                         *channel_ctx;
+    SSL_CTX *channel_ctx;
 
     /* Network-side read and write BIOs. */
-    BIO                             *net_rbio, *net_wbio;
+    BIO *net_rbio, *net_wbio;
 
     /* RX demuxer. We register incoming DCIDs with this. */
-    QUIC_DEMUX                      *demux;
+    QUIC_DEMUX *demux;
 
     /* List of all child channels. */
-    OSSL_LIST(ch)                   channel_list;
+    OSSL_LIST(ch)
+    channel_list;
 
     /*
      * Queue of unaccepted incoming channels. Each such channel is also on
      * channel_list.
      */
-    OSSL_LIST(incoming_ch)          incoming_channel_list;
+    OSSL_LIST(incoming_ch)
+    incoming_channel_list;
 
     /* Special TSERVER channel. To be removed in the future. */
-    QUIC_CHANNEL                    *tserver_ch;
+    QUIC_CHANNEL *tserver_ch;
 
     /* LCIDM used for incoming packet routing by DCID. */
-    QUIC_LCIDM                      *lcidm;
+    QUIC_LCIDM *lcidm;
 
     /* SRTM used for incoming packet routing by SRT. */
-    QUIC_SRTM                       *srtm;
+    QUIC_SRTM *srtm;
 
     /* Port-level permanent errors (causing failure state) are stored here. */
-    ERR_STATE                       *err_state;
+    ERR_STATE *err_state;
 
     /* DCID length used for incoming short header packets. */
-    unsigned char                   rx_short_dcid_len;
+    unsigned char rx_short_dcid_len;
     /* For clients, CID length used for outgoing Initial packets. */
-    unsigned char                   tx_init_dcid_len;
+    unsigned char tx_init_dcid_len;
 
     /* Port state (QUIC_PORT_STATE_*). */
-    unsigned int                    state                           : 1;
+    unsigned int state : 1;
 
     /* Is this port created to support multiple connections? */
-    unsigned int                    is_multi_conn                   : 1;
+    unsigned int is_multi_conn : 1;
 
     /* Is this port doing server address validation */
-    unsigned int                    validate_addr                   : 1;
+    unsigned int validate_addr : 1;
 
     /* Has this port sent any packet of any kind yet? */
-    unsigned int                    have_sent_any_pkt               : 1;
+    unsigned int have_sent_any_pkt : 1;
 
     /* Does this port allow incoming connections? */
-    unsigned int                    allow_incoming                  : 1;
+    unsigned int allow_incoming : 1;
 
     /* Are we on the QUIC_ENGINE linked list of ports? */
-    unsigned int                    on_engine_list                  : 1;
+    unsigned int on_engine_list : 1;
 
     /* Are we using addressed mode (BIO_sendmmsg with non-NULL peer)? */
-    unsigned int                    addressed_mode_w                : 1;
-    unsigned int                    addressed_mode_r                : 1;
+    unsigned int addressed_mode_w : 1;
+    unsigned int addressed_mode_r : 1;
 
     /* Has the BIO been changed since we last updated reactor pollability? */
-    unsigned int                    bio_changed                     : 1;
+    unsigned int bio_changed : 1;
 
     /* AES-256 GCM context for token encryption */
     EVP_CIPHER_CTX *token_ctx;
 };
 
-# endif
+#endif
 
 #endif
diff --git a/crypto/openssl/ssl/quic/quic_rcidm.c b/crypto/openssl/ssl/quic/quic_rcidm.c
index 18f7e8096b20..0d5cb0337b29 100644
--- a/crypto/openssl/ssl/quic/quic_rcidm.c
+++ b/crypto/openssl/ssl/quic/quic_rcidm.c
@@ -35,12 +35,12 @@
  */
 static void rcidm_update(QUIC_RCIDM *rcidm);
 static void rcidm_set_preferred_rcid(QUIC_RCIDM *rcidm,
-                                     const QUIC_CONN_ID *rcid);
+    const QUIC_CONN_ID *rcid);
 
-#define PACKETS_PER_RCID        10000
+#define PACKETS_PER_RCID 10000
 
-#define INITIAL_SEQ_NUM         0
-#define PREF_ADDR_SEQ_NUM       1
+#define INITIAL_SEQ_NUM 0
+#define PREF_ADDR_SEQ_NUM 1
 
 /*
  * RCID
@@ -114,9 +114,9 @@ enum {
 };
 
 enum {
-    RCID_TYPE_INITIAL,      /* CID is from an peer INITIAL packet     (seq 0) */
-    RCID_TYPE_PREF_ADDR,    /* CID is from a preferred_address TPARAM (seq 1) */
-    RCID_TYPE_NCID          /* CID is from a NCID frame */
+    RCID_TYPE_INITIAL, /* CID is from an peer INITIAL packet     (seq 0) */
+    RCID_TYPE_PREF_ADDR, /* CID is from a preferred_address TPARAM (seq 1) */
+    RCID_TYPE_NCID /* CID is from a NCID frame */
     /*
      * INITIAL_ODCID and RETRY_ODCID also conceptually exist but are tracked
      * separately.
@@ -126,11 +126,11 @@ enum {
 typedef struct rcid_st {
     OSSL_LIST_MEMBER(retiring, struct rcid_st); /* valid iff RETIRING */
 
-    QUIC_CONN_ID    cid;        /* The actual CID string for this RCID */
-    uint64_t        seq_num;
-    size_t          pq_idx;     /* Index of entry into priority queue */
-    unsigned int    state  : 2; /* RCID_STATE_* */
-    unsigned int    type   : 2; /* RCID_TYPE_* */
+    QUIC_CONN_ID cid; /* The actual CID string for this RCID */
+    uint64_t seq_num;
+    size_t pq_idx; /* Index of entry into priority queue */
+    unsigned int state : 2; /* RCID_STATE_* */
+    unsigned int type : 2; /* RCID_TYPE_* */
 } RCID;
 
 DEFINE_PRIORITY_QUEUE_OF(RCID);
@@ -168,30 +168,30 @@ struct quic_rcidm_st {
      * otherwise it is set to one of the unnumbered RCIDs (the Initial ODCID or
      * Retry ODCID) if available (and cur_rcid == NULL).
      */
-    QUIC_CONN_ID                preferred_rcid;
+    QUIC_CONN_ID preferred_rcid;
 
     /*
      * These are initialized if the corresponding added_ flags are set.
      */
-    QUIC_CONN_ID                initial_odcid, retry_odcid;
+    QUIC_CONN_ID initial_odcid, retry_odcid;
 
     /*
      * Total number of packets sent since we last made a packet count-based RCID
      * update decision.
      */
-    uint64_t                    packets_sent;
+    uint64_t packets_sent;
 
     /* Number of post-handshake RCID changes we have performed. */
-    uint64_t                    num_changes;
+    uint64_t num_changes;
 
     /*
      * The Retire Prior To watermark value; max(retire_prior_to) of all received
      * NCID frames.
      */
-    uint64_t                    retire_prior_to;
+    uint64_t retire_prior_to;
 
     /* (SORT BY seq_num ASC) -> (RCID *) */
-    PRIORITY_QUEUE_OF(RCID)     *rcids;
+    PRIORITY_QUEUE_OF(RCID) * rcids;
 
     /*
      * Current RCID object we are using. This may differ from the first item in
@@ -200,7 +200,7 @@ struct quic_rcidm_st {
      * keep using seq 5 until we decide to roll again rather than immediately
      * switch to seq 4. Never points to an object on the retiring_list.
      */
-    RCID                        *cur_rcid;
+    RCID *cur_rcid;
 
     /*
      * When a RCID becomes pending-retirement, it is moved to the retiring_list,
@@ -210,28 +210,29 @@ struct quic_rcidm_st {
      * maintain the guarantee that the head (if present) only changes when a
      * caller calls pop().
      */
-    OSSL_LIST(retiring)         retiring_list;
+    OSSL_LIST(retiring)
+    retiring_list;
 
     /* Number of entries on the retiring_list. */
-    size_t                      num_retiring;
+    size_t num_retiring;
 
     /* preferred_rcid has been changed? */
-    unsigned int    preferred_rcid_changed          : 1;
+    unsigned int preferred_rcid_changed : 1;
 
     /* Do we have any RCID we can use currently? */
-    unsigned int    have_preferred_rcid             : 1;
+    unsigned int have_preferred_rcid : 1;
 
     /* QUIC handshake has been completed? */
-    unsigned int    handshake_complete              : 1;
+    unsigned int handshake_complete : 1;
 
     /* odcid was set (not necessarily still valid as a RCID)? */
-    unsigned int    added_initial_odcid             : 1;
+    unsigned int added_initial_odcid : 1;
     /* retry_odcid was set (not necessarily still valid as a RCID?) */
-    unsigned int    added_retry_odcid               : 1;
+    unsigned int added_retry_odcid : 1;
     /* An initial RCID was added as an RCID structure? */
-    unsigned int    added_initial_rcid              : 1;
+    unsigned int added_initial_rcid : 1;
     /* Has a RCID roll been manually requested? */
-    unsigned int    roll_requested                  : 1;
+    unsigned int roll_requested : 1;
 };
 
 /*
@@ -240,31 +241,31 @@ struct quic_rcidm_st {
  * Limit the total number of numbered RCIDs to an implausibly large but safe
  * value.
  */
-#define MAX_NUMBERED_RCIDS      (SIZE_MAX / 2)
+#define MAX_NUMBERED_RCIDS (SIZE_MAX / 2)
 
 static void rcidm_transition_rcid(QUIC_RCIDM *rcidm, RCID *rcid,
-                                  unsigned int state);
+    unsigned int state);
 
 /* Check invariants of an RCID */
 static void rcidm_check_rcid(QUIC_RCIDM *rcidm, RCID *rcid)
 {
     assert(rcid->state == RCID_STATE_PENDING
-           || rcid->state == RCID_STATE_CUR
-           || rcid->state == RCID_STATE_RETIRING);
+        || rcid->state == RCID_STATE_CUR
+        || rcid->state == RCID_STATE_RETIRING);
     assert((rcid->state == RCID_STATE_PENDING)
-           == (rcid->pq_idx != SIZE_MAX));
+        == (rcid->pq_idx != SIZE_MAX));
     assert((rcid->state == RCID_STATE_CUR)
-           == (rcidm->cur_rcid == rcid));
+        == (rcidm->cur_rcid == rcid));
     assert((ossl_list_retiring_next(rcid) != NULL
-            || ossl_list_retiring_prev(rcid) != NULL
-            || ossl_list_retiring_head(&rcidm->retiring_list) == rcid)
-           == (rcid->state == RCID_STATE_RETIRING));
+               || ossl_list_retiring_prev(rcid) != NULL
+               || ossl_list_retiring_head(&rcidm->retiring_list) == rcid)
+        == (rcid->state == RCID_STATE_RETIRING));
     assert(rcid->type != RCID_TYPE_INITIAL || rcid->seq_num == 0);
     assert(rcid->type != RCID_TYPE_PREF_ADDR || rcid->seq_num == 1);
     assert(rcid->seq_num <= OSSL_QUIC_VLINT_MAX);
     assert(rcid->cid.id_len > 0 && rcid->cid.id_len <= QUIC_MAX_CONN_ID_LEN);
     assert(rcid->seq_num >= rcidm->retire_prior_to
-            || rcid->state == RCID_STATE_RETIRING);
+        || rcid->state == RCID_STATE_RETIRING);
     assert(rcidm->num_changes == 0 || rcidm->handshake_complete);
     assert(rcid->state != RCID_STATE_RETIRING || rcidm->num_retiring > 0);
 }
@@ -291,8 +292,8 @@ QUIC_RCIDM *ossl_quic_rcidm_new(const QUIC_CONN_ID *initial_odcid)
     }
 
     if (initial_odcid != NULL) {
-        rcidm->initial_odcid        = *initial_odcid;
-        rcidm->added_initial_odcid  = 1;
+        rcidm->initial_odcid = *initial_odcid;
+        rcidm->added_initial_odcid = 1;
     }
 
     rcidm_update(rcidm);
@@ -311,27 +312,27 @@ void ossl_quic_rcidm_free(QUIC_RCIDM *rcidm)
         OPENSSL_free(rcid);
 
     OSSL_LIST_FOREACH_DELSAFE(rcid, rnext, retiring, &rcidm->retiring_list)
-        OPENSSL_free(rcid);
+    OPENSSL_free(rcid);
 
     ossl_pqueue_RCID_free(rcidm->rcids);
     OPENSSL_free(rcidm);
 }
 
 static void rcidm_set_preferred_rcid(QUIC_RCIDM *rcidm,
-                                     const QUIC_CONN_ID *rcid)
+    const QUIC_CONN_ID *rcid)
 {
     if (rcid == NULL) {
-        rcidm->preferred_rcid_changed   = 1;
-        rcidm->have_preferred_rcid      = 0;
+        rcidm->preferred_rcid_changed = 1;
+        rcidm->have_preferred_rcid = 0;
         return;
     }
 
     if (ossl_quic_conn_id_eq(&rcidm->preferred_rcid, rcid))
         return;
 
-    rcidm->preferred_rcid           = *rcid;
-    rcidm->preferred_rcid_changed   = 1;
-    rcidm->have_preferred_rcid      = 1;
+    rcidm->preferred_rcid = *rcid;
+    rcidm->preferred_rcid_changed = 1;
+    rcidm->have_preferred_rcid = 1;
 }
 
 /*
@@ -339,8 +340,8 @@ static void rcidm_set_preferred_rcid(QUIC_RCIDM *rcidm,
  * =========================
  */
 static RCID *rcidm_create_rcid(QUIC_RCIDM *rcidm, uint64_t seq_num,
-                               const QUIC_CONN_ID *cid,
-                               unsigned int type)
+    const QUIC_CONN_ID *cid,
+    unsigned int type)
 {
     RCID *rcid;
 
@@ -353,9 +354,9 @@ static RCID *rcidm_create_rcid(QUIC_RCIDM *rcidm, uint64_t seq_num,
     if ((rcid = OPENSSL_zalloc(sizeof(*rcid))) == NULL)
         return NULL;
 
-    rcid->seq_num           = seq_num;
-    rcid->cid               = *cid;
-    rcid->type              = type;
+    rcid->seq_num = seq_num;
+    rcid->cid = *cid;
+    rcid->type = type;
 
     if (rcid->seq_num >= rcidm->retire_prior_to) {
         rcid->state = RCID_STATE_PENDING;
@@ -366,8 +367,8 @@ static RCID *rcidm_create_rcid(QUIC_RCIDM *rcidm, uint64_t seq_num,
         }
     } else {
         /* RCID is immediately retired upon creation. */
-        rcid->state     = RCID_STATE_RETIRING;
-        rcid->pq_idx    = SIZE_MAX;
+        rcid->state = RCID_STATE_RETIRING;
+        rcid->pq_idx = SIZE_MAX;
         ossl_list_retiring_insert_tail(&rcidm->retiring_list, rcid);
         ++rcidm->num_retiring;
     }
@@ -377,7 +378,7 @@ static RCID *rcidm_create_rcid(QUIC_RCIDM *rcidm, uint64_t seq_num,
 }
 
 static void rcidm_transition_rcid(QUIC_RCIDM *rcidm, RCID *rcid,
-                                  unsigned int state)
+    unsigned int state)
 {
     unsigned int old_state = rcid->state;
 
@@ -438,7 +439,7 @@ static void rcidm_free_rcid(QUIC_RCIDM *rcidm, RCID *rcid)
 }
 
 static void rcidm_handle_retire_prior_to(QUIC_RCIDM *rcidm,
-                                         uint64_t retire_prior_to)
+    uint64_t retire_prior_to)
 {
     RCID *rcid;
 
@@ -457,7 +458,7 @@ static void rcidm_handle_retire_prior_to(QUIC_RCIDM *rcidm,
      * threshold.
      */
     while ((rcid = ossl_pqueue_RCID_peek(rcidm->rcids)) != NULL
-           && rcid->seq_num < retire_prior_to)
+        && rcid->seq_num < retire_prior_to)
         rcidm_transition_rcid(rcidm, rcid, RCID_STATE_RETIRING);
 
     rcidm->retire_prior_to = retire_prior_to;
@@ -578,7 +579,7 @@ void ossl_quic_rcidm_request_roll(QUIC_RCIDM *rcidm)
  * ===================
  */
 int ossl_quic_rcidm_add_from_initial(QUIC_RCIDM *rcidm,
-                                     const QUIC_CONN_ID *rcid)
+    const QUIC_CONN_ID *rcid)
 {
     RCID *rcid_obj;
 
@@ -586,7 +587,7 @@ int ossl_quic_rcidm_add_from_initial(QUIC_RCIDM *rcidm,
         return 0;
 
     rcid_obj = rcidm_create_rcid(rcidm, INITIAL_SEQ_NUM,
-                                 rcid, RCID_TYPE_INITIAL);
+        rcid, RCID_TYPE_INITIAL);
     if (rcid_obj == NULL)
         return 0;
 
@@ -596,19 +597,19 @@ int ossl_quic_rcidm_add_from_initial(QUIC_RCIDM *rcidm,
 }
 
 int ossl_quic_rcidm_add_from_server_retry(QUIC_RCIDM *rcidm,
-                                          const QUIC_CONN_ID *retry_odcid)
+    const QUIC_CONN_ID *retry_odcid)
 {
     if (rcidm->added_retry_odcid || rcidm->handshake_complete)
         return 0;
 
-    rcidm->retry_odcid          = *retry_odcid;
-    rcidm->added_retry_odcid    = 1;
+    rcidm->retry_odcid = *retry_odcid;
+    rcidm->added_retry_odcid = 1;
     rcidm_tick(rcidm);
     return 1;
 }
 
 int ossl_quic_rcidm_add_from_ncid(QUIC_RCIDM *rcidm,
-                                  const OSSL_QUIC_FRAME_NEW_CONN_ID *ncid)
+    const OSSL_QUIC_FRAME_NEW_CONN_ID *ncid)
 {
     RCID *rcid;
 
@@ -643,19 +644,19 @@ static int rcidm_get_retire(QUIC_RCIDM *rcidm, uint64_t *seq_num, int peek)
 }
 
 int ossl_quic_rcidm_pop_retire_seq_num(QUIC_RCIDM *rcidm,
-                                       uint64_t *seq_num)
+    uint64_t *seq_num)
 {
     return rcidm_get_retire(rcidm, seq_num, /*peek=*/0);
 }
 
 int ossl_quic_rcidm_peek_retire_seq_num(QUIC_RCIDM *rcidm,
-                                        uint64_t *seq_num)
+    uint64_t *seq_num)
 {
     return rcidm_get_retire(rcidm, seq_num, /*peek=*/1);
 }
 
 int ossl_quic_rcidm_get_preferred_tx_dcid(QUIC_RCIDM *rcidm,
-                                          QUIC_CONN_ID *tx_dcid)
+    QUIC_CONN_ID *tx_dcid)
 {
     if (!rcidm->have_preferred_rcid)
         return 0;
@@ -665,7 +666,7 @@ int ossl_quic_rcidm_get_preferred_tx_dcid(QUIC_RCIDM *rcidm,
 }
 
 int ossl_quic_rcidm_get_preferred_tx_dcid_changed(QUIC_RCIDM *rcidm,
-                                                  int clear)
+    int clear)
 {
     int r = rcidm->preferred_rcid_changed;
 
diff --git a/crypto/openssl/ssl/quic/quic_reactor.c b/crypto/openssl/ssl/quic/quic_reactor.c
index bca46011f2e9..c30bc3c595ab 100644
--- a/crypto/openssl/ssl/quic/quic_reactor.c
+++ b/crypto/openssl/ssl/quic/quic_reactor.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022-2025 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2022-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy
@@ -11,6 +11,12 @@
 #include "internal/thread_arch.h"
 #include <assert.h>
 
+#if defined(OPENSSL_SYS_WINDOWS)
+#include <winsock2.h>
+#include <mstcpip.h>
+#include <mswsock.h>
+#endif
+
 /*
  * Core I/O Reactor Framework
  * ==========================
@@ -18,24 +24,24 @@
 static void rtor_notify_other_threads(QUIC_REACTOR *rtor);
 
 int ossl_quic_reactor_init(QUIC_REACTOR *rtor,
-                           void (*tick_cb)(QUIC_TICK_RESULT *res, void *arg,
-                                           uint32_t flags),
-                           void *tick_cb_arg,
-                           CRYPTO_MUTEX *mutex,
-                           OSSL_TIME initial_tick_deadline,
-                           uint64_t flags)
+    void (*tick_cb)(QUIC_TICK_RESULT *res, void *arg,
+        uint32_t flags),
+    void *tick_cb_arg,
+    CRYPTO_MUTEX *mutex,
+    OSSL_TIME initial_tick_deadline,
+    uint64_t flags)
 {
-    rtor->poll_r.type       = BIO_POLL_DESCRIPTOR_TYPE_NONE;
-    rtor->poll_w.type       = BIO_POLL_DESCRIPTOR_TYPE_NONE;
-    rtor->net_read_desired  = 0;
+    rtor->poll_r.type = BIO_POLL_DESCRIPTOR_TYPE_NONE;
+    rtor->poll_w.type = BIO_POLL_DESCRIPTOR_TYPE_NONE;
+    rtor->net_read_desired = 0;
     rtor->net_write_desired = 0;
-    rtor->can_poll_r        = 0;
-    rtor->can_poll_w        = 0;
-    rtor->tick_deadline     = initial_tick_deadline;
+    rtor->can_poll_r = 0;
+    rtor->can_poll_w = 0;
+    rtor->tick_deadline = initial_tick_deadline;
 
-    rtor->tick_cb           = tick_cb;
-    rtor->tick_cb_arg       = tick_cb_arg;
-    rtor->mutex             = mutex;
+    rtor->tick_cb = tick_cb;
+    rtor->tick_cb_arg = tick_cb_arg;
+    rtor->mutex = mutex;
 
     rtor->cur_blocking_waiters = 0;
 
@@ -69,6 +75,34 @@ void ossl_quic_reactor_cleanup(QUIC_REACTOR *rtor)
     }
 }
 
+#if defined(OPENSSL_SYS_WINDOWS)
+
+/* Work around for MinGW builds. */
+#if defined(__MINGW32__) && !defined(SIO_UDP_NETRESET)
+#define SIO_UDP_NETRESET _WSAIOW(IOC_VENDOR, 15)
+#endif
+
+/*
+ * On Windows recvfrom() may return WSAECONNRESET when destination port
+ * used in preceding call to sendto() is no longer reachable. The reset
+ * error received from UDP socket takes the whole port down. This behavior
+ * must be suppressed for QUIC protocol so QUIC applications may rely on
+ * QUIC protocol itself to detect network failures.
+ */
+static void rtor_configure_winsock(BIO_POLL_DESCRIPTOR *bpd)
+{
+    BOOL bNewBehavior = FALSE;
+    DWORD dwBytesReturned = 0;
+
+    if (bpd->type == BIO_POLL_DESCRIPTOR_TYPE_SOCK_FD) {
+        WSAIoctl(bpd->value.fd, SIO_UDP_CONNRESET, &bNewBehavior,
+            sizeof(bNewBehavior), NULL, 0, &dwBytesReturned, NULL, NULL);
+        WSAIoctl(bpd->value.fd, SIO_UDP_NETRESET, &bNewBehavior,
+            sizeof(bNewBehavior), NULL, 0, &dwBytesReturned, NULL, NULL);
+    }
+}
+#endif
+
 void ossl_quic_reactor_set_poll_r(QUIC_REACTOR *rtor, const BIO_POLL_DESCRIPTOR *r)
 {
     if (r == NULL)
@@ -76,6 +110,10 @@ void ossl_quic_reactor_set_poll_r(QUIC_REACTOR *rtor, const BIO_POLL_DESCRIPTOR
     else
         rtor->poll_r = *r;
 
+#if defined(OPENSSL_SYS_WINDOWS)
+    rtor_configure_winsock(&rtor->poll_r);
+#endif
+
     rtor->can_poll_r
         = ossl_quic_reactor_can_support_poll_descriptor(rtor, &rtor->poll_r);
 }
@@ -87,6 +125,10 @@ void ossl_quic_reactor_set_poll_w(QUIC_REACTOR *rtor, const BIO_POLL_DESCRIPTOR
     else
         rtor->poll_w = *w;
 
+#if defined(OPENSSL_SYS_WINDOWS)
+    rtor_configure_winsock(&rtor->poll_w);
+#endif
+
     rtor->can_poll_w
         = ossl_quic_reactor_can_support_poll_descriptor(rtor, &rtor->poll_w);
 }
@@ -102,7 +144,7 @@ const BIO_POLL_DESCRIPTOR *ossl_quic_reactor_get_poll_w(const QUIC_REACTOR *rtor
 }
 
 int ossl_quic_reactor_can_support_poll_descriptor(const QUIC_REACTOR *rtor,
-                                                  const BIO_POLL_DESCRIPTOR *d)
+    const BIO_POLL_DESCRIPTOR *d)
 {
     return d->type == BIO_POLL_DESCRIPTOR_TYPE_SOCK_FD;
 }
@@ -134,7 +176,7 @@ OSSL_TIME ossl_quic_reactor_get_tick_deadline(QUIC_REACTOR *rtor)
 
 int ossl_quic_reactor_tick(QUIC_REACTOR *rtor, uint32_t flags)
 {
-    QUIC_TICK_RESULT res = {0};
+    QUIC_TICK_RESULT res = { 0 };
 
     /*
      * Note that the tick callback cannot fail; this is intentional. Arguably it
@@ -145,9 +187,9 @@ int ossl_quic_reactor_tick(QUIC_REACTOR *rtor, uint32_t flags)
      */
     rtor->tick_cb(&res, rtor->tick_cb_arg, flags);
 
-    rtor->net_read_desired  = res.net_read_desired;
+    rtor->net_read_desired = res.net_read_desired;
     rtor->net_write_desired = res.net_write_desired;
-    rtor->tick_deadline     = res.tick_deadline;
+    rtor->tick_deadline = res.tick_deadline;
     if (res.notify_other_threads)
         rtor_notify_other_threads(rtor);
 
@@ -207,10 +249,10 @@ RIO_NOTIFIER *ossl_quic_reactor_get0_notifier(QUIC_REACTOR *rtor)
  *                   CRYPTO_THREAD_write_lock fails)
  */
 static int poll_two_fds(int rfd, int rfd_want_read,
-                        int wfd, int wfd_want_write,
-                        int notify_rfd,
-                        OSSL_TIME deadline,
-                        CRYPTO_MUTEX *mutex)
+    int wfd, int wfd_want_write,
+    int notify_rfd,
+    OSSL_TIME deadline,
+    CRYPTO_MUTEX *mutex)
 {
 #if defined(OPENSSL_SYS_WINDOWS) || !defined(POLLIN)
     fd_set rfd_set, wfd_set, efd_set;
@@ -218,14 +260,14 @@ static int poll_two_fds(int rfd, int rfd_want_read,
     struct timeval tv, *ptv;
     int maxfd, pres;
 
-# ifndef OPENSSL_SYS_WINDOWS
+#ifndef OPENSSL_SYS_WINDOWS
     /*
      * On Windows there is no relevant limit to the magnitude of a fd value (see
      * above). On *NIX the fd_set uses a bitmap and we must check the limit.
      */
     if (rfd >= FD_SETSIZE || wfd >= FD_SETSIZE)
         return 0;
-# endif
+#endif
 
     FD_ZERO(&rfd_set);
     FD_ZERO(&wfd_set);
@@ -255,7 +297,7 @@ static int poll_two_fds(int rfd, int rfd_want_read,
         maxfd = notify_rfd;
 
     if (!ossl_assert(rfd != INVALID_SOCKET || wfd != INVALID_SOCKET
-                     || !ossl_time_is_infinite(deadline)))
+            || !ossl_time_is_infinite(deadline)))
         /* Do not block forever; should not happen. */
         return 0;
 
@@ -265,10 +307,10 @@ static int poll_two_fds(int rfd, int rfd_want_read,
      * two threads arrive to select/poll with the same file
      * descriptors. We just need to be aware of this.
      */
-# if defined(OPENSSL_THREADS)
+#if defined(OPENSSL_THREADS)
     if (mutex != NULL)
         ossl_crypto_mutex_unlock(mutex);
-# endif
+#endif
 
     do {
         /*
@@ -285,46 +327,46 @@ static int poll_two_fds(int rfd, int rfd_want_read,
              * now > deadline.
              */
             timeout = ossl_time_subtract(deadline, now);
-            tv      = ossl_time_to_timeval(timeout);
-            ptv     = &tv;
+            tv = ossl_time_to_timeval(timeout);
+            ptv = &tv;
         }
 
         pres = select(maxfd + 1, &rfd_set, &wfd_set, &efd_set, ptv);
     } while (pres == -1 && get_last_socket_error_is_eintr());
 
-# if defined(OPENSSL_THREADS)
+#if defined(OPENSSL_THREADS)
     if (mutex != NULL)
         ossl_crypto_mutex_lock(mutex);
-# endif
+#endif
 
     return pres < 0 ? 0 : 1;
 #else
     int pres, timeout_ms;
     OSSL_TIME now, timeout;
-    struct pollfd pfds[3] = {0};
+    struct pollfd pfds[3] = { 0 };
     size_t npfd = 0;
 
     if (rfd == wfd) {
         pfds[npfd].fd = rfd;
-        pfds[npfd].events = (rfd_want_read  ? POLLIN  : 0)
-                          | (wfd_want_write ? POLLOUT : 0);
+        pfds[npfd].events = (rfd_want_read ? POLLIN : 0)
+            | (wfd_want_write ? POLLOUT : 0);
         if (rfd >= 0 && pfds[npfd].events != 0)
             ++npfd;
     } else {
-        pfds[npfd].fd     = rfd;
+        pfds[npfd].fd = rfd;
         pfds[npfd].events = (rfd_want_read ? POLLIN : 0);
         if (rfd >= 0 && pfds[npfd].events != 0)
             ++npfd;
 
-        pfds[npfd].fd     = wfd;
+        pfds[npfd].fd = wfd;
         pfds[npfd].events = (wfd_want_write ? POLLOUT : 0);
         if (wfd >= 0 && pfds[npfd].events != 0)
             ++npfd;
     }
 
     if (notify_rfd >= 0) {
-        pfds[npfd].fd       = notify_rfd;
-        pfds[npfd].events   = POLLIN;
+        pfds[npfd].fd = notify_rfd;
+        pfds[npfd].events = POLLIN;
         ++npfd;
     }
 
@@ -332,27 +374,27 @@ static int poll_two_fds(int rfd, int rfd_want_read,
         /* Do not block forever; should not happen. */
         return 0;
 
-# if defined(OPENSSL_THREADS)
+#if defined(OPENSSL_THREADS)
     if (mutex != NULL)
         ossl_crypto_mutex_unlock(mutex);
-# endif
+#endif
 
     do {
         if (ossl_time_is_infinite(deadline)) {
             timeout_ms = -1;
         } else {
-            now         = ossl_time_now();
-            timeout     = ossl_time_subtract(deadline, now);
-            timeout_ms  = ossl_time2ms(timeout);
+            now = ossl_time_now();
+            timeout = ossl_time_subtract(deadline, now);
+            timeout_ms = ossl_time2ms(timeout);
         }
 
         pres = poll(pfds, npfd, timeout_ms);
     } while (pres == -1 && get_last_socket_error_is_eintr());
 
-# if defined(OPENSSL_THREADS)
+#if defined(OPENSSL_THREADS)
     if (mutex != NULL)
         ossl_crypto_mutex_lock(mutex);
-# endif
+#endif
 
     return pres < 0 ? 0 : 1;
 #endif
@@ -366,7 +408,7 @@ static int poll_descriptor_to_fd(const BIO_POLL_DESCRIPTOR *d, int *fd)
     }
 
     if (d->type != BIO_POLL_DESCRIPTOR_TYPE_SOCK_FD
-            || d->value.fd == INVALID_SOCKET)
+        || d->value.fd == INVALID_SOCKET)
         return 0;
 
     *fd = d->value.fd;
@@ -385,10 +427,10 @@ static int poll_descriptor_to_fd(const BIO_POLL_DESCRIPTOR *d, int *fd)
  *                   CRYPTO_THREAD_write_lock fails)
  */
 static int poll_two_descriptors(const BIO_POLL_DESCRIPTOR *r, int r_want_read,
-                                const BIO_POLL_DESCRIPTOR *w, int w_want_write,
-                                int notify_rfd,
-                                OSSL_TIME deadline,
-                                CRYPTO_MUTEX *mutex)
+    const BIO_POLL_DESCRIPTOR *w, int w_want_write,
+    int notify_rfd,
+    OSSL_TIME deadline,
+    CRYPTO_MUTEX *mutex)
 {
     int rfd, wfd;
 
@@ -397,7 +439,7 @@ static int poll_two_descriptors(const BIO_POLL_DESCRIPTOR *r, int r_want_read,
         return 0;
 
     return poll_two_fds(rfd, r_want_read, wfd, w_want_write,
-                        notify_rfd, deadline, mutex);
+        notify_rfd, deadline, mutex);
 }
 
 /*
@@ -428,21 +470,21 @@ static void rtor_notify_other_threads(QUIC_REACTOR *rtor)
      * threads have woken.
      */
 
-   if (rtor->cur_blocking_waiters == 0)
-       /* Nothing to do in this case. */
-       return;
+    if (rtor->cur_blocking_waiters == 0)
+        /* Nothing to do in this case. */
+        return;
 
-   /* Signal the notifier to wake up all threads. */
-   if (!rtor->signalled_notifier) {
-       ossl_rio_notifier_signal(&rtor->notifier);
-       rtor->signalled_notifier = 1;
-   }
+    /* Signal the notifier to wake up all threads. */
+    if (!rtor->signalled_notifier) {
+        ossl_rio_notifier_signal(&rtor->notifier);
+        rtor->signalled_notifier = 1;
+    }
 
-   /*
-    * Wait on the CV until all threads have finished the first phase of the
-    * wakeup process and the last thread out has taken responsibility for
-    * unsignalling the notifier.
-    */
+    /*
+     * Wait on the CV until all threads have finished the first phase of the
+     * wakeup process and the last thread out has taken responsibility for
+     * unsignalling the notifier.
+     */
     while (rtor->signalled_notifier)
         ossl_crypto_condvar_wait(rtor->notifier_cv, rtor->mutex);
 }
@@ -459,8 +501,8 @@ static void rtor_notify_other_threads(QUIC_REACTOR *rtor)
  *                   CRYPTO_THREAD_write_lock fails)
  */
 int ossl_quic_reactor_block_until_pred(QUIC_REACTOR *rtor,
-                                       int (*pred)(void *arg), void *pred_arg,
-                                       uint32_t flags)
+    int (*pred)(void *arg), void *pred_arg,
+    uint32_t flags)
 {
     int res, net_read_desired, net_write_desired, notifier_fd;
     OSSL_TIME tick_deadline;
@@ -479,9 +521,9 @@ int ossl_quic_reactor_block_until_pred(QUIC_REACTOR *rtor,
         if ((res = pred(pred_arg)) != 0)
             return res;
 
-        net_read_desired  = ossl_quic_reactor_net_read_desired(rtor);
+        net_read_desired = ossl_quic_reactor_net_read_desired(rtor);
         net_write_desired = ossl_quic_reactor_net_write_desired(rtor);
-        tick_deadline     = ossl_quic_reactor_get_tick_deadline(rtor);
+        tick_deadline = ossl_quic_reactor_get_tick_deadline(rtor);
         if (!net_read_desired && !net_write_desired
             && ossl_time_is_infinite(tick_deadline))
             /* Can't wait if there is nothing to wait for. */
@@ -490,12 +532,12 @@ int ossl_quic_reactor_block_until_pred(QUIC_REACTOR *rtor,
         ossl_quic_reactor_enter_blocking_section(rtor);
 
         res = poll_two_descriptors(ossl_quic_reactor_get_poll_r(rtor),
-                                   net_read_desired,
-                                   ossl_quic_reactor_get_poll_w(rtor),
-                                   net_write_desired,
-                                   notifier_fd,
-                                   tick_deadline,
-                                   rtor->mutex);
+            net_read_desired,
+            ossl_quic_reactor_get_poll_w(rtor),
+            net_write_desired,
+            notifier_fd,
+            tick_deadline,
+            rtor->mutex);
 
         /*
          * We have now exited the OS poller call. We may have
diff --git a/crypto/openssl/ssl/quic/quic_reactor_wait_ctx.c b/crypto/openssl/ssl/quic/quic_reactor_wait_ctx.c
index 00efac715603..ae3b7cb3efe3 100644
--- a/crypto/openssl/ssl/quic/quic_reactor_wait_ctx.c
+++ b/crypto/openssl/ssl/quic/quic_reactor_wait_ctx.c
@@ -13,8 +13,8 @@
 
 struct quic_reactor_wait_slot_st {
     OSSL_LIST_MEMBER(quic_reactor_wait_slot, QUIC_REACTOR_WAIT_SLOT);
-    QUIC_REACTOR            *rtor;              /* primary key */
-    size_t                  blocking_count;     /* datum */
+    QUIC_REACTOR *rtor; /* primary key */
+    size_t blocking_count; /* datum */
 };
 
 DEFINE_LIST_OF_IMPL(quic_reactor_wait_slot, QUIC_REACTOR_WAIT_SLOT);
@@ -41,13 +41,13 @@ static void slot_deactivate(QUIC_REACTOR_WAIT_SLOT *slot)
 }
 
 int ossl_quic_reactor_wait_ctx_enter(QUIC_REACTOR_WAIT_CTX *ctx,
-                                     QUIC_REACTOR *rtor)
+    QUIC_REACTOR *rtor)
 {
     QUIC_REACTOR_WAIT_SLOT *slot;
 
     OSSL_LIST_FOREACH(slot, quic_reactor_wait_slot, &ctx->slots)
-        if (slot->rtor == rtor)
-            break;
+    if (slot->rtor == rtor)
+        break;
 
     if (slot == NULL) {
         if ((slot = OPENSSL_zalloc(sizeof(QUIC_REACTOR_WAIT_SLOT))) == NULL)
@@ -62,13 +62,13 @@ int ossl_quic_reactor_wait_ctx_enter(QUIC_REACTOR_WAIT_CTX *ctx,
 }
 
 void ossl_quic_reactor_wait_ctx_leave(QUIC_REACTOR_WAIT_CTX *ctx,
-                                      QUIC_REACTOR *rtor)
+    QUIC_REACTOR *rtor)
 {
     QUIC_REACTOR_WAIT_SLOT *slot;
 
     OSSL_LIST_FOREACH(slot, quic_reactor_wait_slot, &ctx->slots)
-        if (slot->rtor == rtor)
-            break;
+    if (slot->rtor == rtor)
+        break;
 
     assert(slot != NULL);
     slot_deactivate(slot);
@@ -78,7 +78,8 @@ void ossl_quic_reactor_wait_ctx_cleanup(QUIC_REACTOR_WAIT_CTX *ctx)
 {
     QUIC_REACTOR_WAIT_SLOT *slot, *nslot;
 
-    OSSL_LIST_FOREACH_DELSAFE(slot, nslot, quic_reactor_wait_slot, &ctx->slots) {
+    OSSL_LIST_FOREACH_DELSAFE(slot, nslot, quic_reactor_wait_slot, &ctx->slots)
+    {
         assert(slot->blocking_count == 0);
         OPENSSL_free(slot);
     }
diff --git a/crypto/openssl/ssl/quic/quic_record_rx.c b/crypto/openssl/ssl/quic/quic_record_rx.c
index 1a8194b396d7..d9e2b4323bdf 100644
--- a/crypto/openssl/ssl/quic/quic_record_rx.c
+++ b/crypto/openssl/ssl/quic/quic_record_rx.c
@@ -42,36 +42,36 @@ static ossl_inline int pkt_is_marked(const uint64_t *bitf, size_t pkt_idx)
 typedef struct rxe_st RXE;
 
 struct rxe_st {
-    OSSL_QRX_PKT        pkt;
+    OSSL_QRX_PKT pkt;
     OSSL_LIST_MEMBER(rxe, RXE);
-    size_t              data_len, alloc_len, refcount;
+    size_t data_len, alloc_len, refcount;
 
     /* Extra fields for per-packet information. */
-    QUIC_PKT_HDR        hdr; /* data/len are decrypted payload */
+    QUIC_PKT_HDR hdr; /* data/len are decrypted payload */
 
     /* Decoded packet number. */
-    QUIC_PN             pn;
+    QUIC_PN pn;
 
     /* Addresses copied from URXE. */
-    BIO_ADDR            peer, local;
+    BIO_ADDR peer, local;
 
     /* Time we received the packet (not when we processed it). */
-    OSSL_TIME           time;
+    OSSL_TIME time;
 
     /* Total length of the datagram which contained this packet. */
-    size_t              datagram_len;
+    size_t datagram_len;
 
     /*
      * The key epoch the packet was received with. Always 0 for non-1-RTT
      * packets.
      */
-    uint64_t            key_epoch;
+    uint64_t key_epoch;
 
     /*
      * Monotonically increases with each datagram received.
      * For diagnostic use only.
      */
-    uint64_t            datagram_id;
+    uint64_t datagram_id;
 
     /*
      * alloc_len allocated bytes (of which data_len bytes are valid) follow this
@@ -92,80 +92,80 @@ static ossl_inline unsigned char *rxe_data(const RXE *e)
  * ===
  */
 struct ossl_qrx_st {
-    OSSL_LIB_CTX               *libctx;
-    const char                 *propq;
+    OSSL_LIB_CTX *libctx;
+    const char *propq;
 
     /* Demux to receive datagrams from. */
-    QUIC_DEMUX                 *demux;
+    QUIC_DEMUX *demux;
 
     /* Length of connection IDs used in short-header packets in bytes. */
-    size_t                      short_conn_id_len;
+    size_t short_conn_id_len;
 
     /* Maximum number of deferred datagrams buffered at any one time. */
-    size_t                      max_deferred;
+    size_t max_deferred;
 
     /* Current count of deferred datagrams. */
-    size_t                      num_deferred;
+    size_t num_deferred;
 
     /*
      * List of URXEs which are filled with received encrypted data.
      * These are returned to the DEMUX's free list as they are processed.
      */
-    QUIC_URXE_LIST              urx_pending;
+    QUIC_URXE_LIST urx_pending;
 
     /*
      * List of URXEs which we could not decrypt immediately and which are being
      * kept in case they can be decrypted later.
      */
-    QUIC_URXE_LIST              urx_deferred;
+    QUIC_URXE_LIST urx_deferred;
 
     /*
      * List of RXEs which are not currently in use. These are moved
      * to the pending list as they are filled.
      */
-    RXE_LIST                    rx_free;
+    RXE_LIST rx_free;
 
     /*
      * List of RXEs which are filled with decrypted packets ready to be passed
      * to the user. A RXE is removed from all lists inside the QRL when passed
      * to the user, then returned to the free list when the user returns it.
      */
-    RXE_LIST                    rx_pending;
+    RXE_LIST rx_pending;
 
     /* Largest PN we have received and processed in a given PN space. */
-    QUIC_PN                     largest_pn[QUIC_PN_SPACE_NUM];
+    QUIC_PN largest_pn[QUIC_PN_SPACE_NUM];
 
     /* Per encryption-level state. */
-    OSSL_QRL_ENC_LEVEL_SET      el_set;
+    OSSL_QRL_ENC_LEVEL_SET el_set;
 
     /* Bytes we have received since this counter was last cleared. */
-    uint64_t                    bytes_received;
+    uint64_t bytes_received;
 
     /*
      * Number of forged packets we have received since the QRX was instantiated.
      * Note that as per RFC 9001, this is connection-level state; it is not per
      * EL and is not reset by a key update.
      */
-    uint64_t                    forged_pkt_count;
+    uint64_t forged_pkt_count;
 
     /*
      * The PN the current key epoch started at, inclusive.
      */
-    uint64_t                    cur_epoch_start_pn;
+    uint64_t cur_epoch_start_pn;
 
     /* Validation callback. */
-    ossl_qrx_late_validation_cb    *validation_cb;
-    void                           *validation_cb_arg;
+    ossl_qrx_late_validation_cb *validation_cb;
+    void *validation_cb_arg;
 
     /* Key update callback. */
-    ossl_qrx_key_update_cb         *key_update_cb;
-    void                           *key_update_cb_arg;
+    ossl_qrx_key_update_cb *key_update_cb;
+    void *key_update_cb_arg;
 
     /* Initial key phase. For debugging use only; always 0 in real use. */
-    unsigned char                   init_key_phase_bit;
+    unsigned char init_key_phase_bit;
 
     /* Are we allowed to process 1-RTT packets yet? */
-    unsigned char                   allow_1rtt;
+    unsigned char allow_1rtt;
 
     /* Message callback related arguments */
     ossl_msg_cb msg_callback;
@@ -175,18 +175,18 @@ struct ossl_qrx_st {
 
 static RXE *qrx_ensure_free_rxe(OSSL_QRX *qrx, size_t alloc_len);
 static int qrx_validate_hdr_early(OSSL_QRX *qrx, RXE *rxe,
-                                  const QUIC_CONN_ID *first_dcid);
+    const QUIC_CONN_ID *first_dcid);
 static int qrx_relocate_buffer(OSSL_QRX *qrx, RXE **prxe, size_t *pi,
-                               const unsigned char **pptr, size_t buf_len);
+    const unsigned char **pptr, size_t buf_len);
 static int qrx_validate_hdr(OSSL_QRX *qrx, RXE *rxe);
 static RXE *qrx_reserve_rxe(RXE_LIST *rxl, RXE *rxe, size_t n);
 static int qrx_decrypt_pkt_body(OSSL_QRX *qrx, unsigned char *dst,
-                                const unsigned char *src,
-                                size_t src_len, size_t *dec_len,
-                                const unsigned char *aad, size_t aad_len,
-                                QUIC_PN pn, uint32_t enc_level,
-                                unsigned char key_phase_bit,
-                                uint64_t *rx_key_epoch);
+    const unsigned char *src,
+    size_t src_len, size_t *dec_len,
+    const unsigned char *aad, size_t aad_len,
+    QUIC_PN pn, uint32_t enc_level,
+    unsigned char key_phase_bit,
+    uint64_t *rx_key_epoch);
 static int qrx_validate_hdr_late(OSSL_QRX *qrx, RXE *rxe);
 static uint32_t rxe_determine_pn_space(RXE *rxe);
 static void ignore_res(int x);
@@ -206,12 +206,12 @@ OSSL_QRX *ossl_qrx_new(const OSSL_QRX_ARGS *args)
     for (i = 0; i < OSSL_NELEM(qrx->largest_pn); ++i)
         qrx->largest_pn[i] = args->init_largest_pn[i];
 
-    qrx->libctx                 = args->libctx;
-    qrx->propq                  = args->propq;
-    qrx->demux                  = args->demux;
-    qrx->short_conn_id_len      = args->short_conn_id_len;
-    qrx->init_key_phase_bit     = args->init_key_phase_bit;
-    qrx->max_deferred           = args->max_deferred;
+    qrx->libctx = args->libctx;
+    qrx->propq = args->propq;
+    qrx->demux = args->demux;
+    qrx->short_conn_id_len = args->short_conn_id_len;
+    qrx->init_key_phase_bit = args->init_key_phase_bit;
+    qrx->max_deferred = args->max_deferred;
     return qrx;
 }
 
@@ -270,15 +270,15 @@ void ossl_qrx_free(OSSL_QRX *qrx)
 void ossl_qrx_inject_urxe(OSSL_QRX *qrx, QUIC_URXE *urxe)
 {
     /* Initialize our own fields inside the URXE and add to the pending list. */
-    urxe->processed     = 0;
-    urxe->hpr_removed   = 0;
-    urxe->deferred      = 0;
+    urxe->processed = 0;
+    urxe->hpr_removed = 0;
+    urxe->deferred = 0;
     ossl_list_urxe_insert_tail(&qrx->urx_pending, urxe);
 
     if (qrx->msg_callback != NULL)
         qrx->msg_callback(0, OSSL_QUIC1_VERSION, SSL3_RT_QUIC_DATAGRAM, urxe + 1,
-                          urxe->data_len, qrx->msg_callback_ssl,
-                          qrx->msg_callback_arg);
+            urxe->data_len, qrx->msg_callback_ssl,
+            qrx->msg_callback_arg);
 }
 
 void ossl_qrx_inject_pkt(OSSL_QRX *qrx, OSSL_QRX_PKT *pkt)
@@ -303,8 +303,8 @@ void ossl_qrx_inject_pkt(OSSL_QRX *qrx, OSSL_QRX_PKT *pkt)
  * packet instead of creating a new channel for it.
  */
 static int qrx_validate_initial_pkt(OSSL_QRX *qrx, QUIC_URXE *urxe,
-                                    const QUIC_CONN_ID *first_dcid,
-                                    size_t datagram_len)
+    const QUIC_CONN_ID *first_dcid,
+    size_t datagram_len)
 {
     PACKET pkt, orig_pkt;
     RXE *rxe;
@@ -335,11 +335,11 @@ static int qrx_validate_initial_pkt(OSSL_QRX *qrx, QUIC_URXE *urxe,
      * short_conn_id_len as 0.
      */
     if (!ossl_quic_wire_decode_pkt_hdr(&pkt,
-                                       0, /* short_conn_id_len */
-                                       1, /* need second decode */
-                                       0, /* nodata -> want to read data */
-                                       &rxe->hdr, &ptrs,
-                                       NULL))
+            0, /* short_conn_id_len */
+            1, /* need second decode */
+            0, /* nodata -> want to read data */
+            &rxe->hdr, &ptrs,
+            NULL))
         goto malformed;
 
     if (rxe->hdr.type != QUIC_PKT_TYPE_INITIAL)
@@ -381,7 +381,8 @@ static int qrx_validate_initial_pkt(OSSL_QRX *qrx, QUIC_URXE *urxe,
 
     /* Decode the now unprotected header. */
     if (ossl_quic_wire_decode_pkt_hdr(&pkt, 0,
-                                      0, 0, &rxe->hdr, NULL, NULL) != 1)
+            0, 0, &rxe->hdr, NULL, NULL)
+        != 1)
         goto malformed;
 
     /* Validate header and decode PN. */
@@ -414,8 +415,8 @@ static int qrx_validate_initial_pkt(OSSL_QRX *qrx, QUIC_URXE *urxe,
      */
     dst = (unsigned char *)rxe_data(rxe) + i;
     if (!qrx_decrypt_pkt_body(qrx, dst, rxe->hdr.data, rxe->hdr.len,
-                              &dec_len, sop, aad_len, rxe->pn, QUIC_ENC_LEVEL_INITIAL,
-                              rxe->hdr.key_phase, &rx_key_epoch))
+            &dec_len, sop, aad_len, rxe->pn, QUIC_ENC_LEVEL_INITIAL,
+            rxe->hdr.key_phase, &rx_key_epoch))
         goto malformed;
 
     /*
@@ -438,11 +439,11 @@ static int qrx_validate_initial_pkt(OSSL_QRX *qrx, QUIC_URXE *urxe,
      * Update header to point to the decrypted buffer, which may be shorter
      * due to AEAD tags, block padding, etc.
      */
-    rxe->hdr.data       = dst;
-    rxe->hdr.len        = dec_len;
-    rxe->data_len       = dec_len;
-    rxe->datagram_len   = datagram_len;
-    rxe->key_epoch      = rx_key_epoch;
+    rxe->hdr.data = dst;
+    rxe->hdr.len = dec_len;
+    rxe->data_len = dec_len;
+    rxe->datagram_len = datagram_len;
+    rxe->key_epoch = rx_key_epoch;
 
     /* We processed the PN successfully, so update largest processed PN. */
     pn_space = rxe_determine_pn_space(rxe);
@@ -450,10 +451,10 @@ static int qrx_validate_initial_pkt(OSSL_QRX *qrx, QUIC_URXE *urxe,
         qrx->largest_pn[pn_space] = rxe->pn;
 
     /* Copy across network addresses and RX time from URXE to RXE. */
-    rxe->peer           = urxe->peer;
-    rxe->local          = urxe->local;
-    rxe->time           = urxe->time;
-    rxe->datagram_id    = urxe->datagram_id;
+    rxe->peer = urxe->peer;
+    rxe->local = urxe->local;
+    rxe->time = urxe->time;
+    rxe->datagram_id = urxe->datagram_id;
 
     /*
      * The packet is decrypted, we are going to move it from
@@ -471,11 +472,11 @@ malformed:
 }
 
 int ossl_qrx_validate_initial_packet(OSSL_QRX *qrx, QUIC_URXE *urxe,
-                                     const QUIC_CONN_ID *dcid)
+    const QUIC_CONN_ID *dcid)
 {
-    urxe->processed     = 0;
-    urxe->hpr_removed   = 0;
-    urxe->deferred      = 0;
+    urxe->processed = 0;
+    urxe->hpr_removed = 0;
+    urxe->deferred = 0;
 
     return qrx_validate_initial_pkt(qrx, urxe, dcid, urxe->data_len);
 }
@@ -491,22 +492,22 @@ static void qrx_requeue_deferred(OSSL_QRX *qrx)
 }
 
 int ossl_qrx_provide_secret(OSSL_QRX *qrx, uint32_t enc_level,
-                            uint32_t suite_id, EVP_MD *md,
-                            const unsigned char *secret, size_t secret_len)
+    uint32_t suite_id, EVP_MD *md,
+    const unsigned char *secret, size_t secret_len)
 {
     if (enc_level >= QUIC_ENC_LEVEL_NUM)
         return 0;
 
     if (!ossl_qrl_enc_level_set_provide_secret(&qrx->el_set,
-                                               qrx->libctx,
-                                               qrx->propq,
-                                               enc_level,
-                                               suite_id,
-                                               md,
-                                               secret,
-                                               secret_len,
-                                               qrx->init_key_phase_bit,
-                                               /*is_tx=*/0))
+            qrx->libctx,
+            qrx->propq,
+            enc_level,
+            suite_id,
+            md,
+            secret,
+            secret_len,
+            qrx->init_key_phase_bit,
+            /*is_tx=*/0))
         return 0;
 
     /*
@@ -537,7 +538,7 @@ int ossl_qrx_processed_read_pending(OSSL_QRX *qrx)
 int ossl_qrx_unprocessed_read_pending(OSSL_QRX *qrx)
 {
     return !ossl_list_urxe_is_empty(&qrx->urx_pending)
-           || !ossl_list_urxe_is_empty(&qrx->urx_deferred);
+        || !ossl_list_urxe_is_empty(&qrx->urx_deferred);
 }
 
 /* Pop the next pending RXE. Returns NULL if no RXE is pending. */
@@ -566,8 +567,8 @@ static RXE *qrx_alloc_rxe(size_t alloc_len)
 
     ossl_list_rxe_init_elem(rxe);
     rxe->alloc_len = alloc_len;
-    rxe->data_len  = 0;
-    rxe->refcount  = 0;
+    rxe->data_len = 0;
+    rxe->refcount = 0;
     return rxe;
 }
 
@@ -645,7 +646,7 @@ static RXE *qrx_resize_rxe(RXE_LIST *rxl, RXE *rxe, size_t n)
  * Returns NULL on failure.
  */
 static RXE *qrx_reserve_rxe(RXE_LIST *rxl,
-                            RXE *rxe, size_t n)
+    RXE *rxe, size_t n)
 {
     if (rxe->alloc_len >= n)
         return rxe;
@@ -658,9 +659,9 @@ static void qrx_recycle_rxe(OSSL_QRX *qrx, RXE *rxe)
 {
     /* RXE should not be in any list */
     assert(ossl_list_rxe_prev(rxe) == NULL && ossl_list_rxe_next(rxe) == NULL);
-    rxe->pkt.hdr    = NULL;
-    rxe->pkt.peer   = NULL;
-    rxe->pkt.local  = NULL;
+    rxe->pkt.hdr = NULL;
+    rxe->pkt.peer = NULL;
+    rxe->pkt.local = NULL;
     ossl_list_rxe_insert_tail(&qrx->rx_free, rxe);
 }
 
@@ -672,7 +673,7 @@ static void qrx_recycle_rxe(OSSL_QRX *qrx, RXE *rxe)
  * copied buffer. *pptr is updated to point to the new location of the buffer.
  */
 static int qrx_relocate_buffer(OSSL_QRX *qrx, RXE **prxe, size_t *pi,
-                               const unsigned char **pptr, size_t buf_len)
+    const unsigned char **pptr, size_t buf_len)
 {
     RXE *rxe;
     unsigned char *dst;
@@ -695,20 +696,20 @@ static int qrx_relocate_buffer(OSSL_QRX *qrx, RXE **prxe, size_t *pi,
 static uint32_t qrx_determine_enc_level(const QUIC_PKT_HDR *hdr)
 {
     switch (hdr->type) {
-        case QUIC_PKT_TYPE_INITIAL:
-            return QUIC_ENC_LEVEL_INITIAL;
-        case QUIC_PKT_TYPE_HANDSHAKE:
-            return QUIC_ENC_LEVEL_HANDSHAKE;
-        case QUIC_PKT_TYPE_0RTT:
-            return QUIC_ENC_LEVEL_0RTT;
-        case QUIC_PKT_TYPE_1RTT:
-            return QUIC_ENC_LEVEL_1RTT;
+    case QUIC_PKT_TYPE_INITIAL:
+        return QUIC_ENC_LEVEL_INITIAL;
+    case QUIC_PKT_TYPE_HANDSHAKE:
+        return QUIC_ENC_LEVEL_HANDSHAKE;
+    case QUIC_PKT_TYPE_0RTT:
+        return QUIC_ENC_LEVEL_0RTT;
+    case QUIC_PKT_TYPE_1RTT:
+        return QUIC_ENC_LEVEL_1RTT;
 
-        default:
-            assert(0);
-        case QUIC_PKT_TYPE_RETRY:
-        case QUIC_PKT_TYPE_VERSION_NEG:
-            return QUIC_ENC_LEVEL_INITIAL; /* not used */
+    default:
+        assert(0);
+    case QUIC_PKT_TYPE_RETRY:
+    case QUIC_PKT_TYPE_VERSION_NEG:
+        return QUIC_ENC_LEVEL_INITIAL; /* not used */
     }
 }
 
@@ -721,7 +722,7 @@ static uint32_t rxe_determine_pn_space(RXE *rxe)
 }
 
 static int qrx_validate_hdr_early(OSSL_QRX *qrx, RXE *rxe,
-                                  const QUIC_CONN_ID *first_dcid)
+    const QUIC_CONN_ID *first_dcid)
 {
     /* Ensure version is what we want. */
     if (rxe->hdr.version != QUIC_VERSION_1
@@ -743,8 +744,8 @@ static int qrx_validate_hdr_early(OSSL_QRX *qrx, RXE *rxe,
     if (first_dcid != NULL) {
         if (!ossl_assert(first_dcid->id_len < QUIC_MAX_CONN_ID_LEN)
             || !ossl_quic_conn_id_eq(first_dcid,
-                                     &rxe->hdr.dst_conn_id))
-        return 0;
+                &rxe->hdr.dst_conn_id))
+            return 0;
     }
 
     return 1;
@@ -756,8 +757,8 @@ static int qrx_validate_hdr(OSSL_QRX *qrx, RXE *rxe)
     int pn_space = rxe_determine_pn_space(rxe);
 
     if (!ossl_quic_wire_decode_pkt_hdr_pn(rxe->hdr.pn, rxe->hdr.pn_len,
-                                          qrx->largest_pn[pn_space],
-                                          &rxe->pn))
+            qrx->largest_pn[pn_space],
+            &rxe->pn))
         return 0;
 
     return 1;
@@ -784,10 +785,10 @@ static int qrx_validate_hdr_late(OSSL_QRX *qrx, RXE *rxe)
  * epoch number actually used for packet decryption to *rx_key_epoch.
  */
 static size_t qrx_get_cipher_ctx_idx(OSSL_QRX *qrx, OSSL_QRL_ENC_LEVEL *el,
-                                     uint32_t enc_level,
-                                     unsigned char key_phase_bit,
-                                     uint64_t *rx_key_epoch,
-                                     int *is_old_key)
+    uint32_t enc_level,
+    unsigned char key_phase_bit,
+    uint64_t *rx_key_epoch,
+    int *is_old_key)
 {
     size_t idx;
 
@@ -884,18 +885,18 @@ static size_t qrx_get_cipher_ctx_idx(OSSL_QRX *qrx, OSSL_QRL_ENC_LEVEL *el,
  * less than) src_len.
  */
 static int qrx_decrypt_pkt_body(OSSL_QRX *qrx, unsigned char *dst,
-                                const unsigned char *src,
-                                size_t src_len, size_t *dec_len,
-                                const unsigned char *aad, size_t aad_len,
-                                QUIC_PN pn, uint32_t enc_level,
-                                unsigned char key_phase_bit,
-                                uint64_t *rx_key_epoch)
+    const unsigned char *src,
+    size_t src_len, size_t *dec_len,
+    const unsigned char *aad, size_t aad_len,
+    QUIC_PN pn, uint32_t enc_level,
+    unsigned char key_phase_bit,
+    uint64_t *rx_key_epoch)
 {
     int l = 0, l2 = 0, is_old_key, nonce_len;
     unsigned char nonce[EVP_MAX_IV_LENGTH];
     size_t i, cctx_idx;
     OSSL_QRL_ENC_LEVEL *el = ossl_qrl_enc_level_set_get(&qrx->el_set,
-                                                        enc_level, 1);
+        enc_level, 1);
     EVP_CIPHER_CTX *cctx;
 
     if (src_len > INT_MAX || aad_len > INT_MAX)
@@ -916,7 +917,7 @@ static int qrx_decrypt_pkt_body(OSSL_QRX *qrx, unsigned char *dst,
         return 0;
 
     cctx_idx = qrx_get_cipher_ctx_idx(qrx, el, enc_level, key_phase_bit,
-                                      rx_key_epoch, &is_old_key);
+        rx_key_epoch, &is_old_key);
     if (!ossl_assert(cctx_idx < OSSL_NELEM(el->cctx)))
         return 0;
 
@@ -946,13 +947,15 @@ static int qrx_decrypt_pkt_body(OSSL_QRX *qrx, unsigned char *dst,
 
     /* type and key will already have been setup; feed the IV. */
     if (EVP_CipherInit_ex(cctx, NULL,
-                          NULL, NULL, nonce, /*enc=*/0) != 1)
+            NULL, NULL, nonce, /*enc=*/0)
+        != 1)
         return 0;
 
     /* Feed the AEAD tag we got so the cipher can validate it. */
     if (EVP_CIPHER_CTX_ctrl(cctx, EVP_CTRL_AEAD_SET_TAG,
-                            el->tag_len,
-                            (unsigned char *)src + src_len - el->tag_len) != 1)
+            el->tag_len,
+            (unsigned char *)src + src_len - el->tag_len)
+        != 1)
         return 0;
 
     /* Feed AAD data. */
@@ -1006,9 +1009,9 @@ static void qrx_key_update_initiated(OSSL_QRX *qrx, QUIC_PN pn)
 
 /* Process a single packet in a datagram. */
 static int qrx_process_pkt(OSSL_QRX *qrx, QUIC_URXE *urxe,
-                           PACKET *pkt, size_t pkt_idx,
-                           QUIC_CONN_ID *first_dcid,
-                           size_t datagram_len)
+    PACKET *pkt, size_t pkt_idx,
+    QUIC_CONN_ID *first_dcid,
+    size_t datagram_len)
 {
     RXE *rxe;
     const unsigned char *eop = NULL;
@@ -1041,9 +1044,9 @@ static int qrx_process_pkt(OSSL_QRX *qrx, QUIC_URXE *urxe,
      */
     need_second_decode = !pkt_is_marked(&urxe->hpr_removed, pkt_idx);
     if (!ossl_quic_wire_decode_pkt_hdr(pkt,
-                                       qrx->short_conn_id_len,
-                                       need_second_decode, 0, &rxe->hdr, &ptrs,
-                                       NULL))
+            qrx->short_conn_id_len,
+            need_second_decode, 0, &rxe->hdr, &ptrs,
+            NULL))
         goto malformed;
 
     /*
@@ -1090,16 +1093,16 @@ static int qrx_process_pkt(OSSL_QRX *qrx, QUIC_URXE *urxe,
         memcpy(rxe_data(rxe), rxe->hdr.data, rxe->hdr.len);
         pkt_mark(&urxe->processed, pkt_idx);
 
-        rxe->hdr.data   = rxe_data(rxe);
-        rxe->pn         = QUIC_PN_INVALID;
+        rxe->hdr.data = rxe_data(rxe);
+        rxe->pn = QUIC_PN_INVALID;
 
-        rxe->data_len       = rxe->hdr.len;
-        rxe->datagram_len   = datagram_len;
-        rxe->key_epoch      = 0;
-        rxe->peer           = urxe->peer;
-        rxe->local          = urxe->local;
-        rxe->time           = urxe->time;
-        rxe->datagram_id    = urxe->datagram_id;
+        rxe->data_len = rxe->hdr.len;
+        rxe->datagram_len = datagram_len;
+        rxe->key_epoch = 0;
+        rxe->peer = urxe->peer;
+        rxe->local = urxe->local;
+        rxe->time = urxe->time;
+        rxe->datagram_id = urxe->datagram_id;
 
         /* Move RXE to pending. */
         ossl_list_rxe_remove(&qrx->rx_free, rxe);
@@ -1112,22 +1115,22 @@ static int qrx_process_pkt(OSSL_QRX *qrx, QUIC_URXE *urxe,
 
     /* If we do not have keying material for this encryption level yet, defer. */
     switch (ossl_qrl_enc_level_set_have_el(&qrx->el_set, enc_level)) {
-        case 1:
-            /* We have keys. */
-            if (enc_level == QUIC_ENC_LEVEL_1RTT && !qrx->allow_1rtt)
-                /*
-                 * But we cannot process 1-RTT packets until the handshake is
-                 * completed (RFC 9000 s. 5.7).
-                 */
-                goto cannot_decrypt;
-
-            break;
-        case 0:
-            /* No keys yet. */
+    case 1:
+        /* We have keys. */
+        if (enc_level == QUIC_ENC_LEVEL_1RTT && !qrx->allow_1rtt)
+            /*
+             * But we cannot process 1-RTT packets until the handshake is
+             * completed (RFC 9000 s. 5.7).
+             */
             goto cannot_decrypt;
-        default:
-            /* We already discarded keys for this EL, we will never process this.*/
-            goto malformed;
+
+        break;
+    case 0:
+        /* No keys yet. */
+        goto cannot_decrypt;
+    default:
+        /* We already discarded keys for this EL, we will never process this.*/
+        goto malformed;
     }
 
     /*
@@ -1179,7 +1182,8 @@ static int qrx_process_pkt(OSSL_QRX *qrx, QUIC_URXE *urxe,
 
         /* Decode the now unprotected header. */
         if (ossl_quic_wire_decode_pkt_hdr(pkt, qrx->short_conn_id_len,
-                                          0, 0, &rxe->hdr, NULL, NULL) != 1)
+                0, 0, &rxe->hdr, NULL, NULL)
+            != 1)
             goto malformed;
     }
 
@@ -1189,8 +1193,8 @@ static int qrx_process_pkt(OSSL_QRX *qrx, QUIC_URXE *urxe,
 
     if (qrx->msg_callback != NULL)
         qrx->msg_callback(0, OSSL_QUIC1_VERSION, SSL3_RT_QUIC_PACKET, sop,
-                          eop - sop - rxe->hdr.len, qrx->msg_callback_ssl,
-                          qrx->msg_callback_arg);
+            eop - sop - rxe->hdr.len, qrx->msg_callback_ssl,
+            qrx->msg_callback_arg);
 
     /*
      * The AAD data is the entire (unprotected) packet header including the PN.
@@ -1225,8 +1229,8 @@ static int qrx_process_pkt(OSSL_QRX *qrx, QUIC_URXE *urxe,
      */
     dst = (unsigned char *)rxe_data(rxe) + i;
     if (!qrx_decrypt_pkt_body(qrx, dst, rxe->hdr.data, rxe->hdr.len,
-                              &dec_len, sop, aad_len, rxe->pn, enc_level,
-                              rxe->hdr.key_phase, &rx_key_epoch))
+            &dec_len, sop, aad_len, rxe->pn, enc_level,
+            rxe->hdr.key_phase, &rx_key_epoch))
         goto malformed;
 
     /*
@@ -1269,11 +1273,11 @@ static int qrx_process_pkt(OSSL_QRX *qrx, QUIC_URXE *urxe,
      * Update header to point to the decrypted buffer, which may be shorter
      * due to AEAD tags, block padding, etc.
      */
-    rxe->hdr.data       = dst;
-    rxe->hdr.len        = dec_len;
-    rxe->data_len       = dec_len;
-    rxe->datagram_len   = datagram_len;
-    rxe->key_epoch      = rx_key_epoch;
+    rxe->hdr.data = dst;
+    rxe->hdr.len = dec_len;
+    rxe->data_len = dec_len;
+    rxe->datagram_len = datagram_len;
+    rxe->key_epoch = rx_key_epoch;
 
     /* We processed the PN successfully, so update largest processed PN. */
     pn_space = rxe_determine_pn_space(rxe);
@@ -1281,10 +1285,10 @@ static int qrx_process_pkt(OSSL_QRX *qrx, QUIC_URXE *urxe,
         qrx->largest_pn[pn_space] = rxe->pn;
 
     /* Copy across network addresses and RX time from URXE to RXE. */
-    rxe->peer           = urxe->peer;
-    rxe->local          = urxe->local;
-    rxe->time           = urxe->time;
-    rxe->datagram_id    = urxe->datagram_id;
+    rxe->peer = urxe->peer;
+    rxe->local = urxe->local;
+    rxe->time = urxe->time;
+    rxe->datagram_id = urxe->datagram_id;
 
     /* Move RXE to pending. */
     ossl_list_rxe_remove(&qrx->rx_free, rxe);
@@ -1338,8 +1342,8 @@ malformed:
 
 /* Process a datagram which was received. */
 static int qrx_process_datagram(OSSL_QRX *qrx, QUIC_URXE *e,
-                                const unsigned char *data,
-                                size_t data_len)
+    const unsigned char *data,
+    size_t data_len)
 {
     int have_deferred = 0;
     PACKET pkt;
@@ -1398,15 +1402,14 @@ static int qrx_process_one_urxe(OSSL_QRX *qrx, QUIC_URXE *e)
      * error.
      */
     was_deferred = qrx_process_datagram(qrx, e, ossl_quic_urxe_data(e),
-                                        e->data_len);
+        e->data_len);
 
     /*
      * Remove the URXE from the pending list and return it to
      * either the free or deferred list.
      */
     ossl_list_urxe_remove(&qrx->urx_pending, e);
-    if (was_deferred > 0 &&
-            (e->deferred || qrx->num_deferred < qrx->max_deferred)) {
+    if (was_deferred > 0 && (e->deferred || qrx->num_deferred < qrx->max_deferred)) {
         ossl_list_urxe_insert_tail(&qrx->urx_deferred, e);
         if (!e->deferred) {
             e->deferred = 1;
@@ -1454,17 +1457,17 @@ int ossl_qrx_read_pkt(OSSL_QRX *qrx, OSSL_QRX_PKT **ppkt)
     assert(rxe->refcount == 0);
     rxe->refcount = 1;
 
-    rxe->pkt.hdr            = &rxe->hdr;
-    rxe->pkt.pn             = rxe->pn;
-    rxe->pkt.time           = rxe->time;
-    rxe->pkt.datagram_len   = rxe->datagram_len;
+    rxe->pkt.hdr = &rxe->hdr;
+    rxe->pkt.pn = rxe->pn;
+    rxe->pkt.time = rxe->time;
+    rxe->pkt.datagram_len = rxe->datagram_len;
     rxe->pkt.peer
         = BIO_ADDR_family(&rxe->peer) != AF_UNSPEC ? &rxe->peer : NULL;
     rxe->pkt.local
         = BIO_ADDR_family(&rxe->local) != AF_UNSPEC ? &rxe->local : NULL;
-    rxe->pkt.key_epoch      = rxe->key_epoch;
-    rxe->pkt.datagram_id    = rxe->datagram_id;
-    rxe->pkt.qrx            = qrx;
+    rxe->pkt.key_epoch = rxe->key_epoch;
+    rxe->pkt.datagram_id = rxe->datagram_id;
+    rxe->pkt.qrx = qrx;
     *ppkt = &rxe->pkt;
 
     return 1;
@@ -1515,27 +1518,27 @@ uint64_t ossl_qrx_get_bytes_received(OSSL_QRX *qrx, int clear)
 }
 
 int ossl_qrx_set_late_validation_cb(OSSL_QRX *qrx,
-                                    ossl_qrx_late_validation_cb *cb,
-                                    void *cb_arg)
+    ossl_qrx_late_validation_cb *cb,
+    void *cb_arg)
 {
-    qrx->validation_cb       = cb;
-    qrx->validation_cb_arg   = cb_arg;
+    qrx->validation_cb = cb;
+    qrx->validation_cb_arg = cb_arg;
     return 1;
 }
 
 int ossl_qrx_set_key_update_cb(OSSL_QRX *qrx,
-                               ossl_qrx_key_update_cb *cb,
-                               void *cb_arg)
+    ossl_qrx_key_update_cb *cb,
+    void *cb_arg)
 {
-    qrx->key_update_cb      = cb;
-    qrx->key_update_cb_arg  = cb_arg;
+    qrx->key_update_cb = cb;
+    qrx->key_update_cb_arg = cb_arg;
     return 1;
 }
 
 uint64_t ossl_qrx_get_key_epoch(OSSL_QRX *qrx)
 {
     OSSL_QRL_ENC_LEVEL *el = ossl_qrl_enc_level_set_get(&qrx->el_set,
-                                                        QUIC_ENC_LEVEL_1RTT, 1);
+        QUIC_ENC_LEVEL_1RTT, 1);
 
     return el == NULL ? UINT64_MAX : el->key_epoch;
 }
@@ -1543,19 +1546,19 @@ uint64_t ossl_qrx_get_key_epoch(OSSL_QRX *qrx)
 int ossl_qrx_key_update_timeout(OSSL_QRX *qrx, int normal)
 {
     OSSL_QRL_ENC_LEVEL *el = ossl_qrl_enc_level_set_get(&qrx->el_set,
-                                                        QUIC_ENC_LEVEL_1RTT, 1);
+        QUIC_ENC_LEVEL_1RTT, 1);
 
     if (el == NULL)
         return 0;
 
     if (el->state == QRL_EL_STATE_PROV_UPDATING
         && !ossl_qrl_enc_level_set_key_update_done(&qrx->el_set,
-                                                   QUIC_ENC_LEVEL_1RTT))
+            QUIC_ENC_LEVEL_1RTT))
         return 0;
 
     if (normal && el->state == QRL_EL_STATE_PROV_COOLDOWN
         && !ossl_qrl_enc_level_set_key_cooldown_done(&qrx->el_set,
-                                                     QUIC_ENC_LEVEL_1RTT))
+            QUIC_ENC_LEVEL_1RTT))
         return 0;
 
     return 1;
@@ -1567,13 +1570,13 @@ uint64_t ossl_qrx_get_cur_forged_pkt_count(OSSL_QRX *qrx)
 }
 
 uint64_t ossl_qrx_get_max_forged_pkt_count(OSSL_QRX *qrx,
-                                           uint32_t enc_level)
+    uint32_t enc_level)
 {
     OSSL_QRL_ENC_LEVEL *el = ossl_qrl_enc_level_set_get(&qrx->el_set,
-                                                        enc_level, 1);
+        enc_level, 1);
 
     return el == NULL ? UINT64_MAX
-        : ossl_qrl_get_suite_max_forged_pkt(el->suite_id);
+                      : ossl_qrl_get_suite_max_forged_pkt(el->suite_id);
 }
 
 void ossl_qrx_allow_1rtt_processing(OSSL_QRX *qrx)
@@ -1586,7 +1589,7 @@ void ossl_qrx_allow_1rtt_processing(OSSL_QRX *qrx)
 }
 
 void ossl_qrx_set_msg_callback(OSSL_QRX *qrx, ossl_msg_cb msg_callback,
-                               SSL *msg_callback_ssl)
+    SSL *msg_callback_ssl)
 {
     qrx->msg_callback = msg_callback;
     qrx->msg_callback_ssl = msg_callback_ssl;
diff --git a/crypto/openssl/ssl/quic/quic_record_shared.c b/crypto/openssl/ssl/quic/quic_record_shared.c
index a3fd51db6dcf..29accf602e59 100644
--- a/crypto/openssl/ssl/quic/quic_record_shared.c
+++ b/crypto/openssl/ssl/quic/quic_record_shared.c
@@ -18,8 +18,8 @@ static const unsigned char quic_v1_ku_label[] = {
 };
 
 OSSL_QRL_ENC_LEVEL *ossl_qrl_enc_level_set_get(OSSL_QRL_ENC_LEVEL_SET *els,
-                                               uint32_t enc_level,
-                                               int require_prov)
+    uint32_t enc_level,
+    int require_prov)
 {
     OSSL_QRL_ENC_LEVEL *el;
 
@@ -30,39 +30,39 @@ OSSL_QRL_ENC_LEVEL *ossl_qrl_enc_level_set_get(OSSL_QRL_ENC_LEVEL_SET *els,
 
     if (require_prov)
         switch (el->state) {
-            case QRL_EL_STATE_PROV_NORMAL:
-            case QRL_EL_STATE_PROV_UPDATING:
-            case QRL_EL_STATE_PROV_COOLDOWN:
-                break;
-            default:
-                return NULL;
+        case QRL_EL_STATE_PROV_NORMAL:
+        case QRL_EL_STATE_PROV_UPDATING:
+        case QRL_EL_STATE_PROV_COOLDOWN:
+            break;
+        default:
+            return NULL;
         }
 
     return el;
 }
 
 int ossl_qrl_enc_level_set_have_el(OSSL_QRL_ENC_LEVEL_SET *els,
-                                  uint32_t enc_level)
+    uint32_t enc_level)
 {
     OSSL_QRL_ENC_LEVEL *el = ossl_qrl_enc_level_set_get(els, enc_level, 0);
 
     switch (el->state) {
-        case QRL_EL_STATE_UNPROV:
-            return 0;
-        case QRL_EL_STATE_PROV_NORMAL:
-        case QRL_EL_STATE_PROV_UPDATING:
-        case QRL_EL_STATE_PROV_COOLDOWN:
-            return 1;
-        default:
-        case QRL_EL_STATE_DISCARDED:
-            return -1;
+    case QRL_EL_STATE_UNPROV:
+        return 0;
+    case QRL_EL_STATE_PROV_NORMAL:
+    case QRL_EL_STATE_PROV_UPDATING:
+    case QRL_EL_STATE_PROV_COOLDOWN:
+        return 1;
+    default:
+    case QRL_EL_STATE_DISCARDED:
+        return -1;
     }
 }
 
 int ossl_qrl_enc_level_set_has_keyslot(OSSL_QRL_ENC_LEVEL_SET *els,
-                                       uint32_t enc_level,
-                                       unsigned char tgt_state,
-                                       size_t keyslot)
+    uint32_t enc_level,
+    unsigned char tgt_state,
+    size_t keyslot)
 {
     OSSL_QRL_ENC_LEVEL *el = ossl_qrl_enc_level_set_get(els, enc_level, 0);
 
@@ -70,20 +70,20 @@ int ossl_qrl_enc_level_set_has_keyslot(OSSL_QRL_ENC_LEVEL_SET *els,
         return 0;
 
     switch (tgt_state) {
-        case QRL_EL_STATE_PROV_NORMAL:
-        case QRL_EL_STATE_PROV_UPDATING:
-            return enc_level == QUIC_ENC_LEVEL_1RTT || keyslot == 0;
-        case QRL_EL_STATE_PROV_COOLDOWN:
-            assert(enc_level == QUIC_ENC_LEVEL_1RTT);
-            return keyslot == (el->key_epoch & 1);
-        default:
-            return 0;
+    case QRL_EL_STATE_PROV_NORMAL:
+    case QRL_EL_STATE_PROV_UPDATING:
+        return enc_level == QUIC_ENC_LEVEL_1RTT || keyslot == 0;
+    case QRL_EL_STATE_PROV_COOLDOWN:
+        assert(enc_level == QUIC_ENC_LEVEL_1RTT);
+        return keyslot == (el->key_epoch & 1);
+    default:
+        return 0;
     }
 }
 
 static void el_teardown_keyslot(OSSL_QRL_ENC_LEVEL_SET *els,
-                                uint32_t enc_level,
-                                size_t keyslot)
+    uint32_t enc_level,
+    size_t keyslot)
 {
     OSSL_QRL_ENC_LEVEL *el = ossl_qrl_enc_level_set_get(els, enc_level, 0);
 
@@ -99,11 +99,11 @@ static void el_teardown_keyslot(OSSL_QRL_ENC_LEVEL_SET *els,
 }
 
 static int el_setup_keyslot(OSSL_QRL_ENC_LEVEL_SET *els,
-                            uint32_t enc_level,
-                            unsigned char tgt_state,
-                            size_t keyslot,
-                            const unsigned char *secret,
-                            size_t secret_len)
+    uint32_t enc_level,
+    unsigned char tgt_state,
+    size_t keyslot,
+    const unsigned char *secret,
+    size_t secret_len)
 {
     OSSL_QRL_ENC_LEVEL *el = ossl_qrl_enc_level_set_get(els, enc_level, 0);
     unsigned char key[EVP_MAX_KEY_LENGTH];
@@ -113,15 +113,15 @@ static int el_setup_keyslot(OSSL_QRL_ENC_LEVEL_SET *els,
     EVP_CIPHER_CTX *cctx = NULL;
 
     if (!ossl_assert(el != NULL
-                     && ossl_qrl_enc_level_set_has_keyslot(els, enc_level,
-                                                           tgt_state, keyslot))) {
+            && ossl_qrl_enc_level_set_has_keyslot(els, enc_level,
+                tgt_state, keyslot))) {
         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
         return 0;
     }
 
     cipher_name = ossl_qrl_get_suite_cipher_name(el->suite_id);
-    iv_len      = ossl_qrl_get_suite_cipher_iv_len(el->suite_id);
-    key_len     = ossl_qrl_get_suite_cipher_key_len(el->suite_id);
+    iv_len = ossl_qrl_get_suite_cipher_iv_len(el->suite_id);
+    key_len = ossl_qrl_get_suite_cipher_key_len(el->suite_id);
     if (cipher_name == NULL) {
         ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
         return 0;
@@ -137,22 +137,22 @@ static int el_setup_keyslot(OSSL_QRL_ENC_LEVEL_SET *els,
 
     /* Derive "quic iv" key. */
     if (!tls13_hkdf_expand_ex(el->libctx, el->propq,
-                              el->md,
-                              secret,
-                              quic_v1_iv_label,
-                              sizeof(quic_v1_iv_label),
-                              NULL, 0,
-                              el->iv[keyslot], iv_len, 1))
+            el->md,
+            secret,
+            quic_v1_iv_label,
+            sizeof(quic_v1_iv_label),
+            NULL, 0,
+            el->iv[keyslot], iv_len, 1))
         goto err;
 
     /* Derive "quic key" key. */
     if (!tls13_hkdf_expand_ex(el->libctx, el->propq,
-                              el->md,
-                              secret,
-                              quic_v1_key_label,
-                              sizeof(quic_v1_key_label),
-                              NULL, 0,
-                              key, key_len, 1))
+            el->md,
+            secret,
+            quic_v1_key_label,
+            sizeof(quic_v1_key_label),
+            NULL, 0,
+            key, key_len, 1))
         goto err;
 
     /* Create and initialise cipher context. */
@@ -185,7 +185,7 @@ static int el_setup_keyslot(OSSL_QRL_ENC_LEVEL_SET *els,
     EVP_CIPHER_free(cipher);
     return 1;
 
- err:
+err:
     EVP_CIPHER_CTX_free(cctx);
     EVP_CIPHER_free(cipher);
     OPENSSL_cleanse(el->iv[keyslot], sizeof(el->iv[keyslot]));
@@ -194,15 +194,15 @@ static int el_setup_keyslot(OSSL_QRL_ENC_LEVEL_SET *els,
 }
 
 int ossl_qrl_enc_level_set_provide_secret(OSSL_QRL_ENC_LEVEL_SET *els,
-                                          OSSL_LIB_CTX *libctx,
-                                          const char *propq,
-                                          uint32_t enc_level,
-                                          uint32_t suite_id,
-                                          EVP_MD *md,
-                                          const unsigned char *secret,
-                                          size_t secret_len,
-                                          unsigned char init_key_phase_bit,
-                                          int is_tx)
+    OSSL_LIB_CTX *libctx,
+    const char *propq,
+    uint32_t enc_level,
+    uint32_t suite_id,
+    EVP_MD *md,
+    const unsigned char *secret,
+    size_t secret_len,
+    unsigned char init_key_phase_bit,
+    int is_tx)
 {
     OSSL_QRL_ENC_LEVEL *el = ossl_qrl_enc_level_set_get(els, enc_level, 0);
     unsigned char ku_key[EVP_MAX_KEY_LENGTH], hpr_key[EVP_MAX_KEY_LENGTH];
@@ -252,28 +252,28 @@ int ossl_qrl_enc_level_set_provide_secret(OSSL_QRL_ENC_LEVEL_SET *els,
         own_md = 1;
     }
 
-    el->libctx      = libctx;
-    el->propq       = propq;
-    el->md          = md;
-    el->suite_id    = suite_id;
-    el->tag_len     = ossl_qrl_get_suite_cipher_tag_len(suite_id);
-    el->op_count    = 0;
-    el->key_epoch   = (uint64_t)init_key_phase_bit;
-    el->is_tx       = (unsigned char)is_tx;
+    el->libctx = libctx;
+    el->propq = propq;
+    el->md = md;
+    el->suite_id = suite_id;
+    el->tag_len = ossl_qrl_get_suite_cipher_tag_len(suite_id);
+    el->op_count = 0;
+    el->key_epoch = (uint64_t)init_key_phase_bit;
+    el->is_tx = (unsigned char)is_tx;
 
     /* Derive "quic hp" key. */
     if (!tls13_hkdf_expand_ex(libctx, propq,
-                              md,
-                              secret,
-                              quic_v1_hp_label,
-                              sizeof(quic_v1_hp_label),
-                              NULL, 0,
-                              hpr_key, hpr_key_len, 1))
+            md,
+            secret,
+            quic_v1_hp_label,
+            sizeof(quic_v1_hp_label),
+            NULL, 0,
+            hpr_key, hpr_key_len, 1))
         goto err;
 
     /* Setup KS0 (or KS1 if init_key_phase_bit), our initial keyslot. */
     if (!el_setup_keyslot(els, enc_level, QRL_EL_STATE_PROV_NORMAL,
-                          init_keyslot, secret, secret_len))
+            init_keyslot, secret, secret_len))
         goto err;
 
     have_ks0 = 1;
@@ -281,39 +281,39 @@ int ossl_qrl_enc_level_set_provide_secret(OSSL_QRL_ENC_LEVEL_SET *els,
     if (enc_level == QUIC_ENC_LEVEL_1RTT) {
         /* Derive "quic ku" key (the epoch 1 secret). */
         if (!tls13_hkdf_expand_ex(libctx, propq,
-                                  md,
-                                  secret,
-                                  quic_v1_ku_label,
-                                  sizeof(quic_v1_ku_label),
-                                  NULL, 0,
-                                  is_tx ? el->ku : ku_key, secret_len, 1))
+                md,
+                secret,
+                quic_v1_ku_label,
+                sizeof(quic_v1_ku_label),
+                NULL, 0,
+                is_tx ? el->ku : ku_key, secret_len, 1))
             goto err;
 
         if (!is_tx) {
             /* Setup KS1 (or KS0 if init_key_phase_bit), our next keyslot. */
             if (!el_setup_keyslot(els, enc_level, QRL_EL_STATE_PROV_NORMAL,
-                                  !init_keyslot, ku_key, secret_len))
+                    !init_keyslot, ku_key, secret_len))
                 goto err;
 
             have_ks1 = 1;
 
             /* Derive NEXT "quic ku" key (the epoch 2 secret). */
             if (!tls13_hkdf_expand_ex(libctx, propq,
-                                      md,
-                                      ku_key,
-                                      quic_v1_ku_label,
-                                      sizeof(quic_v1_ku_label),
-                                      NULL, 0,
-                                      el->ku, secret_len, 1))
+                    md,
+                    ku_key,
+                    quic_v1_ku_label,
+                    sizeof(quic_v1_ku_label),
+                    NULL, 0,
+                    el->ku, secret_len, 1))
                 goto err;
         }
     }
 
     /* Setup header protection context. */
     if (!ossl_quic_hdr_protector_init(&el->hpr,
-                                      libctx, propq,
-                                      ossl_qrl_get_suite_hdr_prot_cipher_id(suite_id),
-                                      hpr_key, hpr_key_len))
+            libctx, propq,
+            ossl_qrl_get_suite_hdr_prot_cipher_id(suite_id),
+            hpr_key, hpr_key_len))
         goto err;
 
     /*
@@ -327,7 +327,7 @@ int ossl_qrl_enc_level_set_provide_secret(OSSL_QRL_ENC_LEVEL_SET *els,
     el->state = QRL_EL_STATE_PROV_NORMAL;
     return 1;
 
- err:
+err:
     el->suite_id = 0;
     el->md = NULL;
     OPENSSL_cleanse(hpr_key, sizeof(hpr_key));
@@ -343,7 +343,7 @@ int ossl_qrl_enc_level_set_provide_secret(OSSL_QRL_ENC_LEVEL_SET *els,
 }
 
 int ossl_qrl_enc_level_set_key_update(OSSL_QRL_ENC_LEVEL_SET *els,
-                                      uint32_t enc_level)
+    uint32_t enc_level)
 {
     OSSL_QRL_ENC_LEVEL *el = ossl_qrl_enc_level_set_get(els, enc_level, 0);
     size_t secret_len;
@@ -376,18 +376,18 @@ int ossl_qrl_enc_level_set_key_update(OSSL_QRL_ENC_LEVEL_SET *els,
 
     /* Derive NEXT "quic ku" key (the epoch n+1 secret). */
     if (!tls13_hkdf_expand_ex(el->libctx, el->propq,
-                              el->md, el->ku,
-                              quic_v1_ku_label,
-                              sizeof(quic_v1_ku_label),
-                              NULL, 0,
-                              new_ku, secret_len, 1))
+            el->md, el->ku,
+            quic_v1_ku_label,
+            sizeof(quic_v1_ku_label),
+            NULL, 0,
+            new_ku, secret_len, 1))
         return 0;
 
     el_teardown_keyslot(els, enc_level, 0);
 
     /* Setup keyslot for CURRENT "quic ku" key. */
     if (!el_setup_keyslot(els, enc_level, QRL_EL_STATE_PROV_NORMAL,
-                          0, el->ku, secret_len))
+            0, el->ku, secret_len))
         return 0;
 
     ++el->key_epoch;
@@ -399,7 +399,7 @@ int ossl_qrl_enc_level_set_key_update(OSSL_QRL_ENC_LEVEL_SET *els,
 
 /* Transitions from PROV_UPDATING to PROV_COOLDOWN. */
 int ossl_qrl_enc_level_set_key_update_done(OSSL_QRL_ENC_LEVEL_SET *els,
-                                           uint32_t enc_level)
+    uint32_t enc_level)
 {
     OSSL_QRL_ENC_LEVEL *el = ossl_qrl_enc_level_set_get(els, enc_level, 0);
 
@@ -419,7 +419,7 @@ int ossl_qrl_enc_level_set_key_update_done(OSSL_QRL_ENC_LEVEL_SET *els,
  * auto-transitions to PROV_COOLDOWN first.)
  */
 int ossl_qrl_enc_level_set_key_cooldown_done(OSSL_QRL_ENC_LEVEL_SET *els,
-                                             uint32_t enc_level)
+    uint32_t enc_level)
 {
     OSSL_QRL_ENC_LEVEL *el = ossl_qrl_enc_level_set_get(els, enc_level, 0);
     size_t secret_len;
@@ -444,17 +444,17 @@ int ossl_qrl_enc_level_set_key_cooldown_done(OSSL_QRL_ENC_LEVEL_SET *els,
     secret_len = ossl_qrl_get_suite_secret_len(el->suite_id);
 
     if (!el_setup_keyslot(els, enc_level, QRL_EL_STATE_PROV_NORMAL,
-                          ~el->key_epoch & 1, el->ku, secret_len))
+            ~el->key_epoch & 1, el->ku, secret_len))
         return 0;
 
     /* Derive NEXT "quic ku" key (the epoch n+1 secret). */
     if (!tls13_hkdf_expand_ex(el->libctx, el->propq,
-                              el->md,
-                              el->ku,
-                              quic_v1_ku_label,
-                              sizeof(quic_v1_ku_label),
-                              NULL, 0,
-                              new_ku, secret_len, 1)) {
+            el->md,
+            el->ku,
+            quic_v1_ku_label,
+            sizeof(quic_v1_ku_label),
+            NULL, 0,
+            new_ku, secret_len, 1)) {
         el_teardown_keyslot(els, enc_level, ~el->key_epoch & 1);
         return 0;
     }
@@ -469,7 +469,7 @@ int ossl_qrl_enc_level_set_key_cooldown_done(OSSL_QRL_ENC_LEVEL_SET *els,
  * state to DISCARDED.
  */
 void ossl_qrl_enc_level_set_discard(OSSL_QRL_ENC_LEVEL_SET *els,
-                                    uint32_t enc_level)
+    uint32_t enc_level)
 {
     OSSL_QRL_ENC_LEVEL *el = ossl_qrl_enc_level_set_get(els, enc_level, 0);
 
@@ -484,6 +484,6 @@ void ossl_qrl_enc_level_set_discard(OSSL_QRL_ENC_LEVEL_SET *els,
     }
 
     EVP_MD_free(el->md);
-    el->md      = NULL;
-    el->state   = QRL_EL_STATE_DISCARDED;
+    el->md = NULL;
+    el->state = QRL_EL_STATE_DISCARDED;
 }
diff --git a/crypto/openssl/ssl/quic/quic_record_shared.h b/crypto/openssl/ssl/quic/quic_record_shared.h
index e8c9e28e92a4..ba9571f450fe 100644
--- a/crypto/openssl/ssl/quic/quic_record_shared.h
+++ b/crypto/openssl/ssl/quic/quic_record_shared.h
@@ -8,11 +8,11 @@
  */
 
 #ifndef OSSL_QUIC_RECORD_SHARED_H
-# define OSSL_QUIC_RECORD_SHARED_H
+#define OSSL_QUIC_RECORD_SHARED_H
 
-# include <openssl/ssl.h>
-# include "internal/quic_types.h"
-# include "internal/quic_wire_pkt.h"
+#include <openssl/ssl.h>
+#include "internal/quic_types.h"
+#include "internal/quic_wire_pkt.h"
 
 /*
  * QUIC Record Layer EL Management Utilities
@@ -29,27 +29,27 @@
  *
  * Key material is available if in the Provisioned state.
  */
-#define QRL_EL_STATE_UNPROV         0   /* Unprovisioned (initial state) */
-#define QRL_EL_STATE_PROV_NORMAL    1   /* Provisioned - Normal */
-#define QRL_EL_STATE_PROV_UPDATING  2   /* Provisioned - Updating */
-#define QRL_EL_STATE_PROV_COOLDOWN  3   /* Provisioned - Cooldown */
-#define QRL_EL_STATE_DISCARDED      4   /* Discarded (terminal state) */
+#define QRL_EL_STATE_UNPROV 0 /* Unprovisioned (initial state) */
+#define QRL_EL_STATE_PROV_NORMAL 1 /* Provisioned - Normal */
+#define QRL_EL_STATE_PROV_UPDATING 2 /* Provisioned - Updating */
+#define QRL_EL_STATE_PROV_COOLDOWN 3 /* Provisioned - Cooldown */
+#define QRL_EL_STATE_DISCARDED 4 /* Discarded (terminal state) */
 
 typedef struct ossl_qrl_enc_level_st {
     /*
      * Cryptographic context used to apply and remove header protection from
      * packet headers.
      */
-    QUIC_HDR_PROTECTOR          hpr;
+    QUIC_HDR_PROTECTOR hpr;
 
     /* Hash function used for key derivation. */
-    EVP_MD                     *md;
+    EVP_MD *md;
 
     /* Context used for packet body ciphering. One for each keyslot. */
-    EVP_CIPHER_CTX             *cctx[2];
+    EVP_CIPHER_CTX *cctx[2];
 
-    OSSL_LIB_CTX               *libctx;
-    const char                 *propq;
+    OSSL_LIB_CTX *libctx;
+    const char *propq;
 
     /*
      * Key epoch, essentially the number of times we have done a key update.
@@ -57,30 +57,30 @@ typedef struct ossl_qrl_enc_level_st {
      * The least significant bit of this is therefore by definition the current
      * Key Phase bit value.
      */
-    uint64_t                    key_epoch;
+    uint64_t key_epoch;
 
     /* Usage counter. The caller maintains this. Used by TX side only. */
-    uint64_t                    op_count;
+    uint64_t op_count;
 
     /* QRL_SUITE_* value. */
-    uint32_t                    suite_id;
+    uint32_t suite_id;
 
     /* Length of authentication tag. */
-    uint32_t                    tag_len;
+    uint32_t tag_len;
 
     /* Current EL state. */
-    unsigned char               state; /* QRL_EL_STATE_* */
+    unsigned char state; /* QRL_EL_STATE_* */
 
     /* 1 if for TX, else RX. Initialised when secret provided. */
-    unsigned char               is_tx;
+    unsigned char is_tx;
 
     /* IV used to construct nonces used for AEAD packet body ciphering. */
-    unsigned char               iv[2][EVP_MAX_IV_LENGTH];
+    unsigned char iv[2][EVP_MAX_IV_LENGTH];
 
     /*
      * Secret for next key epoch.
      */
-    unsigned char               ku[EVP_MAX_KEY_LENGTH];
+    unsigned char ku[EVP_MAX_KEY_LENGTH];
 } OSSL_QRL_ENC_LEVEL;
 
 typedef struct ossl_qrl_enc_level_set_st {
@@ -94,7 +94,7 @@ typedef struct ossl_qrl_enc_level_set_st {
  * DISCARDED state).
  */
 int ossl_qrl_enc_level_set_have_el(OSSL_QRL_ENC_LEVEL_SET *els,
-                                   uint32_t enc_level);
+    uint32_t enc_level);
 
 /*
  * Returns EL in a set. If enc_level is not a valid QUIC_ENC_LEVEL_* value,
@@ -102,49 +102,49 @@ int ossl_qrl_enc_level_set_have_el(OSSL_QRL_ENC_LEVEL_SET *els,
  * the PROVISIONED state; otherwise, the returned EL may be in any state.
  */
 OSSL_QRL_ENC_LEVEL *ossl_qrl_enc_level_set_get(OSSL_QRL_ENC_LEVEL_SET *els,
-                                               uint32_t enc_level,
-                                               int require_prov);
+    uint32_t enc_level,
+    int require_prov);
 
 /* Provide secret to an EL. md may be NULL. */
 int ossl_qrl_enc_level_set_provide_secret(OSSL_QRL_ENC_LEVEL_SET *els,
-                                          OSSL_LIB_CTX *libctx,
-                                          const char *propq,
-                                          uint32_t enc_level,
-                                          uint32_t suite_id,
-                                          EVP_MD *md,
-                                          const unsigned char *secret,
-                                          size_t secret_len,
-                                          unsigned char init_key_phase_bit,
-                                          int is_tx);
+    OSSL_LIB_CTX *libctx,
+    const char *propq,
+    uint32_t enc_level,
+    uint32_t suite_id,
+    EVP_MD *md,
+    const unsigned char *secret,
+    size_t secret_len,
+    unsigned char init_key_phase_bit,
+    int is_tx);
 
 /*
  * Returns 1 if the given keyslot index is currently valid for a given EL and EL
  * state.
  */
 int ossl_qrl_enc_level_set_has_keyslot(OSSL_QRL_ENC_LEVEL_SET *els,
-                                       uint32_t enc_level,
-                                       unsigned char tgt_state,
-                                       size_t keyslot);
+    uint32_t enc_level,
+    unsigned char tgt_state,
+    size_t keyslot);
 
 /* Perform a key update. Transitions from PROV_NORMAL to PROV_UPDATING. */
 int ossl_qrl_enc_level_set_key_update(OSSL_QRL_ENC_LEVEL_SET *els,
-                                      uint32_t enc_level);
+    uint32_t enc_level);
 
 /* Transitions from PROV_UPDATING to PROV_COOLDOWN. */
 int ossl_qrl_enc_level_set_key_update_done(OSSL_QRL_ENC_LEVEL_SET *els,
-                                           uint32_t enc_level);
+    uint32_t enc_level);
 
 /*
  * Transitions from PROV_COOLDOWN to PROV_NORMAL. (If in PROV_UPDATING,
  * auto-transitions to PROV_COOLDOWN first.)
  */
 int ossl_qrl_enc_level_set_key_cooldown_done(OSSL_QRL_ENC_LEVEL_SET *els,
-                                             uint32_t enc_level);
+    uint32_t enc_level);
 
 /*
  * Discard an EL. No secret can be provided for the EL ever again.
  */
 void ossl_qrl_enc_level_set_discard(OSSL_QRL_ENC_LEVEL_SET *els,
-                                    uint32_t enc_level);
+    uint32_t enc_level);
 
 #endif
diff --git a/crypto/openssl/ssl/quic/quic_record_tx.c b/crypto/openssl/ssl/quic/quic_record_tx.c
index ae37353a9b26..28158ae03895 100644
--- a/crypto/openssl/ssl/quic/quic_record_tx.c
+++ b/crypto/openssl/ssl/quic/quic_record_tx.c
@@ -25,13 +25,13 @@ typedef struct txe_st TXE;
 
 struct txe_st {
     OSSL_LIST_MEMBER(txe, TXE);
-    size_t              data_len, alloc_len;
+    size_t data_len, alloc_len;
 
     /*
      * Destination and local addresses, as applicable. Both of these are only
      * used if the family is not AF_UNSPEC.
      */
-    BIO_ADDR            peer, local;
+    BIO_ADDR peer, local;
 
     /*
      * alloc_len allocated bytes (of which data_len bytes are valid) follow this
@@ -52,52 +52,52 @@ static ossl_inline unsigned char *txe_data(const TXE *e)
  * ===
  */
 struct ossl_qtx_st {
-    OSSL_LIB_CTX               *libctx;
-    const char                 *propq;
+    OSSL_LIB_CTX *libctx;
+    const char *propq;
 
     /* Per encryption-level state. */
-    OSSL_QRL_ENC_LEVEL_SET      el_set;
+    OSSL_QRL_ENC_LEVEL_SET el_set;
 
     /* TX BIO. */
-    BIO                        *bio;
+    BIO *bio;
 
     /* QLOG instance retrieval callback if in use, or NULL. */
-    QLOG                     *(*get_qlog_cb)(void *arg);
-    void                       *get_qlog_cb_arg;
+    QLOG *(*get_qlog_cb)(void *arg);
+    void *get_qlog_cb_arg;
 
     /* TX maximum datagram payload length. */
-    size_t                      mdpl;
+    size_t mdpl;
 
     /*
      * List of TXEs which are not currently in use. These are moved to the
      * pending list (possibly via tx_cons first) as they are filled.
      */
-    TXE_LIST                    free;
+    TXE_LIST free;
 
     /*
      * List of TXEs which are filled with completed datagrams ready to be
      * transmitted.
      */
-    TXE_LIST                    pending;
-    size_t                      pending_count; /* items in list */
-    size_t                      pending_bytes; /* sum(txe->data_len) in pending */
+    TXE_LIST pending;
+    size_t pending_count; /* items in list */
+    size_t pending_bytes; /* sum(txe->data_len) in pending */
 
     /*
      * TXE which is under construction for coalescing purposes, if any.
      * This TXE is neither on the free nor pending list. Once the datagram
      * is completed, it is moved to the pending list.
      */
-    TXE                        *cons;
-    size_t                      cons_count; /* num packets */
+    TXE *cons;
+    size_t cons_count; /* num packets */
 
     /*
      * Number of packets transmitted in this key epoch. Used to enforce AEAD
      * confidentiality limit.
      */
-    uint64_t                    epoch_pkt_count;
+    uint64_t epoch_pkt_count;
 
     /* Datagram counter. Increases monotonically per datagram (not per packet). */
-    uint64_t                    datagram_count;
+    uint64_t datagram_count;
 
     ossl_mutate_packet_cb mutatecb;
     ossl_finish_mutate_cb finishmutatecb;
@@ -121,12 +121,12 @@ OSSL_QTX *ossl_qtx_new(const OSSL_QTX_ARGS *args)
     if (qtx == NULL)
         return 0;
 
-    qtx->libctx             = args->libctx;
-    qtx->propq              = args->propq;
-    qtx->bio                = args->bio;
-    qtx->mdpl               = args->mdpl;
-    qtx->get_qlog_cb        = args->get_qlog_cb;
-    qtx->get_qlog_cb_arg    = args->get_qlog_cb_arg;
+    qtx->libctx = args->libctx;
+    qtx->propq = args->propq;
+    qtx->bio = args->bio;
+    qtx->mdpl = args->mdpl;
+    qtx->get_qlog_cb = args->get_qlog_cb;
+    qtx->get_qlog_cb_arg = args->get_qlog_cb_arg;
 
     return qtx;
 }
@@ -163,40 +163,40 @@ void ossl_qtx_free(OSSL_QTX *qtx)
 
 /* Set mutator callbacks for test framework support */
 void ossl_qtx_set_mutator(OSSL_QTX *qtx, ossl_mutate_packet_cb mutatecb,
-                          ossl_finish_mutate_cb finishmutatecb, void *mutatearg)
+    ossl_finish_mutate_cb finishmutatecb, void *mutatearg)
 {
-    qtx->mutatecb       = mutatecb;
+    qtx->mutatecb = mutatecb;
     qtx->finishmutatecb = finishmutatecb;
-    qtx->mutatearg      = mutatearg;
+    qtx->mutatearg = mutatearg;
 }
 
 void ossl_qtx_set_qlog_cb(OSSL_QTX *qtx, QLOG *(*get_qlog_cb)(void *arg),
-                          void *get_qlog_cb_arg)
+    void *get_qlog_cb_arg)
 {
-    qtx->get_qlog_cb        = get_qlog_cb;
-    qtx->get_qlog_cb_arg    = get_qlog_cb_arg;
+    qtx->get_qlog_cb = get_qlog_cb;
+    qtx->get_qlog_cb_arg = get_qlog_cb_arg;
 }
 
-int ossl_qtx_provide_secret(OSSL_QTX              *qtx,
-                            uint32_t               enc_level,
-                            uint32_t               suite_id,
-                            EVP_MD                *md,
-                            const unsigned char   *secret,
-                            size_t                 secret_len)
+int ossl_qtx_provide_secret(OSSL_QTX *qtx,
+    uint32_t enc_level,
+    uint32_t suite_id,
+    EVP_MD *md,
+    const unsigned char *secret,
+    size_t secret_len)
 {
     if (enc_level >= QUIC_ENC_LEVEL_NUM)
         return 0;
 
     return ossl_qrl_enc_level_set_provide_secret(&qtx->el_set,
-                                                 qtx->libctx,
-                                                 qtx->propq,
-                                                 enc_level,
-                                                 suite_id,
-                                                 md,
-                                                 secret,
-                                                 secret_len,
-                                                 0,
-                                                 /*is_tx=*/1);
+        qtx->libctx,
+        qtx->propq,
+        enc_level,
+        suite_id,
+        md,
+        secret,
+        secret_len,
+        0,
+        /*is_tx=*/1);
 }
 
 int ossl_qtx_discard_enc_level(OSSL_QTX *qtx, uint32_t enc_level)
@@ -304,7 +304,7 @@ static TXE *qtx_resize_txe(OSSL_QTX *qtx, TXE_LIST *txl, TXE *txe, size_t n)
  * Returns NULL on failure.
  */
 static TXE *qtx_reserve_txe(OSSL_QTX *qtx, TXE_LIST *txl,
-                            TXE *txe, size_t n)
+    TXE *txe, size_t n)
 {
     if (txe->alloc_len >= n)
         return txe;
@@ -334,11 +334,11 @@ static void qtx_add_to_pending(OSSL_QTX *qtx, TXE *txe)
 
 struct iovec_cur {
     const OSSL_QTX_IOVEC *iovec;
-    size_t                num_iovec, idx, byte_off, bytes_remaining;
+    size_t num_iovec, idx, byte_off, bytes_remaining;
 };
 
 static size_t iovec_total_bytes(const OSSL_QTX_IOVEC *iovec,
-                                size_t num_iovec)
+    size_t num_iovec)
 {
     size_t i, l = 0;
 
@@ -349,14 +349,14 @@ static size_t iovec_total_bytes(const OSSL_QTX_IOVEC *iovec,
 }
 
 static void iovec_cur_init(struct iovec_cur *cur,
-                           const OSSL_QTX_IOVEC *iovec,
-                           size_t num_iovec)
+    const OSSL_QTX_IOVEC *iovec,
+    size_t num_iovec)
 {
-    cur->iovec              = iovec;
-    cur->num_iovec          = num_iovec;
-    cur->idx                = 0;
-    cur->byte_off           = 0;
-    cur->bytes_remaining    = iovec_total_bytes(iovec, num_iovec);
+    cur->iovec = iovec;
+    cur->num_iovec = num_iovec;
+    cur->idx = 0;
+    cur->byte_off = 0;
+    cur->bytes_remaining = iovec_total_bytes(iovec, num_iovec);
 }
 
 /*
@@ -366,8 +366,8 @@ static void iovec_cur_init(struct iovec_cur *cur,
  * available, returns 0.
  */
 static size_t iovec_cur_get_buffer(struct iovec_cur *cur,
-                                   const unsigned char **buf,
-                                   size_t max_buf_len)
+    const unsigned char **buf,
+    size_t max_buf_len)
 {
     size_t l;
 
@@ -402,8 +402,8 @@ static size_t iovec_cur_get_buffer(struct iovec_cur *cur,
 
 /* Determines the size of the AEAD output given the input size. */
 int ossl_qtx_calculate_ciphertext_payload_len(OSSL_QTX *qtx, uint32_t enc_level,
-                                              size_t plaintext_len,
-                                              size_t *ciphertext_len)
+    size_t plaintext_len,
+    size_t *ciphertext_len)
 {
     OSSL_QRL_ENC_LEVEL *el
         = ossl_qrl_enc_level_set_get(&qtx->el_set, enc_level, 1);
@@ -426,8 +426,8 @@ int ossl_qtx_calculate_ciphertext_payload_len(OSSL_QTX *qtx, uint32_t enc_level,
 
 /* Determines the size of the AEAD input given the output size. */
 int ossl_qtx_calculate_plaintext_payload_len(OSSL_QTX *qtx, uint32_t enc_level,
-                                             size_t ciphertext_len,
-                                             size_t *plaintext_len)
+    size_t ciphertext_len,
+    size_t *plaintext_len)
 {
     OSSL_QRL_ENC_LEVEL *el
         = ossl_qrl_enc_level_set_get(&qtx->el_set, enc_level, 1);
@@ -450,16 +450,16 @@ int ossl_qtx_calculate_plaintext_payload_len(OSSL_QTX *qtx, uint32_t enc_level,
 }
 
 /* Any other error (including packet being too big for MDPL). */
-#define QTX_FAIL_GENERIC            (-1)
+#define QTX_FAIL_GENERIC (-1)
 
 /*
  * Returned where there is insufficient room in the datagram to write the
  * packet.
  */
-#define QTX_FAIL_INSUFFICIENT_LEN   (-2)
+#define QTX_FAIL_INSUFFICIENT_LEN (-2)
 
 static int qtx_write_hdr(OSSL_QTX *qtx, const QUIC_PKT_HDR *hdr, TXE *txe,
-                         QUIC_PKT_HDR_PTRS *ptrs)
+    QUIC_PKT_HDR_PTRS *ptrs)
 {
     WPACKET wpkt;
     size_t l = 0;
@@ -469,7 +469,7 @@ static int qtx_write_hdr(OSSL_QTX *qtx, const QUIC_PKT_HDR *hdr, TXE *txe,
         return 0;
 
     if (!ossl_quic_wire_encode_pkt_hdr(&wpkt, hdr->dst_conn_id.id_len,
-                                       hdr, ptrs)
+            hdr, ptrs)
         || !WPACKET_get_total_written(&wpkt, &l)) {
         WPACKET_finish(&wpkt);
         return 0;
@@ -478,7 +478,7 @@ static int qtx_write_hdr(OSSL_QTX *qtx, const QUIC_PKT_HDR *hdr, TXE *txe,
 
     if (qtx->msg_callback != NULL)
         qtx->msg_callback(1, OSSL_QUIC1_VERSION, SSL3_RT_QUIC_PACKET, data, l,
-                          qtx->msg_callback_ssl, qtx->msg_callback_arg);
+            qtx->msg_callback_ssl, qtx->msg_callback_arg);
 
     txe->data_len += l;
 
@@ -486,9 +486,9 @@ static int qtx_write_hdr(OSSL_QTX *qtx, const QUIC_PKT_HDR *hdr, TXE *txe,
 }
 
 static int qtx_encrypt_into_txe(OSSL_QTX *qtx, struct iovec_cur *cur, TXE *txe,
-                                uint32_t enc_level, QUIC_PN pn,
-                                const unsigned char *hdr, size_t hdr_len,
-                                QUIC_PKT_HDR_PTRS *ptrs)
+    uint32_t enc_level, QUIC_PN pn,
+    const unsigned char *hdr, size_t hdr_len,
+    QUIC_PKT_HDR_PTRS *ptrs)
 {
     int l = 0, l2 = 0, nonce_len;
     OSSL_QRL_ENC_LEVEL *el
@@ -556,7 +556,8 @@ static int qtx_encrypt_into_txe(OSSL_QTX *qtx, struct iovec_cur *cur, TXE *txe,
             break;
 
         if (EVP_CipherUpdate(cctx, txe_data(txe) + txe->data_len,
-                             &l, src, src_len) != 1) {
+                &l, src, src_len)
+            != 1) {
             ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
             return 0;
         }
@@ -577,7 +578,8 @@ static int qtx_encrypt_into_txe(OSSL_QTX *qtx, struct iovec_cur *cur, TXE *txe,
     }
 
     if (EVP_CIPHER_CTX_ctrl(cctx, EVP_CTRL_AEAD_GET_TAG,
-                            el->tag_len, txe_data(txe) + txe->data_len) != 1) {
+            el->tag_len, txe_data(txe) + txe->data_len)
+        != 1) {
         ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
         return 0;
     }
@@ -597,8 +599,8 @@ static int qtx_encrypt_into_txe(OSSL_QTX *qtx, struct iovec_cur *cur, TXE *txe,
  * process.
  */
 static int qtx_write(OSSL_QTX *qtx, const OSSL_QTX_PKT *pkt, TXE *txe,
-                     uint32_t enc_level, QUIC_PKT_HDR *hdr,
-                     const OSSL_QTX_IOVEC *iovec, size_t num_iovec)
+    uint32_t enc_level, QUIC_PKT_HDR *hdr,
+    const OSSL_QTX_IOVEC *iovec, size_t num_iovec)
 {
     int ret, needs_encrypt;
     size_t hdr_len, pred_hdr_len, payload_len, pkt_len, space_left;
@@ -647,16 +649,16 @@ static int qtx_write(OSSL_QTX *qtx, const OSSL_QTX_PKT *pkt, TXE *txe,
     /* Determine encrypted payload length. */
     if (needs_encrypt)
         ossl_qtx_calculate_ciphertext_payload_len(qtx, enc_level,
-                                                  cur.bytes_remaining,
-                                                  &payload_len);
+            cur.bytes_remaining,
+            &payload_len);
     else
         payload_len = cur.bytes_remaining;
 
     /* Determine header length. */
-    hdr->data  = NULL;
-    hdr->len   = payload_len;
+    hdr->data = NULL;
+    hdr->len = payload_len;
     pred_hdr_len = ossl_quic_wire_get_encoded_pkt_hdr_len(hdr->dst_conn_id.id_len,
-                                                          hdr);
+        hdr);
     if (pred_hdr_len == 0) {
         ret = QTX_FAIL_GENERIC;
         goto err;
@@ -672,8 +674,8 @@ static int qtx_write(OSSL_QTX *qtx, const OSSL_QTX_PKT *pkt, TXE *txe,
 
     if (ossl_quic_pkt_type_has_pn(hdr->type)) {
         if (!ossl_quic_wire_encode_pkt_hdr_pn(pkt->pn,
-                                              hdr->pn,
-                                              hdr->pn_len)) {
+                hdr->pn,
+                hdr->pn_len)) {
             ret = QTX_FAIL_GENERIC;
             goto err;
         }
@@ -706,7 +708,7 @@ static int qtx_write(OSSL_QTX *qtx, const OSSL_QTX_PKT *pkt, TXE *txe,
     } else {
         /* Encrypt into TXE. */
         if (!qtx_encrypt_into_txe(qtx, &cur, txe, enc_level, pkt->pn,
-                                  hdr_start, hdr_len, &ptrs)) {
+                hdr_start, hdr_len, &ptrs)) {
             ret = QTX_FAIL_GENERIC;
             goto err;
         }
@@ -752,7 +754,7 @@ static QLOG *qtx_get_qlog(OSSL_QTX *qtx)
 }
 
 static int qtx_mutate_write(OSSL_QTX *qtx, const OSSL_QTX_PKT *pkt, TXE *txe,
-                            uint32_t enc_level)
+    uint32_t enc_level)
 {
     int ret;
     QUIC_PKT_HDR *hdr;
@@ -762,20 +764,20 @@ static int qtx_mutate_write(OSSL_QTX *qtx, const OSSL_QTX_PKT *pkt, TXE *txe,
     /* If we are running tests then mutate_packet may be non NULL */
     if (qtx->mutatecb != NULL) {
         if (!qtx->mutatecb(pkt->hdr, pkt->iovec, pkt->num_iovec, &hdr,
-                           &iovec, &num_iovec, qtx->mutatearg))
+                &iovec, &num_iovec, qtx->mutatearg))
             return QTX_FAIL_GENERIC;
     } else {
-        hdr         = pkt->hdr;
-        iovec       = pkt->iovec;
-        num_iovec   = pkt->num_iovec;
+        hdr = pkt->hdr;
+        iovec = pkt->iovec;
+        num_iovec = pkt->num_iovec;
     }
 
     ret = qtx_write(qtx, pkt, txe, enc_level,
-                    hdr, iovec, num_iovec);
+        hdr, iovec, num_iovec);
     if (ret == 1)
         ossl_qlog_event_transport_packet_sent(qtx_get_qlog(qtx), hdr, pkt->pn,
-                                              iovec, num_iovec,
-                                              qtx->datagram_count);
+            iovec, num_iovec,
+            qtx->datagram_count);
 
     if (qtx->finishmutatecb != NULL)
         qtx->finishmutatecb(qtx->mutatearg);
@@ -786,7 +788,7 @@ static int qtx_mutate_write(OSSL_QTX *qtx, const OSSL_QTX_PKT *pkt, TXE *txe,
 static int addr_eq(const BIO_ADDR *a, const BIO_ADDR *b)
 {
     return ((a == NULL || BIO_ADDR_family(a) == AF_UNSPEC)
-            && (b == NULL || BIO_ADDR_family(b) == AF_UNSPEC))
+               && (b == NULL || BIO_ADDR_family(b) == AF_UNSPEC))
         || (a != NULL && b != NULL && memcmp(a, b, sizeof(*a)) == 0);
 }
 
@@ -808,7 +810,7 @@ int ossl_qtx_write_pkt(OSSL_QTX *qtx, const OSSL_QTX_PKT *pkt)
     if (!ossl_quic_pkt_type_can_share_dgram(pkt->hdr->type))
         ossl_qtx_finish_dgram(qtx);
     else if (enc_level >= QUIC_ENC_LEVEL_NUM
-               || ossl_qrl_enc_level_set_have_el(&qtx->el_set, enc_level) != 1) {
+        || ossl_qrl_enc_level_set_have_el(&qtx->el_set, enc_level) != 1) {
         /* All other packet types are encrypted. */
         return 0;
     }
@@ -915,23 +917,23 @@ void ossl_qtx_finish_dgram(OSSL_QTX *qtx)
     else
         qtx_add_to_pending(qtx, txe);
 
-    qtx->cons       = NULL;
+    qtx->cons = NULL;
     qtx->cons_count = 0;
     ++qtx->datagram_count;
 }
 
 static void txe_to_msg(TXE *txe, BIO_MSG *msg)
 {
-    msg->data       = txe_data(txe);
-    msg->data_len   = txe->data_len;
-    msg->flags      = 0;
+    msg->data = txe_data(txe);
+    msg->data_len = txe->data_len;
+    msg->flags = 0;
     msg->peer
         = BIO_ADDR_family(&txe->peer) != AF_UNSPEC ? &txe->peer : NULL;
     msg->local
         = BIO_ADDR_family(&txe->local) != AF_UNSPEC ? &txe->local : NULL;
 }
 
-#define MAX_MSGS_PER_SEND   32
+#define MAX_MSGS_PER_SEND 32
 
 int ossl_qtx_flush_net(OSSL_QTX *qtx)
 {
@@ -948,8 +950,8 @@ int ossl_qtx_flush_net(OSSL_QTX *qtx)
 
     for (;;) {
         for (txe = ossl_list_txe_head(&qtx->pending), i = 0;
-             txe != NULL && i < OSSL_NELEM(msg);
-             txe = ossl_list_txe_next(txe), ++i)
+            txe != NULL && i < OSSL_NELEM(msg);
+            txe = ossl_list_txe_next(txe), ++i)
             txe_to_msg(txe, &msg[i]);
 
         if (!i)
@@ -988,9 +990,9 @@ int ossl_qtx_flush_net(OSSL_QTX *qtx)
         for (i = 0; i < wr; ++i) {
             if (qtx->msg_callback != NULL)
                 qtx->msg_callback(1, OSSL_QUIC1_VERSION, SSL3_RT_QUIC_DATAGRAM,
-                                msg[i].data, msg[i].data_len,
-                                qtx->msg_callback_ssl,
-                                qtx->msg_callback_arg);
+                    msg[i].data, msg[i].data_len,
+                    qtx->msg_callback_ssl,
+                    qtx->msg_callback_arg);
             qtx_pending_to_free(qtx);
         }
 
@@ -1056,7 +1058,7 @@ size_t ossl_qtx_get_unflushed_pkt_count(OSSL_QTX *qtx)
 int ossl_qtx_trigger_key_update(OSSL_QTX *qtx)
 {
     return ossl_qrl_enc_level_set_key_update(&qtx->el_set,
-                                             QUIC_ENC_LEVEL_1RTT);
+        QUIC_ENC_LEVEL_1RTT);
 }
 
 uint64_t ossl_qtx_get_cur_epoch_pkt_count(OSSL_QTX *qtx, uint32_t enc_level)
@@ -1082,7 +1084,7 @@ uint64_t ossl_qtx_get_max_epoch_pkt_count(OSSL_QTX *qtx, uint32_t enc_level)
 }
 
 void ossl_qtx_set_msg_callback(OSSL_QTX *qtx, ossl_msg_cb msg_callback,
-                               SSL *msg_callback_ssl)
+    SSL *msg_callback_ssl)
 {
     qtx->msg_callback = msg_callback;
     qtx->msg_callback_ssl = msg_callback_ssl;
diff --git a/crypto/openssl/ssl/quic/quic_record_util.c b/crypto/openssl/ssl/quic/quic_record_util.c
index d7c3cece888d..61b67a21503f 100644
--- a/crypto/openssl/ssl/quic/quic_record_util.c
+++ b/crypto/openssl/ssl/quic/quic_record_util.c
@@ -20,11 +20,11 @@
  * =============================
  */
 int ossl_quic_hkdf_extract(OSSL_LIB_CTX *libctx,
-                           const char *propq,
-                           const EVP_MD *md,
-                           const unsigned char *salt, size_t salt_len,
-                           const unsigned char *ikm, size_t ikm_len,
-                           unsigned char *out, size_t out_len)
+    const char *propq,
+    const EVP_MD *md,
+    const unsigned char *salt, size_t salt_len,
+    const unsigned char *ikm, size_t ikm_len,
+    unsigned char *out, size_t out_len)
 {
     int ret = 0;
     EVP_KDF *kdf = NULL;
@@ -44,17 +44,17 @@ int ossl_quic_hkdf_extract(OSSL_LIB_CTX *libctx,
      * at least 8 bytes. It means that the length of destination connection ID
      * may be less than the minimum length for HKDF required by FIPS provider.
      *
-     * Therefore, we need to set `key-check` to zero to allow using destionation
+     * Therefore, we need to set `key-check` to zero to allow using destination
      * connection ID as IKM.
      */
     *p++ = OSSL_PARAM_construct_int(OSSL_KDF_PARAM_FIPS_KEY_CHECK, &key_check);
     *p++ = OSSL_PARAM_construct_int(OSSL_KDF_PARAM_MODE, &mode);
     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST,
-                                            (char *)md_name, 0);
+        (char *)md_name, 0);
     *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SALT,
-                                             (unsigned char *)salt, salt_len);
+        (unsigned char *)salt, salt_len);
     *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY,
-                                             (unsigned char *)ikm, ikm_len);
+        (unsigned char *)ikm, ikm_len);
     *p++ = OSSL_PARAM_construct_end();
 
     ret = EVP_KDF_derive(kctx, out, out_len, params);
@@ -80,11 +80,11 @@ static const unsigned char quic_v1_initial_salt[] = {
 };
 
 int ossl_quic_provide_initial_secret(OSSL_LIB_CTX *libctx,
-                                     const char *propq,
-                                     const QUIC_CONN_ID *dst_conn_id,
-                                     int is_server,
-                                     struct ossl_qrx_st *qrx,
-                                     struct ossl_qtx_st *qtx)
+    const char *propq,
+    const QUIC_CONN_ID *dst_conn_id,
+    int is_server,
+    struct ossl_qrx_st *qrx,
+    struct ossl_qtx_st *qtx)
 {
     unsigned char initial_secret[32];
     unsigned char client_initial_secret[32], server_initial_secret[32];
@@ -108,48 +108,48 @@ int ossl_quic_provide_initial_secret(OSSL_LIB_CTX *libctx,
 
     /* Derive initial secret from destination connection ID. */
     if (!ossl_quic_hkdf_extract(libctx, propq,
-                                sha256,
-                                quic_v1_initial_salt,
-                                sizeof(quic_v1_initial_salt),
-                                dst_conn_id->id,
-                                dst_conn_id->id_len,
-                                initial_secret,
-                                sizeof(initial_secret)))
+            sha256,
+            quic_v1_initial_salt,
+            sizeof(quic_v1_initial_salt),
+            dst_conn_id->id,
+            dst_conn_id->id_len,
+            initial_secret,
+            sizeof(initial_secret)))
         goto err;
 
     /* Derive "client in" secret. */
     if (((qtx != NULL && tx_secret == client_initial_secret)
-         || (qrx != NULL && rx_secret == client_initial_secret))
+            || (qrx != NULL && rx_secret == client_initial_secret))
         && !tls13_hkdf_expand_ex(libctx, propq,
-                                 sha256,
-                                 initial_secret,
-                                 quic_client_in_label,
-                                 sizeof(quic_client_in_label),
-                                 NULL, 0,
-                                 client_initial_secret,
-                                 sizeof(client_initial_secret), 1))
+            sha256,
+            initial_secret,
+            quic_client_in_label,
+            sizeof(quic_client_in_label),
+            NULL, 0,
+            client_initial_secret,
+            sizeof(client_initial_secret), 1))
         goto err;
 
     /* Derive "server in" secret. */
     if (((qtx != NULL && tx_secret == server_initial_secret)
-         || (qrx != NULL && rx_secret == server_initial_secret))
+            || (qrx != NULL && rx_secret == server_initial_secret))
         && !tls13_hkdf_expand_ex(libctx, propq,
-                                 sha256,
-                                 initial_secret,
-                                 quic_server_in_label,
-                                 sizeof(quic_server_in_label),
-                                 NULL, 0,
-                                 server_initial_secret,
-                                 sizeof(server_initial_secret), 1))
+            sha256,
+            initial_secret,
+            quic_server_in_label,
+            sizeof(quic_server_in_label),
+            NULL, 0,
+            server_initial_secret,
+            sizeof(server_initial_secret), 1))
         goto err;
 
     /* Setup RX EL. Initial encryption always uses AES-128-GCM. */
     if (qrx != NULL
         && !ossl_qrx_provide_secret(qrx, QUIC_ENC_LEVEL_INITIAL,
-                                    QRL_SUITE_AES128GCM,
-                                    sha256,
-                                    rx_secret,
-                                    sizeof(server_initial_secret)))
+            QRL_SUITE_AES128GCM,
+            sha256,
+            rx_secret,
+            sizeof(server_initial_secret)))
         goto err;
 
     /*
@@ -165,10 +165,10 @@ int ossl_quic_provide_initial_secret(OSSL_LIB_CTX *libctx,
     /* Setup TX cipher. */
     if (qtx != NULL
         && !ossl_qtx_provide_secret(qtx, QUIC_ENC_LEVEL_INITIAL,
-                                    QRL_SUITE_AES128GCM,
-                                    sha256,
-                                    tx_secret,
-                                    sizeof(server_initial_secret)))
+            QRL_SUITE_AES128GCM,
+            sha256,
+            tx_secret,
+            sizeof(server_initial_secret)))
         goto err;
 
     return 1;
@@ -191,38 +191,56 @@ struct suite_info {
 };
 
 static const struct suite_info suite_aes128gcm = {
-    "AES-128-GCM", "SHA256", 32, 16, 12, 16, 16,
+    "AES-128-GCM",
+    "SHA256",
+    32,
+    16,
+    12,
+    16,
+    16,
     QUIC_HDR_PROT_CIPHER_AES_128,
     ((uint64_t)1) << 23, /* Limits as prescribed by RFC 9001 */
     ((uint64_t)1) << 52,
 };
 
 static const struct suite_info suite_aes256gcm = {
-    "AES-256-GCM", "SHA384", 48, 32, 12, 16, 32,
+    "AES-256-GCM",
+    "SHA384",
+    48,
+    32,
+    12,
+    16,
+    32,
     QUIC_HDR_PROT_CIPHER_AES_256,
     ((uint64_t)1) << 23, /* Limits as prescribed by RFC 9001 */
     ((uint64_t)1) << 52,
 };
 
 static const struct suite_info suite_chacha20poly1305 = {
-    "ChaCha20-Poly1305", "SHA256", 32, 32, 12, 16, 32,
+    "ChaCha20-Poly1305",
+    "SHA256",
+    32,
+    32,
+    12,
+    16,
+    32,
     QUIC_HDR_PROT_CIPHER_CHACHA,
     /* Do not use UINT64_MAX here as this represents an invalid value */
-    UINT64_MAX - 1,         /* No applicable limit for this suite (RFC 9001) */
-    ((uint64_t)1) << 36,    /* Limit as prescribed by RFC 9001 */
+    UINT64_MAX - 1, /* No applicable limit for this suite (RFC 9001) */
+    ((uint64_t)1) << 36, /* Limit as prescribed by RFC 9001 */
 };
 
 static const struct suite_info *get_suite(uint32_t suite_id)
 {
     switch (suite_id) {
-        case QRL_SUITE_AES128GCM:
-            return &suite_aes128gcm;
-        case QRL_SUITE_AES256GCM:
-            return &suite_aes256gcm;
-        case QRL_SUITE_CHACHA20POLY1305:
-            return &suite_chacha20poly1305;
-        default:
-            return NULL;
+    case QRL_SUITE_AES128GCM:
+        return &suite_aes128gcm;
+    case QRL_SUITE_AES256GCM:
+        return &suite_aes256gcm;
+    case QRL_SUITE_CHACHA20POLY1305:
+        return &suite_chacha20poly1305;
+    default:
+        return NULL;
     }
 }
 
diff --git a/crypto/openssl/ssl/quic/quic_rstream.c b/crypto/openssl/ssl/quic/quic_rstream.c
index dd3dbf756b44..2fe1cb2cdbe4 100644
--- a/crypto/openssl/ssl/quic/quic_rstream.c
+++ b/crypto/openssl/ssl/quic/quic_rstream.c
@@ -1,11 +1,11 @@
 /*
-* Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved.
-*
-* Licensed under the Apache License 2.0 (the "License").  You may not use
-* this file except in compliance with the License.  You can obtain a copy
-* in the file LICENSE in the source distribution or at
-* https://www.openssl.org/source/license.html
-*/
+ * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
 #include <openssl/err.h>
 #include "internal/common.h"
 #include "internal/time.h"
@@ -22,7 +22,7 @@ struct quic_rstream_st {
 };
 
 QUIC_RSTREAM *ossl_quic_rstream_new(QUIC_RXFC *rxfc,
-                                    OSSL_STATM *statm, size_t rbuf_size)
+    OSSL_STATM *statm, size_t rbuf_size)
 {
     QUIC_RSTREAM *ret = OPENSSL_zalloc(sizeof(*ret));
 
@@ -55,9 +55,9 @@ void ossl_quic_rstream_free(QUIC_RSTREAM *qrs)
 }
 
 int ossl_quic_rstream_queue_data(QUIC_RSTREAM *qrs, OSSL_QRX_PKT *pkt,
-                                 uint64_t offset,
-                                 const unsigned char *data, uint64_t data_len,
-                                 int fin)
+    uint64_t offset,
+    const unsigned char *data, uint64_t data_len,
+    int fin)
 {
     UINT_RANGE range;
 
@@ -74,7 +74,7 @@ int ossl_quic_rstream_queue_data(QUIC_RSTREAM *qrs, OSSL_QRX_PKT *pkt,
 }
 
 static int read_internal(QUIC_RSTREAM *qrs, unsigned char *buf, size_t size,
-                         size_t *readbytes, int *fin, int drop)
+    size_t *readbytes, int *fin, int drop)
 {
     void *iter = NULL;
     UINT_RANGE range;
@@ -107,7 +107,7 @@ static int read_internal(QUIC_RSTREAM *qrs, unsigned char *buf, size_t size,
                 readbytes_ += max_len;
                 l -= max_len;
                 data = ring_buf_get_ptr(&qrs->rbuf, range.start + max_len,
-                                        &max_len);
+                    &max_len);
                 if (!ossl_assert(data != NULL) || !ossl_assert(max_len > l))
                     return 0;
             }
@@ -150,7 +150,7 @@ static OSSL_TIME get_rtt(QUIC_RSTREAM *qrs)
 }
 
 int ossl_quic_rstream_read(QUIC_RSTREAM *qrs, unsigned char *buf, size_t size,
-                           size_t *readbytes, int *fin)
+    size_t *readbytes, int *fin)
 {
     OSSL_TIME rtt = get_rtt(qrs);
 
@@ -165,7 +165,7 @@ int ossl_quic_rstream_read(QUIC_RSTREAM *qrs, unsigned char *buf, size_t size,
 }
 
 int ossl_quic_rstream_peek(QUIC_RSTREAM *qrs, unsigned char *buf, size_t size,
-                           size_t *readbytes, int *fin)
+    size_t *readbytes, int *fin)
 {
     return read_internal(qrs, buf, size, readbytes, fin, 0);
 }
@@ -189,8 +189,8 @@ int ossl_quic_rstream_available(QUIC_RSTREAM *qrs, size_t *avail, int *fin)
 }
 
 int ossl_quic_rstream_get_record(QUIC_RSTREAM *qrs,
-                                 const unsigned char **record, size_t *rec_len,
-                                 int *fin)
+    const unsigned char **record, size_t *rec_len,
+    int *fin)
 {
     const unsigned char *record_ = NULL;
     size_t rec_len_, max_len;
@@ -214,7 +214,7 @@ int ossl_quic_rstream_get_record(QUIC_RSTREAM *qrs,
 
     if (record_ == NULL && rec_len_ != 0) {
         record_ = ring_buf_get_ptr(&qrs->rbuf, qrs->head_range.start,
-                                   &max_len);
+            &max_len);
         if (!ossl_assert(record_ != NULL))
             return 0;
         if (max_len < rec_len_) {
@@ -228,7 +228,6 @@ int ossl_quic_rstream_get_record(QUIC_RSTREAM *qrs,
     return 1;
 }
 
-
 int ossl_quic_rstream_release_record(QUIC_RSTREAM *qrs, size_t read_len)
 {
     uint64_t offset;
@@ -261,9 +260,9 @@ int ossl_quic_rstream_release_record(QUIC_RSTREAM *qrs, size_t read_len)
 }
 
 static int write_at_ring_buf_cb(uint64_t logical_offset,
-                                const unsigned char *buf,
-                                size_t buf_len,
-                                void *cb_arg)
+    const unsigned char *buf,
+    size_t buf_len,
+    void *cb_arg)
 {
     struct ring_buf *rbuf = cb_arg;
 
@@ -275,7 +274,7 @@ int ossl_quic_rstream_move_to_rbuf(QUIC_RSTREAM *qrs)
     if (ring_buf_avail(&qrs->rbuf) == 0)
         return 0;
     return ossl_sframe_list_move_data(&qrs->fl,
-                                      write_at_ring_buf_cb, &qrs->rbuf);
+        write_at_ring_buf_cb, &qrs->rbuf);
 }
 
 int ossl_quic_rstream_resize_rbuf(QUIC_RSTREAM *qrs, size_t rbuf_size)
diff --git a/crypto/openssl/ssl/quic/quic_rx_depack.c b/crypto/openssl/ssl/quic/quic_rx_depack.c
index f800d8984193..786af9b4c221 100644
--- a/crypto/openssl/ssl/quic/quic_rx_depack.c
+++ b/crypto/openssl/ssl/quic/quic_rx_depack.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022-2025 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2022-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy
@@ -30,9 +30,9 @@
  * them a verifiable pattern against tables where this is specified.
  */
 static int depack_do_implicit_stream_create(QUIC_CHANNEL *ch,
-                                            uint64_t stream_id,
-                                            uint64_t frame_type,
-                                            QUIC_STREAM **result);
+    uint64_t stream_id,
+    uint64_t frame_type,
+    QUIC_STREAM **result);
 
 static int depack_do_frame_padding(PACKET *pkt)
 {
@@ -42,15 +42,15 @@ static int depack_do_frame_padding(PACKET *pkt)
 }
 
 static int depack_do_frame_ping(PACKET *pkt, QUIC_CHANNEL *ch,
-                                uint32_t enc_level,
-                                OSSL_ACKM_RX_PKT *ackm_data)
+    uint32_t enc_level,
+    OSSL_ACKM_RX_PKT *ackm_data)
 {
     /* We ignore this frame, apart from eliciting an ACK */
     if (!ossl_quic_wire_decode_frame_ping(pkt)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_PING,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            OSSL_QUIC_FRAME_TYPE_PING,
+            "decode error");
         return 0;
     }
 
@@ -59,9 +59,9 @@ static int depack_do_frame_ping(PACKET *pkt, QUIC_CHANNEL *ch,
 }
 
 static int depack_do_frame_ack(PACKET *pkt, QUIC_CHANNEL *ch,
-                               int packet_space, OSSL_TIME received,
-                               uint64_t frame_type,
-                               OSSL_QRX_PKT *qpacket)
+    int packet_space, OSSL_TIME received,
+    uint64_t frame_type,
+    OSSL_QRX_PKT *qpacket)
 {
     OSSL_QUIC_FRAME_ACK ack;
     OSSL_QUIC_ACK_RANGE *p;
@@ -75,12 +75,13 @@ static int depack_do_frame_ack(PACKET *pkt, QUIC_CHANNEL *ch,
 
     if (ch->num_ack_range_scratch < (size_t)total_ranges) {
         if ((p = OPENSSL_realloc(ch->ack_range_scratch,
-                                 sizeof(OSSL_QUIC_ACK_RANGE)
-                                 * (size_t)total_ranges)) == NULL)
+                 sizeof(OSSL_QUIC_ACK_RANGE)
+                     * (size_t)total_ranges))
+            == NULL)
             goto malformed;
 
-        ch->ack_range_scratch       = p;
-        ch->num_ack_range_scratch   = (size_t)total_ranges;
+        ch->ack_range_scratch = p;
+        ch->num_ack_range_scratch = (size_t)total_ranges;
     }
 
     ack.ack_ranges = ch->ack_range_scratch;
@@ -115,16 +116,16 @@ static int depack_do_frame_ack(PACKET *pkt, QUIC_CHANNEL *ch,
          *     epoch has not incremented and ch->rxku_expected is still 1.
          */
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_KEY_UPDATE_ERROR,
-                                               frame_type,
-                                               "acked packet which initiated a "
-                                               "key update without a "
-                                               "corresponding key update");
+            OSSL_QUIC_ERR_KEY_UPDATE_ERROR,
+            frame_type,
+            "acked packet which initiated a "
+            "key update without a "
+            "corresponding key update");
         return 0;
     }
 
     if (!ossl_ackm_on_rx_ack_frame(ch->ackm, &ack,
-                                   packet_space, received))
+            packet_space, received))
         goto malformed;
 
     ++ch->diag_num_rx_ack;
@@ -132,15 +133,15 @@ static int depack_do_frame_ack(PACKET *pkt, QUIC_CHANNEL *ch,
 
 malformed:
     ossl_quic_channel_raise_protocol_error(ch,
-                                           OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                           frame_type,
-                                           "decode error");
+        OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+        frame_type,
+        "decode error");
     return 0;
 }
 
 static int depack_do_frame_reset_stream(PACKET *pkt,
-                                        QUIC_CHANNEL *ch,
-                                        OSSL_ACKM_RX_PKT *ackm_data)
+    QUIC_CHANNEL *ch,
+    OSSL_ACKM_RX_PKT *ackm_data)
 {
     OSSL_QUIC_FRAME_RESET_STREAM frame_data;
     QUIC_STREAM *stream = NULL;
@@ -148,15 +149,15 @@ static int depack_do_frame_reset_stream(PACKET *pkt,
 
     if (!ossl_quic_wire_decode_frame_reset_stream(pkt, &frame_data)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
+            "decode error");
         return 0;
     }
 
     if (!depack_do_implicit_stream_create(ch, frame_data.stream_id,
-                                          OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
-                                          &stream))
+            OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
+            &stream))
         return 0; /* error already raised for us */
 
     if (stream == NULL)
@@ -164,10 +165,10 @@ static int depack_do_frame_reset_stream(PACKET *pkt,
 
     if (!ossl_quic_stream_has_recv(stream)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_STREAM_STATE_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
-                                               "RESET_STREAM frame for "
-                                               "TX only stream");
+            OSSL_QUIC_ERR_STREAM_STATE_ERROR,
+            OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
+            "RESET_STREAM frame for "
+            "TX only stream");
         return 0;
     }
 
@@ -182,11 +183,11 @@ static int depack_do_frame_reset_stream(PACKET *pkt,
      * of this for us.
      */
     if (!ossl_quic_rxfc_on_rx_stream_frame(&stream->rxfc,
-                                           frame_data.final_size, /*is_fin=*/1)) {
+            frame_data.final_size, /*is_fin=*/1)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_INTERNAL_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
-                                               "internal error (flow control)");
+            OSSL_QUIC_ERR_INTERNAL_ERROR,
+            OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
+            "internal error (flow control)");
         return 0;
     }
 
@@ -194,9 +195,9 @@ static int depack_do_frame_reset_stream(PACKET *pkt,
     fce = ossl_quic_rxfc_get_error(&stream->rxfc, 0);
     if (fce != OSSL_QUIC_ERR_NO_ERROR) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               fce,
-                                               OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
-                                               "flow control violation");
+            fce,
+            OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
+            "flow control violation");
         return 0;
     }
 
@@ -207,31 +208,31 @@ static int depack_do_frame_reset_stream(PACKET *pkt,
      * protocol error conditions we need to check for here.
      */
     ossl_quic_stream_map_notify_reset_recv_part(&ch->qsm, stream,
-                                                frame_data.app_error_code,
-                                                frame_data.final_size);
+        frame_data.app_error_code,
+        frame_data.final_size);
 
     ossl_quic_stream_map_update_state(&ch->qsm, stream);
     return 1;
 }
 
 static int depack_do_frame_stop_sending(PACKET *pkt,
-                                        QUIC_CHANNEL *ch,
-                                        OSSL_ACKM_RX_PKT *ackm_data)
+    QUIC_CHANNEL *ch,
+    OSSL_ACKM_RX_PKT *ackm_data)
 {
     OSSL_QUIC_FRAME_STOP_SENDING frame_data;
     QUIC_STREAM *stream = NULL;
 
     if (!ossl_quic_wire_decode_frame_stop_sending(pkt, &frame_data)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_STOP_SENDING,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            OSSL_QUIC_FRAME_TYPE_STOP_SENDING,
+            "decode error");
         return 0;
     }
 
     if (!depack_do_implicit_stream_create(ch, frame_data.stream_id,
-                                          OSSL_QUIC_FRAME_TYPE_STOP_SENDING,
-                                          &stream))
+            OSSL_QUIC_FRAME_TYPE_STOP_SENDING,
+            &stream))
         return 0; /* error already raised for us */
 
     if (stream == NULL)
@@ -239,15 +240,15 @@ static int depack_do_frame_stop_sending(PACKET *pkt,
 
     if (!ossl_quic_stream_has_send(stream)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_STREAM_STATE_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_STOP_SENDING,
-                                               "STOP_SENDING frame for "
-                                               "RX only stream");
+            OSSL_QUIC_ERR_STREAM_STATE_ERROR,
+            OSSL_QUIC_FRAME_TYPE_STOP_SENDING,
+            "STOP_SENDING frame for "
+            "RX only stream");
         return 0;
     }
 
-    stream->peer_stop_sending       = 1;
-    stream->peer_stop_sending_aec   = frame_data.app_error_code;
+    stream->peer_stop_sending = 1;
+    stream->peer_stop_sending_aec = frame_data.app_error_code;
 
     /*
      * RFC 9000 s. 3.5: Receiving a STOP_SENDING frame means we must respond in
@@ -255,14 +256,14 @@ static int depack_do_frame_stop_sending(PACKET *pkt,
      * part is unaffected.
      */
     ossl_quic_stream_map_reset_stream_send_part(&ch->qsm, stream,
-                                                frame_data.app_error_code);
+        frame_data.app_error_code);
     return 1;
 }
 
 static int depack_do_frame_crypto(PACKET *pkt, QUIC_CHANNEL *ch,
-                                  OSSL_QRX_PKT *parent_pkt,
-                                  OSSL_ACKM_RX_PKT *ackm_data,
-                                  uint64_t *datalen)
+    OSSL_QRX_PKT *parent_pkt,
+    OSSL_ACKM_RX_PKT *ackm_data,
+    uint64_t *datalen)
 {
     OSSL_QUIC_FRAME_CRYPTO f;
     QUIC_RSTREAM *rstream;
@@ -272,9 +273,9 @@ static int depack_do_frame_crypto(PACKET *pkt, QUIC_CHANNEL *ch,
 
     if (!ossl_quic_wire_decode_frame_crypto(pkt, 0, &f)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_CRYPTO,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            OSSL_QUIC_FRAME_TYPE_CRYPTO,
+            "decode error");
         return 0;
     }
 
@@ -293,27 +294,27 @@ static int depack_do_frame_crypto(PACKET *pkt, QUIC_CHANNEL *ch,
     rxfc = &ch->crypto_rxfc[ackm_data->pkt_space];
 
     if (!ossl_quic_rxfc_on_rx_stream_frame(rxfc, f.offset + f.len,
-                                           /*is_fin=*/0)) {
+            /*is_fin=*/0)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_INTERNAL_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_CRYPTO,
-                                               "internal error (crypto RXFC)");
+            OSSL_QUIC_ERR_INTERNAL_ERROR,
+            OSSL_QUIC_FRAME_TYPE_CRYPTO,
+            "internal error (crypto RXFC)");
         return 0;
     }
 
     if (ossl_quic_rxfc_get_error(rxfc, 0) != OSSL_QUIC_ERR_NO_ERROR) {
         ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_CRYPTO_BUFFER_EXCEEDED,
-                                               OSSL_QUIC_FRAME_TYPE_CRYPTO,
-                                               "exceeded maximum crypto buffer");
+            OSSL_QUIC_FRAME_TYPE_CRYPTO,
+            "exceeded maximum crypto buffer");
         return 0;
     }
 
     if (!ossl_quic_rstream_queue_data(rstream, parent_pkt,
-                                      f.offset, f.data, f.len, 0)) {
+            f.offset, f.data, f.len, 0)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_INTERNAL_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_CRYPTO,
-                                               "internal error (rstream queue)");
+            OSSL_QUIC_ERR_INTERNAL_ERROR,
+            OSSL_QUIC_FRAME_TYPE_CRYPTO,
+            "internal error (rstream queue)");
         return 0;
     }
 
@@ -324,16 +325,16 @@ static int depack_do_frame_crypto(PACKET *pkt, QUIC_CHANNEL *ch,
 }
 
 static int depack_do_frame_new_token(PACKET *pkt, QUIC_CHANNEL *ch,
-                                     OSSL_ACKM_RX_PKT *ackm_data)
+    OSSL_ACKM_RX_PKT *ackm_data)
 {
     const uint8_t *token;
     size_t token_len;
 
     if (!ossl_quic_wire_decode_frame_new_token(pkt, &token, &token_len)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_NEW_TOKEN,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            OSSL_QUIC_FRAME_TYPE_NEW_TOKEN,
+            "decode error");
         return 0;
     }
 
@@ -344,15 +345,15 @@ static int depack_do_frame_new_token(PACKET *pkt, QUIC_CHANNEL *ch,
          * FRAME_ENCODING_ERROR."
          */
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_NEW_TOKEN,
-                                               "zero-length NEW_TOKEN");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            OSSL_QUIC_FRAME_TYPE_NEW_TOKEN,
+            "zero-length NEW_TOKEN");
         return 0;
     }
 
     /* store the new token in our token cache */
     if (!ossl_quic_set_peer_token(ossl_quic_port_get_channel_ctx(ch->port),
-                                  &ch->cur_peer_addr, token, token_len))
+            &ch->cur_peer_addr, token, token_len))
         return 0;
 
     return 1;
@@ -364,9 +365,9 @@ static int depack_do_frame_new_token(PACKET *pkt, QUIC_CHANNEL *ch,
  * causing this function to be called. Returns 0 on protocol violation.
  */
 static int depack_do_implicit_stream_create(QUIC_CHANNEL *ch,
-                                            uint64_t stream_id,
-                                            uint64_t frame_type,
-                                            QUIC_STREAM **result)
+    uint64_t stream_id,
+    uint64_t frame_type,
+    QUIC_STREAM **result)
 {
     QUIC_STREAM *stream;
     uint64_t peer_role, stream_ordinal;
@@ -425,19 +426,19 @@ static int depack_do_implicit_stream_create(QUIC_CHANNEL *ch,
             : &ch->max_streams_bidi_rxfc;
 
         if (!ossl_quic_rxfc_on_rx_stream_frame(max_streams_fc,
-                                               stream_ordinal + 1,
-                                               /*is_fin=*/0)) {
+                stream_ordinal + 1,
+                /*is_fin=*/0)) {
             ossl_quic_channel_raise_protocol_error(ch,
-                                                   OSSL_QUIC_ERR_INTERNAL_ERROR,
-                                                   frame_type,
-                                                   "internal error (stream count RXFC)");
+                OSSL_QUIC_ERR_INTERNAL_ERROR,
+                frame_type,
+                "internal error (stream count RXFC)");
             return 0;
         }
 
         if (ossl_quic_rxfc_get_error(max_streams_fc, 0) != OSSL_QUIC_ERR_NO_ERROR) {
             ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_STREAM_LIMIT_ERROR,
-                                                   frame_type,
-                                                   "exceeded maximum allowed streams");
+                frame_type,
+                "exceeded maximum allowed streams");
             return 0;
         }
 
@@ -446,16 +447,14 @@ static int depack_do_implicit_stream_create(QUIC_CHANNEL *ch,
          * created.
          */
         while (*p_next_ordinal_remote <= stream_ordinal) {
-            uint64_t cur_stream_id = (*p_next_ordinal_remote << 2) |
-                (stream_id
-                 & (QUIC_STREAM_DIR_MASK | QUIC_STREAM_INITIATOR_MASK));
+            uint64_t cur_stream_id = (*p_next_ordinal_remote << 2) | (stream_id & (QUIC_STREAM_DIR_MASK | QUIC_STREAM_INITIATOR_MASK));
 
             stream = ossl_quic_channel_new_stream_remote(ch, cur_stream_id);
             if (stream == NULL) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_INTERNAL_ERROR,
-                                                       frame_type,
-                                                       "internal error (stream allocation)");
+                    OSSL_QUIC_ERR_INTERNAL_ERROR,
+                    frame_type,
+                    "internal error (stream allocation)");
                 return 0;
             }
 
@@ -475,10 +474,10 @@ static int depack_do_implicit_stream_create(QUIC_CHANNEL *ch,
              * violation.
              */
             ossl_quic_channel_raise_protocol_error(ch,
-                                                   OSSL_QUIC_ERR_STREAM_STATE_ERROR,
-                                                   frame_type,
-                                                   "STREAM frame for nonexistent "
-                                                   "stream");
+                OSSL_QUIC_ERR_STREAM_STATE_ERROR,
+                frame_type,
+                "STREAM frame for nonexistent "
+                "stream");
             return 0;
         }
 
@@ -495,10 +494,10 @@ static int depack_do_implicit_stream_create(QUIC_CHANNEL *ch,
 }
 
 static int depack_do_frame_stream(PACKET *pkt, QUIC_CHANNEL *ch,
-                                  OSSL_QRX_PKT *parent_pkt,
-                                  OSSL_ACKM_RX_PKT *ackm_data,
-                                  uint64_t frame_type,
-                                  uint64_t *datalen)
+    OSSL_QRX_PKT *parent_pkt,
+    OSSL_ACKM_RX_PKT *ackm_data,
+    uint64_t frame_type,
+    uint64_t *datalen)
 {
     OSSL_QUIC_FRAME_STREAM frame_data;
     QUIC_STREAM *stream;
@@ -510,14 +509,14 @@ static int depack_do_frame_stream(PACKET *pkt, QUIC_CHANNEL *ch,
 
     if (!ossl_quic_wire_decode_frame_stream(pkt, 0, &frame_data)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               frame_type,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            frame_type,
+            "decode error");
         return 0;
     }
 
     if (!depack_do_implicit_stream_create(ch, frame_data.stream_id,
-                                          frame_type, &stream))
+            frame_type, &stream))
         return 0; /* protocol error raised by above call */
 
     if (stream == NULL)
@@ -529,21 +528,21 @@ static int depack_do_frame_stream(PACKET *pkt, QUIC_CHANNEL *ch,
 
     if (!ossl_quic_stream_has_recv(stream)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_STREAM_STATE_ERROR,
-                                               frame_type,
-                                               "STREAM frame for TX only "
-                                               "stream");
+            OSSL_QUIC_ERR_STREAM_STATE_ERROR,
+            frame_type,
+            "STREAM frame for TX only "
+            "stream");
         return 0;
     }
 
     /* Notify stream flow controller. */
     if (!ossl_quic_rxfc_on_rx_stream_frame(&stream->rxfc,
-                                           frame_data.offset + frame_data.len,
-                                           frame_data.is_fin)) {
+            frame_data.offset + frame_data.len,
+            frame_data.is_fin)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_INTERNAL_ERROR,
-                                               frame_type,
-                                               "internal error (flow control)");
+            OSSL_QUIC_ERR_INTERNAL_ERROR,
+            frame_type,
+            "internal error (flow control)");
         return 0;
     }
 
@@ -551,9 +550,9 @@ static int depack_do_frame_stream(PACKET *pkt, QUIC_CHANNEL *ch,
     fce = ossl_quic_rxfc_get_error(&stream->rxfc, 0);
     if (fce != OSSL_QUIC_ERR_NO_ERROR) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               fce,
-                                               frame_type,
-                                               "flow control violation");
+            fce,
+            frame_type,
+            "flow control violation");
         return 0;
     }
 
@@ -584,8 +583,8 @@ static int depack_do_frame_stream(PACKET *pkt, QUIC_CHANNEL *ch,
 
         /* State was already checked above, so can't fail. */
         ossl_quic_stream_map_notify_size_known_recv_part(&ch->qsm, stream,
-                                                         frame_data.offset
-                                                         + frame_data.len);
+            frame_data.offset
+                + frame_data.len);
     }
 
     /*
@@ -608,14 +607,14 @@ static int depack_do_frame_stream(PACKET *pkt, QUIC_CHANNEL *ch,
      */
     if ((frame_data.len > 0 || frame_data.is_fin)
         && !ossl_quic_rstream_queue_data(stream->rstream, parent_pkt,
-                                      frame_data.offset,
-                                      frame_data.data,
-                                      frame_data.len,
-                                      frame_data.is_fin)) {
+            frame_data.offset,
+            frame_data.data,
+            frame_data.len,
+            frame_data.is_fin)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_INTERNAL_ERROR,
-                                               frame_type,
-                                               "internal error (rstream queue)");
+            OSSL_QUIC_ERR_INTERNAL_ERROR,
+            frame_type,
+            "internal error (rstream queue)");
         return 0;
     }
 
@@ -628,9 +627,9 @@ static int depack_do_frame_stream(PACKET *pkt, QUIC_CHANNEL *ch,
     if (stream->recv_state == QUIC_RSTREAM_STATE_SIZE_KNOWN
         && !ossl_quic_rstream_available(stream->rstream, &rs_avail, &rs_fin)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_INTERNAL_ERROR,
-                                               frame_type,
-                                               "internal error (rstream available)");
+            OSSL_QUIC_ERR_INTERNAL_ERROR,
+            frame_type,
+            "internal error (rstream available)");
         return 0;
     }
 
@@ -670,15 +669,15 @@ static void update_streams_uni(QUIC_STREAM *s, void *arg)
 }
 
 static int depack_do_frame_max_data(PACKET *pkt, QUIC_CHANNEL *ch,
-                                    OSSL_ACKM_RX_PKT *ackm_data)
+    OSSL_ACKM_RX_PKT *ackm_data)
 {
     uint64_t max_data = 0;
 
     if (!ossl_quic_wire_decode_frame_max_data(pkt, &max_data)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_MAX_DATA,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            OSSL_QUIC_FRAME_TYPE_MAX_DATA,
+            "decode error");
         return 0;
     }
 
@@ -688,25 +687,25 @@ static int depack_do_frame_max_data(PACKET *pkt, QUIC_CHANNEL *ch,
 }
 
 static int depack_do_frame_max_stream_data(PACKET *pkt,
-                                           QUIC_CHANNEL *ch,
-                                           OSSL_ACKM_RX_PKT *ackm_data)
+    QUIC_CHANNEL *ch,
+    OSSL_ACKM_RX_PKT *ackm_data)
 {
     uint64_t stream_id = 0;
     uint64_t max_stream_data = 0;
     QUIC_STREAM *stream;
 
     if (!ossl_quic_wire_decode_frame_max_stream_data(pkt, &stream_id,
-                                                     &max_stream_data)) {
+            &max_stream_data)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA,
+            "decode error");
         return 0;
     }
 
     if (!depack_do_implicit_stream_create(ch, stream_id,
-                                          OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA,
-                                          &stream))
+            OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA,
+            &stream))
         return 0; /* error already raised for us */
 
     if (stream == NULL)
@@ -714,10 +713,10 @@ static int depack_do_frame_max_stream_data(PACKET *pkt,
 
     if (!ossl_quic_stream_has_send(stream)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_STREAM_STATE_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA,
-                                               "MAX_STREAM_DATA for TX only "
-                                               "stream");
+            OSSL_QUIC_ERR_STREAM_STATE_ERROR,
+            OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA,
+            "MAX_STREAM_DATA for TX only "
+            "stream");
         return 0;
     }
 
@@ -727,25 +726,25 @@ static int depack_do_frame_max_stream_data(PACKET *pkt,
 }
 
 static int depack_do_frame_max_streams(PACKET *pkt,
-                                       QUIC_CHANNEL *ch,
-                                       OSSL_ACKM_RX_PKT *ackm_data,
-                                       uint64_t frame_type)
+    QUIC_CHANNEL *ch,
+    OSSL_ACKM_RX_PKT *ackm_data,
+    uint64_t frame_type)
 {
     uint64_t max_streams = 0;
 
     if (!ossl_quic_wire_decode_frame_max_streams(pkt, &max_streams)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               frame_type,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            frame_type,
+            "decode error");
         return 0;
     }
 
     if (max_streams > (((uint64_t)1) << 60)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               frame_type,
-                                               "invalid max streams value");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            frame_type,
+            "invalid max streams value");
         return 0;
     }
 
@@ -766,9 +765,9 @@ static int depack_do_frame_max_streams(PACKET *pkt,
         break;
     default:
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               frame_type,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            frame_type,
+            "decode error");
         return 0;
     }
 
@@ -776,16 +775,16 @@ static int depack_do_frame_max_streams(PACKET *pkt,
 }
 
 static int depack_do_frame_data_blocked(PACKET *pkt,
-                                        QUIC_CHANNEL *ch,
-                                        OSSL_ACKM_RX_PKT *ackm_data)
+    QUIC_CHANNEL *ch,
+    OSSL_ACKM_RX_PKT *ackm_data)
 {
     uint64_t max_data = 0;
 
     if (!ossl_quic_wire_decode_frame_data_blocked(pkt, &max_data)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED,
+            "decode error");
         return 0;
     }
 
@@ -794,19 +793,19 @@ static int depack_do_frame_data_blocked(PACKET *pkt,
 }
 
 static int depack_do_frame_stream_data_blocked(PACKET *pkt,
-                                               QUIC_CHANNEL *ch,
-                                               OSSL_ACKM_RX_PKT *ackm_data)
+    QUIC_CHANNEL *ch,
+    OSSL_ACKM_RX_PKT *ackm_data)
 {
     uint64_t stream_id = 0;
     uint64_t max_data = 0;
     QUIC_STREAM *stream;
 
     if (!ossl_quic_wire_decode_frame_stream_data_blocked(pkt, &stream_id,
-                                                         &max_data)) {
+            &max_data)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED,
+            "decode error");
         return 0;
     }
 
@@ -815,8 +814,8 @@ static int depack_do_frame_stream_data_blocked(PACKET *pkt,
      * but it does trigger stream creation.
      */
     if (!depack_do_implicit_stream_create(ch, stream_id,
-                                          OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED,
-                                          &stream))
+            OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED,
+            &stream))
         return 0; /* error already raised for us */
 
     if (stream == NULL)
@@ -829,10 +828,10 @@ static int depack_do_frame_stream_data_blocked(PACKET *pkt,
          * STREAM_STATE_ERROR."
          */
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_STREAM_STATE_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED,
-                                               "STREAM_DATA_BLOCKED frame for "
-                                               "TX only stream");
+            OSSL_QUIC_ERR_STREAM_STATE_ERROR,
+            OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED,
+            "STREAM_DATA_BLOCKED frame for "
+            "TX only stream");
         return 0;
     }
 
@@ -841,17 +840,17 @@ static int depack_do_frame_stream_data_blocked(PACKET *pkt,
 }
 
 static int depack_do_frame_streams_blocked(PACKET *pkt,
-                                           QUIC_CHANNEL *ch,
-                                           OSSL_ACKM_RX_PKT *ackm_data,
-                                           uint64_t frame_type)
+    QUIC_CHANNEL *ch,
+    OSSL_ACKM_RX_PKT *ackm_data,
+    uint64_t frame_type)
 {
     uint64_t max_data = 0;
 
     if (!ossl_quic_wire_decode_frame_streams_blocked(pkt, &max_data)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               frame_type,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            frame_type,
+            "decode error");
         return 0;
     }
 
@@ -863,9 +862,9 @@ static int depack_do_frame_streams_blocked(PACKET *pkt,
          * error of type STREAM_LIMIT_ERROR or FRAME_ENCODING_ERROR."
          */
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_STREAM_LIMIT_ERROR,
-                                               frame_type,
-                                               "invalid stream count limit");
+            OSSL_QUIC_ERR_STREAM_LIMIT_ERROR,
+            frame_type,
+            "invalid stream count limit");
         return 0;
     }
 
@@ -874,16 +873,16 @@ static int depack_do_frame_streams_blocked(PACKET *pkt,
 }
 
 static int depack_do_frame_new_conn_id(PACKET *pkt,
-                                       QUIC_CHANNEL *ch,
-                                       OSSL_ACKM_RX_PKT *ackm_data)
+    QUIC_CHANNEL *ch,
+    OSSL_ACKM_RX_PKT *ackm_data)
 {
     OSSL_QUIC_FRAME_NEW_CONN_ID frame_data;
 
     if (!ossl_quic_wire_decode_frame_new_conn_id(pkt, &frame_data)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
+            "decode error");
         return 0;
     }
 
@@ -893,16 +892,16 @@ static int depack_do_frame_new_conn_id(PACKET *pkt,
 }
 
 static int depack_do_frame_retire_conn_id(PACKET *pkt,
-                                          QUIC_CHANNEL *ch,
-                                          OSSL_ACKM_RX_PKT *ackm_data)
+    QUIC_CHANNEL *ch,
+    OSSL_ACKM_RX_PKT *ackm_data)
 {
     uint64_t seq_num;
 
     if (!ossl_quic_wire_decode_frame_retire_conn_id(pkt, &seq_num)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID,
+            "decode error");
         return 0;
     }
 
@@ -921,9 +920,9 @@ static int depack_do_frame_retire_conn_id(PACKET *pkt,
      */
     if (!ch->is_server) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                               OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID,
-                                               "conn has zero-length CID");
+            OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+            OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID,
+            "conn has zero-length CID");
         return 0;
     }
 
@@ -936,8 +935,8 @@ static void free_path_response(unsigned char *buf, size_t buf_len, void *arg)
 }
 
 static int depack_do_frame_path_challenge(PACKET *pkt,
-                                          QUIC_CHANNEL *ch,
-                                          OSSL_ACKM_RX_PKT *ackm_data)
+    QUIC_CHANNEL *ch,
+    OSSL_ACKM_RX_PKT *ackm_data)
 {
     uint64_t frame_data = 0;
     unsigned char *encoded = NULL;
@@ -946,9 +945,9 @@ static int depack_do_frame_path_challenge(PACKET *pkt,
 
     if (!ossl_quic_wire_decode_frame_path_challenge(pkt, &frame_data)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE,
+            "decode error");
         return 0;
     }
 
@@ -974,10 +973,10 @@ static int depack_do_frame_path_challenge(PACKET *pkt,
     WPACKET_finish(&wpkt);
 
     if (!ossl_quic_cfq_add_frame(ch->cfq, 0, QUIC_PN_SPACE_APP,
-                                 OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE,
-                                 QUIC_CFQ_ITEM_FLAG_UNRELIABLE,
-                                 encoded, encoded_len,
-                                 free_path_response, NULL))
+            OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE,
+            QUIC_CFQ_ITEM_FLAG_UNRELIABLE,
+            encoded, encoded_len,
+            free_path_response, NULL))
         goto err;
 
     return 1;
@@ -985,22 +984,22 @@ static int depack_do_frame_path_challenge(PACKET *pkt,
 err:
     OPENSSL_free(encoded);
     ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_INTERNAL_ERROR,
-                                           OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE,
-                                           "internal error");
+        OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE,
+        "internal error");
     return 0;
 }
 
 static int depack_do_frame_path_response(PACKET *pkt,
-                                         QUIC_CHANNEL *ch,
-                                         OSSL_ACKM_RX_PKT *ackm_data)
+    QUIC_CHANNEL *ch,
+    OSSL_ACKM_RX_PKT *ackm_data)
 {
     uint64_t frame_data = 0;
 
     if (!ossl_quic_wire_decode_frame_path_response(pkt, &frame_data)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE,
+            "decode error");
         return 0;
     }
 
@@ -1010,15 +1009,15 @@ static int depack_do_frame_path_response(PACKET *pkt,
 }
 
 static int depack_do_frame_conn_close(PACKET *pkt, QUIC_CHANNEL *ch,
-                                      uint64_t frame_type)
+    uint64_t frame_type)
 {
     OSSL_QUIC_FRAME_CONN_CLOSE frame_data;
 
     if (!ossl_quic_wire_decode_frame_conn_close(pkt, &frame_data)) {
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                               frame_type,
-                                               "decode error");
+            OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+            frame_type,
+            "decode error");
         return 0;
     }
 
@@ -1027,15 +1026,15 @@ static int depack_do_frame_conn_close(PACKET *pkt, QUIC_CHANNEL *ch,
 }
 
 static int depack_do_frame_handshake_done(PACKET *pkt,
-                                          QUIC_CHANNEL *ch,
-                                          OSSL_ACKM_RX_PKT *ackm_data)
+    QUIC_CHANNEL *ch,
+    OSSL_ACKM_RX_PKT *ackm_data)
 {
     if (!ossl_quic_wire_decode_frame_handshake_done(pkt)) {
         /* This can fail only with an internal error. */
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_INTERNAL_ERROR,
-                                               OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE,
-                                               "internal error (decode frame handshake done)");
+            OSSL_QUIC_ERR_INTERNAL_ERROR,
+            OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE,
+            "internal error (decode frame handshake done)");
         return 0;
     }
 
@@ -1046,8 +1045,8 @@ static int depack_do_frame_handshake_done(PACKET *pkt,
 /* Main frame processor */
 
 static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
-                                 OSSL_QRX_PKT *parent_pkt, uint32_t enc_level,
-                                 OSSL_TIME received, OSSL_ACKM_RX_PKT *ackm_data)
+    OSSL_QRX_PKT *parent_pkt, uint32_t enc_level,
+    OSSL_TIME received, OSSL_ACKM_RX_PKT *ackm_data)
 {
     uint32_t pkt_type = parent_pkt->hdr->type;
     uint32_t packet_space = ossl_quic_enc_level_to_pn_space(enc_level);
@@ -1059,9 +1058,9 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
          * PROTOCOL_VIOLATION.
          */
         ossl_quic_channel_raise_protocol_error(ch,
-                                               OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                               0,
-                                               "empty packet payload");
+            OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+            0,
+            "empty packet payload");
         return 0;
     }
 
@@ -1076,17 +1075,17 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
 
         if (!ossl_quic_wire_peek_frame_header(pkt, &frame_type, &was_minimal)) {
             ossl_quic_channel_raise_protocol_error(ch,
-                                                   OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                   0,
-                                                   "malformed frame header");
+                OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                0,
+                "malformed frame header");
             return 0;
         }
 
         if (!was_minimal) {
             ossl_quic_channel_raise_protocol_error(ch,
-                                                   OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                   frame_type,
-                                                   "non-minimal frame type encoding");
+                OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                frame_type,
+                "non-minimal frame type encoding");
             return 0;
         }
 
@@ -1125,13 +1124,13 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             /* ACK frames are valid everywhere except in 0RTT packets */
             if (pkt_type == QUIC_PKT_TYPE_0RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "ACK not valid in 0-RTT");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "ACK not valid in 0-RTT");
                 return 0;
             }
             if (!depack_do_frame_ack(pkt, ch, packet_space, received,
-                                     frame_type, parent_pkt))
+                    frame_type, parent_pkt))
                 return 0;
             break;
 
@@ -1140,10 +1139,10 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             if (pkt_type != QUIC_PKT_TYPE_0RTT
                 && pkt_type != QUIC_PKT_TYPE_1RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "RESET_STREAM not valid in "
-                                                       "INITIAL/HANDSHAKE");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "RESET_STREAM not valid in "
+                    "INITIAL/HANDSHAKE");
                 return 0;
             }
             if (!depack_do_frame_reset_stream(pkt, ch, ackm_data))
@@ -1154,10 +1153,10 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             if (pkt_type != QUIC_PKT_TYPE_0RTT
                 && pkt_type != QUIC_PKT_TYPE_1RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "STOP_SENDING not valid in "
-                                                       "INITIAL/HANDSHAKE");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "STOP_SENDING not valid in "
+                    "INITIAL/HANDSHAKE");
                 return 0;
             }
             if (!depack_do_frame_stop_sending(pkt, ch, ackm_data))
@@ -1167,9 +1166,9 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             /* CRYPTO frames are valid everywhere except in 0RTT packets */
             if (pkt_type == QUIC_PKT_TYPE_0RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "CRYPTO frame not valid in 0-RTT");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "CRYPTO frame not valid in 0-RTT");
                 return 0;
             }
             if (!depack_do_frame_crypto(pkt, ch, parent_pkt, ackm_data, &datalen))
@@ -1179,9 +1178,9 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             /* NEW_TOKEN frames are valid in 1RTT packets */
             if (pkt_type != QUIC_PKT_TYPE_1RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "NEW_TOKEN valid only in 1-RTT");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "NEW_TOKEN valid only in 1-RTT");
                 return 0;
             }
 
@@ -1191,9 +1190,9 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
              */
             if (ch->is_server) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "NEW_TOKEN can only be sent by a server");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "NEW_TOKEN can only be sent by a server");
                 return 0;
             }
 
@@ -1213,13 +1212,13 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             if (pkt_type != QUIC_PKT_TYPE_0RTT
                 && pkt_type != QUIC_PKT_TYPE_1RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "STREAM valid only in 0/1-RTT");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "STREAM valid only in 0/1-RTT");
                 return 0;
             }
             if (!depack_do_frame_stream(pkt, ch, parent_pkt, ackm_data,
-                                        frame_type, &datalen))
+                    frame_type, &datalen))
                 return 0;
             break;
 
@@ -1228,9 +1227,9 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             if (pkt_type != QUIC_PKT_TYPE_0RTT
                 && pkt_type != QUIC_PKT_TYPE_1RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "MAX_DATA valid only in 0/1-RTT");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "MAX_DATA valid only in 0/1-RTT");
                 return 0;
             }
             if (!depack_do_frame_max_data(pkt, ch, ackm_data))
@@ -1241,9 +1240,9 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             if (pkt_type != QUIC_PKT_TYPE_0RTT
                 && pkt_type != QUIC_PKT_TYPE_1RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "MAX_STREAM_DATA valid only in 0/1-RTT");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "MAX_STREAM_DATA valid only in 0/1-RTT");
                 return 0;
             }
             if (!depack_do_frame_max_stream_data(pkt, ch, ackm_data))
@@ -1256,13 +1255,13 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             if (pkt_type != QUIC_PKT_TYPE_0RTT
                 && pkt_type != QUIC_PKT_TYPE_1RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "MAX_STREAMS valid only in 0/1-RTT");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "MAX_STREAMS valid only in 0/1-RTT");
                 return 0;
             }
             if (!depack_do_frame_max_streams(pkt, ch, ackm_data,
-                                             frame_type))
+                    frame_type))
                 return 0;
             break;
 
@@ -1271,9 +1270,9 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             if (pkt_type != QUIC_PKT_TYPE_0RTT
                 && pkt_type != QUIC_PKT_TYPE_1RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "DATA_BLOCKED valid only in 0/1-RTT");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "DATA_BLOCKED valid only in 0/1-RTT");
                 return 0;
             }
             if (!depack_do_frame_data_blocked(pkt, ch, ackm_data))
@@ -1284,9 +1283,9 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             if (pkt_type != QUIC_PKT_TYPE_0RTT
                 && pkt_type != QUIC_PKT_TYPE_1RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "STREAM_DATA_BLOCKED valid only in 0/1-RTT");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "STREAM_DATA_BLOCKED valid only in 0/1-RTT");
                 return 0;
             }
             if (!depack_do_frame_stream_data_blocked(pkt, ch, ackm_data))
@@ -1299,13 +1298,13 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             if (pkt_type != QUIC_PKT_TYPE_0RTT
                 && pkt_type != QUIC_PKT_TYPE_1RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "STREAMS valid only in 0/1-RTT");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "STREAMS valid only in 0/1-RTT");
                 return 0;
             }
             if (!depack_do_frame_streams_blocked(pkt, ch, ackm_data,
-                                                 frame_type))
+                    frame_type))
                 return 0;
             break;
 
@@ -1314,9 +1313,10 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             if (pkt_type != QUIC_PKT_TYPE_0RTT
                 && pkt_type != QUIC_PKT_TYPE_1RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "NEW_CONN_ID valid only in 0/1-RTT");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "NEW_CONN_ID valid only in 0/1-RTT");
+                return 0;
             }
             if (!depack_do_frame_new_conn_id(pkt, ch, ackm_data))
                 return 0;
@@ -1326,9 +1326,9 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             if (pkt_type != QUIC_PKT_TYPE_0RTT
                 && pkt_type != QUIC_PKT_TYPE_1RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "RETIRE_CONN_ID valid only in 0/1-RTT");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "RETIRE_CONN_ID valid only in 0/1-RTT");
                 return 0;
             }
             if (!depack_do_frame_retire_conn_id(pkt, ch, ackm_data))
@@ -1339,9 +1339,9 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             if (pkt_type != QUIC_PKT_TYPE_0RTT
                 && pkt_type != QUIC_PKT_TYPE_1RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "PATH_CHALLENGE valid only in 0/1-RTT");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "PATH_CHALLENGE valid only in 0/1-RTT");
                 return 0;
             }
             if (!depack_do_frame_path_challenge(pkt, ch, ackm_data))
@@ -1352,9 +1352,9 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             /* PATH_RESPONSE frames are valid in 1RTT packets */
             if (pkt_type != QUIC_PKT_TYPE_1RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "PATH_CHALLENGE valid only in 1-RTT");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "PATH_CHALLENGE valid only in 1-RTT");
                 return 0;
             }
             if (!depack_do_frame_path_response(pkt, ch, ackm_data))
@@ -1366,9 +1366,9 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             if (pkt_type != QUIC_PKT_TYPE_0RTT
                 && pkt_type != QUIC_PKT_TYPE_1RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "CONN_CLOSE (APP) valid only in 0/1-RTT");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "CONN_CLOSE (APP) valid only in 0/1-RTT");
                 return 0;
             }
             /* FALLTHRU */
@@ -1382,9 +1382,9 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             /* HANDSHAKE_DONE frames are valid in 1RTT packets */
             if (pkt_type != QUIC_PKT_TYPE_1RTT) {
                 ossl_quic_channel_raise_protocol_error(ch,
-                                                       OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
-                                                       frame_type,
-                                                       "HANDSHAKE_DONE valid only in 1-RTT");
+                    OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
+                    frame_type,
+                    "HANDSHAKE_DONE valid only in 1-RTT");
                 return 0;
             }
             if (!depack_do_frame_handshake_done(pkt, ch, ackm_data))
@@ -1394,9 +1394,9 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
         default:
             /* Unknown frame type */
             ossl_quic_channel_raise_protocol_error(ch,
-                                                   OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
-                                                   frame_type,
-                                                   "Unknown frame type received");
+                OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
+                frame_type,
+                "Unknown frame type received");
             return 0;
         }
 
@@ -1408,13 +1408,13 @@ static int depack_process_frames(QUIC_CHANNEL *ch, PACKET *pkt,
             if (frame_type == OSSL_QUIC_FRAME_TYPE_PADDING) {
                 ctype = SSL3_RT_QUIC_FRAME_PADDING;
             } else if (OSSL_QUIC_FRAME_TYPE_IS_STREAM(frame_type)
-                    || frame_type == OSSL_QUIC_FRAME_TYPE_CRYPTO) {
+                || frame_type == OSSL_QUIC_FRAME_TYPE_CRYPTO) {
                 ctype = SSL3_RT_QUIC_FRAME_HEADER;
                 framelen -= (size_t)datalen;
             }
 
             ch->msg_callback(0, OSSL_QUIC1_VERSION, ctype, sof, framelen,
-                             ch->msg_callback_ssl, ch->msg_callback_arg);
+                ch->msg_callback_ssl, ch->msg_callback_arg);
         }
     }
 
@@ -1468,9 +1468,9 @@ int ossl_quic_handle_frames(QUIC_CHANNEL *ch, OSSL_QRX_PKT *qpacket)
     /* Now that special cases are out of the way, parse frames */
     if (!PACKET_buf_init(&pkt, qpacket->hdr->data, qpacket->hdr->len)
         || !depack_process_frames(ch, &pkt, qpacket,
-                                  enc_level,
-                                  qpacket->time,
-                                  &ackm_data))
+            enc_level,
+            qpacket->time,
+            &ackm_data))
         return 0;
 
     ossl_ackm_on_rx_packet(ch->ackm, &ackm_data);
diff --git a/crypto/openssl/ssl/quic/quic_sf_list.c b/crypto/openssl/ssl/quic/quic_sf_list.c
index 0541a2ab6371..03bbbe6d3561 100644
--- a/crypto/openssl/ssl/quic/quic_sf_list.c
+++ b/crypto/openssl/ssl/quic/quic_sf_list.c
@@ -22,13 +22,13 @@ static void stream_frame_free(SFRAME_LIST *fl, STREAM_FRAME *sf)
 {
     if (fl->cleanse && sf->data != NULL)
         OPENSSL_cleanse((unsigned char *)sf->data,
-                        (size_t)(sf->range.end - sf->range.start));
+            (size_t)(sf->range.end - sf->range.start));
     ossl_qrx_pkt_release(sf->pkt);
     OPENSSL_free(sf);
 }
 
 static STREAM_FRAME *stream_frame_new(UINT_RANGE *range, OSSL_QRX_PKT *pkt,
-                                      const unsigned char *data)
+    const unsigned char *data)
 {
     STREAM_FRAME *sf = OPENSSL_zalloc(sizeof(*sf));
 
@@ -61,8 +61,8 @@ void ossl_sframe_list_destroy(SFRAME_LIST *fl)
 }
 
 static int append_frame(SFRAME_LIST *fl, UINT_RANGE *range,
-                        OSSL_QRX_PKT *pkt,
-                        const unsigned char *data)
+    OSSL_QRX_PKT *pkt,
+    const unsigned char *data)
 {
     STREAM_FRAME *new_frame;
 
@@ -77,8 +77,8 @@ static int append_frame(SFRAME_LIST *fl, UINT_RANGE *range,
 }
 
 int ossl_sframe_list_insert(SFRAME_LIST *fl, UINT_RANGE *range,
-                            OSSL_QRX_PKT *pkt,
-                            const unsigned char *data, int fin)
+    OSSL_QRX_PKT *pkt,
+    const unsigned char *data, int fin)
 {
     STREAM_FRAME *sf, *new_frame, *prev_frame, *next_frame;
 #ifndef NDEBUG
@@ -87,7 +87,7 @@ int ossl_sframe_list_insert(SFRAME_LIST *fl, UINT_RANGE *range,
 
     /* This check for FINAL_SIZE_ERROR is handled by QUIC FC already */
     assert((!fin || curr_end <= range->end)
-           && (!fl->fin || curr_end >= range->end));
+        && (!fl->fin || curr_end >= range->end));
 #endif
 
     if (fl->offset >= range->end)
@@ -115,7 +115,7 @@ int ossl_sframe_list_insert(SFRAME_LIST *fl, UINT_RANGE *range,
 
     prev_frame = NULL;
     for (sf = fl->head; sf != NULL && sf->range.start < range->start;
-         sf = sf->next)
+        sf = sf->next)
         prev_frame = sf;
 
     if (!ossl_assert(sf != NULL))
@@ -134,7 +134,7 @@ int ossl_sframe_list_insert(SFRAME_LIST *fl, UINT_RANGE *range,
         return 0;
 
     for (next_frame = sf;
-         next_frame != NULL && next_frame->range.end <= range->end;) {
+        next_frame != NULL && next_frame->range.end <= range->end;) {
         STREAM_FRAME *drop_frame = next_frame;
 
         next_frame = next_frame->next;
@@ -172,15 +172,15 @@ int ossl_sframe_list_insert(SFRAME_LIST *fl, UINT_RANGE *range,
 
     ++fl->num_frames;
 
- end:
+end:
     fl->fin = fin || fl->fin;
 
     return 1;
 }
 
 int ossl_sframe_list_peek(const SFRAME_LIST *fl, void **iter,
-                          UINT_RANGE *range, const unsigned char **data,
-                          int *fin)
+    UINT_RANGE *range, const unsigned char **data,
+    int *fin)
 {
     STREAM_FRAME *sf = *iter;
     uint64_t start;
@@ -222,9 +222,9 @@ int ossl_sframe_list_drop_frames(SFRAME_LIST *fl, uint64_t limit)
     /* offset cannot move back or past the data received */
     if (!ossl_assert(limit >= fl->offset)
         || !ossl_assert(fl->tail == NULL
-                        || limit <= fl->tail->range.end)
+            || limit <= fl->tail->range.end)
         || !ossl_assert(fl->tail != NULL
-                        || limit == fl->offset))
+            || limit == fl->offset))
         return 0;
 
     fl->offset = limit;
@@ -249,8 +249,8 @@ int ossl_sframe_list_drop_frames(SFRAME_LIST *fl, uint64_t limit)
 }
 
 int ossl_sframe_list_lock_head(SFRAME_LIST *fl, UINT_RANGE *range,
-                               const unsigned char **data,
-                               int *fin)
+    const unsigned char **data,
+    int *fin)
 {
     int ret;
     void *iter = NULL;
@@ -270,8 +270,8 @@ int ossl_sframe_list_is_head_locked(SFRAME_LIST *fl)
 }
 
 int ossl_sframe_list_move_data(SFRAME_LIST *fl,
-                               sframe_list_write_at_cb *write_at_cb,
-                               void *cb_arg)
+    sframe_list_write_at_cb *write_at_cb,
+    void *cb_arg)
 {
     STREAM_FRAME *sf = fl->head, *prev_frame = NULL;
     uint64_t limit = fl->offset;
@@ -300,7 +300,7 @@ int ossl_sframe_list_move_data(SFRAME_LIST *fl,
 
             if (fl->cleanse)
                 OPENSSL_cleanse((unsigned char *)sf->data,
-                                (size_t)(sf->range.end - sf->range.start));
+                    (size_t)(sf->range.end - sf->range.start));
 
             /* release the packet */
             sf->data = NULL;
diff --git a/crypto/openssl/ssl/quic/quic_srt_gen.c b/crypto/openssl/ssl/quic/quic_srt_gen.c
index 233e4aa628cb..1390a0d9faf9 100644
--- a/crypto/openssl/ssl/quic/quic_srt_gen.c
+++ b/crypto/openssl/ssl/quic/quic_srt_gen.c
@@ -11,8 +11,8 @@
 #include <openssl/evp.h>
 
 struct quic_srt_gen_st {
-    EVP_MAC         *mac;
-    EVP_MAC_CTX     *mac_ctx;
+    EVP_MAC *mac;
+    EVP_MAC_CTX *mac_ctx;
 };
 
 /*
@@ -20,7 +20,7 @@ struct quic_srt_gen_st {
  */
 
 QUIC_SRT_GEN *ossl_quic_srt_gen_new(OSSL_LIB_CTX *libctx, const char *propq,
-                                    const unsigned char *key, size_t key_len)
+    const unsigned char *key, size_t key_len)
 {
     QUIC_SRT_GEN *srt_gen;
     OSSL_PARAM params[3], *p = params;
@@ -37,7 +37,7 @@ QUIC_SRT_GEN *ossl_quic_srt_gen_new(OSSL_LIB_CTX *libctx, const char *propq,
     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST, "SHA256", 7);
     if (propq != NULL)
         *p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_PROPERTIES,
-                                                (char *)propq, 0);
+            (char *)propq, 0);
     *p++ = OSSL_PARAM_construct_end();
 
     if (!EVP_MAC_init(srt_gen->mac_ctx, key, key_len, params))
@@ -61,8 +61,8 @@ void ossl_quic_srt_gen_free(QUIC_SRT_GEN *srt_gen)
 }
 
 int ossl_quic_srt_gen_calculate_token(QUIC_SRT_GEN *srt_gen,
-                                      const QUIC_CONN_ID *dcid,
-                                      QUIC_STATELESS_RESET_TOKEN *token)
+    const QUIC_CONN_ID *dcid,
+    QUIC_STATELESS_RESET_TOKEN *token)
 {
     size_t outl = 0;
     unsigned char mac[SHA256_DIGEST_LENGTH];
@@ -71,7 +71,7 @@ int ossl_quic_srt_gen_calculate_token(QUIC_SRT_GEN *srt_gen,
         return 0;
 
     if (!EVP_MAC_update(srt_gen->mac_ctx, (const unsigned char *)dcid->id,
-                        dcid->id_len))
+            dcid->id_len))
         return 0;
 
     if (!EVP_MAC_final(srt_gen->mac_ctx, mac, &outl, sizeof(mac))
diff --git a/crypto/openssl/ssl/quic/quic_srtm.c b/crypto/openssl/ssl/quic/quic_srtm.c
index 3d0bfd97c7e0..46f675cef239 100644
--- a/crypto/openssl/ssl/quic/quic_srtm.c
+++ b/crypto/openssl/ssl/quic/quic_srtm.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2023-2024 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2023-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy
@@ -19,7 +19,7 @@
  */
 typedef struct srtm_item_st SRTM_ITEM;
 
-#define BLINDED_SRT_LEN     16
+#define BLINDED_SRT_LEN 16
 
 DEFINE_LHASH_OF_EX(SRTM_ITEM);
 
@@ -40,30 +40,30 @@ DEFINE_LHASH_OF_EX(SRTM_ITEM);
  * all connections for that QUIC_PORT.
  */
 struct srtm_item_st {
-    SRTM_ITEM                   *next_by_srt_blinded; /* SORT BY opaque  DESC */
-    SRTM_ITEM                   *next_by_seq_num;     /* SORT BY seq_num DESC */
-    void                        *opaque; /* \__ unique identity for item */
-    uint64_t                    seq_num; /* /                            */
-    QUIC_STATELESS_RESET_TOKEN  srt;
-    unsigned char               srt_blinded[BLINDED_SRT_LEN]; /* H(srt) */
+    SRTM_ITEM *next_by_srt_blinded; /* SORT BY opaque  DESC */
+    SRTM_ITEM *next_by_seq_num; /* SORT BY seq_num DESC */
+    void *opaque; /* \__ unique identity for item */
+    uint64_t seq_num; /* /                            */
+    QUIC_STATELESS_RESET_TOKEN srt;
+    unsigned char srt_blinded[BLINDED_SRT_LEN]; /* H(srt) */
 
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    uint32_t                    debug_token;
+    uint32_t debug_token;
 #endif
 };
 
 struct quic_srtm_st {
     /* Crypto context used to calculate blinded SRTs H(srt). */
-    EVP_CIPHER_CTX              *blind_ctx; /* kept with key */
+    EVP_CIPHER_CTX *blind_ctx; /* kept with key */
 
-    LHASH_OF(SRTM_ITEM)         *items_fwd; /* (opaque)  -> SRTM_ITEM */
-    LHASH_OF(SRTM_ITEM)         *items_rev; /* (H(srt))  -> SRTM_ITEM */
+    LHASH_OF(SRTM_ITEM) *items_fwd; /* (opaque)  -> SRTM_ITEM */
+    LHASH_OF(SRTM_ITEM) *items_rev; /* (H(srt))  -> SRTM_ITEM */
 
     /*
      * Monotonically transitions to 1 in event of allocation failure. The only
      * valid operation on such an object is to free it.
      */
-    unsigned int                alloc_failed : 1;
+    unsigned int alloc_failed : 1;
 };
 
 static unsigned long items_fwd_hash(const SRTM_ITEM *item)
@@ -168,6 +168,11 @@ void ossl_quic_srtm_free(QUIC_SRTM *srtm)
 
     lh_SRTM_ITEM_free(srtm->items_rev);
     if (srtm->items_fwd != NULL) {
+        /*
+         * We don't need to call lh_SRTM_ITEM_set_down_load(..., 0)
+         * here because srtm_free_each() callback for _doall() does
+         * not call to lh_SRTIM_ITEM_delete().
+         */
         lh_SRTM_ITEM_doall(srtm->items_fwd, srtm_free_each);
         lh_SRTM_ITEM_free(srtm->items_fwd);
     }
@@ -184,11 +189,11 @@ void ossl_quic_srtm_free(QUIC_SRTM *srtm)
  * the first item.
  */
 static SRTM_ITEM *srtm_find(QUIC_SRTM *srtm, void *opaque, uint64_t seq_num,
-                            SRTM_ITEM **head_p, SRTM_ITEM **prev_p)
+    SRTM_ITEM **head_p, SRTM_ITEM **prev_p)
 {
     SRTM_ITEM key, *item = NULL, *prev = NULL;
 
-    key.opaque  = opaque;
+    key.opaque = opaque;
 
     item = lh_SRTM_ITEM_retrieve(srtm->items_fwd, &key);
     if (head_p != NULL)
@@ -260,7 +265,7 @@ static void sorted_insert_srt(SRTM_ITEM *head, SRTM_ITEM *item, SRTM_ITEM **new_
  * is formed.
  */
 static int srtm_compute_blinded(QUIC_SRTM *srtm, SRTM_ITEM *item,
-                                const QUIC_STATELESS_RESET_TOKEN *token)
+    const QUIC_STATELESS_RESET_TOKEN *token)
 {
     int outl = 0;
 
@@ -270,7 +275,7 @@ static int srtm_compute_blinded(QUIC_SRTM *srtm, SRTM_ITEM *item,
      * block.
      */
     if (!EVP_EncryptUpdate(srtm->blind_ctx, item->srt_blinded, &outl,
-                           (const unsigned char *)token, sizeof(*token)))
+            (const unsigned char *)token, sizeof(*token)))
         return 0;
 
     if (!ossl_assert(outl == sizeof(*token)))
@@ -280,7 +285,7 @@ static int srtm_compute_blinded(QUIC_SRTM *srtm, SRTM_ITEM *item,
 }
 
 int ossl_quic_srtm_add(QUIC_SRTM *srtm, void *opaque, uint64_t seq_num,
-                       const QUIC_STATELESS_RESET_TOKEN *token)
+    const QUIC_STATELESS_RESET_TOKEN *token)
 {
     SRTM_ITEM *item = NULL, *head = NULL, *new_head, *r_item;
 
@@ -294,9 +299,9 @@ int ossl_quic_srtm_add(QUIC_SRTM *srtm, void *opaque, uint64_t seq_num,
     if ((item = OPENSSL_zalloc(sizeof(*item))) == NULL)
         return 0;
 
-    item->opaque    = opaque;
-    item->seq_num   = seq_num;
-    item->srt       = *token;
+    item->opaque = opaque;
+    item->seq_num = seq_num;
+    item->srt = *token;
     if (!srtm_compute_blinded(srtm, item, &item->srt)) {
         OPENSSL_free(item);
         return 0;
@@ -369,7 +374,8 @@ static int srtm_remove_from_rev(QUIC_SRTM *srtm, SRTM_ITEM *item)
     } else {
         /* Find our entry in the SRT list */
         for (; rh_item->next_by_srt_blinded != item;
-               rh_item = rh_item->next_by_srt_blinded);
+            rh_item = rh_item->next_by_srt_blinded)
+            ;
         rh_item->next_by_srt_blinded = item->next_by_srt_blinded;
     }
 
@@ -439,9 +445,9 @@ int ossl_quic_srtm_cull(QUIC_SRTM *srtm, void *opaque)
 }
 
 int ossl_quic_srtm_lookup(QUIC_SRTM *srtm,
-                          const QUIC_STATELESS_RESET_TOKEN *token,
-                          size_t idx,
-                          void **opaque, uint64_t *seq_num)
+    const QUIC_STATELESS_RESET_TOKEN *token,
+    size_t idx,
+    void **opaque, uint64_t *seq_num)
 {
     SRTM_ITEM key, *item;
 
@@ -452,14 +458,15 @@ int ossl_quic_srtm_lookup(QUIC_SRTM *srtm,
         return 0;
 
     item = lh_SRTM_ITEM_retrieve(srtm->items_rev, &key);
-    for (; idx > 0 && item != NULL; --idx, item = item->next_by_srt_blinded);
+    for (; idx > 0 && item != NULL; --idx, item = item->next_by_srt_blinded)
+        ;
     if (item == NULL)
         return 0;
 
     if (opaque != NULL)
-        *opaque     = item->opaque;
+        *opaque = item->opaque;
     if (seq_num != NULL)
-        *seq_num    = item->seq_num;
+        *seq_num = item->seq_num;
 
     return 1;
 }
@@ -471,7 +478,7 @@ static size_t tokens_seen;
 
 struct check_args {
     uint32_t token;
-    int      mode;
+    int mode;
 };
 
 static void check_mark(SRTM_ITEM *item, void *arg)
@@ -493,7 +500,7 @@ static void check_mark(SRTM_ITEM *item, void *arg)
 
         ++tokens_seen;
         item->debug_token = token;
-        prev_opaque  = item->opaque;
+        prev_opaque = item->opaque;
         prev_seq_num = item->seq_num;
         have_prev = 1;
 
@@ -527,7 +534,7 @@ static void check_count(SRTM_ITEM *item, void *arg)
 void ossl_quic_srtm_check(const QUIC_SRTM *srtm)
 {
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-    struct check_args args = {0};
+    struct check_args args = { 0 };
     size_t tokens_expected, tokens_expected_old;
 
     args.token = token_next;
diff --git a/crypto/openssl/ssl/quic/quic_sstream.c b/crypto/openssl/ssl/quic/quic_sstream.c
index 1f0b5497fce5..dd5ab13fb95a 100644
--- a/crypto/openssl/ssl/quic/quic_sstream.c
+++ b/crypto/openssl/ssl/quic/quic_sstream.c
@@ -43,16 +43,16 @@ struct quic_sstream_st {
      *
      * Invariant: No logical byte is ever in both new_set and acked_set.
      */
-    UINT_SET        new_set, acked_set;
+    UINT_SET new_set, acked_set;
 
     /*
      * The current size of the stream is ring_buf.head_offset. If
      * have_final_size is true, this is also the final size of the stream.
      */
-    unsigned int    have_final_size     : 1;
-    unsigned int    sent_final_size     : 1;
-    unsigned int    acked_final_size    : 1;
-    unsigned int    cleanse             : 1;
+    unsigned int have_final_size : 1;
+    unsigned int sent_final_size : 1;
+    unsigned int acked_final_size : 1;
+    unsigned int cleanse : 1;
 };
 
 static void qss_cull(QUIC_SSTREAM *qss);
@@ -89,10 +89,10 @@ void ossl_quic_sstream_free(QUIC_SSTREAM *qss)
 }
 
 int ossl_quic_sstream_get_stream_frame(QUIC_SSTREAM *qss,
-                                       size_t skip,
-                                       OSSL_QUIC_FRAME_STREAM *hdr,
-                                       OSSL_QTX_IOVEC *iov,
-                                       size_t *num_iov)
+    size_t skip,
+    OSSL_QUIC_FRAME_STREAM *hdr,
+    OSSL_QTX_IOVEC *iov,
+    size_t *num_iov)
 {
     size_t num_iov_ = 0, src_len = 0, total_len = 0, i;
     uint64_t max_len;
@@ -115,9 +115,9 @@ int ossl_quic_sstream_get_stream_frame(QUIC_SSTREAM *qss,
             return 0;
 
         hdr->offset = qss->ring_buf.head_offset;
-        hdr->len    = 0;
+        hdr->len = 0;
         hdr->is_fin = 1;
-        *num_iov    = 0;
+        *num_iov = 0;
         return 1;
     }
 
@@ -135,8 +135,8 @@ int ossl_quic_sstream_get_stream_frame(QUIC_SSTREAM *qss,
             break;
 
         if (!ring_buf_get_buf_at(&qss->ring_buf,
-                                 range->range.start + total_len,
-                                 &src, &src_len))
+                range->range.start + total_len,
+                &src, &src_len))
             return 0;
 
         if (src_len == 0)
@@ -147,19 +147,19 @@ int ossl_quic_sstream_get_stream_frame(QUIC_SSTREAM *qss,
         if (total_len + src_len > max_len)
             src_len = (size_t)(max_len - total_len);
 
-        iov[num_iov_].buf       = src;
-        iov[num_iov_].buf_len   = src_len;
+        iov[num_iov_].buf = src;
+        iov[num_iov_].buf_len = src_len;
 
         total_len += src_len;
         ++num_iov_;
     }
 
     hdr->offset = range->range.start;
-    hdr->len    = total_len;
+    hdr->len = total_len;
     hdr->is_fin = qss->have_final_size
         && hdr->offset + hdr->len == qss->ring_buf.head_offset;
 
-    *num_iov    = num_iov_;
+    *num_iov = num_iov_;
     return 1;
 }
 
@@ -178,13 +178,13 @@ uint64_t ossl_quic_sstream_get_cur_size(QUIC_SSTREAM *qss)
 }
 
 int ossl_quic_sstream_mark_transmitted(QUIC_SSTREAM *qss,
-                                       uint64_t start,
-                                       uint64_t end)
+    uint64_t start,
+    uint64_t end)
 {
     UINT_RANGE r;
 
     r.start = start;
-    r.end   = end;
+    r.end = end;
 
     if (!ossl_uint_set_remove(&qss->new_set, &r))
         return 0;
@@ -193,7 +193,7 @@ int ossl_quic_sstream_mark_transmitted(QUIC_SSTREAM *qss,
 }
 
 int ossl_quic_sstream_mark_transmitted_fin(QUIC_SSTREAM *qss,
-                                           uint64_t final_size)
+    uint64_t final_size)
 {
     /*
      * We do not really need final_size since we already know the size of the
@@ -207,12 +207,12 @@ int ossl_quic_sstream_mark_transmitted_fin(QUIC_SSTREAM *qss,
 }
 
 int ossl_quic_sstream_mark_lost(QUIC_SSTREAM *qss,
-                                uint64_t start,
-                                uint64_t end)
+    uint64_t start,
+    uint64_t end)
 {
     UINT_RANGE r;
     r.start = start;
-    r.end   = end;
+    r.end = end;
 
     /*
      * We lost a range of stream data bytes, so reinsert them into the new set,
@@ -236,12 +236,12 @@ int ossl_quic_sstream_mark_lost_fin(QUIC_SSTREAM *qss)
 }
 
 int ossl_quic_sstream_mark_acked(QUIC_SSTREAM *qss,
-                                 uint64_t start,
-                                 uint64_t end)
+    uint64_t start,
+    uint64_t end)
 {
     UINT_RANGE r;
     r.start = start;
-    r.end   = end;
+    r.end = end;
 
     if (!ossl_uint_set_insert(&qss->acked_set, &r))
         return 0;
@@ -280,9 +280,9 @@ int ossl_quic_sstream_get_final_size(QUIC_SSTREAM *qss, uint64_t *final_size)
 }
 
 int ossl_quic_sstream_append(QUIC_SSTREAM *qss,
-                             const unsigned char *buf,
-                             size_t buf_len,
-                             size_t *consumed)
+    const unsigned char *buf,
+    size_t buf_len,
+    size_t *consumed)
 {
     size_t l, consumed_ = 0;
     UINT_RANGE r;
@@ -309,14 +309,14 @@ int ossl_quic_sstream_append(QUIC_SSTREAM *qss,
         if (l == 0)
             break;
 
-        buf         += l;
-        buf_len     -= l;
-        consumed_   += l;
+        buf += l;
+        buf_len -= l;
+        consumed_ += l;
     }
 
     if (consumed_ > 0) {
         r.start = old_ring_buf.head_offset;
-        r.end   = r.start + consumed_ - 1;
+        r.end = r.start + consumed_ - 1;
         assert(r.end + 1 == qss->ring_buf.head_offset);
         if (!ossl_uint_set_insert(&qss->new_set, &r)) {
             qss->ring_buf = old_ring_buf;
@@ -351,7 +351,7 @@ static void qss_cull(QUIC_SSTREAM *qss)
      */
     if (h != NULL)
         ring_buf_cpop_range(&qss->ring_buf, h->range.start, h->range.end,
-                            qss->cleanse);
+            qss->cleanse);
 }
 
 int ossl_quic_sstream_set_buffer_size(QUIC_SSTREAM *qss, size_t num_bytes)
@@ -401,8 +401,8 @@ int ossl_quic_sstream_is_totally_acked(QUIC_SSTREAM *qss)
 }
 
 void ossl_quic_sstream_adjust_iov(size_t len,
-                                  OSSL_QTX_IOVEC *iov,
-                                  size_t num_iov)
+    OSSL_QTX_IOVEC *iov,
+    size_t num_iov)
 {
     size_t running = 0, i, iovlen;
 
diff --git a/crypto/openssl/ssl/quic/quic_statm.c b/crypto/openssl/ssl/quic/quic_statm.c
index f1e0f6591411..1e8ba0e2d197 100644
--- a/crypto/openssl/ssl/quic/quic_statm.c
+++ b/crypto/openssl/ssl/quic/quic_statm.c
@@ -10,8 +10,8 @@
 #include "internal/quic_statm.h"
 
 void ossl_statm_update_rtt(OSSL_STATM *statm,
-                           OSSL_TIME ack_delay,
-                           OSSL_TIME override_latest_rtt)
+    OSSL_TIME ack_delay,
+    OSSL_TIME override_latest_rtt)
 {
     OSSL_TIME adjusted_rtt, latest_rtt = override_latest_rtt;
 
@@ -22,10 +22,10 @@ void ossl_statm_update_rtt(OSSL_STATM *statm,
         statm->latest_rtt = latest_rtt;
 
     if (!statm->have_first_sample) {
-        statm->min_rtt              = latest_rtt;
-        statm->smoothed_rtt         = latest_rtt;
-        statm->rtt_variance         = ossl_time_divide(latest_rtt, 2);
-        statm->have_first_sample    = 1;
+        statm->min_rtt = latest_rtt;
+        statm->smoothed_rtt = latest_rtt;
+        statm->rtt_variance = ossl_time_divide(latest_rtt, 2);
+        statm->have_first_sample = 1;
         return;
     }
 
@@ -43,22 +43,24 @@ void ossl_statm_update_rtt(OSSL_STATM *statm,
         adjusted_rtt = ossl_time_subtract(latest_rtt, ack_delay);
 
     statm->rtt_variance = ossl_time_divide(ossl_time_add(ossl_time_multiply(statm->rtt_variance, 3),
-                                                         ossl_time_abs_difference(statm->smoothed_rtt,
-                                                                              adjusted_rtt)), 4);
+                                               ossl_time_abs_difference(statm->smoothed_rtt,
+                                                   adjusted_rtt)),
+        4);
     statm->smoothed_rtt = ossl_time_divide(ossl_time_add(ossl_time_multiply(statm->smoothed_rtt, 7),
-                                                         adjusted_rtt), 8);
+                                               adjusted_rtt),
+        8);
 }
 
 /* RFC 9002 kInitialRtt value. RFC recommended value. */
-#define K_INITIAL_RTT               ossl_ms2time(333)
+#define K_INITIAL_RTT ossl_ms2time(333)
 
 int ossl_statm_init(OSSL_STATM *statm)
 {
-    statm->smoothed_rtt             = K_INITIAL_RTT;
-    statm->latest_rtt               = ossl_time_zero();
-    statm->min_rtt                  = ossl_time_infinite();
-    statm->rtt_variance             = ossl_time_divide(K_INITIAL_RTT, 2);
-    statm->have_first_sample        = 0;
+    statm->smoothed_rtt = K_INITIAL_RTT;
+    statm->latest_rtt = ossl_time_zero();
+    statm->min_rtt = ossl_time_infinite();
+    statm->rtt_variance = ossl_time_divide(K_INITIAL_RTT, 2);
+    statm->have_first_sample = 0;
     return 1;
 }
 
@@ -69,8 +71,8 @@ void ossl_statm_destroy(OSSL_STATM *statm)
 
 void ossl_statm_get_rtt_info(OSSL_STATM *statm, OSSL_RTT_INFO *rtt_info)
 {
-    rtt_info->min_rtt           = statm->min_rtt;
-    rtt_info->latest_rtt        = statm->latest_rtt;
-    rtt_info->smoothed_rtt      = statm->smoothed_rtt;
-    rtt_info->rtt_variance      = statm->rtt_variance;
+    rtt_info->min_rtt = statm->min_rtt;
+    rtt_info->latest_rtt = statm->latest_rtt;
+    rtt_info->smoothed_rtt = statm->smoothed_rtt;
+    rtt_info->rtt_variance = statm->rtt_variance;
 }
diff --git a/crypto/openssl/ssl/quic/quic_stream_map.c b/crypto/openssl/ssl/quic/quic_stream_map.c
index 64700b09d95e..b8175849a019 100644
--- a/crypto/openssl/ssl/quic/quic_stream_map.c
+++ b/crypto/openssl/ssl/quic/quic_stream_map.c
@@ -1,11 +1,11 @@
 /*
-* Copyright 2022-2024 The OpenSSL Project Authors. All Rights Reserved.
-*
-* Licensed under the Apache License 2.0 (the "License").  You may not use
-* this file except in compliance with the License.  You can obtain a copy
-* in the file LICENSE in the source distribution or at
-* https://www.openssl.org/source/license.html
-*/
+ * Copyright 2022-2026 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
 
 #include "internal/quic_stream_map.h"
 #include "internal/nelem.h"
@@ -20,11 +20,11 @@ static void shutdown_flush_done(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs);
 
 /* Circular list management. */
 static void list_insert_tail(QUIC_STREAM_LIST_NODE *l,
-                             QUIC_STREAM_LIST_NODE *n)
+    QUIC_STREAM_LIST_NODE *n)
 {
     /* Must not be in list. */
     assert(n->prev == NULL && n->next == NULL
-           && l->prev != NULL && l->next != NULL);
+        && l->prev != NULL && l->next != NULL);
 
     n->prev = l->prev;
     n->prev->next = n;
@@ -33,10 +33,10 @@ static void list_insert_tail(QUIC_STREAM_LIST_NODE *l,
 }
 
 static void list_remove(QUIC_STREAM_LIST_NODE *l,
-                        QUIC_STREAM_LIST_NODE *n)
+    QUIC_STREAM_LIST_NODE *n)
 {
     assert(n->prev != NULL && n->next != NULL
-           && n->prev != n && n->next != n);
+        && n->prev != n && n->next != n);
 
     n->prev->next = n->next;
     n->next->prev = n->prev;
@@ -44,11 +44,11 @@ static void list_remove(QUIC_STREAM_LIST_NODE *l,
 }
 
 static QUIC_STREAM *list_next(QUIC_STREAM_LIST_NODE *l, QUIC_STREAM_LIST_NODE *n,
-                              size_t off)
+    size_t off)
 {
     assert(n->prev != NULL && n->next != NULL
-           && (n == l || (n->prev != n && n->next != n))
-           && l->prev != NULL && l->next != NULL);
+        && (n == l || (n->prev != n && n->next != n))
+        && l->prev != NULL && l->next != NULL);
 
     n = n->next;
 
@@ -62,16 +62,14 @@ static QUIC_STREAM *list_next(QUIC_STREAM_LIST_NODE *l, QUIC_STREAM_LIST_NODE *n
     return (QUIC_STREAM *)(((char *)n) - off);
 }
 
-#define active_next(l, s)       list_next((l), &(s)->active_node, \
-                                          offsetof(QUIC_STREAM, active_node))
-#define accept_next(l, s)       list_next((l), &(s)->accept_node, \
-                                          offsetof(QUIC_STREAM, accept_node))
-#define ready_for_gc_next(l, s) list_next((l), &(s)->ready_for_gc_node, \
-                                          offsetof(QUIC_STREAM, ready_for_gc_node))
-#define accept_head(l)          list_next((l), (l), \
-                                          offsetof(QUIC_STREAM, accept_node))
-#define ready_for_gc_head(l)    list_next((l), (l), \
-                                          offsetof(QUIC_STREAM, ready_for_gc_node))
+#define active_next(l, s) list_next((l), &(s)->active_node, \
+    offsetof(QUIC_STREAM, active_node))
+#define accept_next(l, s) list_next((l), &(s)->accept_node, \
+    offsetof(QUIC_STREAM, accept_node))
+#define accept_head(l) list_next((l), (l), \
+    offsetof(QUIC_STREAM, accept_node))
+#define ready_for_gc_head(l) list_next((l), (l), \
+    offsetof(QUIC_STREAM, ready_for_gc_node))
 
 static unsigned long hash_stream(const QUIC_STREAM *s)
 {
@@ -88,11 +86,11 @@ static int cmp_stream(const QUIC_STREAM *a, const QUIC_STREAM *b)
 }
 
 int ossl_quic_stream_map_init(QUIC_STREAM_MAP *qsm,
-                              uint64_t (*get_stream_limit_cb)(int uni, void *arg),
-                              void *get_stream_limit_cb_arg,
-                              QUIC_RXFC *max_streams_bidi_rxfc,
-                              QUIC_RXFC *max_streams_uni_rxfc,
-                              int is_server)
+    uint64_t (*get_stream_limit_cb)(int uni, void *arg),
+    void *get_stream_limit_cb_arg,
+    QUIC_RXFC *max_streams_bidi_rxfc,
+    QUIC_RXFC *max_streams_uni_rxfc,
+    int is_server)
 {
     qsm->map = lh_QUIC_STREAM_new(hash_stream, cmp_stream);
     qsm->active_list.prev = qsm->active_list.next = &qsm->active_list;
@@ -100,18 +98,18 @@ int ossl_quic_stream_map_init(QUIC_STREAM_MAP *qsm,
     qsm->ready_for_gc_list.prev = qsm->ready_for_gc_list.next
         = &qsm->ready_for_gc_list;
     qsm->rr_stepping = 1;
-    qsm->rr_counter  = 0;
-    qsm->rr_cur      = NULL;
+    qsm->rr_counter = 0;
+    qsm->rr_cur = NULL;
 
-    qsm->num_accept_bidi    = 0;
-    qsm->num_accept_uni     = 0;
+    qsm->num_accept_bidi = 0;
+    qsm->num_accept_uni = 0;
     qsm->num_shutdown_flush = 0;
 
-    qsm->get_stream_limit_cb        = get_stream_limit_cb;
-    qsm->get_stream_limit_cb_arg    = get_stream_limit_cb_arg;
-    qsm->max_streams_bidi_rxfc      = max_streams_bidi_rxfc;
-    qsm->max_streams_uni_rxfc       = max_streams_uni_rxfc;
-    qsm->is_server                  = is_server;
+    qsm->get_stream_limit_cb = get_stream_limit_cb;
+    qsm->get_stream_limit_cb_arg = get_stream_limit_cb_arg;
+    qsm->max_streams_bidi_rxfc = max_streams_bidi_rxfc;
+    qsm->max_streams_uni_rxfc = max_streams_uni_rxfc;
+    qsm->is_server = is_server;
     return 1;
 }
 
@@ -124,6 +122,7 @@ static void release_each(QUIC_STREAM *stream, void *arg)
 
 void ossl_quic_stream_map_cleanup(QUIC_STREAM_MAP *qsm)
 {
+    lh_QUIC_STREAM_set_down_load(qsm->map, 0);
     ossl_quic_stream_map_visit(qsm, release_each, qsm);
 
     lh_QUIC_STREAM_free(qsm->map);
@@ -131,15 +130,15 @@ void ossl_quic_stream_map_cleanup(QUIC_STREAM_MAP *qsm)
 }
 
 void ossl_quic_stream_map_visit(QUIC_STREAM_MAP *qsm,
-                                void (*visit_cb)(QUIC_STREAM *stream, void *arg),
-                                void *visit_cb_arg)
+    void (*visit_cb)(QUIC_STREAM *stream, void *arg),
+    void *visit_cb_arg)
 {
     lh_QUIC_STREAM_doall_arg(qsm->map, visit_cb, visit_cb_arg);
 }
 
 QUIC_STREAM *ossl_quic_stream_map_alloc(QUIC_STREAM_MAP *qsm,
-                                        uint64_t stream_id,
-                                        int type)
+    uint64_t stream_id,
+    int type)
 {
     QUIC_STREAM *s;
     QUIC_STREAM key;
@@ -154,19 +153,19 @@ QUIC_STREAM *ossl_quic_stream_map_alloc(QUIC_STREAM_MAP *qsm,
     if (s == NULL)
         return NULL;
 
-    s->id           = stream_id;
-    s->type         = type;
-    s->as_server    = qsm->is_server;
-    s->send_state   = (ossl_quic_stream_is_local_init(s)
-                       || ossl_quic_stream_is_bidi(s))
+    s->id = stream_id;
+    s->type = type;
+    s->as_server = qsm->is_server;
+    s->send_state = (ossl_quic_stream_is_local_init(s)
+                        || ossl_quic_stream_is_bidi(s))
         ? QUIC_SSTREAM_STATE_READY
         : QUIC_SSTREAM_STATE_NONE;
-    s->recv_state   = (!ossl_quic_stream_is_local_init(s)
-                       || ossl_quic_stream_is_bidi(s))
+    s->recv_state = (!ossl_quic_stream_is_local_init(s)
+                        || ossl_quic_stream_is_bidi(s))
         ? QUIC_RSTREAM_STATE_RECV
         : QUIC_RSTREAM_STATE_NONE;
 
-    s->send_final_size  = UINT64_MAX;
+    s->send_final_size = UINT64_MAX;
 
     lh_QUIC_STREAM_insert(qsm->map, s);
     return s;
@@ -195,7 +194,7 @@ void ossl_quic_stream_map_release(QUIC_STREAM_MAP *qsm, QUIC_STREAM *stream)
 }
 
 QUIC_STREAM *ossl_quic_stream_map_get_by_id(QUIC_STREAM_MAP *qsm,
-                                            uint64_t stream_id)
+    uint64_t stream_id)
 {
     QUIC_STREAM key;
 
@@ -235,7 +234,7 @@ static void stream_map_mark_inactive(QUIC_STREAM_MAP *qsm, QUIC_STREAM *s)
 void ossl_quic_stream_map_set_rr_stepping(QUIC_STREAM_MAP *qsm, size_t stepping)
 {
     qsm->rr_stepping = stepping;
-    qsm->rr_counter  = 0;
+    qsm->rr_counter = 0;
 }
 
 static int stream_has_data_to_send(QUIC_STREAM *s)
@@ -267,12 +266,12 @@ static int stream_has_data_to_send(QUIC_STREAM *s)
      */
     num_iov = OSSL_NELEM(iov);
     if (!ossl_quic_sstream_get_stream_frame(s->sstream, 0, &shdr, iov,
-                                            &num_iov))
+            &num_iov))
         return 0;
 
     fc_credit = ossl_quic_txfc_get_credit(&s->txfc, 0);
-    fc_swm    = ossl_quic_txfc_get_swm(&s->txfc);
-    fc_limit  = fc_swm + fc_credit;
+    fc_swm = ossl_quic_txfc_get_swm(&s->txfc);
+    fc_limit = fc_swm + fc_credit;
 
     return (shdr.is_fin && shdr.len == 0) || shdr.offset < fc_limit;
 }
@@ -298,12 +297,11 @@ static int qsm_ready_for_gc(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs)
      * we don't need to worry about that here.
      */
     assert(!qs->deleted
-           || !ossl_quic_stream_has_send(qs)
-           || ossl_quic_stream_send_is_reset(qs)
-           || ossl_quic_stream_send_get_final_size(qs, NULL));
+        || !ossl_quic_stream_has_send(qs)
+        || ossl_quic_stream_send_is_reset(qs)
+        || ossl_quic_stream_send_get_final_size(qs, NULL));
 
-    return
-        qs->deleted
+    return qs->deleted
         && (!ossl_quic_stream_has_recv(qs)
             || recv_stream_fully_drained
             || qs->acked_stop_sending)
@@ -313,8 +311,8 @@ static int qsm_ready_for_gc(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs)
 }
 
 int ossl_quic_stream_map_is_local_allowed_by_stream_limit(QUIC_STREAM_MAP *qsm,
-                                                          uint64_t stream_ordinal,
-                                                          int is_uni)
+    uint64_t stream_ordinal,
+    int is_uni)
 {
     uint64_t stream_limit;
 
@@ -335,16 +333,16 @@ void ossl_quic_stream_map_update_state(QUIC_STREAM_MAP *qsm, QUIC_STREAM *s)
 
         allowed_by_stream_limit
             = ossl_quic_stream_map_is_local_allowed_by_stream_limit(qsm,
-                                                                    stream_ordinal,
-                                                                    is_uni);
+                stream_ordinal,
+                is_uni);
     }
 
     if (s->send_state == QUIC_SSTREAM_STATE_DATA_SENT
         && ossl_quic_sstream_is_totally_acked(s->sstream))
         ossl_quic_stream_map_notify_totally_acked(qsm, s);
     else if (s->shutdown_flush
-             && s->send_state == QUIC_SSTREAM_STATE_SEND
-             && ossl_quic_sstream_is_totally_acked(s->sstream))
+        && s->send_state == QUIC_SSTREAM_STATE_SEND
+        && ossl_quic_sstream_is_totally_acked(s->sstream))
         shutdown_flush_done(qsm, s);
 
     if (!s->ready_for_gc) {
@@ -357,10 +355,10 @@ void ossl_quic_stream_map_update_state(QUIC_STREAM_MAP *qsm, QUIC_STREAM *s)
         = allowed_by_stream_limit
         && !s->ready_for_gc
         && ((ossl_quic_stream_has_recv(s)
-             && !ossl_quic_stream_recv_is_reset(s)
-             && (s->recv_state == QUIC_RSTREAM_STATE_RECV
-                 && (s->want_max_stream_data
-                     || ossl_quic_rxfc_has_cwm_changed(&s->rxfc, 0))))
+                && !ossl_quic_stream_recv_is_reset(s)
+                && (s->recv_state == QUIC_RSTREAM_STATE_RECV
+                    && (s->want_max_stream_data
+                        || ossl_quic_rxfc_has_cwm_changed(&s->rxfc, 0))))
             || s->want_stop_sending
             || s->want_reset_stream
             || (!s->peer_stop_sending && stream_has_data_to_send(s)));
@@ -377,7 +375,7 @@ void ossl_quic_stream_map_update_state(QUIC_STREAM_MAP *qsm, QUIC_STREAM *s)
  */
 
 int ossl_quic_stream_map_ensure_send_part_id(QUIC_STREAM_MAP *qsm,
-                                             QUIC_STREAM *qs)
+    QUIC_STREAM *qs)
 {
     switch (qs->send_state) {
     case QUIC_SSTREAM_STATE_NONE:
@@ -399,7 +397,7 @@ int ossl_quic_stream_map_ensure_send_part_id(QUIC_STREAM_MAP *qsm,
 }
 
 int ossl_quic_stream_map_notify_all_data_sent(QUIC_STREAM_MAP *qsm,
-                                              QUIC_STREAM *qs)
+    QUIC_STREAM *qs)
 {
     switch (qs->send_state) {
     default:
@@ -428,7 +426,7 @@ static void shutdown_flush_done(QUIC_STREAM_MAP *qsm, QUIC_STREAM *qs)
 }
 
 int ossl_quic_stream_map_notify_totally_acked(QUIC_STREAM_MAP *qsm,
-                                              QUIC_STREAM *qs)
+    QUIC_STREAM *qs)
 {
     switch (qs->send_state) {
     default:
@@ -449,8 +447,8 @@ int ossl_quic_stream_map_notify_totally_acked(QUIC_STREAM_MAP *qsm,
 }
 
 int ossl_quic_stream_map_reset_stream_send_part(QUIC_STREAM_MAP *qsm,
-                                                QUIC_STREAM *qs,
-                                                uint64_t aec)
+    QUIC_STREAM *qs,
+    uint64_t aec)
 {
     switch (qs->send_state) {
     default:
@@ -488,9 +486,9 @@ int ossl_quic_stream_map_reset_stream_send_part(QUIC_STREAM_MAP *qsm,
 
         /* FALLTHROUGH */
     case QUIC_SSTREAM_STATE_DATA_SENT:
-        qs->reset_stream_aec    = aec;
-        qs->want_reset_stream   = 1;
-        qs->send_state          = QUIC_SSTREAM_STATE_RESET_SENT;
+        qs->reset_stream_aec = aec;
+        qs->want_reset_stream = 1;
+        qs->send_state = QUIC_SSTREAM_STATE_RESET_SENT;
 
         ossl_quic_sstream_free(qs->sstream);
         qs->sstream = NULL;
@@ -510,14 +508,14 @@ int ossl_quic_stream_map_reset_stream_send_part(QUIC_STREAM_MAP *qsm,
 }
 
 int ossl_quic_stream_map_notify_reset_stream_acked(QUIC_STREAM_MAP *qsm,
-                                                   QUIC_STREAM *qs)
+    QUIC_STREAM *qs)
 {
     switch (qs->send_state) {
     default:
         /* Wrong state - caller error. */
     case QUIC_SSTREAM_STATE_NONE:
         /* Stream without send part - caller error. */
-         return 0;
+        return 0;
 
     case QUIC_SSTREAM_STATE_RESET_SENT:
         qs->send_state = QUIC_SSTREAM_STATE_RESET_RECVD;
@@ -535,8 +533,8 @@ int ossl_quic_stream_map_notify_reset_stream_acked(QUIC_STREAM_MAP *qsm,
  */
 
 int ossl_quic_stream_map_notify_size_known_recv_part(QUIC_STREAM_MAP *qsm,
-                                                     QUIC_STREAM *qs,
-                                                     uint64_t final_size)
+    QUIC_STREAM *qs,
+    uint64_t final_size)
 {
     switch (qs->recv_state) {
     default:
@@ -552,7 +550,7 @@ int ossl_quic_stream_map_notify_size_known_recv_part(QUIC_STREAM_MAP *qsm,
 }
 
 int ossl_quic_stream_map_notify_totally_received(QUIC_STREAM_MAP *qsm,
-                                                 QUIC_STREAM *qs)
+    QUIC_STREAM *qs)
 {
     switch (qs->recv_state) {
     default:
@@ -562,14 +560,14 @@ int ossl_quic_stream_map_notify_totally_received(QUIC_STREAM_MAP *qsm,
         return 0;
 
     case QUIC_RSTREAM_STATE_SIZE_KNOWN:
-        qs->recv_state          = QUIC_RSTREAM_STATE_DATA_RECVD;
-        qs->want_stop_sending   = 0;
+        qs->recv_state = QUIC_RSTREAM_STATE_DATA_RECVD;
+        qs->want_stop_sending = 0;
         return 1;
     }
 }
 
 int ossl_quic_stream_map_notify_totally_read(QUIC_STREAM_MAP *qsm,
-                                             QUIC_STREAM *qs)
+    QUIC_STREAM *qs)
 {
     switch (qs->recv_state) {
     default:
@@ -589,9 +587,9 @@ int ossl_quic_stream_map_notify_totally_read(QUIC_STREAM_MAP *qsm,
 }
 
 int ossl_quic_stream_map_notify_reset_recv_part(QUIC_STREAM_MAP *qsm,
-                                                QUIC_STREAM *qs,
-                                                uint64_t app_error_code,
-                                                uint64_t final_size)
+    QUIC_STREAM *qs,
+    uint64_t app_error_code,
+    uint64_t final_size)
 {
     uint64_t prev_final_size;
 
@@ -609,11 +607,11 @@ int ossl_quic_stream_map_notify_reset_recv_part(QUIC_STREAM_MAP *qsm,
             /* Cannot change previous final size. */
             return 0;
 
-        qs->recv_state              = QUIC_RSTREAM_STATE_RESET_RECVD;
-        qs->peer_reset_stream_aec   = app_error_code;
+        qs->recv_state = QUIC_RSTREAM_STATE_RESET_RECVD;
+        qs->peer_reset_stream_aec = app_error_code;
 
         /* RFC 9000 s. 3.3: No point sending STOP_SENDING if already reset. */
-        qs->want_stop_sending       = 0;
+        qs->want_stop_sending = 0;
 
         /* QUIC_RSTREAM is no longer needed */
         ossl_quic_rstream_free(qs->rstream);
@@ -635,7 +633,7 @@ int ossl_quic_stream_map_notify_reset_recv_part(QUIC_STREAM_MAP *qsm,
 }
 
 int ossl_quic_stream_map_notify_app_read_reset_recv_part(QUIC_STREAM_MAP *qsm,
-                                                         QUIC_STREAM *qs)
+    QUIC_STREAM *qs)
 {
     switch (qs->recv_state) {
     default:
@@ -651,8 +649,8 @@ int ossl_quic_stream_map_notify_app_read_reset_recv_part(QUIC_STREAM_MAP *qsm,
 }
 
 int ossl_quic_stream_map_stop_sending_recv_part(QUIC_STREAM_MAP *qsm,
-                                                QUIC_STREAM *qs,
-                                                uint64_t aec)
+    QUIC_STREAM *qs,
+    uint64_t aec)
 {
     if (qs->stop_sending)
         return 0;
@@ -690,8 +688,8 @@ int ossl_quic_stream_map_stop_sending_recv_part(QUIC_STREAM_MAP *qsm,
         break;
     }
 
-    qs->stop_sending        = 1;
-    qs->stop_sending_aec    = aec;
+    qs->stop_sending = 1;
+    qs->stop_sending_aec = aec;
     return ossl_quic_stream_map_schedule_stop_sending(qsm, qs);
 }
 
@@ -735,7 +733,7 @@ QUIC_STREAM *ossl_quic_stream_map_peek_accept_queue(QUIC_STREAM_MAP *qsm)
 }
 
 void ossl_quic_stream_map_push_accept_queue(QUIC_STREAM_MAP *qsm,
-                                            QUIC_STREAM *s)
+    QUIC_STREAM *s)
 {
     list_insert_tail(&qsm->accept_list, &s->accept_node);
     if (ossl_quic_stream_is_bidi(s))
@@ -752,8 +750,8 @@ static QUIC_RXFC *qsm_get_max_streams_rxfc(QUIC_STREAM_MAP *qsm, QUIC_STREAM *s)
 }
 
 void ossl_quic_stream_map_remove_from_accept_queue(QUIC_STREAM_MAP *qsm,
-                                                   QUIC_STREAM *s,
-                                                   OSSL_TIME rtt)
+    QUIC_STREAM *s,
+    OSSL_TIME rtt)
 {
     QUIC_RXFC *max_streams_rxfc;
 
@@ -780,15 +778,10 @@ size_t ossl_quic_stream_map_get_total_accept_queue_len(QUIC_STREAM_MAP *qsm)
 
 void ossl_quic_stream_map_gc(QUIC_STREAM_MAP *qsm)
 {
-    QUIC_STREAM *qs, *qs_head, *qsn = NULL;
-
-    for (qs = qs_head = ready_for_gc_head(&qsm->ready_for_gc_list);
-         qs != NULL && qs != qs_head;
-         qs = qsn)
-    {
-         qsn = ready_for_gc_next(&qsm->ready_for_gc_list, qs);
+    QUIC_STREAM *qs;
 
-         ossl_quic_stream_map_release(qsm, qs);
+    while ((qs = ready_for_gc_head(&qsm->ready_for_gc_list)) != NULL) {
+        ossl_quic_stream_map_release(qsm, qs);
     }
 }
 
@@ -839,14 +832,14 @@ int ossl_quic_stream_map_is_shutdown_flush_finished(QUIC_STREAM_MAP *qsm)
  * ====================
  */
 void ossl_quic_stream_iter_init(QUIC_STREAM_ITER *it, QUIC_STREAM_MAP *qsm,
-                                int advance_rr)
+    int advance_rr)
 {
-    it->qsm    = qsm;
+    it->qsm = qsm;
     it->stream = it->first_stream = qsm->rr_cur;
     if (advance_rr && it->stream != NULL
         && ++qsm->rr_counter >= qsm->rr_stepping) {
         qsm->rr_counter = 0;
-        qsm->rr_cur     = active_next(&qsm->active_list, qsm->rr_cur);
+        qsm->rr_cur = active_next(&qsm->active_list, qsm->rr_cur);
     }
 }
 
diff --git a/crypto/openssl/ssl/quic/quic_thread_assist.c b/crypto/openssl/ssl/quic/quic_thread_assist.c
index 5315bf1662c6..d875e3ad0f23 100644
--- a/crypto/openssl/ssl/quic/quic_thread_assist.c
+++ b/crypto/openssl/ssl/quic/quic_thread_assist.c
@@ -64,23 +64,23 @@ static unsigned int assist_thread_main(void *arg)
 }
 
 int ossl_quic_thread_assist_init_start(QUIC_THREAD_ASSIST *qta,
-                                       QUIC_CHANNEL *ch)
+    QUIC_CHANNEL *ch)
 {
     CRYPTO_MUTEX *mutex = ossl_quic_channel_get_mutex(ch);
 
     if (mutex == NULL)
         return 0;
 
-    qta->ch         = ch;
-    qta->teardown   = 0;
-    qta->joined     = 0;
+    qta->ch = ch;
+    qta->teardown = 0;
+    qta->joined = 0;
 
     qta->cv = ossl_crypto_condvar_new();
     if (qta->cv == NULL)
         return 0;
 
     qta->t = ossl_crypto_thread_native_start(assist_thread_main,
-                                             qta, /*joinable=*/1);
+        qta, /*joinable=*/1);
     if (qta->t == NULL) {
         ossl_crypto_condvar_free(&qta->cv);
         return 0;
@@ -131,8 +131,8 @@ int ossl_quic_thread_assist_cleanup(QUIC_THREAD_ASSIST *qta)
     ossl_crypto_condvar_free(&qta->cv);
     ossl_crypto_thread_native_clean(qta->t);
 
-    qta->ch     = NULL;
-    qta->t      = NULL;
+    qta->ch = NULL;
+    qta->t = NULL;
     return 1;
 }
 
diff --git a/crypto/openssl/ssl/quic/quic_tls.c b/crypto/openssl/ssl/quic/quic_tls.c
index ccc053203d4f..587685d0b233 100644
--- a/crypto/openssl/ssl/quic/quic_tls.c
+++ b/crypto/openssl/ssl/quic/quic_tls.c
@@ -15,12 +15,14 @@
 #include "internal/quic_types.h"
 #include "internal/ssl_unwrap.h"
 
-#define QUIC_TLS_FATAL(rl, ad, err) \
-    do { \
-        if ((rl) != NULL) (rl)->alert = (ad); \
+#define QUIC_TLS_FATAL(rl, ad, err)    \
+    do {                               \
+        if ((rl) != NULL)              \
+            (rl)->alert = (ad);        \
         ERR_raise(ERR_LIB_SSL, (err)); \
-        if ((rl) != NULL) (rl)->qtls->inerror = 1; \
-    } while(0)
+        if ((rl) != NULL)              \
+            (rl)->qtls->inerror = 1;   \
+    } while (0)
 
 struct quic_tls_st {
     QUIC_TLS_ARGS args;
@@ -95,18 +97,18 @@ static int quic_free(OSSL_RECORD_LAYER *r);
 
 static int
 quic_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
-                      int role, int direction, int level, uint16_t epoch,
-                      unsigned char *secret, size_t secretlen,
-                      unsigned char *key, size_t keylen, unsigned char *iv,
-                      size_t ivlen, unsigned char *mackey, size_t mackeylen,
-                      const EVP_CIPHER *ciph, size_t taglen,
-                      int mactype,
-                      const EVP_MD *md, COMP_METHOD *comp,
-                      const EVP_MD *kdfdigest, BIO *prev, BIO *transport,
-                      BIO *next, BIO_ADDR *local, BIO_ADDR *peer,
-                      const OSSL_PARAM *settings, const OSSL_PARAM *options,
-                      const OSSL_DISPATCH *fns, void *cbarg, void *rlarg,
-                      OSSL_RECORD_LAYER **retrl)
+    int role, int direction, int level, uint16_t epoch,
+    unsigned char *secret, size_t secretlen,
+    unsigned char *key, size_t keylen, unsigned char *iv,
+    size_t ivlen, unsigned char *mackey, size_t mackeylen,
+    const EVP_CIPHER *ciph, size_t taglen,
+    int mactype,
+    const EVP_MD *md, COMP_METHOD *comp,
+    const EVP_MD *kdfdigest, BIO *prev, BIO *transport,
+    BIO *next, BIO_ADDR *local, BIO_ADDR *peer,
+    const OSSL_PARAM *settings, const OSSL_PARAM *options,
+    const OSSL_DISPATCH *fns, void *cbarg, void *rlarg,
+    OSSL_RECORD_LAYER **retrl)
 {
     OSSL_RECORD_LAYER *rl = OPENSSL_zalloc(sizeof(*rl));
     int qdir;
@@ -182,15 +184,15 @@ quic_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
     }
 
     if (!rl->qtls->args.yield_secret_cb(level, qdir, suite_id,
-                                        (EVP_MD *)kdfdigest, secret, secretlen,
-                                        rl->qtls->args.yield_secret_cb_arg)) {
+            (EVP_MD *)kdfdigest, secret, secretlen,
+            rl->qtls->args.yield_secret_cb_arg)) {
         QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         EVP_MD_free((EVP_MD *)kdfdigest);
         goto err;
     }
 
     return 1;
- err:
+err:
     *retrl = NULL;
     quic_free(rl);
     return 0;
@@ -234,15 +236,15 @@ static int quic_processed_read_pending(OSSL_RECORD_LAYER *rl)
 }
 
 static size_t quic_get_max_records(OSSL_RECORD_LAYER *rl, uint8_t type,
-                                   size_t len,
-                                   size_t maxfrag, size_t *preffrag)
+    size_t len,
+    size_t maxfrag, size_t *preffrag)
 {
     return 1;
 }
 
 static int quic_write_records(OSSL_RECORD_LAYER *rl,
-                              OSSL_RECORD_TEMPLATE *template,
-                              size_t numtempl)
+    OSSL_RECORD_TEMPLATE *template,
+    size_t numtempl)
 {
     size_t consumed;
     unsigned char alert;
@@ -263,8 +265,8 @@ static int quic_write_records(OSSL_RECORD_LAYER *rl,
          * and manufacture a dummy record header
          */
         dummyrec[0] = (rl->level == OSSL_RECORD_PROTECTION_LEVEL_NONE)
-                        ? template->type
-                        : SSL3_RT_APPLICATION_DATA;
+            ? template->type
+            : SSL3_RT_APPLICATION_DATA;
         dummyrec[1] = (unsigned char)((template->version >> 8) & 0xff);
         dummyrec[2] = (unsigned char)(template->version & 0xff);
         /*
@@ -277,11 +279,11 @@ static int quic_write_records(OSSL_RECORD_LAYER *rl,
         dummyrec[4] = (unsigned char)(template->buflen & 0xff);
 
         rl->msg_callback(1, TLS1_3_VERSION, SSL3_RT_HEADER, dummyrec,
-                            SSL3_RT_HEADER_LENGTH, rl->cbarg);
+            SSL3_RT_HEADER_LENGTH, rl->cbarg);
 
         if (rl->level != OSSL_RECORD_PROTECTION_LEVEL_NONE) {
             rl->msg_callback(1, TLS1_3_VERSION, SSL3_RT_INNER_CONTENT_TYPE,
-                             &template->type, 1, rl->cbarg);
+                &template->type, 1, rl->cbarg);
         }
     }
 
@@ -314,9 +316,9 @@ static int quic_write_records(OSSL_RECORD_LAYER *rl,
          * failure)
          */
         if (!rl->qtls->args.crypto_send_cb(template->buf + rl->written,
-                                           template->buflen - rl->written,
-                                           &consumed,
-                                           rl->qtls->args.crypto_send_cb_arg)) {
+                template->buflen - rl->written,
+                &consumed,
+                rl->qtls->args.crypto_send_cb_arg)) {
             QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return OSSL_RECORD_RETURN_FATAL;
         }
@@ -360,9 +362,9 @@ static int quic_retry_write_records(OSSL_RECORD_LAYER *rl)
 }
 
 static int quic_read_record(OSSL_RECORD_LAYER *rl, void **rechandle,
-                            int *rversion, uint8_t *type, const unsigned char **data,
-                            size_t *datalen, uint16_t *epoch,
-                            unsigned char *seq_num)
+    int *rversion, uint8_t *type, const unsigned char **data,
+    size_t *datalen, uint16_t *epoch,
+    unsigned char *seq_num)
 {
     if (rl->recread != 0 || rl->recunreleased != 0)
         return OSSL_RECORD_RETURN_FATAL;
@@ -370,7 +372,7 @@ static int quic_read_record(OSSL_RECORD_LAYER *rl, void **rechandle,
     BIO_clear_retry_flags(rl->dummybio);
 
     if (!rl->qtls->args.crypto_recv_rcd_cb(data, datalen,
-                                           rl->qtls->args.crypto_recv_rcd_cb_arg)) {
+            rl->qtls->args.crypto_recv_rcd_cb_arg)) {
         QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return OSSL_RECORD_RETURN_FATAL;
     }
@@ -394,8 +396,8 @@ static int quic_read_record(OSSL_RECORD_LAYER *rl, void **rechandle,
          * and manufacture a dummy record header
          */
         dummyrec[0] = (rl->level == OSSL_RECORD_PROTECTION_LEVEL_NONE)
-                      ? SSL3_RT_HANDSHAKE
-                      : SSL3_RT_APPLICATION_DATA;
+            ? SSL3_RT_HANDSHAKE
+            : SSL3_RT_APPLICATION_DATA;
         dummyrec[1] = (unsigned char)((TLS1_2_VERSION >> 8) & 0xff);
         dummyrec[2] = (unsigned char)(TLS1_2_VERSION & 0xff);
         /*
@@ -406,28 +408,28 @@ static int quic_read_record(OSSL_RECORD_LAYER *rl, void **rechandle,
         dummyrec[4] = (unsigned char)(*datalen & 0xff);
 
         rl->msg_callback(0, TLS1_3_VERSION, SSL3_RT_HEADER, dummyrec,
-                         SSL3_RT_HEADER_LENGTH, rl->cbarg);
+            SSL3_RT_HEADER_LENGTH, rl->cbarg);
         rl->msg_callback(0, TLS1_3_VERSION, SSL3_RT_INNER_CONTENT_TYPE, type, 1,
-                         rl->cbarg);
+            rl->cbarg);
     }
 
     return OSSL_RECORD_RETURN_SUCCESS;
 }
 
 static int quic_release_record(OSSL_RECORD_LAYER *rl, void *rechandle,
-                               size_t length)
+    size_t length)
 {
     if (!ossl_assert(rl->recread > 0)
-            || !ossl_assert(rl->recunreleased <= rl->recread)
-            || !ossl_assert(rl == rechandle)
-            || !ossl_assert(length <= rl->recunreleased)) {
+        || !ossl_assert(rl->recunreleased <= rl->recread)
+        || !ossl_assert(rl == rechandle)
+        || !ossl_assert(length <= rl->recunreleased)) {
         QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return OSSL_RECORD_RETURN_FATAL;
     }
 
     if (rl->recunreleased == length) {
         if (!rl->qtls->args.crypto_release_rcd_cb(rl->recread,
-                                                  rl->qtls->args.crypto_release_rcd_cb_arg)) {
+                rl->qtls->args.crypto_release_rcd_cb_arg)) {
             QUIC_TLS_FATAL(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return OSSL_RECORD_RETURN_FATAL;
         }
@@ -469,7 +471,7 @@ static void quic_set_max_pipelines(OSSL_RECORD_LAYER *rl, size_t max_pipelines)
 }
 
 static void quic_get_state(OSSL_RECORD_LAYER *rl, const char **shortstr,
-                    const char **longstr)
+    const char **longstr)
 {
     /*
      * According to the docs, valid read state strings are: "RH"/"read header",
@@ -595,10 +597,10 @@ static const OSSL_RECORD_METHOD quic_tls_record_method = {
 };
 
 static int add_transport_params_cb(SSL *s, unsigned int ext_type,
-                                   unsigned int context,
-                                   const unsigned char **out, size_t *outlen,
-                                   X509 *x, size_t chainidx, int *al,
-                                   void *add_arg)
+    unsigned int context,
+    const unsigned char **out, size_t *outlen,
+    X509 *x, size_t chainidx, int *al,
+    void *add_arg)
 {
     QUIC_TLS *qtls = add_arg;
 
@@ -609,23 +611,23 @@ static int add_transport_params_cb(SSL *s, unsigned int ext_type,
 }
 
 static void free_transport_params_cb(SSL *s, unsigned int ext_type,
-                                     unsigned int context,
-                                     const unsigned char *out,
-                                     void *add_arg)
+    unsigned int context,
+    const unsigned char *out,
+    void *add_arg)
 {
 }
 
 static int parse_transport_params_cb(SSL *s, unsigned int ext_type,
-                                     unsigned int context,
-                                     const unsigned char *in,
-                                     size_t inlen, X509 *x,
-                                     size_t chainidx,
-                                     int *al, void *parse_arg)
+    unsigned int context,
+    const unsigned char *in,
+    size_t inlen, X509 *x,
+    size_t chainidx,
+    int *al, void *parse_arg)
 {
     QUIC_TLS *qtls = parse_arg;
 
     return qtls->args.got_transport_params_cb(in, inlen,
-                                              qtls->args.got_transport_params_cb_arg);
+        qtls->args.got_transport_params_cb_arg);
 }
 
 QUIC_TLS *ossl_quic_tls_new(const QUIC_TLS_ARGS *args)
@@ -661,10 +663,10 @@ void ossl_quic_tls_free(QUIC_TLS *qtls)
 }
 
 static int raise_error(QUIC_TLS *qtls, uint64_t error_code,
-                       const char *error_msg,
-                       const char *src_file,
-                       int src_line,
-                       const char *src_func)
+    const char *error_msg,
+    const char *src_file,
+    int src_line,
+    const char *src_func)
 {
     /*
      * When QTLS fails, add a "cover letter" error with information, potentially
@@ -676,8 +678,8 @@ static int raise_error(QUIC_TLS *qtls, uint64_t error_code,
     ERR_new();
     ERR_set_debug(src_file, src_line, src_func);
     ERR_set_error(ERR_LIB_SSL, SSL_R_QUIC_HANDSHAKE_LAYER_ERROR,
-                  "handshake layer error, error code %llu (0x%llx) (\"%s\")",
-                  error_code, error_code, error_msg);
+        "handshake layer error, error code %llu (0x%llx) (\"%s\")",
+        error_code, error_code, error_msg);
 
     if (qtls->args.ossl_quic) {
         OSSL_ERR_STATE_save_to_mark(qtls->error_state);
@@ -686,24 +688,24 @@ static int raise_error(QUIC_TLS *qtls, uint64_t error_code,
          * We record the error information reported via the QUIC protocol
          * separately.
          */
-        qtls->error_code        = error_code;
-        qtls->error_msg         = error_msg;
-        qtls->inerror           = 1;
+        qtls->error_code = error_code;
+        qtls->error_msg = error_msg;
+        qtls->inerror = 1;
 
         ERR_pop_to_mark();
     }
     return 0;
 }
 
-#define RAISE_ERROR(qtls, error_code, error_msg) \
+#define RAISE_ERROR(qtls, error_code, error_msg)   \
     raise_error((qtls), (error_code), (error_msg), \
-                OPENSSL_FILE, OPENSSL_LINE, OPENSSL_FUNC)
+        OPENSSL_FILE, OPENSSL_LINE, OPENSSL_FUNC)
 
 #ifndef OPENSSL_NO_QUIC
-# define RAISE_INTERNAL_ERROR(qtls) \
+#define RAISE_INTERNAL_ERROR(qtls) \
     RAISE_ERROR((qtls), OSSL_QUIC_ERR_INTERNAL_ERROR, "internal error")
 #else
-# define RAISE_INTERNAL_ERROR(qtls) \
+#define RAISE_INTERNAL_ERROR(qtls) \
     RAISE_ERROR((qtls), 0x01, "internal error")
 #endif
 
@@ -729,15 +731,15 @@ int ossl_quic_tls_configure(QUIC_TLS *qtls)
     ossl_ssl_set_custom_record_layer(sc, &quic_tls_record_method, qtls);
 
     if (!ossl_tls_add_custom_ext_intern(NULL, &sc->cert->custext,
-                                        qtls->args.is_server ? ENDPOINT_SERVER
-                                                             : ENDPOINT_CLIENT,
-                                        TLSEXT_TYPE_quic_transport_parameters,
-                                        SSL_EXT_TLS1_3_ONLY
-                                        | SSL_EXT_CLIENT_HELLO
-                                        | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
-                                        add_transport_params_cb,
-                                        free_transport_params_cb, qtls,
-                                        parse_transport_params_cb, qtls))
+            qtls->args.is_server ? ENDPOINT_SERVER
+                                 : ENDPOINT_CLIENT,
+            TLSEXT_TYPE_quic_transport_parameters,
+            SSL_EXT_TLS1_3_ONLY
+                | SSL_EXT_CLIENT_HELLO
+                | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
+            add_transport_params_cb,
+            free_transport_params_cb, qtls,
+            parse_transport_params_cb, qtls))
         return 0;
 
     sc->s3.flags |= TLS1_FLAGS_QUIC;
@@ -798,7 +800,7 @@ int ossl_quic_tls_tick(QUIC_TLS *qtls)
         } else {
             if (sc->ext.alpn == NULL || sc->ext.alpn_len == 0)
                 return RAISE_ERROR(qtls, OSSL_QUIC_ERR_CRYPTO_NO_APP_PROTO,
-                                   "ALPN must be configured when using QUIC");
+                    "ALPN must be configured when using QUIC");
         }
 
         if (!ossl_quic_tls_configure(qtls))
@@ -825,7 +827,7 @@ int ossl_quic_tls_tick(QUIC_TLS *qtls)
 
     if (ret <= 0) {
         err = ossl_ssl_get_error(qtls->args.s, ret,
-                                 /*check_err=*/ERR_count_to_mark() > 0);
+            /*check_err=*/ERR_count_to_mark() > 0);
 
         switch (err) {
         case SSL_ERROR_WANT_READ:
@@ -846,7 +848,7 @@ int ossl_quic_tls_tick(QUIC_TLS *qtls)
         SSL_get0_alpn_selected(qtls->args.s, &alpn, &alpnlen);
         if (alpn == NULL || alpnlen == 0)
             return RAISE_ERROR(qtls, OSSL_QUIC_ERR_CRYPTO_NO_APP_PROTO,
-                               "no application protocol negotiated");
+                "no application protocol negotiated");
 
         qtls->complete = 1;
         ERR_pop_to_mark();
@@ -866,26 +868,26 @@ void ossl_quic_tls_clear(QUIC_TLS *qtls)
 }
 
 int ossl_quic_tls_set_transport_params(QUIC_TLS *qtls,
-                                       const unsigned char *transport_params,
-                                       size_t transport_params_len)
+    const unsigned char *transport_params,
+    size_t transport_params_len)
 {
     if (qtls->local_transport_params_consumed)
         return 0;
 
-    qtls->local_transport_params       = transport_params;
-    qtls->local_transport_params_len   = transport_params_len;
+    qtls->local_transport_params = transport_params;
+    qtls->local_transport_params_len = transport_params_len;
     return 1;
 }
 
 int ossl_quic_tls_get_error(QUIC_TLS *qtls,
-                            uint64_t *error_code,
-                            const char **error_msg,
-                            ERR_STATE **error_state)
+    uint64_t *error_code,
+    const char **error_msg,
+    ERR_STATE **error_state)
 {
     if (qtls->inerror) {
-        *error_code     = qtls->error_code;
-        *error_msg      = qtls->error_msg;
-        *error_state    = qtls->error_state;
+        *error_code = qtls->error_code;
+        *error_msg = qtls->error_msg;
+        *error_state = qtls->error_state;
     }
 
     return qtls->inerror;
diff --git a/crypto/openssl/ssl/quic/quic_tls_api.c b/crypto/openssl/ssl/quic/quic_tls_api.c
index ea8924f2c416..fba852f59008 100644
--- a/crypto/openssl/ssl/quic/quic_tls_api.c
+++ b/crypto/openssl/ssl/quic/quic_tls_api.c
@@ -13,7 +13,7 @@
 #include "../ssl_local.h"
 
 static int crypto_send_cb(const unsigned char *buf, size_t buf_len,
-                          size_t *consumed, void *arg)
+    size_t *consumed, void *arg)
 {
     SSL *s = (SSL *)arg;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
@@ -24,7 +24,7 @@ static int crypto_send_cb(const unsigned char *buf, size_t buf_len,
 }
 
 static int crypto_recv_rcd_cb(const unsigned char **buf, size_t *bytes_read,
-                              void *arg)
+    void *arg)
 {
     SSL *s = (SSL *)arg;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
@@ -44,9 +44,9 @@ static int crypto_release_rcd_cb(size_t bytes_read, void *arg)
     return sc->qtcb.crypto_release_rcd_cb(s, bytes_read, sc->qtarg);
 }
 static int yield_secret_cb(uint32_t prot_level, int direction,
-                           uint32_t suite_id, EVP_MD *md,
-                           const unsigned char *secret, size_t secret_len,
-                           void *arg)
+    uint32_t suite_id, EVP_MD *md,
+    const unsigned char *secret, size_t secret_len,
+    void *arg)
 {
     SSL *s = (SSL *)arg;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
@@ -54,12 +54,12 @@ static int yield_secret_cb(uint32_t prot_level, int direction,
     if (sc == NULL)
         return 0;
     return sc->qtcb.yield_secret_cb(s, prot_level, direction,
-                                    secret, secret_len, sc->qtarg);
+        secret, secret_len, sc->qtarg);
 }
 
 static int got_transport_params_cb(const unsigned char *params,
-                                   size_t params_len,
-                                   void *arg)
+    size_t params_len,
+    void *arg)
 {
     SSL *s = (SSL *)arg;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
@@ -80,7 +80,7 @@ static int alert_cb(void *arg, unsigned char alert_code)
 }
 
 static int tls_callbacks_from_dispatch(OSSL_QUIC_TLS_CALLBACKS *qtcb,
-                                       const OSSL_DISPATCH *qtdis)
+    const OSSL_DISPATCH *qtdis)
 {
     for (; qtdis->function_id != 0; qtdis++) {
         switch (qtdis->function_id) {
@@ -90,38 +90,33 @@ static int tls_callbacks_from_dispatch(OSSL_QUIC_TLS_CALLBACKS *qtcb,
             break;
         case OSSL_FUNC_SSL_QUIC_TLS_CRYPTO_RECV_RCD:
             if (qtcb->crypto_recv_rcd_cb == NULL)
-                qtcb->crypto_recv_rcd_cb =
-                    OSSL_FUNC_SSL_QUIC_TLS_crypto_recv_rcd(qtdis);
+                qtcb->crypto_recv_rcd_cb = OSSL_FUNC_SSL_QUIC_TLS_crypto_recv_rcd(qtdis);
             break;
         case OSSL_FUNC_SSL_QUIC_TLS_CRYPTO_RELEASE_RCD:
             if (qtcb->crypto_release_rcd_cb == NULL)
-                qtcb->crypto_release_rcd_cb =
-                    OSSL_FUNC_SSL_QUIC_TLS_crypto_release_rcd(qtdis);
+                qtcb->crypto_release_rcd_cb = OSSL_FUNC_SSL_QUIC_TLS_crypto_release_rcd(qtdis);
             break;
         case OSSL_FUNC_SSL_QUIC_TLS_YIELD_SECRET:
             if (qtcb->yield_secret_cb == NULL)
-                qtcb->yield_secret_cb =
-                    OSSL_FUNC_SSL_QUIC_TLS_yield_secret(qtdis);
+                qtcb->yield_secret_cb = OSSL_FUNC_SSL_QUIC_TLS_yield_secret(qtdis);
             break;
         case OSSL_FUNC_SSL_QUIC_TLS_GOT_TRANSPORT_PARAMS:
             if (qtcb->got_transport_params_cb == NULL)
-                qtcb->got_transport_params_cb =
-                    OSSL_FUNC_SSL_QUIC_TLS_got_transport_params(qtdis);
+                qtcb->got_transport_params_cb = OSSL_FUNC_SSL_QUIC_TLS_got_transport_params(qtdis);
             break;
         case OSSL_FUNC_SSL_QUIC_TLS_ALERT:
             if (qtcb->alert_cb == NULL)
-                qtcb->alert_cb =
-                    OSSL_FUNC_SSL_QUIC_TLS_alert(qtdis);
+                qtcb->alert_cb = OSSL_FUNC_SSL_QUIC_TLS_alert(qtdis);
             break;
         }
     }
 
     if (qtcb->crypto_send_cb == NULL
-            || qtcb->crypto_recv_rcd_cb == NULL
-            || qtcb->crypto_release_rcd_cb == NULL
-            || qtcb->yield_secret_cb == NULL
-            || qtcb->got_transport_params_cb == NULL
-            || qtcb->alert_cb == NULL) {
+        || qtcb->crypto_recv_rcd_cb == NULL
+        || qtcb->crypto_release_rcd_cb == NULL
+        || qtcb->yield_secret_cb == NULL
+        || qtcb->got_transport_params_cb == NULL
+        || qtcb->alert_cb == NULL) {
         ERR_raise(ERR_LIB_SSL, SSL_R_MISSING_QUIC_TLS_FUNCTIONS);
         return 0;
     }
@@ -174,8 +169,8 @@ int SSL_set_quic_tls_cbs(SSL *s, const OSSL_DISPATCH *qtdis, void *arg)
 }
 
 int SSL_set_quic_tls_transport_params(SSL *s,
-                                      const unsigned char *params,
-                                      size_t params_len)
+    const unsigned char *params,
+    size_t params_len)
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 
diff --git a/crypto/openssl/ssl/quic/quic_trace.c b/crypto/openssl/ssl/quic/quic_trace.c
index 936707a573f1..05debed99ff3 100644
--- a/crypto/openssl/ssl/quic/quic_trace.c
+++ b/crypto/openssl/ssl/quic/quic_trace.c
@@ -90,7 +90,8 @@ static int frame_ack(BIO *bio, PACKET *pkt)
         /* In case sizeof(uint64_t) > sizeof(size_t) */
         || total_ranges > SIZE_MAX / sizeof(ack_ranges[0])
         || (ack_ranges = OPENSSL_zalloc(sizeof(ack_ranges[0])
-                                        * (size_t)total_ranges)) == NULL)
+                * (size_t)total_ranges))
+            == NULL)
         return ret;
 
     ack.ack_ranges = ack_ranges;
@@ -101,21 +102,21 @@ static int frame_ack(BIO *bio, PACKET *pkt)
         goto end;
 
     BIO_printf(bio, "    Largest acked: %llu\n",
-               (unsigned long long)ack.ack_ranges[0].end);
+        (unsigned long long)ack.ack_ranges[0].end);
     BIO_printf(bio, "    Ack delay (raw) %llu\n",
-               (unsigned long long)ossl_time2ticks(ack.delay_time));
+        (unsigned long long)ossl_time2ticks(ack.delay_time));
     BIO_printf(bio, "    Ack range count: %llu\n",
-               (unsigned long long)total_ranges - 1);
+        (unsigned long long)total_ranges - 1);
     BIO_printf(bio, "    First ack range: %llu\n",
-               (unsigned long long)(ack.ack_ranges[0].end
-                                    - ack.ack_ranges[0].start));
+        (unsigned long long)(ack.ack_ranges[0].end
+            - ack.ack_ranges[0].start));
     for (i = 1; i < total_ranges; i++) {
         BIO_printf(bio, "    Gap: %llu\n",
-                   (unsigned long long)(ack.ack_ranges[i - 1].start
-                                        - ack.ack_ranges[i].end - 2));
+            (unsigned long long)(ack.ack_ranges[i - 1].start
+                - ack.ack_ranges[i].end - 2));
         BIO_printf(bio, "    Ack range len: %llu\n",
-                   (unsigned long long)(ack.ack_ranges[i].end
-                                        - ack.ack_ranges[i].start));
+            (unsigned long long)(ack.ack_ranges[i].end
+                - ack.ack_ranges[i].start));
     }
 
     ret = 1;
@@ -132,11 +133,11 @@ static int frame_reset_stream(BIO *bio, PACKET *pkt)
         return 0;
 
     BIO_printf(bio, "    Stream id: %llu\n",
-               (unsigned long long)frame_data.stream_id);
+        (unsigned long long)frame_data.stream_id);
     BIO_printf(bio, "    App Protocol Error Code: %llu\n",
-               (unsigned long long)frame_data.app_error_code);
+        (unsigned long long)frame_data.app_error_code);
     BIO_printf(bio, "    Final size: %llu\n",
-               (unsigned long long)frame_data.final_size);
+        (unsigned long long)frame_data.final_size);
 
     return 1;
 }
@@ -149,9 +150,9 @@ static int frame_stop_sending(BIO *bio, PACKET *pkt)
         return 0;
 
     BIO_printf(bio, "    Stream id: %llu\n",
-               (unsigned long long)frame_data.stream_id);
+        (unsigned long long)frame_data.stream_id);
     BIO_printf(bio, "    App Protocol Error Code: %llu\n",
-               (unsigned long long)frame_data.app_error_code);
+        (unsigned long long)frame_data.app_error_code);
 
     return 1;
 }
@@ -190,7 +191,7 @@ static int frame_stream(BIO *bio, PACKET *pkt, uint64_t frame_type)
     OSSL_QUIC_FRAME_STREAM frame_data;
 
     BIO_puts(bio, "Stream");
-    switch(frame_type) {
+    switch (frame_type) {
     case OSSL_QUIC_FRAME_TYPE_STREAM:
         BIO_puts(bio, "\n");
         break;
@@ -231,9 +232,9 @@ static int frame_stream(BIO *bio, PACKET *pkt, uint64_t frame_type)
         return 0;
 
     BIO_printf(bio, "    Stream id: %llu\n",
-               (unsigned long long)frame_data.stream_id);
+        (unsigned long long)frame_data.stream_id);
     BIO_printf(bio, "    Offset: %llu\n",
-               (unsigned long long)frame_data.offset);
+        (unsigned long long)frame_data.offset);
     /*
      * It would be nice to find a way of passing the implicit length through
      * to the msg_callback. But this is not currently possible.
@@ -264,11 +265,11 @@ static int frame_max_stream_data(BIO *bio, PACKET *pkt)
     uint64_t max_stream_data = 0;
 
     if (!ossl_quic_wire_decode_frame_max_stream_data(pkt, &stream_id,
-                                                     &max_stream_data))
+            &max_stream_data))
         return 0;
 
     BIO_printf(bio, "    Max Stream Data: %llu\n",
-               (unsigned long long)max_stream_data);
+        (unsigned long long)max_stream_data);
 
     return 1;
 }
@@ -303,7 +304,7 @@ static int frame_stream_data_blocked(BIO *bio, PACKET *pkt)
     uint64_t max_data = 0;
 
     if (!ossl_quic_wire_decode_frame_stream_data_blocked(pkt, &stream_id,
-                                                         &max_data))
+            &max_data))
         return 0;
 
     BIO_printf(bio, "    Stream id: %llu\n", (unsigned long long)stream_id);
@@ -332,14 +333,14 @@ static int frame_new_conn_id(BIO *bio, PACKET *pkt)
         return 0;
 
     BIO_printf(bio, "    Sequence Number: %llu\n",
-               (unsigned long long)frame_data.seq_num);
+        (unsigned long long)frame_data.seq_num);
     BIO_printf(bio, "    Retire prior to: %llu\n",
-               (unsigned long long)frame_data.retire_prior_to);
+        (unsigned long long)frame_data.retire_prior_to);
     BIO_puts(bio, "    Connection id: ");
     put_conn_id(bio, &frame_data.conn_id);
     BIO_puts(bio, "\n    Stateless Reset Token: ");
     put_data(bio, frame_data.stateless_reset.token,
-             sizeof(frame_data.stateless_reset.token));
+        sizeof(frame_data.stateless_reset.token));
     BIO_puts(bio, "\n");
 
     return 1;
@@ -389,7 +390,7 @@ static int frame_conn_closed(BIO *bio, PACKET *pkt)
         return 0;
 
     BIO_printf(bio, "    Error Code: %llu\n",
-               (unsigned long long)frame_data.error_code);
+        (unsigned long long)frame_data.error_code);
     BIO_puts(bio, "    Reason: ");
     put_str(bio, frame_data.reason, frame_data.reason_len);
     BIO_puts(bio, "\n");
@@ -562,7 +563,7 @@ static int trace_frame_data(BIO *bio, PACKET *pkt)
 }
 
 int ossl_quic_trace(int write_p, int version, int content_type,
-                    const void *buf, size_t msglen, SSL *ssl, void *arg)
+    const void *buf, size_t msglen, SSL *ssl, void *arg)
 {
     BIO *bio = arg;
     PACKET pkt;
@@ -580,66 +581,64 @@ int ossl_quic_trace(int write_p, int version, int content_type,
         BIO_printf(bio, " Datagram\n  Length: %zu\n", msglen);
         break;
 
-    case SSL3_RT_QUIC_PACKET:
-        {
-            QUIC_PKT_HDR hdr;
-            size_t i;
+    case SSL3_RT_QUIC_PACKET: {
+        QUIC_PKT_HDR hdr;
+        size_t i;
 
-            if (!PACKET_buf_init(&pkt, buf, msglen))
-                return 0;
-            /* Decode the packet header */
-            ch = ossl_quic_conn_get_channel(ssl);
-            id_len = ossl_quic_channel_get_short_header_conn_id_len(ch);
-            if (ossl_quic_wire_decode_pkt_hdr(&pkt, id_len, 0, 1, &hdr, NULL,
-                                              NULL) != 1)
-                return 0;
+        if (!PACKET_buf_init(&pkt, buf, msglen))
+            return 0;
+        /* Decode the packet header */
+        ch = ossl_quic_conn_get_channel(ssl);
+        id_len = ossl_quic_channel_get_short_header_conn_id_len(ch);
+        if (ossl_quic_wire_decode_pkt_hdr(&pkt, id_len, 0, 1, &hdr, NULL,
+                NULL)
+            != 1)
+            return 0;
 
-            BIO_puts(bio, write_p ? "Sent" : "Received");
-            BIO_puts(bio, " Packet\n");
-            BIO_printf(bio, "  Packet Type: %s\n", packet_type(hdr.type));
-            if (hdr.type != QUIC_PKT_TYPE_1RTT)
-                BIO_printf(bio, "  Version: 0x%08lx\n",
-                           (unsigned long)hdr.version);
-            BIO_puts(bio, "  Destination Conn Id: ");
-            put_conn_id(bio, &hdr.dst_conn_id);
+        BIO_puts(bio, write_p ? "Sent" : "Received");
+        BIO_puts(bio, " Packet\n");
+        BIO_printf(bio, "  Packet Type: %s\n", packet_type(hdr.type));
+        if (hdr.type != QUIC_PKT_TYPE_1RTT)
+            BIO_printf(bio, "  Version: 0x%08lx\n",
+                (unsigned long)hdr.version);
+        BIO_puts(bio, "  Destination Conn Id: ");
+        put_conn_id(bio, &hdr.dst_conn_id);
+        BIO_puts(bio, "\n");
+        if (hdr.type != QUIC_PKT_TYPE_1RTT) {
+            BIO_puts(bio, "  Source Conn Id: ");
+            put_conn_id(bio, &hdr.src_conn_id);
+            BIO_puts(bio, "\n");
+        }
+        BIO_printf(bio, "  Payload length: %zu\n", hdr.len);
+        if (hdr.type == QUIC_PKT_TYPE_INITIAL) {
+            BIO_puts(bio, "  Token: ");
+            put_token(bio, hdr.token, hdr.token_len);
             BIO_puts(bio, "\n");
-            if (hdr.type != QUIC_PKT_TYPE_1RTT) {
-                BIO_puts(bio, "  Source Conn Id: ");
-                put_conn_id(bio, &hdr.src_conn_id);
-                BIO_puts(bio, "\n");
-            }
-            BIO_printf(bio, "  Payload length: %zu\n", hdr.len);
-            if (hdr.type == QUIC_PKT_TYPE_INITIAL) {
-                BIO_puts(bio, "  Token: ");
-                put_token(bio, hdr.token, hdr.token_len);
-                BIO_puts(bio, "\n");
-            }
-            if (hdr.type != QUIC_PKT_TYPE_VERSION_NEG
-                    && hdr.type != QUIC_PKT_TYPE_RETRY) {
-                BIO_puts(bio, "  Packet Number: 0x");
-                /* Will always be at least 1 byte */
-                for (i = 0; i < hdr.pn_len; i++)
-                    BIO_printf(bio, "%02x", hdr.pn[i]);
-                BIO_puts(bio, "\n");
-            }
-            break;
         }
+        if (hdr.type != QUIC_PKT_TYPE_VERSION_NEG
+            && hdr.type != QUIC_PKT_TYPE_RETRY) {
+            BIO_puts(bio, "  Packet Number: 0x");
+            /* Will always be at least 1 byte */
+            for (i = 0; i < hdr.pn_len; i++)
+                BIO_printf(bio, "%02x", hdr.pn[i]);
+            BIO_puts(bio, "\n");
+        }
+        break;
+    }
 
     case SSL3_RT_QUIC_FRAME_PADDING:
     case SSL3_RT_QUIC_FRAME_FULL:
-    case SSL3_RT_QUIC_FRAME_HEADER:
-        {
-            BIO_puts(bio, write_p ? "Sent" : "Received");
-            BIO_puts(bio, " Frame: ");
+    case SSL3_RT_QUIC_FRAME_HEADER: {
+        BIO_puts(bio, write_p ? "Sent" : "Received");
+        BIO_puts(bio, " Frame: ");
 
-            if (!PACKET_buf_init(&pkt, buf, msglen))
-                return 0;
-            if (!trace_frame_data(bio, &pkt)) {
-                BIO_puts(bio, "  <error processing frame data>\n");
-                return 0;
-            }
+        if (!PACKET_buf_init(&pkt, buf, msglen))
+            return 0;
+        if (!trace_frame_data(bio, &pkt)) {
+            BIO_puts(bio, "  <error processing frame data>\n");
+            return 0;
         }
-        break;
+    } break;
 
     default:
         /* Unrecognised content_type. We defer to SSL_trace */
diff --git a/crypto/openssl/ssl/quic/quic_tserver.c b/crypto/openssl/ssl/quic/quic_tserver.c
index f7106b2fef37..f3cf1cbd6acb 100644
--- a/crypto/openssl/ssl/quic/quic_tserver.c
+++ b/crypto/openssl/ssl/quic/quic_tserver.c
@@ -21,7 +21,7 @@
  * =======================
  */
 struct quic_tserver_st {
-    QUIC_TSERVER_ARGS   args;
+    QUIC_TSERVER_ARGS args;
 
     /* Dummy SSL object for this QUIC connection for use by msg_callback */
     SSL *ssl;
@@ -30,12 +30,12 @@ struct quic_tserver_st {
      * The QUIC engine, port and channel providing the core QUIC connection
      * implementation.
      */
-    QUIC_ENGINE     *engine;
-    QUIC_PORT       *port;
-    QUIC_CHANNEL    *ch;
+    QUIC_ENGINE *engine;
+    QUIC_PORT *port;
+    QUIC_CHANNEL *ch;
 
     /* The mutex we give to the QUIC channel. */
-    CRYPTO_MUTEX    *mutex;
+    CRYPTO_MUTEX *mutex;
 
     /* SSL_CTX for creating the underlying TLS connection */
     SSL_CTX *ctx;
@@ -44,12 +44,12 @@ struct quic_tserver_st {
     SSL *tls;
 
     /* Are we connected to a peer? */
-    unsigned int    connected       : 1;
+    unsigned int connected : 1;
 };
 
 static int alpn_select_cb(SSL *ssl, const unsigned char **out,
-                          unsigned char *outlen, const unsigned char *in,
-                          unsigned int inlen, void *arg)
+    unsigned char *outlen, const unsigned char *in,
+    unsigned int inlen, void *arg)
 {
     QUIC_TSERVER *srv = arg;
     static const unsigned char alpndeflt[] = {
@@ -67,18 +67,19 @@ static int alpn_select_cb(SSL *ssl, const unsigned char **out,
     }
 
     if (SSL_select_next_proto((unsigned char **)out, outlen, alpn, alpnlen,
-                              in, inlen) != OPENSSL_NPN_NEGOTIATED)
+            in, inlen)
+        != OPENSSL_NPN_NEGOTIATED)
         return SSL_TLSEXT_ERR_ALERT_FATAL;
 
     return SSL_TLSEXT_ERR_OK;
 }
 
 QUIC_TSERVER *ossl_quic_tserver_new(const QUIC_TSERVER_ARGS *args,
-                                    const char *certfile, const char *keyfile)
+    const char *certfile, const char *keyfile)
 {
     QUIC_TSERVER *srv = NULL;
-    QUIC_ENGINE_ARGS engine_args = {0};
-    QUIC_PORT_ARGS port_args = {0};
+    QUIC_ENGINE_ARGS engine_args = { 0 };
+    QUIC_PORT_ARGS port_args = { 0 };
     QUIC_CONNECTION *qc = NULL;
 
     if (args->net_rbio == NULL || args->net_wbio == NULL)
@@ -98,16 +99,16 @@ QUIC_TSERVER *ossl_quic_tserver_new(const QUIC_TSERVER_ARGS *args,
         srv->ctx = args->ctx;
     else
         srv->ctx = SSL_CTX_new_ex(srv->args.libctx, srv->args.propq,
-                                  TLS_method());
+            TLS_method());
     if (srv->ctx == NULL)
         goto err;
 
     if (certfile != NULL
-            && SSL_CTX_use_certificate_file(srv->ctx, certfile, SSL_FILETYPE_PEM) <= 0)
+        && SSL_CTX_use_certificate_file(srv->ctx, certfile, SSL_FILETYPE_PEM) <= 0)
         goto err;
 
     if (keyfile != NULL
-            && SSL_CTX_use_PrivateKey_file(srv->ctx, keyfile, SSL_FILETYPE_PEM) <= 0)
+        && SSL_CTX_use_PrivateKey_file(srv->ctx, keyfile, SSL_FILETYPE_PEM) <= 0)
         goto err;
 
     SSL_CTX_set_alpn_select_cb(srv->ctx, alpn_select_cb, srv);
@@ -116,18 +117,18 @@ QUIC_TSERVER *ossl_quic_tserver_new(const QUIC_TSERVER_ARGS *args,
     if (srv->tls == NULL)
         goto err;
 
-    engine_args.libctx          = srv->args.libctx;
-    engine_args.propq           = srv->args.propq;
-    engine_args.mutex           = srv->mutex;
+    engine_args.libctx = srv->args.libctx;
+    engine_args.propq = srv->args.propq;
+    engine_args.mutex = srv->mutex;
 
     if ((srv->engine = ossl_quic_engine_new(&engine_args)) == NULL)
         goto err;
 
     ossl_quic_engine_set_time_cb(srv->engine, srv->args.now_cb,
-                                 srv->args.now_cb_arg);
+        srv->args.now_cb_arg);
 
-    port_args.channel_ctx       = srv->ctx;
-    port_args.is_multi_conn     = 1;
+    port_args.channel_ctx = srv->ctx;
+    port_args.is_multi_conn = 1;
     port_args.do_addr_validation = 1;
     if ((srv->port = ossl_quic_engine_create_port(srv->engine, &port_args)) == NULL)
         goto err;
@@ -187,23 +188,23 @@ void ossl_quic_tserver_free(QUIC_TSERVER *srv)
 
 /* Set mutator callbacks for test framework support */
 int ossl_quic_tserver_set_plain_packet_mutator(QUIC_TSERVER *srv,
-                                               ossl_mutate_packet_cb mutatecb,
-                                               ossl_finish_mutate_cb finishmutatecb,
-                                               void *mutatearg)
+    ossl_mutate_packet_cb mutatecb,
+    ossl_finish_mutate_cb finishmutatecb,
+    void *mutatearg)
 {
     return ossl_quic_channel_set_mutator(srv->ch, mutatecb, finishmutatecb,
-                                         mutatearg);
+        mutatearg);
 }
 
 int ossl_quic_tserver_set_handshake_mutator(QUIC_TSERVER *srv,
-                                            ossl_statem_mutate_handshake_cb mutate_handshake_cb,
-                                            ossl_statem_finish_mutate_handshake_cb finish_mutate_handshake_cb,
-                                            void *mutatearg)
+    ossl_statem_mutate_handshake_cb mutate_handshake_cb,
+    ossl_statem_finish_mutate_handshake_cb finish_mutate_handshake_cb,
+    void *mutatearg)
 {
     return ossl_statem_set_mutator(ossl_quic_channel_get0_ssl(srv->ch),
-                                   mutate_handshake_cb,
-                                   finish_mutate_handshake_cb,
-                                   mutatearg);
+        mutate_handshake_cb,
+        finish_mutate_handshake_cb,
+        mutatearg);
 }
 
 int ossl_quic_tserver_tick(QUIC_TSERVER *srv)
@@ -250,20 +251,20 @@ int ossl_quic_tserver_is_handshake_confirmed(const QUIC_TSERVER *srv)
 }
 
 int ossl_quic_tserver_read(QUIC_TSERVER *srv,
-                           uint64_t stream_id,
-                           unsigned char *buf,
-                           size_t buf_len,
-                           size_t *bytes_read)
+    uint64_t stream_id,
+    unsigned char *buf,
+    size_t buf_len,
+    size_t *bytes_read)
 {
     int is_fin = 0;
     QUIC_STREAM *qs;
 
     qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(srv->ch),
-                                        stream_id);
+        stream_id);
     if (qs == NULL) {
         int is_client_init
             = ((stream_id & QUIC_STREAM_INITIATOR_MASK)
-               == QUIC_STREAM_INITIATOR_CLIENT);
+                == QUIC_STREAM_INITIATOR_CLIENT);
 
         /*
          * A client-initiated stream might spontaneously come into existence, so
@@ -283,7 +284,7 @@ int ossl_quic_tserver_read(QUIC_TSERVER *srv,
         return 0;
 
     if (!ossl_quic_rstream_read(qs->rstream, buf, buf_len,
-                                bytes_read, &is_fin))
+            bytes_read, &is_fin))
         return 0;
 
     if (*bytes_read > 0) {
@@ -298,13 +299,13 @@ int ossl_quic_tserver_read(QUIC_TSERVER *srv,
         ossl_statm_get_rtt_info(ossl_quic_channel_get_statm(srv->ch), &rtt_info);
 
         if (!ossl_quic_rxfc_on_retire(&qs->rxfc, *bytes_read,
-                                      rtt_info.smoothed_rtt))
+                rtt_info.smoothed_rtt))
             return 0;
     }
 
     if (is_fin)
         ossl_quic_stream_map_notify_totally_read(ossl_quic_channel_get_qsm(srv->ch),
-                                                 qs);
+            qs);
 
     if (*bytes_read > 0)
         ossl_quic_stream_map_update_state(ossl_quic_channel_get_qsm(srv->ch), qs);
@@ -320,7 +321,7 @@ int ossl_quic_tserver_has_read_ended(QUIC_TSERVER *srv, uint64_t stream_id)
     int is_fin = 0;
 
     qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(srv->ch),
-                                        stream_id);
+        stream_id);
 
     if (qs == NULL)
         return 0;
@@ -338,21 +339,21 @@ int ossl_quic_tserver_has_read_ended(QUIC_TSERVER *srv, uint64_t stream_id)
      * called since the FIN was received.
      */
     if (!ossl_quic_rstream_peek(qs->rstream, buf, sizeof(buf),
-                                &bytes_read, &is_fin))
+            &bytes_read, &is_fin))
         return 0;
 
     if (is_fin && bytes_read == 0) {
         /* If we have a FIN awaiting retirement and no data before it... */
         /* Let RSTREAM know we've consumed this FIN. */
         if (!ossl_quic_rstream_read(qs->rstream, buf, sizeof(buf),
-                                    &bytes_read, &is_fin))
+                &bytes_read, &is_fin))
             return 0;
 
         assert(is_fin && bytes_read == 0);
         assert(qs->recv_state == QUIC_RSTREAM_STATE_DATA_RECVD);
 
         ossl_quic_stream_map_notify_totally_read(ossl_quic_channel_get_qsm(srv->ch),
-                                                 qs);
+            qs);
         ossl_quic_stream_map_update_state(ossl_quic_channel_get_qsm(srv->ch), qs);
         return 1;
     }
@@ -361,10 +362,10 @@ int ossl_quic_tserver_has_read_ended(QUIC_TSERVER *srv, uint64_t stream_id)
 }
 
 int ossl_quic_tserver_write(QUIC_TSERVER *srv,
-                            uint64_t stream_id,
-                            const unsigned char *buf,
-                            size_t buf_len,
-                            size_t *bytes_written)
+    uint64_t stream_id,
+    const unsigned char *buf,
+    size_t buf_len,
+    size_t *bytes_written)
 {
     QUIC_STREAM *qs;
 
@@ -372,12 +373,12 @@ int ossl_quic_tserver_write(QUIC_TSERVER *srv,
         return 0;
 
     qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(srv->ch),
-                                        stream_id);
+        stream_id);
     if (qs == NULL || !ossl_quic_stream_has_send_buffer(qs))
         return 0;
 
     if (!ossl_quic_sstream_append(qs->sstream,
-                                  buf, buf_len, bytes_written))
+            buf, buf_len, bytes_written))
         return 0;
 
     if (*bytes_written > 0)
@@ -400,7 +401,7 @@ int ossl_quic_tserver_conclude(QUIC_TSERVER *srv, uint64_t stream_id)
         return 0;
 
     qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(srv->ch),
-                                        stream_id);
+        stream_id);
     if (qs == NULL || !ossl_quic_stream_has_send_buffer(qs))
         return 0;
 
@@ -414,8 +415,8 @@ int ossl_quic_tserver_conclude(QUIC_TSERVER *srv, uint64_t stream_id)
 }
 
 int ossl_quic_tserver_stream_new(QUIC_TSERVER *srv,
-                                 int is_uni,
-                                 uint64_t *stream_id)
+    int is_uni,
+    uint64_t *stream_id)
 {
     QUIC_STREAM *qs;
 
@@ -440,13 +441,13 @@ SSL_CTX *ossl_quic_tserver_get0_ssl_ctx(QUIC_TSERVER *srv)
 }
 
 int ossl_quic_tserver_stream_has_peer_stop_sending(QUIC_TSERVER *srv,
-                                                   uint64_t stream_id,
-                                                   uint64_t *app_error_code)
+    uint64_t stream_id,
+    uint64_t *app_error_code)
 {
     QUIC_STREAM *qs;
 
     qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(srv->ch),
-                                        stream_id);
+        stream_id);
     if (qs == NULL)
         return 0;
 
@@ -457,13 +458,13 @@ int ossl_quic_tserver_stream_has_peer_stop_sending(QUIC_TSERVER *srv,
 }
 
 int ossl_quic_tserver_stream_has_peer_reset_stream(QUIC_TSERVER *srv,
-                                                   uint64_t stream_id,
-                                                   uint64_t  *app_error_code)
+    uint64_t stream_id,
+    uint64_t *app_error_code)
 {
     QUIC_STREAM *qs;
 
     qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(srv->ch),
-                                        stream_id);
+        stream_id);
     if (qs == NULL)
         return 0;
 
@@ -474,7 +475,7 @@ int ossl_quic_tserver_stream_has_peer_reset_stream(QUIC_TSERVER *srv,
 }
 
 int ossl_quic_tserver_set_new_local_cid(QUIC_TSERVER *srv,
-                                        const QUIC_CONN_ID *conn_id)
+    const QUIC_CONN_ID *conn_id)
 {
     /* Replace existing local connection ID in the QUIC_CHANNEL */
     return ossl_quic_channel_replace_local_cid(srv->ch, conn_id);
@@ -494,12 +495,12 @@ uint64_t ossl_quic_tserver_pop_incoming_stream(QUIC_TSERVER *srv)
 }
 
 int ossl_quic_tserver_is_stream_totally_acked(QUIC_TSERVER *srv,
-                                              uint64_t stream_id)
+    uint64_t stream_id)
 {
     QUIC_STREAM *qs;
 
     qs = ossl_quic_stream_map_get_by_id(ossl_quic_channel_get_qsm(srv->ch),
-                                        stream_id);
+        stream_id);
     if (qs == NULL)
         return 1;
 
@@ -509,19 +510,19 @@ int ossl_quic_tserver_is_stream_totally_acked(QUIC_TSERVER *srv,
 int ossl_quic_tserver_get_net_read_desired(QUIC_TSERVER *srv)
 {
     return ossl_quic_reactor_net_read_desired(
-                ossl_quic_channel_get_reactor(srv->ch));
+        ossl_quic_channel_get_reactor(srv->ch));
 }
 
 int ossl_quic_tserver_get_net_write_desired(QUIC_TSERVER *srv)
 {
     return ossl_quic_reactor_net_write_desired(
-                ossl_quic_channel_get_reactor(srv->ch));
+        ossl_quic_channel_get_reactor(srv->ch));
 }
 
 OSSL_TIME ossl_quic_tserver_get_deadline(QUIC_TSERVER *srv)
 {
     return ossl_quic_reactor_get_tick_deadline(
-                ossl_quic_channel_get_reactor(srv->ch));
+        ossl_quic_channel_get_reactor(srv->ch));
 }
 
 int ossl_quic_tserver_shutdown(QUIC_TSERVER *srv, uint64_t app_error_code)
@@ -554,11 +555,11 @@ QUIC_CHANNEL *ossl_quic_tserver_get_channel(QUIC_TSERVER *srv)
 }
 
 void ossl_quic_tserver_set_msg_callback(QUIC_TSERVER *srv,
-                                        void (*f)(int write_p, int version,
-                                                  int content_type,
-                                                  const void *buf, size_t len,
-                                                  SSL *ssl, void *arg),
-                                        void *arg)
+    void (*f)(int write_p, int version,
+        int content_type,
+        const void *buf, size_t len,
+        SSL *ssl, void *arg),
+    void *arg)
 {
     ossl_quic_channel_set_msg_callback(srv->ch, f, srv->ssl);
     ossl_quic_channel_set_msg_callback_arg(srv->ch, arg);
@@ -572,13 +573,13 @@ int ossl_quic_tserver_new_ticket(QUIC_TSERVER *srv)
 }
 
 int ossl_quic_tserver_set_max_early_data(QUIC_TSERVER *srv,
-                                         uint32_t max_early_data)
+    uint32_t max_early_data)
 {
     return SSL_set_max_early_data(srv->tls, max_early_data);
 }
 
 void ossl_quic_tserver_set_psk_find_session_cb(QUIC_TSERVER *srv,
-                                               SSL_psk_find_session_cb_func cb)
+    SSL_psk_find_session_cb_func cb)
 {
     SSL_set_psk_find_session_callback(srv->tls, cb);
 }
diff --git a/crypto/openssl/ssl/quic/quic_txp.c b/crypto/openssl/ssl/quic/quic_txp.c
index 10d842bce0bf..44aaad868d2f 100644
--- a/crypto/openssl/ssl/quic/quic_txp.c
+++ b/crypto/openssl/ssl/quic/quic_txp.c
@@ -14,15 +14,15 @@
 #include "internal/common.h"
 #include <openssl/err.h>
 
-#define MIN_CRYPTO_HDR_SIZE             3
+#define MIN_CRYPTO_HDR_SIZE 3
 
-#define MIN_FRAME_SIZE_HANDSHAKE_DONE   1
-#define MIN_FRAME_SIZE_MAX_DATA         2
-#define MIN_FRAME_SIZE_ACK              5
-#define MIN_FRAME_SIZE_CRYPTO           (MIN_CRYPTO_HDR_SIZE + 1)
-#define MIN_FRAME_SIZE_STREAM           3 /* minimum useful size (for non-FIN) */
+#define MIN_FRAME_SIZE_HANDSHAKE_DONE 1
+#define MIN_FRAME_SIZE_MAX_DATA 2
+#define MIN_FRAME_SIZE_ACK 5
+#define MIN_FRAME_SIZE_CRYPTO (MIN_CRYPTO_HDR_SIZE + 1)
+#define MIN_FRAME_SIZE_STREAM 3 /* minimum useful size (for non-FIN) */
 #define MIN_FRAME_SIZE_MAX_STREAMS_BIDI 2
-#define MIN_FRAME_SIZE_MAX_STREAMS_UNI  2
+#define MIN_FRAME_SIZE_MAX_STREAMS_UNI 2
 
 /*
  * Packet Archetypes
@@ -30,23 +30,23 @@
  */
 
 /* Generate normal packets containing most frame types, subject to EL. */
-#define TX_PACKETISER_ARCHETYPE_NORMAL              0
+#define TX_PACKETISER_ARCHETYPE_NORMAL 0
 
 /*
  * A probe packet is different in that:
  *   - It bypasses CC, but *is* counted as in flight for purposes of CC;
  *   - It must be ACK-eliciting.
  */
-#define TX_PACKETISER_ARCHETYPE_PROBE               1
+#define TX_PACKETISER_ARCHETYPE_PROBE 1
 
 /*
  * An ACK-only packet is different in that:
  *   - It bypasses CC, and is considered a 'non-inflight' packet;
  *   - It may not contain anything other than an ACK frame, not even padding.
  */
-#define TX_PACKETISER_ARCHETYPE_ACK_ONLY            2
+#define TX_PACKETISER_ARCHETYPE_ACK_ONLY 2
 
-#define TX_PACKETISER_ARCHETYPE_NUM                 3
+#define TX_PACKETISER_ARCHETYPE_NUM 3
 
 struct ossl_quic_tx_packetiser_st {
     OSSL_QUIC_TX_PACKETISER_ARGS args;
@@ -55,55 +55,55 @@ struct ossl_quic_tx_packetiser_st {
      * Opaque initial token blob provided by caller. TXP frees using the
      * callback when it is no longer needed.
      */
-    const unsigned char             *initial_token;
-    size_t                          initial_token_len;
+    const unsigned char *initial_token;
+    size_t initial_token_len;
     ossl_quic_initial_token_free_fn *initial_token_free_cb;
-    void                            *initial_token_free_cb_arg;
+    void *initial_token_free_cb_arg;
 
     /* Subcomponents of the TXP that we own. */
-    QUIC_FIFD       fifd;       /* QUIC Frame-in-Flight Dispatcher */
+    QUIC_FIFD fifd; /* QUIC Frame-in-Flight Dispatcher */
 
     /* Internal state. */
-    uint64_t        next_pn[QUIC_PN_SPACE_NUM]; /* Next PN to use in given PN space. */
-    OSSL_TIME       last_tx_time;               /* Last time a packet was generated, or 0. */
+    uint64_t next_pn[QUIC_PN_SPACE_NUM]; /* Next PN to use in given PN space. */
+    OSSL_TIME last_tx_time; /* Last time a packet was generated, or 0. */
 
-    size_t          unvalidated_credit;         /* Limit of data we can send until validated */
+    size_t unvalidated_credit; /* Limit of data we can send until validated */
 
     /* Internal state - frame (re)generation flags. */
-    unsigned int    want_handshake_done     : 1;
-    unsigned int    want_max_data           : 1;
-    unsigned int    want_max_streams_bidi   : 1;
-    unsigned int    want_max_streams_uni    : 1;
+    unsigned int want_handshake_done : 1;
+    unsigned int want_max_data : 1;
+    unsigned int want_max_streams_bidi : 1;
+    unsigned int want_max_streams_uni : 1;
 
     /* Internal state - frame (re)generation flags - per PN space. */
-    unsigned int    want_ack                : QUIC_PN_SPACE_NUM;
-    unsigned int    force_ack_eliciting     : QUIC_PN_SPACE_NUM;
+    unsigned int want_ack : QUIC_PN_SPACE_NUM;
+    unsigned int force_ack_eliciting : QUIC_PN_SPACE_NUM;
 
     /*
      * Internal state - connection close terminal state.
      * Once this is set, it is not unset unlike other want_ flags - we keep
      * sending it in every packet.
      */
-    unsigned int    want_conn_close         : 1;
+    unsigned int want_conn_close : 1;
 
     /* Has the handshake been completed? */
-    unsigned int    handshake_complete      : 1;
+    unsigned int handshake_complete : 1;
 
-    OSSL_QUIC_FRAME_CONN_CLOSE  conn_close_frame;
+    OSSL_QUIC_FRAME_CONN_CLOSE conn_close_frame;
 
     /*
      * Counts of the number of bytes received and sent while in the closing
      * state.
      */
-    uint64_t                        closing_bytes_recv;
-    uint64_t                        closing_bytes_xmit;
+    uint64_t closing_bytes_recv;
+    uint64_t closing_bytes_xmit;
 
     /* Internal state - packet assembly. */
     struct txp_el {
-        unsigned char   *scratch;       /* scratch buffer for packet assembly */
-        size_t          scratch_len;    /* number of bytes allocated for scratch */
-        OSSL_QTX_IOVEC  *iovec;         /* scratch iovec array for use with QTX */
-        size_t          alloc_iovec;    /* size of iovec array */
+        unsigned char *scratch; /* scratch buffer for packet assembly */
+        size_t scratch_len; /* number of bytes allocated for scratch */
+        OSSL_QTX_IOVEC *iovec; /* scratch iovec array for use with QTX */
+        size_t alloc_iovec; /* size of iovec array */
     } el[QUIC_ENC_LEVEL_NUM];
 
     /* Message callback related arguments */
@@ -112,10 +112,10 @@ struct ossl_quic_tx_packetiser_st {
     SSL *msg_callback_ssl;
 
     /* Callbacks. */
-    void            (*ack_tx_cb)(const OSSL_QUIC_FRAME_ACK *ack,
-                                 uint32_t pn_space,
-                                 void *arg);
-    void            *ack_tx_cb_arg;
+    void (*ack_tx_cb)(const OSSL_QUIC_FRAME_ACK *ack,
+        uint32_t pn_space,
+        void *arg);
+    void *ack_tx_cb_arg;
 };
 
 /*
@@ -176,9 +176,9 @@ struct tx_helper {
          * The fields in this structure are valid if active is set, which means
          * that a serialization transaction is currently in progress.
          */
-        unsigned char   *data;
-        WPACKET         wpkt;
-        unsigned int    active : 1;
+        unsigned char *data;
+        WPACKET wpkt;
+        unsigned int active : 1;
     } txn;
 };
 
@@ -187,22 +187,22 @@ static int txp_el_ensure_iovec(struct txp_el *el, size_t num);
 
 /* Initialises the TX helper. */
 static int tx_helper_init(struct tx_helper *h, OSSL_QUIC_TX_PACKETISER *txp,
-                          uint32_t enc_level, size_t max_ppl, size_t reserve)
+    uint32_t enc_level, size_t max_ppl, size_t reserve)
 {
     if (reserve > max_ppl)
         return 0;
 
-    h->txp                  = txp;
-    h->enc_level            = enc_level;
-    h->max_ppl              = max_ppl;
-    h->reserve              = reserve;
-    h->num_iovec            = 0;
-    h->bytes_appended       = 0;
-    h->scratch_bytes        = 0;
-    h->reserve_allowed      = 0;
-    h->done_implicit        = 0;
-    h->txn.data             = NULL;
-    h->txn.active           = 0;
+    h->txp = txp;
+    h->enc_level = enc_level;
+    h->max_ppl = max_ppl;
+    h->reserve = reserve;
+    h->num_iovec = 0;
+    h->bytes_appended = 0;
+    h->scratch_bytes = 0;
+    h->reserve_allowed = 0;
+    h->done_implicit = 0;
+    h->txn.data = NULL;
+    h->txn.active = 0;
 
     if (max_ppl > h->txp->el[enc_level].scratch_len) {
         unsigned char *scratch;
@@ -211,7 +211,7 @@ static int tx_helper_init(struct tx_helper *h, OSSL_QUIC_TX_PACKETISER *txp,
         if (scratch == NULL)
             return 0;
 
-        h->txp->el[enc_level].scratch     = scratch;
+        h->txp->el[enc_level].scratch = scratch;
         h->txp->el[enc_level].scratch_len = max_ppl;
     }
 
@@ -246,8 +246,8 @@ static void tx_helper_unrestrict(struct tx_helper *h)
  *
  */
 static int tx_helper_append_iovec(struct tx_helper *h,
-                                  const unsigned char *buf,
-                                  size_t buf_len)
+    const unsigned char *buf,
+    size_t buf_len)
 {
     struct txp_el *el = &h->txp->el[h->enc_level];
 
@@ -260,7 +260,7 @@ static int tx_helper_append_iovec(struct tx_helper *h,
     if (!txp_el_ensure_iovec(el, h->num_iovec + 1))
         return 0;
 
-    el->iovec[h->num_iovec].buf     = buf;
+    el->iovec[h->num_iovec].buf = buf;
     el->iovec[h->num_iovec].buf_len = buf_len;
 
     ++h->num_iovec;
@@ -297,7 +297,7 @@ static WPACKET *tx_helper_begin(struct tx_helper *h)
         return NULL;
 
     data = (unsigned char *)el->scratch + h->scratch_bytes;
-    len  = el->scratch_len - h->scratch_bytes;
+    len = el->scratch_len - h->scratch_bytes;
 
     space_left = tx_helper_get_space_left(h);
     if (!ossl_assert(space_left <= len))
@@ -311,8 +311,8 @@ static WPACKET *tx_helper_begin(struct tx_helper *h)
         return NULL;
     }
 
-    h->txn.data     = data;
-    h->txn.active   = 1;
+    h->txn.data = data;
+    h->txn.active = 1;
     return &h->txn.wpkt;
 }
 
@@ -323,8 +323,8 @@ static void tx_helper_end(struct tx_helper *h, int success)
     else
         WPACKET_cleanup(&h->txn.wpkt);
 
-    h->txn.active       = 0;
-    h->txn.data         = NULL;
+    h->txn.active = 0;
+    h->txn.data = NULL;
 }
 
 /* Abort a control frame serialization transaction. */
@@ -360,7 +360,7 @@ static int tx_helper_commit(struct tx_helper *h)
         PACKET pkt;
 
         if (!PACKET_buf_init(&pkt, h->txn.data, l)
-                || !ossl_quic_wire_peek_frame_header(&pkt, &ftype, NULL)) {
+            || !ossl_quic_wire_peek_frame_header(&pkt, &ftype, NULL)) {
             tx_helper_end(h, 0);
             return 0;
         }
@@ -368,12 +368,12 @@ static int tx_helper_commit(struct tx_helper *h)
         if (ftype == OSSL_QUIC_FRAME_TYPE_PADDING)
             ctype = SSL3_RT_QUIC_FRAME_PADDING;
         else if (OSSL_QUIC_FRAME_TYPE_IS_STREAM(ftype)
-                || ftype == OSSL_QUIC_FRAME_TYPE_CRYPTO)
+            || ftype == OSSL_QUIC_FRAME_TYPE_CRYPTO)
             ctype = SSL3_RT_QUIC_FRAME_HEADER;
 
         h->txp->msg_callback(1, OSSL_QUIC1_VERSION, ctype, h->txn.data, l,
-                             h->txp->msg_callback_ssl,
-                             h->txp->msg_callback_arg);
+            h->txp->msg_callback_ssl,
+            h->txp->msg_callback_arg);
     }
 
     h->scratch_bytes += l;
@@ -382,76 +382,76 @@ static int tx_helper_commit(struct tx_helper *h)
 }
 
 struct archetype_data {
-    unsigned int allow_ack                  : 1;
-    unsigned int allow_ping                 : 1;
-    unsigned int allow_crypto               : 1;
-    unsigned int allow_handshake_done       : 1;
-    unsigned int allow_path_challenge       : 1;
-    unsigned int allow_path_response        : 1;
-    unsigned int allow_new_conn_id          : 1;
-    unsigned int allow_retire_conn_id       : 1;
-    unsigned int allow_stream_rel           : 1;
-    unsigned int allow_conn_fc              : 1;
-    unsigned int allow_conn_close           : 1;
-    unsigned int allow_cfq_other            : 1;
-    unsigned int allow_new_token            : 1;
-    unsigned int allow_force_ack_eliciting  : 1;
-    unsigned int allow_padding              : 1;
-    unsigned int require_ack_eliciting      : 1;
-    unsigned int bypass_cc                  : 1;
+    unsigned int allow_ack : 1;
+    unsigned int allow_ping : 1;
+    unsigned int allow_crypto : 1;
+    unsigned int allow_handshake_done : 1;
+    unsigned int allow_path_challenge : 1;
+    unsigned int allow_path_response : 1;
+    unsigned int allow_new_conn_id : 1;
+    unsigned int allow_retire_conn_id : 1;
+    unsigned int allow_stream_rel : 1;
+    unsigned int allow_conn_fc : 1;
+    unsigned int allow_conn_close : 1;
+    unsigned int allow_cfq_other : 1;
+    unsigned int allow_new_token : 1;
+    unsigned int allow_force_ack_eliciting : 1;
+    unsigned int allow_padding : 1;
+    unsigned int require_ack_eliciting : 1;
+    unsigned int bypass_cc : 1;
 };
 
 struct txp_pkt_geom {
-    size_t                  cmpl, cmppl, hwm, pkt_overhead;
-    uint32_t                archetype;
-    struct archetype_data   adata;
+    size_t cmpl, cmppl, hwm, pkt_overhead;
+    uint32_t archetype;
+    struct archetype_data adata;
 };
 
 struct txp_pkt {
-    struct tx_helper    h;
-    int                 h_valid;
-    QUIC_TXPIM_PKT      *tpkt;
-    QUIC_STREAM         *stream_head;
-    QUIC_PKT_HDR        phdr;
+    struct tx_helper h;
+    int h_valid;
+    QUIC_TXPIM_PKT *tpkt;
+    QUIC_STREAM *stream_head;
+    QUIC_PKT_HDR phdr;
     struct txp_pkt_geom geom;
-    int                 force_pad;
+    int force_pad;
 };
 
 static QUIC_SSTREAM *get_sstream_by_id(uint64_t stream_id, uint32_t pn_space,
-                                       void *arg);
+    void *arg);
 static void on_regen_notify(uint64_t frame_type, uint64_t stream_id,
-                            QUIC_TXPIM_PKT *pkt, void *arg);
+    QUIC_TXPIM_PKT *pkt, void *arg);
 static void on_confirm_notify(uint64_t frame_type, uint64_t stream_id,
-                              QUIC_TXPIM_PKT *pkt, void *arg);
+    QUIC_TXPIM_PKT *pkt, void *arg);
 static void on_sstream_updated(uint64_t stream_id, void *arg);
 static int sstream_is_pending(QUIC_SSTREAM *sstream);
 static int txp_should_try_staging(OSSL_QUIC_TX_PACKETISER *txp,
-                                  uint32_t enc_level,
-                                  uint32_t archetype,
-                                  uint64_t cc_limit,
-                                  uint32_t *conn_close_enc_level);
+    uint32_t enc_level,
+    uint32_t archetype,
+    uint64_t cc_limit,
+    uint32_t *conn_close_enc_level);
 static size_t txp_determine_pn_len(OSSL_QUIC_TX_PACKETISER *txp);
 static int txp_determine_ppl_from_pl(OSSL_QUIC_TX_PACKETISER *txp,
-                                     size_t pl,
-                                     uint32_t enc_level,
-                                     size_t hdr_len,
-                                     size_t *r);
+    size_t pl,
+    uint32_t enc_level,
+    size_t hdr_len,
+    size_t *r);
 static size_t txp_get_mdpl(OSSL_QUIC_TX_PACKETISER *txp);
 static int txp_generate_for_el(OSSL_QUIC_TX_PACKETISER *txp,
-                               struct txp_pkt *pkt,
-                               int chosen_for_conn_close);
+    struct txp_pkt *pkt,
+    int chosen_for_conn_close);
 static int txp_pkt_init(struct txp_pkt *pkt, OSSL_QUIC_TX_PACKETISER *txp,
-                        uint32_t enc_level, uint32_t archetype,
-                        size_t running_total);
+    uint32_t enc_level, uint32_t archetype,
+    size_t running_total);
 static void txp_pkt_cleanup(struct txp_pkt *pkt, OSSL_QUIC_TX_PACKETISER *txp);
 static int txp_pkt_postgen_update_pkt_overhead(struct txp_pkt *pkt,
-                                               OSSL_QUIC_TX_PACKETISER *txp);
+    OSSL_QUIC_TX_PACKETISER *txp);
 static int txp_pkt_append_padding(struct txp_pkt *pkt,
-                                  OSSL_QUIC_TX_PACKETISER *txp, size_t num_bytes);
+    OSSL_QUIC_TX_PACKETISER *txp, size_t num_bytes);
 static int txp_pkt_commit(OSSL_QUIC_TX_PACKETISER *txp, struct txp_pkt *pkt,
-                          uint32_t archetype, int *txpim_pkt_reffed);
+    uint32_t archetype, int *txpim_pkt_reffed);
 static uint32_t txp_determine_archetype(OSSL_QUIC_TX_PACKETISER *txp,
-                                        uint64_t cc_limit);
+    uint64_t cc_limit);
 
 /**
  * Sets the validated state of a QUIC TX packetiser.
@@ -482,7 +482,7 @@ void ossl_quic_tx_packetiser_set_validated(OSSL_QUIC_TX_PACKETISER *txp)
  * @param credit The amount of credit to add, multiplied by 3.
  */
 void ossl_quic_tx_packetiser_add_unvalidated_credit(OSSL_QUIC_TX_PACKETISER *txp,
-                                                    size_t credit)
+    size_t credit)
 {
     if (txp->unvalidated_credit != SIZE_MAX) {
         if ((SIZE_MAX - txp->unvalidated_credit) > (credit * 3))
@@ -506,7 +506,7 @@ void ossl_quic_tx_packetiser_add_unvalidated_credit(OSSL_QUIC_TX_PACKETISER *txp
  * @param credit The amount of credit to consume.
  */
 void ossl_quic_tx_packetiser_consume_unvalidated_credit(OSSL_QUIC_TX_PACKETISER *txp,
-                                                        size_t credit)
+    size_t credit)
 {
     if (txp->unvalidated_credit != SIZE_MAX) {
         if (txp->unvalidated_credit < credit)
@@ -530,7 +530,7 @@ void ossl_quic_tx_packetiser_consume_unvalidated_credit(OSSL_QUIC_TX_PACKETISER
  * @return 1 if the unvalidated credit exceeds `req_credit`, 0 otherwise.
  */
 int ossl_quic_tx_packetiser_check_unvalidated_credit(OSSL_QUIC_TX_PACKETISER *txp,
-                                                     size_t req_credit)
+    size_t req_credit)
 {
     return (txp->unvalidated_credit > req_credit);
 }
@@ -558,17 +558,17 @@ OSSL_QUIC_TX_PACKETISER *ossl_quic_tx_packetiser_new(const OSSL_QUIC_TX_PACKETIS
     if (txp == NULL)
         return NULL;
 
-    txp->args           = *args;
-    txp->last_tx_time   = ossl_time_zero();
+    txp->args = *args;
+    txp->last_tx_time = ossl_time_zero();
 
     if (!ossl_quic_fifd_init(&txp->fifd,
-                             txp->args.cfq, txp->args.ackm, txp->args.txpim,
-                             get_sstream_by_id, txp,
-                             on_regen_notify, txp,
-                             on_confirm_notify, txp,
-                             on_sstream_updated, txp,
-                             args->get_qlog_cb,
-                             args->get_qlog_cb_arg)) {
+            txp->args.cfq, txp->args.ackm, txp->args.txpim,
+            get_sstream_by_id, txp,
+            on_regen_notify, txp,
+            on_confirm_notify, txp,
+            on_sstream_updated, txp,
+            args->get_qlog_cb,
+            args->get_qlog_cb_arg)) {
         OPENSSL_free(txp);
         return NULL;
     }
@@ -588,8 +588,8 @@ void ossl_quic_tx_packetiser_free(OSSL_QUIC_TX_PACKETISER *txp)
     OPENSSL_free(txp->conn_close_frame.reason);
 
     for (enc_level = QUIC_ENC_LEVEL_INITIAL;
-         enc_level < QUIC_ENC_LEVEL_NUM;
-         ++enc_level) {
+        enc_level < QUIC_ENC_LEVEL_NUM;
+        ++enc_level) {
         OPENSSL_free(txp->el[enc_level].iovec);
         OPENSSL_free(txp->el[enc_level].scratch);
     }
@@ -625,7 +625,7 @@ void ossl_quic_tx_packetiser_free(OSSL_QUIC_TX_PACKETISER *txp)
  * estimation of the minimum we would require to guarantee forward progress
  * under worst case packet overheads.
  */
-#define TXP_REQUIRED_TOKEN_MARGIN       160
+#define TXP_REQUIRED_TOKEN_MARGIN 160
 
 static int txp_check_token_len(size_t token_len, size_t mdpl)
 {
@@ -646,34 +646,34 @@ static int txp_check_token_len(size_t token_len, size_t mdpl)
 }
 
 int ossl_quic_tx_packetiser_set_initial_token(OSSL_QUIC_TX_PACKETISER *txp,
-                                              const unsigned char *token,
-                                              size_t token_len,
-                                              ossl_quic_initial_token_free_fn *free_cb,
-                                              void *free_cb_arg)
+    const unsigned char *token,
+    size_t token_len,
+    ossl_quic_initial_token_free_fn *free_cb,
+    void *free_cb_arg)
 {
     if (!txp_check_token_len(token_len, txp_get_mdpl(txp)))
         return 0;
 
     if (txp->initial_token != NULL && txp->initial_token_free_cb != NULL)
         txp->initial_token_free_cb(txp->initial_token, txp->initial_token_len,
-                                   txp->initial_token_free_cb_arg);
+            txp->initial_token_free_cb_arg);
 
-    txp->initial_token              = token;
-    txp->initial_token_len          = token_len;
-    txp->initial_token_free_cb      = free_cb;
-    txp->initial_token_free_cb_arg  = free_cb_arg;
+    txp->initial_token = token;
+    txp->initial_token_len = token_len;
+    txp->initial_token_free_cb = free_cb;
+    txp->initial_token_free_cb_arg = free_cb_arg;
     return 1;
 }
 
 int ossl_quic_tx_packetiser_set_protocol_version(OSSL_QUIC_TX_PACKETISER *txp,
-                                                 uint32_t protocol_version)
+    uint32_t protocol_version)
 {
     txp->args.protocol_version = protocol_version;
     return 1;
 }
 
 int ossl_quic_tx_packetiser_set_cur_dcid(OSSL_QUIC_TX_PACKETISER *txp,
-                                         const QUIC_CONN_ID *dcid)
+    const QUIC_CONN_ID *dcid)
 {
     if (dcid == NULL) {
         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
@@ -685,7 +685,7 @@ int ossl_quic_tx_packetiser_set_cur_dcid(OSSL_QUIC_TX_PACKETISER *txp,
 }
 
 int ossl_quic_tx_packetiser_set_cur_scid(OSSL_QUIC_TX_PACKETISER *txp,
-                                         const QUIC_CONN_ID *scid)
+    const QUIC_CONN_ID *scid)
 {
     if (scid == NULL) {
         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
@@ -698,7 +698,7 @@ int ossl_quic_tx_packetiser_set_cur_scid(OSSL_QUIC_TX_PACKETISER *txp,
 
 /* Change the destination L4 address the TXP uses to send datagrams. */
 int ossl_quic_tx_packetiser_set_peer(OSSL_QUIC_TX_PACKETISER *txp,
-                                     const BIO_ADDR *peer)
+    const BIO_ADDR *peer)
 {
     if (peer == NULL) {
         BIO_ADDR_clear(&txp->args.peer);
@@ -709,25 +709,24 @@ int ossl_quic_tx_packetiser_set_peer(OSSL_QUIC_TX_PACKETISER *txp,
 }
 
 void ossl_quic_tx_packetiser_set_ack_tx_cb(OSSL_QUIC_TX_PACKETISER *txp,
-                                           void (*cb)(const OSSL_QUIC_FRAME_ACK *ack,
-                                                      uint32_t pn_space,
-                                                      void *arg),
-                                           void *cb_arg)
+    void (*cb)(const OSSL_QUIC_FRAME_ACK *ack,
+        uint32_t pn_space,
+        void *arg),
+    void *cb_arg)
 {
-    txp->ack_tx_cb      = cb;
-    txp->ack_tx_cb_arg  = cb_arg;
+    txp->ack_tx_cb = cb;
+    txp->ack_tx_cb_arg = cb_arg;
 }
 
 void ossl_quic_tx_packetiser_set_qlog_cb(OSSL_QUIC_TX_PACKETISER *txp,
-                                         QLOG *(*get_qlog_cb)(void *arg),
-                                         void *get_qlog_cb_arg)
+    QLOG *(*get_qlog_cb)(void *arg),
+    void *get_qlog_cb_arg)
 {
     ossl_quic_fifd_set_qlog_cb(&txp->fifd, get_qlog_cb, get_qlog_cb_arg);
-
 }
 
 int ossl_quic_tx_packetiser_discard_enc_level(OSSL_QUIC_TX_PACKETISER *txp,
-                                              uint32_t enc_level)
+    uint32_t enc_level)
 {
     if (enc_level >= QUIC_ENC_LEVEL_NUM) {
         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
@@ -751,21 +750,21 @@ void ossl_quic_tx_packetiser_schedule_handshake_done(OSSL_QUIC_TX_PACKETISER *tx
 }
 
 void ossl_quic_tx_packetiser_schedule_ack_eliciting(OSSL_QUIC_TX_PACKETISER *txp,
-                                                    uint32_t pn_space)
+    uint32_t pn_space)
 {
     txp->force_ack_eliciting |= (1UL << pn_space);
 }
 
 void ossl_quic_tx_packetiser_schedule_ack(OSSL_QUIC_TX_PACKETISER *txp,
-                                          uint32_t pn_space)
+    uint32_t pn_space)
 {
     txp->want_ack |= (1UL << pn_space);
 }
 
-#define TXP_ERR_INTERNAL     0  /* Internal (e.g. alloc) error */
-#define TXP_ERR_SUCCESS      1  /* Success */
-#define TXP_ERR_SPACE        2  /* Not enough room for another packet */
-#define TXP_ERR_INPUT        3  /* Invalid/malformed input */
+#define TXP_ERR_INTERNAL 0 /* Internal (e.g. alloc) error */
+#define TXP_ERR_SUCCESS 1 /* Success */
+#define TXP_ERR_SPACE 2 /* Not enough room for another packet */
+#define TXP_ERR_INPUT 3 /* Invalid/malformed input */
 
 /*
  * Generates a datagram by polling the various ELs to determine if they want to
@@ -773,7 +772,7 @@ void ossl_quic_tx_packetiser_schedule_ack(OSSL_QUIC_TX_PACKETISER *txp,
  * any ELs which do.
  */
 int ossl_quic_tx_packetiser_generate(OSSL_QUIC_TX_PACKETISER *txp,
-                                     QUIC_TXP_STATUS *status)
+    QUIC_TXP_STATUS *status)
 {
     /*
      * Called to generate one or more datagrams, each containing one or more
@@ -866,11 +865,10 @@ int ossl_quic_tx_packetiser_generate(OSSL_QUIC_TX_PACKETISER *txp,
     memset(status, 0, sizeof(*status));
 
     for (enc_level = QUIC_ENC_LEVEL_INITIAL;
-         enc_level < QUIC_ENC_LEVEL_NUM;
-         ++enc_level)
+        enc_level < QUIC_ENC_LEVEL_NUM;
+        ++enc_level)
         pkt[enc_level].h_valid = 0;
 
-
     /*
      * Should not be needed, but a sanity check in case anyone else has been
      * using the QTX.
@@ -882,19 +880,20 @@ int ossl_quic_tx_packetiser_generate(OSSL_QUIC_TX_PACKETISER *txp,
 
     /* 2. Packet Staging */
     for (enc_level = QUIC_ENC_LEVEL_INITIAL;
-         enc_level < QUIC_ENC_LEVEL_NUM;
-         ++enc_level) {
+        enc_level < QUIC_ENC_LEVEL_NUM;
+        ++enc_level) {
         size_t running_total = (enc_level > QUIC_ENC_LEVEL_INITIAL)
-            ? pkt[enc_level - 1].geom.hwm : 0;
+            ? pkt[enc_level - 1].geom.hwm
+            : 0;
 
         pkt[enc_level].geom.hwm = running_total;
 
         if (!txp_should_try_staging(txp, enc_level, archetype, cc_limit,
-                                    &conn_close_enc_level))
+                &conn_close_enc_level))
             continue;
 
         if (!txp_pkt_init(&pkt[enc_level], txp, enc_level, archetype,
-                          running_total))
+                running_total))
             /*
              * If this fails this is not a fatal error - it means the geometry
              * planning determined there was not enough space for another
@@ -903,7 +902,7 @@ int ossl_quic_tx_packetiser_generate(OSSL_QUIC_TX_PACKETISER *txp,
             break;
 
         rc = txp_generate_for_el(txp, &pkt[enc_level],
-                                 conn_close_enc_level == enc_level);
+            conn_close_enc_level == enc_level);
         if (rc != TXP_ERR_SUCCESS)
             goto out;
 
@@ -933,8 +932,8 @@ int ossl_quic_tx_packetiser_generate(OSSL_QUIC_TX_PACKETISER *txp,
         uint32_t pad_el = QUIC_ENC_LEVEL_NUM;
 
         for (enc_level = QUIC_ENC_LEVEL_INITIAL;
-             enc_level < QUIC_ENC_LEVEL_NUM;
-             ++enc_level)
+            enc_level < QUIC_ENC_LEVEL_NUM;
+            ++enc_level)
             if (pkt[enc_level].h_valid && pkt[enc_level].h.bytes_appended > 0) {
                 if (pad_el == QUIC_ENC_LEVEL_NUM
                     /*
@@ -980,8 +979,8 @@ int ossl_quic_tx_packetiser_generate(OSSL_QUIC_TX_PACKETISER *txp,
 
     /* 4. Commit */
     for (enc_level = QUIC_ENC_LEVEL_INITIAL;
-         enc_level < QUIC_ENC_LEVEL_NUM;
-         ++enc_level) {
+        enc_level < QUIC_ENC_LEVEL_NUM;
+        ++enc_level) {
 
         if (!pkt[enc_level].h_valid)
             /* Did not attempt to generate a packet for this EL. */
@@ -992,14 +991,14 @@ int ossl_quic_tx_packetiser_generate(OSSL_QUIC_TX_PACKETISER *txp,
             continue;
 
         if (!ossl_quic_tx_packetiser_check_unvalidated_credit(txp,
-                                                              pkt[enc_level].h.bytes_appended)) {
+                pkt[enc_level].h.bytes_appended)) {
             res = TXP_ERR_SPACE;
             goto out;
         }
         ossl_quic_tx_packetiser_consume_unvalidated_credit(txp, pkt[enc_level].h.bytes_appended);
 
         rc = txp_pkt_commit(txp, &pkt[enc_level], archetype,
-                            &txpim_pkt_reffed);
+            &txpim_pkt_reffed);
         if (rc) {
             status->sent_ack_eliciting
                 = status->sent_ack_eliciting
@@ -1008,7 +1007,7 @@ int ossl_quic_tx_packetiser_generate(OSSL_QUIC_TX_PACKETISER *txp,
             if (enc_level == QUIC_ENC_LEVEL_HANDSHAKE)
                 status->sent_handshake
                     = (pkt[enc_level].h_valid
-                       && pkt[enc_level].h.bytes_appended > 0);
+                        && pkt[enc_level].h.bytes_appended > 0);
         }
 
         if (txpim_pkt_reffed)
@@ -1018,7 +1017,6 @@ int ossl_quic_tx_packetiser_generate(OSSL_QUIC_TX_PACKETISER *txp,
             goto out;
 
         ++pkts_done;
-
     }
 
     /* Flush & Cleanup */
@@ -1027,8 +1025,8 @@ out:
     ossl_qtx_finish_dgram(txp->args.qtx);
 
     for (enc_level = QUIC_ENC_LEVEL_INITIAL;
-         enc_level < QUIC_ENC_LEVEL_NUM;
-         ++enc_level)
+        enc_level < QUIC_ENC_LEVEL_NUM;
+        ++enc_level)
         txp_pkt_cleanup(&pkt[enc_level], txp);
 
     status->sent_pkt = pkts_done;
@@ -1041,259 +1039,258 @@ static const struct archetype_data archetypes[QUIC_ENC_LEVEL_NUM][TX_PACKETISER_
     {
         /* EL 0(INITIAL) - Archetype 0(NORMAL) */
         {
-            /*allow_ack                       =*/ 1,
-            /*allow_ping                      =*/ 1,
-            /*allow_crypto                    =*/ 1,
-            /*allow_handshake_done            =*/ 0,
-            /*allow_path_challenge            =*/ 0,
-            /*allow_path_response             =*/ 0,
-            /*allow_new_conn_id               =*/ 0,
-            /*allow_retire_conn_id            =*/ 0,
-            /*allow_stream_rel                =*/ 0,
-            /*allow_conn_fc                   =*/ 0,
-            /*allow_conn_close                =*/ 1,
-            /*allow_cfq_other                 =*/ 0,
-            /*allow_new_token                 =*/ 0,
-            /*allow_force_ack_eliciting       =*/ 1,
-            /*allow_padding                   =*/ 1,
-            /*require_ack_eliciting           =*/ 0,
-            /*bypass_cc                       =*/ 0,
+            /*allow_ack                       =*/1,
+            /*allow_ping                      =*/1,
+            /*allow_crypto                    =*/1,
+            /*allow_handshake_done            =*/0,
+            /*allow_path_challenge            =*/0,
+            /*allow_path_response             =*/0,
+            /*allow_new_conn_id               =*/0,
+            /*allow_retire_conn_id            =*/0,
+            /*allow_stream_rel                =*/0,
+            /*allow_conn_fc                   =*/0,
+            /*allow_conn_close                =*/1,
+            /*allow_cfq_other                 =*/0,
+            /*allow_new_token                 =*/0,
+            /*allow_force_ack_eliciting       =*/1,
+            /*allow_padding                   =*/1,
+            /*require_ack_eliciting           =*/0,
+            /*bypass_cc                       =*/0,
         },
         /* EL 0(INITIAL) - Archetype 1(PROBE) */
         {
-            /*allow_ack                       =*/ 1,
-            /*allow_ping                      =*/ 1,
-            /*allow_crypto                    =*/ 1,
-            /*allow_handshake_done            =*/ 0,
-            /*allow_path_challenge            =*/ 0,
-            /*allow_path_response             =*/ 0,
-            /*allow_new_conn_id               =*/ 0,
-            /*allow_retire_conn_id            =*/ 0,
-            /*allow_stream_rel                =*/ 0,
-            /*allow_conn_fc                   =*/ 0,
-            /*allow_conn_close                =*/ 1,
-            /*allow_cfq_other                 =*/ 0,
-            /*allow_new_token                 =*/ 0,
-            /*allow_force_ack_eliciting       =*/ 1,
-            /*allow_padding                   =*/ 1,
-            /*require_ack_eliciting           =*/ 1,
-            /*bypass_cc                       =*/ 1,
+            /*allow_ack                       =*/1,
+            /*allow_ping                      =*/1,
+            /*allow_crypto                    =*/1,
+            /*allow_handshake_done            =*/0,
+            /*allow_path_challenge            =*/0,
+            /*allow_path_response             =*/0,
+            /*allow_new_conn_id               =*/0,
+            /*allow_retire_conn_id            =*/0,
+            /*allow_stream_rel                =*/0,
+            /*allow_conn_fc                   =*/0,
+            /*allow_conn_close                =*/1,
+            /*allow_cfq_other                 =*/0,
+            /*allow_new_token                 =*/0,
+            /*allow_force_ack_eliciting       =*/1,
+            /*allow_padding                   =*/1,
+            /*require_ack_eliciting           =*/1,
+            /*bypass_cc                       =*/1,
         },
         /* EL 0(INITIAL) - Archetype 2(ACK_ONLY) */
         {
-            /*allow_ack                       =*/ 1,
-            /*allow_ping                      =*/ 0,
-            /*allow_crypto                    =*/ 0,
-            /*allow_handshake_done            =*/ 0,
-            /*allow_path_challenge            =*/ 0,
-            /*allow_path_response             =*/ 0,
-            /*allow_new_conn_id               =*/ 0,
-            /*allow_retire_conn_id            =*/ 0,
-            /*allow_stream_rel                =*/ 0,
-            /*allow_conn_fc                   =*/ 0,
-            /*allow_conn_close                =*/ 0,
-            /*allow_cfq_other                 =*/ 0,
-            /*allow_new_token                 =*/ 0,
-            /*allow_force_ack_eliciting       =*/ 1,
-            /*allow_padding                   =*/ 0,
-            /*require_ack_eliciting           =*/ 0,
-            /*bypass_cc                       =*/ 1,
+            /*allow_ack                       =*/1,
+            /*allow_ping                      =*/0,
+            /*allow_crypto                    =*/0,
+            /*allow_handshake_done            =*/0,
+            /*allow_path_challenge            =*/0,
+            /*allow_path_response             =*/0,
+            /*allow_new_conn_id               =*/0,
+            /*allow_retire_conn_id            =*/0,
+            /*allow_stream_rel                =*/0,
+            /*allow_conn_fc                   =*/0,
+            /*allow_conn_close                =*/0,
+            /*allow_cfq_other                 =*/0,
+            /*allow_new_token                 =*/0,
+            /*allow_force_ack_eliciting       =*/1,
+            /*allow_padding                   =*/0,
+            /*require_ack_eliciting           =*/0,
+            /*bypass_cc                       =*/1,
         },
     },
     /* EL 1(0RTT) */
     {
         /* EL 1(0RTT) - Archetype 0(NORMAL) */
         {
-            /*allow_ack                       =*/ 0,
-            /*allow_ping                      =*/ 1,
-            /*allow_crypto                    =*/ 0,
-            /*allow_handshake_done            =*/ 0,
-            /*allow_path_challenge            =*/ 0,
-            /*allow_path_response             =*/ 0,
-            /*allow_new_conn_id               =*/ 1,
-            /*allow_retire_conn_id            =*/ 1,
-            /*allow_stream_rel                =*/ 1,
-            /*allow_conn_fc                   =*/ 1,
-            /*allow_conn_close                =*/ 1,
-            /*allow_cfq_other                 =*/ 0,
-            /*allow_new_token                 =*/ 0,
-            /*allow_force_ack_eliciting       =*/ 0,
-            /*allow_padding                   =*/ 1,
-            /*require_ack_eliciting           =*/ 0,
-            /*bypass_cc                       =*/ 0,
+            /*allow_ack                       =*/0,
+            /*allow_ping                      =*/1,
+            /*allow_crypto                    =*/0,
+            /*allow_handshake_done            =*/0,
+            /*allow_path_challenge            =*/0,
+            /*allow_path_response             =*/0,
+            /*allow_new_conn_id               =*/1,
+            /*allow_retire_conn_id            =*/1,
+            /*allow_stream_rel                =*/1,
+            /*allow_conn_fc                   =*/1,
+            /*allow_conn_close                =*/1,
+            /*allow_cfq_other                 =*/0,
+            /*allow_new_token                 =*/0,
+            /*allow_force_ack_eliciting       =*/0,
+            /*allow_padding                   =*/1,
+            /*require_ack_eliciting           =*/0,
+            /*bypass_cc                       =*/0,
         },
         /* EL 1(0RTT) - Archetype 1(PROBE) */
         {
-            /*allow_ack                       =*/ 0,
-            /*allow_ping                      =*/ 1,
-            /*allow_crypto                    =*/ 0,
-            /*allow_handshake_done            =*/ 0,
-            /*allow_path_challenge            =*/ 0,
-            /*allow_path_response             =*/ 0,
-            /*allow_new_conn_id               =*/ 1,
-            /*allow_retire_conn_id            =*/ 1,
-            /*allow_stream_rel                =*/ 1,
-            /*allow_conn_fc                   =*/ 1,
-            /*allow_conn_close                =*/ 1,
-            /*allow_cfq_other                 =*/ 0,
-            /*allow_new_token                 =*/ 0,
-            /*allow_force_ack_eliciting       =*/ 0,
-            /*allow_padding                   =*/ 1,
-            /*require_ack_eliciting           =*/ 1,
-            /*bypass_cc                       =*/ 1,
+            /*allow_ack                       =*/0,
+            /*allow_ping                      =*/1,
+            /*allow_crypto                    =*/0,
+            /*allow_handshake_done            =*/0,
+            /*allow_path_challenge            =*/0,
+            /*allow_path_response             =*/0,
+            /*allow_new_conn_id               =*/1,
+            /*allow_retire_conn_id            =*/1,
+            /*allow_stream_rel                =*/1,
+            /*allow_conn_fc                   =*/1,
+            /*allow_conn_close                =*/1,
+            /*allow_cfq_other                 =*/0,
+            /*allow_new_token                 =*/0,
+            /*allow_force_ack_eliciting       =*/0,
+            /*allow_padding                   =*/1,
+            /*require_ack_eliciting           =*/1,
+            /*bypass_cc                       =*/1,
         },
         /* EL 1(0RTT) - Archetype 2(ACK_ONLY) */
         {
-            /*allow_ack                       =*/ 0,
-            /*allow_ping                      =*/ 0,
-            /*allow_crypto                    =*/ 0,
-            /*allow_handshake_done            =*/ 0,
-            /*allow_path_challenge            =*/ 0,
-            /*allow_path_response             =*/ 0,
-            /*allow_new_conn_id               =*/ 0,
-            /*allow_retire_conn_id            =*/ 0,
-            /*allow_stream_rel                =*/ 0,
-            /*allow_conn_fc                   =*/ 0,
-            /*allow_conn_close                =*/ 0,
-            /*allow_cfq_other                 =*/ 0,
-            /*allow_new_token                 =*/ 0,
-            /*allow_force_ack_eliciting       =*/ 0,
-            /*allow_padding                   =*/ 0,
-            /*require_ack_eliciting           =*/ 0,
-            /*bypass_cc                       =*/ 1,
+            /*allow_ack                       =*/0,
+            /*allow_ping                      =*/0,
+            /*allow_crypto                    =*/0,
+            /*allow_handshake_done            =*/0,
+            /*allow_path_challenge            =*/0,
+            /*allow_path_response             =*/0,
+            /*allow_new_conn_id               =*/0,
+            /*allow_retire_conn_id            =*/0,
+            /*allow_stream_rel                =*/0,
+            /*allow_conn_fc                   =*/0,
+            /*allow_conn_close                =*/0,
+            /*allow_cfq_other                 =*/0,
+            /*allow_new_token                 =*/0,
+            /*allow_force_ack_eliciting       =*/0,
+            /*allow_padding                   =*/0,
+            /*require_ack_eliciting           =*/0,
+            /*bypass_cc                       =*/1,
         },
     },
     /* EL (HANDSHAKE) */
     {
         /* EL 2(HANDSHAKE) - Archetype 0(NORMAL) */
         {
-            /*allow_ack                       =*/ 1,
-            /*allow_ping                      =*/ 1,
-            /*allow_crypto                    =*/ 1,
-            /*allow_handshake_done            =*/ 0,
-            /*allow_path_challenge            =*/ 0,
-            /*allow_path_response             =*/ 0,
-            /*allow_new_conn_id               =*/ 0,
-            /*allow_retire_conn_id            =*/ 0,
-            /*allow_stream_rel                =*/ 0,
-            /*allow_conn_fc                   =*/ 0,
-            /*allow_conn_close                =*/ 1,
-            /*allow_cfq_other                 =*/ 0,
-            /*allow_new_token                 =*/ 0,
-            /*allow_force_ack_eliciting       =*/ 1,
-            /*allow_padding                   =*/ 1,
-            /*require_ack_eliciting           =*/ 0,
-            /*bypass_cc                       =*/ 0,
+            /*allow_ack                       =*/1,
+            /*allow_ping                      =*/1,
+            /*allow_crypto                    =*/1,
+            /*allow_handshake_done            =*/0,
+            /*allow_path_challenge            =*/0,
+            /*allow_path_response             =*/0,
+            /*allow_new_conn_id               =*/0,
+            /*allow_retire_conn_id            =*/0,
+            /*allow_stream_rel                =*/0,
+            /*allow_conn_fc                   =*/0,
+            /*allow_conn_close                =*/1,
+            /*allow_cfq_other                 =*/0,
+            /*allow_new_token                 =*/0,
+            /*allow_force_ack_eliciting       =*/1,
+            /*allow_padding                   =*/1,
+            /*require_ack_eliciting           =*/0,
+            /*bypass_cc                       =*/0,
         },
         /* EL 2(HANDSHAKE) - Archetype 1(PROBE) */
         {
-            /*allow_ack                       =*/ 1,
-            /*allow_ping                      =*/ 1,
-            /*allow_crypto                    =*/ 1,
-            /*allow_handshake_done            =*/ 0,
-            /*allow_path_challenge            =*/ 0,
-            /*allow_path_response             =*/ 0,
-            /*allow_new_conn_id               =*/ 0,
-            /*allow_retire_conn_id            =*/ 0,
-            /*allow_stream_rel                =*/ 0,
-            /*allow_conn_fc                   =*/ 0,
-            /*allow_conn_close                =*/ 1,
-            /*allow_cfq_other                 =*/ 0,
-            /*allow_new_token                 =*/ 0,
-            /*allow_force_ack_eliciting       =*/ 1,
-            /*allow_padding                   =*/ 1,
-            /*require_ack_eliciting           =*/ 1,
-            /*bypass_cc                       =*/ 1,
+            /*allow_ack                       =*/1,
+            /*allow_ping                      =*/1,
+            /*allow_crypto                    =*/1,
+            /*allow_handshake_done            =*/0,
+            /*allow_path_challenge            =*/0,
+            /*allow_path_response             =*/0,
+            /*allow_new_conn_id               =*/0,
+            /*allow_retire_conn_id            =*/0,
+            /*allow_stream_rel                =*/0,
+            /*allow_conn_fc                   =*/0,
+            /*allow_conn_close                =*/1,
+            /*allow_cfq_other                 =*/0,
+            /*allow_new_token                 =*/0,
+            /*allow_force_ack_eliciting       =*/1,
+            /*allow_padding                   =*/1,
+            /*require_ack_eliciting           =*/1,
+            /*bypass_cc                       =*/1,
         },
         /* EL 2(HANDSHAKE) - Archetype 2(ACK_ONLY) */
         {
-            /*allow_ack                       =*/ 1,
-            /*allow_ping                      =*/ 0,
-            /*allow_crypto                    =*/ 0,
-            /*allow_handshake_done            =*/ 0,
-            /*allow_path_challenge            =*/ 0,
-            /*allow_path_response             =*/ 0,
-            /*allow_new_conn_id               =*/ 0,
-            /*allow_retire_conn_id            =*/ 0,
-            /*allow_stream_rel                =*/ 0,
-            /*allow_conn_fc                   =*/ 0,
-            /*allow_conn_close                =*/ 0,
-            /*allow_cfq_other                 =*/ 0,
-            /*allow_new_token                 =*/ 0,
-            /*allow_force_ack_eliciting       =*/ 1,
-            /*allow_padding                   =*/ 0,
-            /*require_ack_eliciting           =*/ 0,
-            /*bypass_cc                       =*/ 1,
+            /*allow_ack                       =*/1,
+            /*allow_ping                      =*/0,
+            /*allow_crypto                    =*/0,
+            /*allow_handshake_done            =*/0,
+            /*allow_path_challenge            =*/0,
+            /*allow_path_response             =*/0,
+            /*allow_new_conn_id               =*/0,
+            /*allow_retire_conn_id            =*/0,
+            /*allow_stream_rel                =*/0,
+            /*allow_conn_fc                   =*/0,
+            /*allow_conn_close                =*/0,
+            /*allow_cfq_other                 =*/0,
+            /*allow_new_token                 =*/0,
+            /*allow_force_ack_eliciting       =*/1,
+            /*allow_padding                   =*/0,
+            /*require_ack_eliciting           =*/0,
+            /*bypass_cc                       =*/1,
         },
     },
     /* EL 3(1RTT) */
     {
         /* EL 3(1RTT) - Archetype 0(NORMAL) */
         {
-            /*allow_ack                       =*/ 1,
-            /*allow_ping                      =*/ 1,
-            /*allow_crypto                    =*/ 1,
-            /*allow_handshake_done            =*/ 1,
-            /*allow_path_challenge            =*/ 0,
-            /*allow_path_response             =*/ 1,
-            /*allow_new_conn_id               =*/ 1,
-            /*allow_retire_conn_id            =*/ 1,
-            /*allow_stream_rel                =*/ 1,
-            /*allow_conn_fc                   =*/ 1,
-            /*allow_conn_close                =*/ 1,
-            /*allow_cfq_other                 =*/ 1,
-            /*allow_new_token                 =*/ 1,
-            /*allow_force_ack_eliciting       =*/ 1,
-            /*allow_padding                   =*/ 1,
-            /*require_ack_eliciting           =*/ 0,
-            /*bypass_cc                       =*/ 0,
+            /*allow_ack                       =*/1,
+            /*allow_ping                      =*/1,
+            /*allow_crypto                    =*/1,
+            /*allow_handshake_done            =*/1,
+            /*allow_path_challenge            =*/0,
+            /*allow_path_response             =*/1,
+            /*allow_new_conn_id               =*/1,
+            /*allow_retire_conn_id            =*/1,
+            /*allow_stream_rel                =*/1,
+            /*allow_conn_fc                   =*/1,
+            /*allow_conn_close                =*/1,
+            /*allow_cfq_other                 =*/1,
+            /*allow_new_token                 =*/1,
+            /*allow_force_ack_eliciting       =*/1,
+            /*allow_padding                   =*/1,
+            /*require_ack_eliciting           =*/0,
+            /*bypass_cc                       =*/0,
         },
         /* EL 3(1RTT) - Archetype 1(PROBE) */
         {
-            /*allow_ack                       =*/ 1,
-            /*allow_ping                      =*/ 1,
-            /*allow_crypto                    =*/ 1,
-            /*allow_handshake_done            =*/ 1,
-            /*allow_path_challenge            =*/ 0,
-            /*allow_path_response             =*/ 1,
-            /*allow_new_conn_id               =*/ 1,
-            /*allow_retire_conn_id            =*/ 1,
-            /*allow_stream_rel                =*/ 1,
-            /*allow_conn_fc                   =*/ 1,
-            /*allow_conn_close                =*/ 1,
-            /*allow_cfq_other                 =*/ 1,
-            /*allow_new_token                 =*/ 1,
-            /*allow_force_ack_eliciting       =*/ 1,
-            /*allow_padding                   =*/ 1,
-            /*require_ack_eliciting           =*/ 1,
-            /*bypass_cc                       =*/ 1,
+            /*allow_ack                       =*/1,
+            /*allow_ping                      =*/1,
+            /*allow_crypto                    =*/1,
+            /*allow_handshake_done            =*/1,
+            /*allow_path_challenge            =*/0,
+            /*allow_path_response             =*/1,
+            /*allow_new_conn_id               =*/1,
+            /*allow_retire_conn_id            =*/1,
+            /*allow_stream_rel                =*/1,
+            /*allow_conn_fc                   =*/1,
+            /*allow_conn_close                =*/1,
+            /*allow_cfq_other                 =*/1,
+            /*allow_new_token                 =*/1,
+            /*allow_force_ack_eliciting       =*/1,
+            /*allow_padding                   =*/1,
+            /*require_ack_eliciting           =*/1,
+            /*bypass_cc                       =*/1,
         },
         /* EL 3(1RTT) - Archetype 2(ACK_ONLY) */
         {
-            /*allow_ack                       =*/ 1,
-            /*allow_ping                      =*/ 0,
-            /*allow_crypto                    =*/ 0,
-            /*allow_handshake_done            =*/ 0,
-            /*allow_path_challenge            =*/ 0,
-            /*allow_path_response             =*/ 0,
-            /*allow_new_conn_id               =*/ 0,
-            /*allow_retire_conn_id            =*/ 0,
-            /*allow_stream_rel                =*/ 0,
-            /*allow_conn_fc                   =*/ 0,
-            /*allow_conn_close                =*/ 0,
-            /*allow_cfq_other                 =*/ 0,
-            /*allow_new_token                 =*/ 0,
-            /*allow_force_ack_eliciting       =*/ 1,
-            /*allow_padding                   =*/ 0,
-            /*require_ack_eliciting           =*/ 0,
-            /*bypass_cc                       =*/ 1,
-        }
-    }
+            /*allow_ack                       =*/1,
+            /*allow_ping                      =*/0,
+            /*allow_crypto                    =*/0,
+            /*allow_handshake_done            =*/0,
+            /*allow_path_challenge            =*/0,
+            /*allow_path_response             =*/0,
+            /*allow_new_conn_id               =*/0,
+            /*allow_retire_conn_id            =*/0,
+            /*allow_stream_rel                =*/0,
+            /*allow_conn_fc                   =*/0,
+            /*allow_conn_close                =*/0,
+            /*allow_cfq_other                 =*/0,
+            /*allow_new_token                 =*/0,
+            /*allow_force_ack_eliciting       =*/1,
+            /*allow_padding                   =*/0,
+            /*require_ack_eliciting           =*/0,
+            /*bypass_cc                       =*/1,
+        } }
 };
 
 static int txp_get_archetype_data(uint32_t enc_level,
-                                  uint32_t archetype,
-                                  struct archetype_data *a)
+    uint32_t archetype,
+    struct archetype_data *a)
 {
     if (enc_level >= QUIC_ENC_LEVEL_NUM
         || archetype >= TX_PACKETISER_ARCHETYPE_NUM)
@@ -1305,28 +1302,28 @@ static int txp_get_archetype_data(uint32_t enc_level,
 }
 
 static int txp_determine_geometry(OSSL_QUIC_TX_PACKETISER *txp,
-                                  uint32_t archetype,
-                                  uint32_t enc_level,
-                                  size_t running_total,
-                                  QUIC_PKT_HDR *phdr,
-                                  struct txp_pkt_geom *geom)
+    uint32_t archetype,
+    uint32_t enc_level,
+    size_t running_total,
+    QUIC_PKT_HDR *phdr,
+    struct txp_pkt_geom *geom)
 {
     size_t mdpl, cmpl, hdr_len;
 
     /* Get information about packet archetype. */
     if (!txp_get_archetype_data(enc_level, archetype, &geom->adata))
-       return 0;
+        return 0;
 
     /* Assemble packet header. */
-    phdr->type          = ossl_quic_enc_level_to_pkt_type(enc_level);
-    phdr->spin_bit      = 0;
-    phdr->pn_len        = txp_determine_pn_len(txp);
-    phdr->partial       = 0;
-    phdr->fixed         = 1;
-    phdr->reserved      = 0;
-    phdr->version       = txp->args.protocol_version;
-    phdr->dst_conn_id   = txp->args.cur_dcid;
-    phdr->src_conn_id   = txp->args.cur_scid;
+    phdr->type = ossl_quic_enc_level_to_pkt_type(enc_level);
+    phdr->spin_bit = 0;
+    phdr->pn_len = txp_determine_pn_len(txp);
+    phdr->partial = 0;
+    phdr->fixed = 1;
+    phdr->reserved = 0;
+    phdr->version = txp->args.protocol_version;
+    phdr->dst_conn_id = txp->args.cur_dcid;
+    phdr->src_conn_id = txp->args.cur_scid;
 
     /*
      * We need to know the length of the payload to get an accurate header
@@ -1348,18 +1345,18 @@ static int txp_determine_geometry(OSSL_QUIC_TX_PACKETISER *txp,
      * worry about this. Thus we estimate the header length assuming a 2-byte
      * length field here, which should in practice work well in all cases.
      */
-    phdr->len           = OSSL_QUIC_VLINT_2B_MAX - phdr->pn_len;
+    phdr->len = OSSL_QUIC_VLINT_2B_MAX - phdr->pn_len;
 
     if (enc_level == QUIC_ENC_LEVEL_INITIAL) {
-        phdr->token     = txp->initial_token;
+        phdr->token = txp->initial_token;
         phdr->token_len = txp->initial_token_len;
     } else {
-        phdr->token     = NULL;
+        phdr->token = NULL;
         phdr->token_len = 0;
     }
 
     hdr_len = ossl_quic_wire_get_encoded_pkt_hdr_len(phdr->dst_conn_id.id_len,
-                                                     phdr);
+        phdr);
     if (hdr_len == 0)
         return 0;
 
@@ -1380,14 +1377,14 @@ static int txp_determine_geometry(OSSL_QUIC_TX_PACKETISER *txp,
     if (!txp_determine_ppl_from_pl(txp, cmpl, enc_level, hdr_len, &geom->cmppl))
         return 0;
 
-    geom->cmpl                  = cmpl;
-    geom->pkt_overhead          = cmpl - geom->cmppl;
-    geom->archetype             = archetype;
+    geom->cmpl = cmpl;
+    geom->pkt_overhead = cmpl - geom->cmppl;
+    geom->archetype = archetype;
     return 1;
 }
 
 static uint32_t txp_determine_archetype(OSSL_QUIC_TX_PACKETISER *txp,
-                                        uint64_t cc_limit)
+    uint64_t cc_limit)
 {
     OSSL_ACKM_PROBE_INFO *probe_info
         = ossl_ackm_get0_probe_request(txp->args.ackm);
@@ -1404,8 +1401,8 @@ static uint32_t txp_determine_archetype(OSSL_QUIC_TX_PACKETISER *txp,
         return TX_PACKETISER_ARCHETYPE_PROBE;
 
     for (pn_space = QUIC_PN_SPACE_INITIAL;
-         pn_space < QUIC_PN_SPACE_NUM;
-         ++pn_space)
+        pn_space < QUIC_PN_SPACE_NUM;
+        ++pn_space)
         if (probe_info->pto[pn_space] > 0)
             return TX_PACKETISER_ARCHETYPE_PROBE;
 
@@ -1422,10 +1419,10 @@ static uint32_t txp_determine_archetype(OSSL_QUIC_TX_PACKETISER *txp,
 }
 
 static int txp_should_try_staging(OSSL_QUIC_TX_PACKETISER *txp,
-                                  uint32_t enc_level,
-                                  uint32_t archetype,
-                                  uint64_t cc_limit,
-                                  uint32_t *conn_close_enc_level)
+    uint32_t enc_level,
+    uint32_t archetype,
+    uint64_t cc_limit,
+    uint32_t *conn_close_enc_level)
 {
     struct archetype_data a;
     uint32_t pn_space = ossl_quic_enc_level_to_pn_space(enc_level);
@@ -1481,7 +1478,7 @@ static int txp_should_try_staging(OSSL_QUIC_TX_PACKETISER *txp,
             = ossl_ackm_get0_probe_request(txp->args.ackm);
 
         if ((enc_level == QUIC_ENC_LEVEL_INITIAL
-             && probe_info->anti_deadlock_initial > 0)
+                && probe_info->anti_deadlock_initial > 0)
             || (enc_level == QUIC_ENC_LEVEL_HANDSHAKE
                 && probe_info->anti_deadlock_handshake > 0)
             || probe_info->pto[pn_space] > 0)
@@ -1493,8 +1490,7 @@ static int txp_should_try_staging(OSSL_QUIC_TX_PACKETISER *txp,
         return 1;
 
     /* Does the ACKM for this PN space want to produce anything? */
-    if (a.allow_ack && (ossl_ackm_is_ack_desired(txp->args.ackm, pn_space)
-                        || (txp->want_ack & (1UL << pn_space)) != 0))
+    if (a.allow_ack && (ossl_ackm_is_ack_desired(txp->args.ackm, pn_space) || (txp->want_ack & (1UL << pn_space)) != 0))
         return 1;
 
     /* Do we need to force emission of an ACK-eliciting packet? */
@@ -1503,18 +1499,17 @@ static int txp_should_try_staging(OSSL_QUIC_TX_PACKETISER *txp,
         return 1;
 
     /* Does the connection-level RXFC want to produce a frame? */
-    if (a.allow_conn_fc && (txp->want_max_data
-        || ossl_quic_rxfc_has_cwm_changed(txp->args.conn_rxfc, 0)))
+    if (a.allow_conn_fc && (txp->want_max_data || ossl_quic_rxfc_has_cwm_changed(txp->args.conn_rxfc, 0)))
         return 1;
 
     /* Do we want to produce a MAX_STREAMS frame? */
     if (a.allow_conn_fc
         && (txp->want_max_streams_bidi
             || ossl_quic_rxfc_has_cwm_changed(txp->args.max_streams_bidi_rxfc,
-                                              0)
+                0)
             || txp->want_max_streams_uni
             || ossl_quic_rxfc_has_cwm_changed(txp->args.max_streams_uni_rxfc,
-                                              0)))
+                0)))
         return 1;
 
     /* Do we want to produce a HANDSHAKE_DONE frame? */
@@ -1522,8 +1517,7 @@ static int txp_should_try_staging(OSSL_QUIC_TX_PACKETISER *txp,
         return 1;
 
     /* Do we want to produce a CONNECTION_CLOSE frame? */
-    if (a.allow_conn_close && txp->want_conn_close &&
-        *conn_close_enc_level == enc_level)
+    if (a.allow_conn_close && txp->want_conn_close && *conn_close_enc_level == enc_level)
         /*
          * This is a bit of a special case since CONNECTION_CLOSE can appear in
          * most packet types, and when we decide we want to send it this status
@@ -1535,8 +1529,8 @@ static int txp_should_try_staging(OSSL_QUIC_TX_PACKETISER *txp,
     /* Does the CFQ have any frames queued for this PN space? */
     if (enc_level != QUIC_ENC_LEVEL_0RTT)
         for (cfq_item = ossl_quic_cfq_get_priority_head(txp->args.cfq, pn_space);
-             cfq_item != NULL;
-             cfq_item = ossl_quic_cfq_item_get_priority_next(cfq_item, pn_space)) {
+            cfq_item != NULL;
+            cfq_item = ossl_quic_cfq_item_get_priority_next(cfq_item, pn_space)) {
             uint64_t frame_type = ossl_quic_cfq_item_get_frame_type(cfq_item);
 
             switch (frame_type) {
@@ -1561,7 +1555,7 @@ static int txp_should_try_staging(OSSL_QUIC_TX_PACKETISER *txp,
                     return 1;
                 break;
             }
-       }
+        }
 
     if (a.allow_stream_rel && txp->handshake_complete) {
         QUIC_STREAM_ITER it;
@@ -1600,10 +1594,10 @@ static size_t txp_determine_pn_len(OSSL_QUIC_TX_PACKETISER *txp)
 
 /* Determine plaintext packet payload length from payload length. */
 static int txp_determine_ppl_from_pl(OSSL_QUIC_TX_PACKETISER *txp,
-                                     size_t pl,
-                                     uint32_t enc_level,
-                                     size_t hdr_len,
-                                     size_t *r)
+    size_t pl,
+    uint32_t enc_level,
+    size_t hdr_len,
+    size_t *r)
 {
     if (pl < hdr_len)
         return 0;
@@ -1611,7 +1605,7 @@ static int txp_determine_ppl_from_pl(OSSL_QUIC_TX_PACKETISER *txp,
     pl -= hdr_len;
 
     if (!ossl_qtx_calculate_plaintext_payload_len(txp->args.qtx, enc_level,
-                                                  pl, &pl))
+            pl, &pl))
         return 0;
 
     *r = pl;
@@ -1624,7 +1618,7 @@ static size_t txp_get_mdpl(OSSL_QUIC_TX_PACKETISER *txp)
 }
 
 static QUIC_SSTREAM *get_sstream_by_id(uint64_t stream_id, uint32_t pn_space,
-                                       void *arg)
+    void *arg)
 {
     OSSL_QUIC_TX_PACKETISER *txp = arg;
     QUIC_STREAM *s;
@@ -1640,70 +1634,64 @@ static QUIC_SSTREAM *get_sstream_by_id(uint64_t stream_id, uint32_t pn_space,
 }
 
 static void on_regen_notify(uint64_t frame_type, uint64_t stream_id,
-                            QUIC_TXPIM_PKT *pkt, void *arg)
+    QUIC_TXPIM_PKT *pkt, void *arg)
 {
     OSSL_QUIC_TX_PACKETISER *txp = arg;
 
     switch (frame_type) {
-        case OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE:
-            txp->want_handshake_done = 1;
-            break;
-        case OSSL_QUIC_FRAME_TYPE_MAX_DATA:
-            txp->want_max_data = 1;
-            break;
-        case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI:
-            txp->want_max_streams_bidi = 1;
-            break;
-        case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI:
-            txp->want_max_streams_uni = 1;
-            break;
-        case OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN:
-            txp->want_ack |= (1UL << pkt->ackm_pkt.pkt_space);
-            break;
-        case OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA:
-            {
-                QUIC_STREAM *s
-                    = ossl_quic_stream_map_get_by_id(txp->args.qsm, stream_id);
+    case OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE:
+        txp->want_handshake_done = 1;
+        break;
+    case OSSL_QUIC_FRAME_TYPE_MAX_DATA:
+        txp->want_max_data = 1;
+        break;
+    case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI:
+        txp->want_max_streams_bidi = 1;
+        break;
+    case OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI:
+        txp->want_max_streams_uni = 1;
+        break;
+    case OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN:
+        txp->want_ack |= (1UL << pkt->ackm_pkt.pkt_space);
+        break;
+    case OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA: {
+        QUIC_STREAM *s
+            = ossl_quic_stream_map_get_by_id(txp->args.qsm, stream_id);
 
-                if (s == NULL)
-                    return;
+        if (s == NULL)
+            return;
 
-                s->want_max_stream_data = 1;
-                ossl_quic_stream_map_update_state(txp->args.qsm, s);
-            }
-            break;
-        case OSSL_QUIC_FRAME_TYPE_STOP_SENDING:
-            {
-                QUIC_STREAM *s
-                    = ossl_quic_stream_map_get_by_id(txp->args.qsm, stream_id);
+        s->want_max_stream_data = 1;
+        ossl_quic_stream_map_update_state(txp->args.qsm, s);
+    } break;
+    case OSSL_QUIC_FRAME_TYPE_STOP_SENDING: {
+        QUIC_STREAM *s
+            = ossl_quic_stream_map_get_by_id(txp->args.qsm, stream_id);
 
-                if (s == NULL)
-                    return;
+        if (s == NULL)
+            return;
 
-                ossl_quic_stream_map_schedule_stop_sending(txp->args.qsm, s);
-            }
-            break;
-        case OSSL_QUIC_FRAME_TYPE_RESET_STREAM:
-            {
-                QUIC_STREAM *s
-                    = ossl_quic_stream_map_get_by_id(txp->args.qsm, stream_id);
+        ossl_quic_stream_map_schedule_stop_sending(txp->args.qsm, s);
+    } break;
+    case OSSL_QUIC_FRAME_TYPE_RESET_STREAM: {
+        QUIC_STREAM *s
+            = ossl_quic_stream_map_get_by_id(txp->args.qsm, stream_id);
 
-                if (s == NULL)
-                    return;
+        if (s == NULL)
+            return;
 
-                s->want_reset_stream = 1;
-                ossl_quic_stream_map_update_state(txp->args.qsm, s);
-            }
-            break;
-        default:
-            assert(0);
-            break;
+        s->want_reset_stream = 1;
+        ossl_quic_stream_map_update_state(txp->args.qsm, s);
+    } break;
+    default:
+        assert(0);
+        break;
     }
 }
 
 static int txp_need_ping(OSSL_QUIC_TX_PACKETISER *txp,
-                         uint32_t pn_space,
-                         const struct archetype_data *adata)
+    uint32_t pn_space,
+    const struct archetype_data *adata)
 {
     return adata->allow_ping
         && (adata->require_ack_eliciting
@@ -1711,13 +1699,13 @@ static int txp_need_ping(OSSL_QUIC_TX_PACKETISER *txp,
 }
 
 static int txp_pkt_init(struct txp_pkt *pkt, OSSL_QUIC_TX_PACKETISER *txp,
-                        uint32_t enc_level, uint32_t archetype,
-                        size_t running_total)
+    uint32_t enc_level, uint32_t archetype,
+    size_t running_total)
 {
     uint32_t pn_space = ossl_quic_enc_level_to_pn_space(enc_level);
 
     if (!txp_determine_geometry(txp, archetype, enc_level,
-                                running_total, &pkt->phdr, &pkt->geom))
+            running_total, &pkt->phdr, &pkt->geom))
         return 0;
 
     /*
@@ -1725,14 +1713,14 @@ static int txp_pkt_init(struct txp_pkt *pkt, OSSL_QUIC_TX_PACKETISER *txp,
      * PING.
      */
     if (!tx_helper_init(&pkt->h, txp, enc_level,
-                        pkt->geom.cmppl,
-                        txp_need_ping(txp, pn_space, &pkt->geom.adata) ? 1 : 0))
+            pkt->geom.cmppl,
+            txp_need_ping(txp, pn_space, &pkt->geom.adata) ? 1 : 0))
         return 0;
 
-    pkt->h_valid            = 1;
-    pkt->tpkt               = NULL;
-    pkt->stream_head        = NULL;
-    pkt->force_pad          = 0;
+    pkt->h_valid = 1;
+    pkt->tpkt = NULL;
+    pkt->stream_head = NULL;
+    pkt->force_pad = 0;
     return 1;
 }
 
@@ -1751,7 +1739,7 @@ static void txp_pkt_cleanup(struct txp_pkt *pkt, OSSL_QUIC_TX_PACKETISER *txp)
 }
 
 static int txp_pkt_postgen_update_pkt_overhead(struct txp_pkt *pkt,
-                                               OSSL_QUIC_TX_PACKETISER *txp)
+    OSSL_QUIC_TX_PACKETISER *txp)
 {
     /*
      * After we have staged and generated our packets, but before we commit
@@ -1779,61 +1767,57 @@ static int txp_pkt_postgen_update_pkt_overhead(struct txp_pkt *pkt,
         return 1;
 
     if (!ossl_qtx_calculate_ciphertext_payload_len(txp->args.qtx, pkt->h.enc_level,
-                                                   pkt->h.bytes_appended,
-                                                   &ciphertext_len))
+            pkt->h.bytes_appended,
+            &ciphertext_len))
         return 0;
 
     pkt->phdr.len = ciphertext_len;
 
     hdr_len = ossl_quic_wire_get_encoded_pkt_hdr_len(pkt->phdr.dst_conn_id.id_len,
-                                                     &pkt->phdr);
+        &pkt->phdr);
 
     pkt->geom.pkt_overhead = hdr_len + ciphertext_len - pkt->h.bytes_appended;
     return 1;
 }
 
 static void on_confirm_notify(uint64_t frame_type, uint64_t stream_id,
-                              QUIC_TXPIM_PKT *pkt, void *arg)
+    QUIC_TXPIM_PKT *pkt, void *arg)
 {
     OSSL_QUIC_TX_PACKETISER *txp = arg;
 
     switch (frame_type) {
-        case OSSL_QUIC_FRAME_TYPE_STOP_SENDING:
-            {
-                QUIC_STREAM *s
-                    = ossl_quic_stream_map_get_by_id(txp->args.qsm, stream_id);
+    case OSSL_QUIC_FRAME_TYPE_STOP_SENDING: {
+        QUIC_STREAM *s
+            = ossl_quic_stream_map_get_by_id(txp->args.qsm, stream_id);
 
-                if (s == NULL)
-                    return;
+        if (s == NULL)
+            return;
 
-                s->acked_stop_sending = 1;
-                ossl_quic_stream_map_update_state(txp->args.qsm, s);
-            }
-            break;
-        case OSSL_QUIC_FRAME_TYPE_RESET_STREAM:
-            {
-                QUIC_STREAM *s
-                    = ossl_quic_stream_map_get_by_id(txp->args.qsm, stream_id);
+        s->acked_stop_sending = 1;
+        ossl_quic_stream_map_update_state(txp->args.qsm, s);
+    } break;
+    case OSSL_QUIC_FRAME_TYPE_RESET_STREAM: {
+        QUIC_STREAM *s
+            = ossl_quic_stream_map_get_by_id(txp->args.qsm, stream_id);
 
-                if (s == NULL)
-                    return;
+        if (s == NULL)
+            return;
 
-                /*
-                 * We must already be in RESET_SENT or RESET_RECVD if we are
-                 * here, so we don't need to check state here.
-                 */
-                ossl_quic_stream_map_notify_reset_stream_acked(txp->args.qsm, s);
-                ossl_quic_stream_map_update_state(txp->args.qsm, s);
-            }
-            break;
-        default:
-            assert(0);
-            break;
+        /*
+         * We must already be in RESET_SENT or RESET_RECVD if we are
+         * here, so we don't need to check state here.
+         */
+        ossl_quic_stream_map_notify_reset_stream_acked(txp->args.qsm, s);
+        ossl_quic_stream_map_update_state(txp->args.qsm, s);
+    } break;
+    default:
+        assert(0);
+        break;
     }
 }
 
 static int txp_pkt_append_padding(struct txp_pkt *pkt,
-                                  OSSL_QUIC_TX_PACKETISER *txp, size_t num_bytes)
+    OSSL_QUIC_TX_PACKETISER *txp, size_t num_bytes)
 {
     WPACKET *wpkt;
 
@@ -1858,9 +1842,9 @@ static int txp_pkt_append_padding(struct txp_pkt *pkt,
     if (!tx_helper_commit(&pkt->h))
         return 0;
 
-    pkt->tpkt->ackm_pkt.num_bytes      += num_bytes;
+    pkt->tpkt->ackm_pkt.num_bytes += num_bytes;
     /* Cannot be non-inflight if we have a PADDING frame */
-    pkt->tpkt->ackm_pkt.is_inflight     = 1;
+    pkt->tpkt->ackm_pkt.is_inflight = 1;
     return 1;
 }
 
@@ -1912,15 +1896,15 @@ static int try_commit_conn_close(OSSL_QUIC_TX_PACKETISER *txp, size_t n)
 }
 
 void ossl_quic_tx_packetiser_record_received_closing_bytes(
-        OSSL_QUIC_TX_PACKETISER *txp, size_t n)
+    OSSL_QUIC_TX_PACKETISER *txp, size_t n)
 {
     txp->closing_bytes_recv += n;
 }
 
 static int txp_generate_pre_token(OSSL_QUIC_TX_PACKETISER *txp,
-                                  struct txp_pkt *pkt,
-                                  int chosen_for_conn_close,
-                                  int *can_be_non_inflight)
+    struct txp_pkt *pkt,
+    int chosen_for_conn_close,
+    int *can_be_non_inflight)
 {
     const uint32_t enc_level = pkt->h.enc_level;
     const uint32_t pn_space = ossl_quic_enc_level_to_pn_space(enc_level);
@@ -1948,8 +1932,8 @@ static int txp_generate_pre_token(OSSL_QUIC_TX_PACKETISER *txp,
         ack2.ecn_present = 0;
 
         if (ossl_quic_wire_encode_frame_ack(wpkt,
-                                            txp->args.ack_delay_exponent,
-                                            &ack2)) {
+                txp->args.ack_delay_exponent,
+                &ack2)) {
             if (!tx_helper_commit(h))
                 return 0;
 
@@ -1992,16 +1976,16 @@ static int txp_generate_pre_token(OSSL_QUIC_TX_PACKETISER *txp,
          */
         if (pn_space != QUIC_PN_SPACE_APP && pf->is_app) {
             pf = &f;
-            pf->is_app      = 0;
-            pf->frame_type  = 0;
-            pf->error_code  = OSSL_QUIC_ERR_APPLICATION_ERROR;
-            pf->reason      = NULL;
-            pf->reason_len  = 0;
+            pf->is_app = 0;
+            pf->frame_type = 0;
+            pf->error_code = OSSL_QUIC_ERR_APPLICATION_ERROR;
+            pf->reason = NULL;
+            pf->reason_len = 0;
         }
 
         if (ossl_quic_wire_encode_frame_conn_close(wpkt, pf)
-                && WPACKET_get_total_written(wpkt, &l)
-                && try_commit_conn_close(txp, l)) {
+            && WPACKET_get_total_written(wpkt, &l)
+            && try_commit_conn_close(txp, l)) {
             if (!tx_helper_commit(h))
                 return 0;
 
@@ -2016,8 +2000,8 @@ static int txp_generate_pre_token(OSSL_QUIC_TX_PACKETISER *txp,
 }
 
 static int try_len(size_t space_left, size_t orig_len,
-                   size_t base_hdr_len, size_t lenbytes,
-                   uint64_t maxn, size_t *hdr_len, size_t *payload_len)
+    size_t base_hdr_len, size_t lenbytes,
+    uint64_t maxn, size_t *hdr_len, size_t *payload_len)
 {
     size_t n;
     size_t maxn_ = maxn > SIZE_MAX ? SIZE_MAX : (size_t)maxn;
@@ -2040,37 +2024,37 @@ static int try_len(size_t space_left, size_t orig_len,
 }
 
 static int determine_len(size_t space_left, size_t orig_len,
-                         size_t base_hdr_len,
-                         uint64_t *hlen, uint64_t *len)
+    size_t base_hdr_len,
+    uint64_t *hlen, uint64_t *len)
 {
     int ok = 0;
     size_t chosen_payload_len = 0;
-    size_t chosen_hdr_len     = 0;
+    size_t chosen_hdr_len = 0;
     size_t payload_len[4], hdr_len[4];
-    int i, valid[4] = {0};
+    int i, valid[4] = { 0 };
 
     valid[0] = try_len(space_left, orig_len, base_hdr_len,
-                       1, OSSL_QUIC_VLINT_1B_MAX,
-                       &hdr_len[0], &payload_len[0]);
+        1, OSSL_QUIC_VLINT_1B_MAX,
+        &hdr_len[0], &payload_len[0]);
     valid[1] = try_len(space_left, orig_len, base_hdr_len,
-                       2, OSSL_QUIC_VLINT_2B_MAX,
-                       &hdr_len[1], &payload_len[1]);
+        2, OSSL_QUIC_VLINT_2B_MAX,
+        &hdr_len[1], &payload_len[1]);
     valid[2] = try_len(space_left, orig_len, base_hdr_len,
-                       4, OSSL_QUIC_VLINT_4B_MAX,
-                       &hdr_len[2], &payload_len[2]);
+        4, OSSL_QUIC_VLINT_4B_MAX,
+        &hdr_len[2], &payload_len[2]);
     valid[3] = try_len(space_left, orig_len, base_hdr_len,
-                       8, OSSL_QUIC_VLINT_8B_MAX,
-                       &hdr_len[3], &payload_len[3]);
+        8, OSSL_QUIC_VLINT_8B_MAX,
+        &hdr_len[3], &payload_len[3]);
 
-   for (i = OSSL_NELEM(valid) - 1; i >= 0; --i)
+    for (i = OSSL_NELEM(valid) - 1; i >= 0; --i)
         if (valid[i] && payload_len[i] >= chosen_payload_len) {
             chosen_payload_len = payload_len[i];
-            chosen_hdr_len     = hdr_len[i];
-            ok                 = 1;
+            chosen_hdr_len = hdr_len[i];
+            ok = 1;
         }
 
     *hlen = chosen_hdr_len;
-    *len  = chosen_payload_len;
+    *len = chosen_payload_len;
     return ok;
 }
 
@@ -2083,10 +2067,10 @@ static int determine_len(size_t space_left, size_t orig_len,
  * encodings and choose the optimal encoding.
  */
 static int determine_crypto_len(struct tx_helper *h,
-                                OSSL_QUIC_FRAME_CRYPTO *chdr,
-                                size_t space_left,
-                                uint64_t *hlen,
-                                uint64_t *len)
+    OSSL_QUIC_FRAME_CRYPTO *chdr,
+    size_t space_left,
+    uint64_t *hlen,
+    uint64_t *len)
 {
     size_t orig_len;
     size_t base_hdr_len; /* CRYPTO header length without length field */
@@ -2108,10 +2092,10 @@ static int determine_crypto_len(struct tx_helper *h,
 }
 
 static int determine_stream_len(struct tx_helper *h,
-                                OSSL_QUIC_FRAME_STREAM *shdr,
-                                size_t space_left,
-                                uint64_t *hlen,
-                                uint64_t *len)
+    OSSL_QUIC_FRAME_STREAM *shdr,
+    size_t space_left,
+    uint64_t *hlen,
+    uint64_t *len)
 {
     size_t orig_len;
     size_t base_hdr_len; /* STREAM header length without length field */
@@ -2134,20 +2118,20 @@ static int determine_stream_len(struct tx_helper *h,
 }
 
 static int txp_generate_crypto_frames(OSSL_QUIC_TX_PACKETISER *txp,
-                                      struct txp_pkt *pkt,
-                                      int *have_ack_eliciting)
+    struct txp_pkt *pkt,
+    int *have_ack_eliciting)
 {
     const uint32_t enc_level = pkt->h.enc_level;
     const uint32_t pn_space = ossl_quic_enc_level_to_pn_space(enc_level);
     QUIC_TXPIM_PKT *tpkt = pkt->tpkt;
     struct tx_helper *h = &pkt->h;
     size_t num_stream_iovec;
-    OSSL_QUIC_FRAME_STREAM shdr = {0};
-    OSSL_QUIC_FRAME_CRYPTO chdr = {0};
+    OSSL_QUIC_FRAME_STREAM shdr = { 0 };
+    OSSL_QUIC_FRAME_CRYPTO chdr = { 0 };
     OSSL_QTX_IOVEC iov[2];
     uint64_t hdr_bytes;
     WPACKET *wpkt;
-    QUIC_TXPIM_CHUNK chunk = {0};
+    QUIC_TXPIM_CHUNK chunk = { 0 };
     size_t i, space_left;
 
     for (i = 0;; ++i) {
@@ -2159,20 +2143,20 @@ static int txp_generate_crypto_frames(OSSL_QUIC_TX_PACKETISER *txp,
         /* Do we have any CRYPTO data waiting? */
         num_stream_iovec = OSSL_NELEM(iov);
         if (!ossl_quic_sstream_get_stream_frame(txp->args.crypto[pn_space],
-                                                i, &shdr, iov,
-                                                &num_stream_iovec))
+                i, &shdr, iov,
+                &num_stream_iovec))
             return 1; /* nothing to do */
 
         /* Convert STREAM frame header to CRYPTO frame header */
         chdr.offset = shdr.offset;
-        chdr.len    = shdr.len;
+        chdr.len = shdr.len;
 
         if (chdr.len == 0)
             return 1; /* nothing to do */
 
         /* Find best fit (header length, payload length) combination. */
         if (!determine_crypto_len(h, &chdr, space_left, &hdr_bytes,
-                                  &chdr.len))
+                &chdr.len))
             return 1; /* can't fit anything */
 
         /*
@@ -2212,9 +2196,9 @@ static int txp_generate_crypto_frames(OSSL_QUIC_TX_PACKETISER *txp,
 
         /* Log chunk to TXPIM. */
         chunk.stream_id = UINT64_MAX; /* crypto stream */
-        chunk.start     = chdr.offset;
-        chunk.end       = chdr.offset + chdr.len - 1;
-        chunk.has_fin   = 0; /* Crypto stream never ends */
+        chunk.start = chdr.offset;
+        chunk.end = chdr.offset + chdr.len - 1;
+        chunk.has_fin = 0; /* Crypto stream never ends */
         if (!ossl_quic_txpim_pkt_append_chunk(tpkt, &chunk))
             return 0; /* alloc error */
     }
@@ -2229,20 +2213,20 @@ struct chunk_info {
 };
 
 static int txp_plan_stream_chunk(OSSL_QUIC_TX_PACKETISER *txp,
-                                 struct tx_helper *h,
-                                 QUIC_SSTREAM *sstream,
-                                 QUIC_TXFC *stream_txfc,
-                                 size_t skip,
-                                 struct chunk_info *chunk,
-                                 uint64_t consumed)
+    struct tx_helper *h,
+    QUIC_SSTREAM *sstream,
+    QUIC_TXFC *stream_txfc,
+    size_t skip,
+    struct chunk_info *chunk,
+    uint64_t consumed)
 {
     uint64_t fc_credit, fc_swm, fc_limit;
 
     chunk->num_stream_iovec = OSSL_NELEM(chunk->iov);
     chunk->valid = ossl_quic_sstream_get_stream_frame(sstream, skip,
-                                                      &chunk->shdr,
-                                                      chunk->iov,
-                                                      &chunk->num_stream_iovec);
+        &chunk->shdr,
+        chunk->iov,
+        &chunk->num_stream_iovec);
     if (!chunk->valid)
         return 1;
 
@@ -2253,13 +2237,14 @@ static int txp_plan_stream_chunk(OSSL_QUIC_TX_PACKETISER *txp,
     chunk->orig_len = chunk->shdr.len;
 
     /* Clamp according to connection and stream-level TXFC. */
-    fc_credit   = ossl_quic_txfc_get_credit(stream_txfc, consumed);
-    fc_swm      = ossl_quic_txfc_get_swm(stream_txfc);
-    fc_limit    = fc_swm + fc_credit;
+    fc_credit = ossl_quic_txfc_get_credit(stream_txfc, consumed);
+    fc_swm = ossl_quic_txfc_get_swm(stream_txfc);
+    fc_limit = fc_swm + fc_credit;
 
     if (chunk->shdr.len > 0 && chunk->shdr.offset + chunk->shdr.len > fc_limit) {
         chunk->shdr.len = (fc_limit <= chunk->shdr.offset)
-            ? 0 : fc_limit - chunk->shdr.offset;
+            ? 0
+            : fc_limit - chunk->shdr.offset;
         chunk->shdr.is_fin = 0;
     }
 
@@ -2282,18 +2267,18 @@ static int txp_plan_stream_chunk(OSSL_QUIC_TX_PACKETISER *txp,
  * frame.
  */
 static int txp_generate_stream_frames(OSSL_QUIC_TX_PACKETISER *txp,
-                                      struct txp_pkt *pkt,
-                                      uint64_t id,
-                                      QUIC_SSTREAM *sstream,
-                                      QUIC_TXFC *stream_txfc,
-                                      QUIC_STREAM *next_stream,
-                                      int *have_ack_eliciting,
-                                      int *packet_full,
-                                      uint64_t *new_credit_consumed,
-                                      uint64_t conn_consumed)
+    struct txp_pkt *pkt,
+    uint64_t id,
+    QUIC_SSTREAM *sstream,
+    QUIC_TXFC *stream_txfc,
+    QUIC_STREAM *next_stream,
+    int *have_ack_eliciting,
+    int *packet_full,
+    uint64_t *new_credit_consumed,
+    uint64_t conn_consumed)
 {
     int rc = 0;
-    struct chunk_info chunks[2] = {0};
+    struct chunk_info chunks[2] = { 0 };
     const uint32_t enc_level = pkt->h.enc_level;
     QUIC_TXPIM_PKT *tpkt = pkt->tpkt;
     struct tx_helper *h = &pkt->h;
@@ -2308,8 +2293,8 @@ static int txp_generate_stream_frames(OSSL_QUIC_TX_PACKETISER *txp,
     uint64_t hdr_len_explicit, payload_len_explicit;
     uint64_t fc_swm, fc_new_hwm;
 
-    fc_swm      = ossl_quic_txfc_get_swm(stream_txfc);
-    fc_new_hwm  = fc_swm;
+    fc_swm = ossl_quic_txfc_get_swm(stream_txfc);
+    fc_new_hwm = fc_swm;
 
     /*
      * Load the first two chunks if any offered by the send stream. We retrieve
@@ -2319,7 +2304,7 @@ static int txp_generate_stream_frames(OSSL_QUIC_TX_PACKETISER *txp,
      */
     for (i = 0; i < 2; ++i) {
         if (!txp_plan_stream_chunk(txp, h, sstream, stream_txfc, i, &chunks[i],
-                                   conn_consumed))
+                conn_consumed))
             goto err;
 
         if (i == 0 && !chunks[i].valid) {
@@ -2358,7 +2343,7 @@ static int txp_generate_stream_frames(OSSL_QUIC_TX_PACKETISER *txp,
         if (i > 0)
             /* Load next chunk for lookahead. */
             if (!txp_plan_stream_chunk(txp, h, sstream, stream_txfc, i + 1,
-                                       &chunks[(i + 1) % 2], conn_consumed))
+                    &chunks[(i + 1) % 2], conn_consumed))
                 goto err;
 
         /*
@@ -2368,7 +2353,7 @@ static int txp_generate_stream_frames(OSSL_QUIC_TX_PACKETISER *txp,
         shdr->has_explicit_len = 0;
         hdr_len_implicit = payload_len_implicit = 0;
         if (!determine_stream_len(h, shdr, space_left,
-                                  &hdr_len_implicit, &payload_len_implicit)) {
+                &hdr_len_implicit, &payload_len_implicit)) {
             *packet_full = 1;
             rc = 1;
             goto err; /* can't fit anything */
@@ -2380,7 +2365,7 @@ static int txp_generate_stream_frames(OSSL_QUIC_TX_PACKETISER *txp,
          * for this STREAM frame to fill the packet.
          */
         can_fill_payload = (hdr_len_implicit + payload_len_implicit
-                            >= space_left);
+            >= space_left);
 
         /*
          * Is there is a stream after this one, or another chunk pending
@@ -2391,7 +2376,7 @@ static int txp_generate_stream_frames(OSSL_QUIC_TX_PACKETISER *txp,
 
         /* Choose between explicit or implicit length representations. */
         use_explicit_len = !((can_fill_payload || !could_have_following_chunk)
-                             && !pkt->force_pad);
+            && !pkt->force_pad);
 
         if (use_explicit_len) {
             /*
@@ -2401,7 +2386,7 @@ static int txp_generate_stream_frames(OSSL_QUIC_TX_PACKETISER *txp,
             shdr->has_explicit_len = 1;
             hdr_len_explicit = payload_len_explicit = 0;
             if (!determine_stream_len(h, shdr, space_left,
-                                      &hdr_len_explicit, &payload_len_explicit)) {
+                    &hdr_len_explicit, &payload_len_explicit)) {
                 *packet_full = 1;
                 rc = 1;
                 goto err; /* can't fit anything */
@@ -2427,7 +2412,7 @@ static int txp_generate_stream_frames(OSSL_QUIC_TX_PACKETISER *txp,
 
         /* Truncate IOVs to match our chosen length. */
         ossl_quic_sstream_adjust_iov((size_t)shdr->len, chunks[i % 2].iov,
-                                     chunks[i % 2].num_stream_iovec);
+            chunks[i % 2].num_stream_iovec);
 
         /*
          * Ensure we have enough iovecs allocated (1 for the header, up to 2 for
@@ -2455,7 +2440,7 @@ static int txp_generate_stream_frames(OSSL_QUIC_TX_PACKETISER *txp,
         /* Add payload iovecs to the helper (infallible). */
         for (j = 0; j < chunks[i % 2].num_stream_iovec; ++j)
             tx_helper_append_iovec(h, chunks[i % 2].iov[j].buf,
-                                   chunks[i % 2].iov[j].buf_len);
+                chunks[i % 2].iov[j].buf_len);
 
         *have_ack_eliciting = 1;
         tx_helper_unrestrict(h); /* no longer need PING */
@@ -2467,12 +2452,12 @@ static int txp_generate_stream_frames(OSSL_QUIC_TX_PACKETISER *txp,
             fc_new_hwm = shdr->offset + shdr->len;
 
         /* Log chunk to TXPIM. */
-        chunk.stream_id         = shdr->stream_id;
-        chunk.start             = shdr->offset;
-        chunk.end               = shdr->offset + shdr->len - 1;
-        chunk.has_fin           = shdr->is_fin;
-        chunk.has_stop_sending  = 0;
-        chunk.has_reset_stream  = 0;
+        chunk.stream_id = shdr->stream_id;
+        chunk.start = shdr->offset;
+        chunk.end = shdr->offset + shdr->len - 1;
+        chunk.has_fin = shdr->is_fin;
+        chunk.has_stop_sending = 0;
+        chunk.has_reset_stream = 0;
         if (!ossl_quic_txpim_pkt_append_chunk(tpkt, &chunk))
             goto err; /* alloc error */
 
@@ -2498,9 +2483,9 @@ static void txp_enlink_tmp(QUIC_STREAM **tmp_head, QUIC_STREAM *stream)
 }
 
 static int txp_generate_stream_related(OSSL_QUIC_TX_PACKETISER *txp,
-                                       struct txp_pkt *pkt,
-                                       int *have_ack_eliciting,
-                                       QUIC_STREAM **tmp_head)
+    struct txp_pkt *pkt,
+    int *have_ack_eliciting,
+    QUIC_STREAM **tmp_head)
 {
     QUIC_STREAM_ITER it;
     WPACKET *wpkt;
@@ -2510,16 +2495,16 @@ static int txp_generate_stream_related(OSSL_QUIC_TX_PACKETISER *txp,
     uint64_t conn_consumed = 0;
 
     for (ossl_quic_stream_iter_init(&it, txp->args.qsm, 1);
-         it.stream != NULL;) {
+        it.stream != NULL;) {
 
         stream = it.stream;
         ossl_quic_stream_iter_next(&it);
         snext = it.stream;
 
-        stream->txp_sent_fc                  = 0;
-        stream->txp_sent_stop_sending        = 0;
-        stream->txp_sent_reset_stream        = 0;
-        stream->txp_blocked                  = 0;
+        stream->txp_sent_fc = 0;
+        stream->txp_sent_stop_sending = 0;
+        stream->txp_sent_reset_stream = 0;
+        stream->txp_blocked = 0;
         stream->txp_txfc_new_credit_consumed = 0;
 
         /* Stream Abort Frames (STOP_SENDING, RESET_STREAM) */
@@ -2530,8 +2515,8 @@ static int txp_generate_stream_related(OSSL_QUIC_TX_PACKETISER *txp,
             if (wpkt == NULL)
                 return 0; /* alloc error */
 
-            f.stream_id         = stream->id;
-            f.app_error_code    = stream->stop_sending_aec;
+            f.stream_id = stream->id;
+            f.app_error_code = stream->stop_sending_aec;
             if (!ossl_quic_wire_encode_frame_stop_sending(wpkt, &f)) {
                 tx_helper_rollback(h); /* can't fit */
                 txp_enlink_tmp(tmp_head, stream);
@@ -2556,8 +2541,8 @@ static int txp_generate_stream_related(OSSL_QUIC_TX_PACKETISER *txp,
             if (wpkt == NULL)
                 return 0; /* alloc error */
 
-            f.stream_id         = stream->id;
-            f.app_error_code    = stream->reset_stream_aec;
+            f.stream_id = stream->id;
+            f.app_error_code = stream->reset_stream_aec;
             if (!ossl_quic_stream_send_get_final_size(stream, &f.final_size))
                 return 0; /* should not be possible */
 
@@ -2606,7 +2591,7 @@ static int txp_generate_stream_related(OSSL_QUIC_TX_PACKETISER *txp,
             cwm = ossl_quic_rxfc_get_cwm(&stream->rxfc);
 
             if (!ossl_quic_wire_encode_frame_max_stream_data(wpkt, stream->id,
-                                                             cwm)) {
+                    cwm)) {
                 tx_helper_rollback(h); /* can't fit */
                 txp_enlink_tmp(tmp_head, stream);
                 break;
@@ -2638,13 +2623,13 @@ static int txp_generate_stream_related(OSSL_QUIC_TX_PACKETISER *txp,
                 return 0;
 
             if (!txp_generate_stream_frames(txp, pkt,
-                                            stream->id, stream->sstream,
-                                            &stream->txfc,
-                                            snext,
-                                            have_ack_eliciting,
-                                            &packet_full,
-                                            &stream->txp_txfc_new_credit_consumed,
-                                            conn_consumed)) {
+                    stream->id, stream->sstream,
+                    &stream->txfc,
+                    snext,
+                    have_ack_eliciting,
+                    &packet_full,
+                    &stream->txp_txfc_new_credit_consumed,
+                    conn_consumed)) {
                 /* Fatal error (allocation, etc.) */
                 txp_enlink_tmp(tmp_head, stream);
                 return 0;
@@ -2664,8 +2649,8 @@ static int txp_generate_stream_related(OSSL_QUIC_TX_PACKETISER *txp,
 }
 
 static int txp_generate_for_el(OSSL_QUIC_TX_PACKETISER *txp,
-                               struct txp_pkt *pkt,
-                               int chosen_for_conn_close)
+    struct txp_pkt *pkt,
+    int chosen_for_conn_close)
 {
     int rc = TXP_ERR_SUCCESS;
     const uint32_t enc_level = pkt->h.enc_level;
@@ -2712,7 +2697,7 @@ static int txp_generate_for_el(OSSL_QUIC_TX_PACKETISER *txp,
 
         if (ossl_quic_wire_encode_frame_handshake_done(wpkt)) {
             tpkt->had_handshake_done_frame = 1;
-            have_ack_eliciting             = 1;
+            have_ack_eliciting = 1;
 
             if (!tx_helper_commit(h))
                 goto fatal_err;
@@ -2736,7 +2721,7 @@ static int txp_generate_for_el(OSSL_QUIC_TX_PACKETISER *txp,
 
         if (ossl_quic_wire_encode_frame_max_data(wpkt, cwm)) {
             tpkt->had_max_data_frame = 1;
-            have_ack_eliciting       = 1;
+            have_ack_eliciting = 1;
 
             if (!tx_helper_commit(h))
                 goto fatal_err;
@@ -2760,9 +2745,9 @@ static int txp_generate_for_el(OSSL_QUIC_TX_PACKETISER *txp,
             goto fatal_err;
 
         if (ossl_quic_wire_encode_frame_max_streams(wpkt, /*is_uni=*/0,
-                                                    max_streams)) {
+                max_streams)) {
             tpkt->had_max_streams_bidi_frame = 1;
-            have_ack_eliciting               = 1;
+            have_ack_eliciting = 1;
 
             if (!tx_helper_commit(h))
                 goto fatal_err;
@@ -2786,9 +2771,9 @@ static int txp_generate_for_el(OSSL_QUIC_TX_PACKETISER *txp,
             goto fatal_err;
 
         if (ossl_quic_wire_encode_frame_max_streams(wpkt, /*is_uni=*/1,
-                                                    max_streams)) {
+                max_streams)) {
             tpkt->had_max_streams_uni_frame = 1;
-            have_ack_eliciting              = 1;
+            have_ack_eliciting = 1;
 
             if (!tx_helper_commit(h))
                 goto fatal_err;
@@ -2801,54 +2786,54 @@ static int txp_generate_for_el(OSSL_QUIC_TX_PACKETISER *txp,
 
     /* GCR Frames */
     for (cfq_item = ossl_quic_cfq_get_priority_head(txp->args.cfq, pn_space);
-         cfq_item != NULL;
-         cfq_item = ossl_quic_cfq_item_get_priority_next(cfq_item, pn_space)) {
+        cfq_item != NULL;
+        cfq_item = ossl_quic_cfq_item_get_priority_next(cfq_item, pn_space)) {
         uint64_t frame_type = ossl_quic_cfq_item_get_frame_type(cfq_item);
         const unsigned char *encoded = ossl_quic_cfq_item_get_encoded(cfq_item);
         size_t encoded_len = ossl_quic_cfq_item_get_encoded_len(cfq_item);
 
         switch (frame_type) {
-            case OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID:
-                if (!a.allow_new_conn_id)
-                    continue;
-                break;
-            case OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID:
-                if (!a.allow_retire_conn_id)
-                    continue;
-                break;
-            case OSSL_QUIC_FRAME_TYPE_NEW_TOKEN:
-                if (!a.allow_new_token)
-                    continue;
+        case OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID:
+            if (!a.allow_new_conn_id)
+                continue;
+            break;
+        case OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID:
+            if (!a.allow_retire_conn_id)
+                continue;
+            break;
+        case OSSL_QUIC_FRAME_TYPE_NEW_TOKEN:
+            if (!a.allow_new_token)
+                continue;
 
-                /*
-                 * NEW_TOKEN frames are handled via GCR, but some
-                 * Regenerate-strategy frames should come before them (namely
-                 * ACK, CONNECTION_CLOSE, PATH_CHALLENGE and PATH_RESPONSE). If
-                 * we find a NEW_TOKEN frame, do these now. If there are no
-                 * NEW_TOKEN frames in the GCR queue we will handle these below.
-                 */
-                if (!done_pre_token)
-                    if (txp_generate_pre_token(txp, pkt,
-                                               chosen_for_conn_close,
-                                               &can_be_non_inflight))
-                        done_pre_token = 1;
+            /*
+             * NEW_TOKEN frames are handled via GCR, but some
+             * Regenerate-strategy frames should come before them (namely
+             * ACK, CONNECTION_CLOSE, PATH_CHALLENGE and PATH_RESPONSE). If
+             * we find a NEW_TOKEN frame, do these now. If there are no
+             * NEW_TOKEN frames in the GCR queue we will handle these below.
+             */
+            if (!done_pre_token)
+                if (txp_generate_pre_token(txp, pkt,
+                        chosen_for_conn_close,
+                        &can_be_non_inflight))
+                    done_pre_token = 1;
 
-                break;
-            case OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE:
-                if (!a.allow_path_response)
-                    continue;
+            break;
+        case OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE:
+            if (!a.allow_path_response)
+                continue;
 
-                /*
-                 * RFC 9000 s. 8.2.2: An endpoint MUST expand datagrams that
-                 * contain a PATH_RESPONSE frame to at least the smallest
-                 * allowed maximum datagram size of 1200 bytes.
-                 */
-                pkt->force_pad = 1;
-                break;
-            default:
-                if (!a.allow_cfq_other)
-                    continue;
-                break;
+            /*
+             * RFC 9000 s. 8.2.2: An endpoint MUST expand datagrams that
+             * contain a PATH_RESPONSE frame to at least the smallest
+             * allowed maximum datagram size of 1200 bytes.
+             */
+            pkt->force_pad = 1;
+            break;
+        default:
+            if (!a.allow_cfq_other)
+                continue;
+            break;
         }
 
         /*
@@ -2875,8 +2860,8 @@ static int txp_generate_for_el(OSSL_QUIC_TX_PACKETISER *txp,
      */
     if (!done_pre_token)
         if (txp_generate_pre_token(txp, pkt,
-                                   chosen_for_conn_close,
-                                   &can_be_non_inflight))
+                chosen_for_conn_close,
+                &can_be_non_inflight))
             done_pre_token = 1;
 
     /* CRYPTO Frames */
@@ -2887,8 +2872,8 @@ static int txp_generate_for_el(OSSL_QUIC_TX_PACKETISER *txp,
     /* Stream-specific frames */
     if (a.allow_stream_rel && txp->handshake_complete)
         if (!txp_generate_stream_related(txp, pkt,
-                                         &have_ack_eliciting,
-                                         &pkt->stream_head))
+                &have_ack_eliciting,
+                &pkt->stream_head))
             goto fatal_err;
 
     /* PING */
@@ -2923,16 +2908,16 @@ static int txp_generate_for_el(OSSL_QUIC_TX_PACKETISER *txp,
         can_be_non_inflight = 0;
 
     /* ACKM Data */
-    tpkt->ackm_pkt.num_bytes        = h->bytes_appended + pkt->geom.pkt_overhead;
-    tpkt->ackm_pkt.pkt_num          = txp->next_pn[pn_space];
+    tpkt->ackm_pkt.num_bytes = h->bytes_appended + pkt->geom.pkt_overhead;
+    tpkt->ackm_pkt.pkt_num = txp->next_pn[pn_space];
     /* largest_acked is set in txp_generate_pre_token */
-    tpkt->ackm_pkt.pkt_space        = pn_space;
-    tpkt->ackm_pkt.is_inflight      = !can_be_non_inflight;
+    tpkt->ackm_pkt.pkt_space = pn_space;
+    tpkt->ackm_pkt.is_inflight = !can_be_non_inflight;
     tpkt->ackm_pkt.is_ack_eliciting = have_ack_eliciting;
-    tpkt->ackm_pkt.is_pto_probe     = 0;
-    tpkt->ackm_pkt.is_mtu_probe     = 0;
-    tpkt->ackm_pkt.time             = txp->args.now(txp->args.now_arg);
-    tpkt->pkt_type                  = pkt->phdr.type;
+    tpkt->ackm_pkt.is_pto_probe = 0;
+    tpkt->ackm_pkt.is_mtu_probe = 0;
+    tpkt->ackm_pkt.time = txp->args.now(txp->args.now_arg);
+    tpkt->pkt_type = pkt->phdr.type;
 
     /* Done. */
     return rc;
@@ -2982,9 +2967,9 @@ fatal_err:
  *
  */
 static int txp_pkt_commit(OSSL_QUIC_TX_PACKETISER *txp,
-                          struct txp_pkt *pkt,
-                          uint32_t archetype,
-                          int *txpim_pkt_reffed)
+    struct txp_pkt *pkt,
+    uint32_t archetype,
+    int *txpim_pkt_reffed)
 {
     int rc = 1;
     uint32_t enc_level = pkt->h.enc_level;
@@ -3004,14 +2989,15 @@ static int txp_pkt_commit(OSSL_QUIC_TX_PACKETISER *txp,
         return 0;
 
     /* Packet Information for QTX */
-    txpkt.hdr       = &pkt->phdr;
-    txpkt.iovec     = txp->el[enc_level].iovec;
+    txpkt.hdr = &pkt->phdr;
+    txpkt.iovec = txp->el[enc_level].iovec;
     txpkt.num_iovec = pkt->h.num_iovec;
-    txpkt.local     = NULL;
-    txpkt.peer      = BIO_ADDR_family(&txp->args.peer) == AF_UNSPEC
-        ? NULL : &txp->args.peer;
-    txpkt.pn        = txp->next_pn[pn_space];
-    txpkt.flags     = OSSL_QTX_PKT_FLAG_COALESCE; /* always try to coalesce */
+    txpkt.local = NULL;
+    txpkt.peer = BIO_ADDR_family(&txp->args.peer) == AF_UNSPEC
+        ? NULL
+        : &txp->args.peer;
+    txpkt.pn = txp->next_pn[pn_space];
+    txpkt.flags = OSSL_QTX_PKT_FLAG_COALESCE; /* always try to coalesce */
 
     /* Generate TXPIM chunks representing STOP_SENDING and RESET_STREAM frames. */
     for (stream = pkt->stream_head; stream != NULL; stream = stream->txp_next)
@@ -3019,12 +3005,12 @@ static int txp_pkt_commit(OSSL_QUIC_TX_PACKETISER *txp,
             /* Log STOP_SENDING/RESET_STREAM chunk to TXPIM. */
             QUIC_TXPIM_CHUNK chunk;
 
-            chunk.stream_id         = stream->id;
-            chunk.start             = UINT64_MAX;
-            chunk.end               = 0;
-            chunk.has_fin           = 0;
-            chunk.has_stop_sending  = stream->txp_sent_stop_sending;
-            chunk.has_reset_stream  = stream->txp_sent_reset_stream;
+            chunk.stream_id = stream->id;
+            chunk.start = UINT64_MAX;
+            chunk.end = 0;
+            chunk.has_fin = 0;
+            chunk.has_stop_sending = stream->txp_sent_stop_sending;
+            chunk.has_reset_stream = stream->txp_sent_reset_stream;
             if (!ossl_quic_txpim_pkt_append_chunk(tpkt, &chunk))
                 return 0; /* alloc error */
         }
@@ -3069,7 +3055,7 @@ static int txp_pkt_commit(OSSL_QUIC_TX_PACKETISER *txp,
 
         if (stream->txp_txfc_new_credit_consumed > 0) {
             if (!ossl_assert(ossl_quic_txfc_consume_credit(&stream->txfc,
-                                                           stream->txp_txfc_new_credit_consumed)))
+                    stream->txp_txfc_new_credit_consumed)))
                 /*
                  * Should not be possible, but we should continue with our
                  * bookkeeping as we have already committed the packet to the
@@ -3164,13 +3150,13 @@ static int txp_el_ensure_iovec(struct txp_el *el, size_t num)
     if (iovec == NULL)
         return 0;
 
-    el->iovec          = iovec;
-    el->alloc_iovec    = num;
+    el->iovec = iovec;
+    el->alloc_iovec = num;
     return 1;
 }
 
 int ossl_quic_tx_packetiser_schedule_conn_close(OSSL_QUIC_TX_PACKETISER *txp,
-                                                const OSSL_QUIC_FRAME_CONN_CLOSE *f)
+    const OSSL_QUIC_FRAME_CONN_CLOSE *f)
 {
     char *reason = NULL;
     size_t reason_len = f->reason_len;
@@ -3192,29 +3178,29 @@ int ossl_quic_tx_packetiser_schedule_conn_close(OSSL_QUIC_TX_PACKETISER *txp,
             return 0;
     }
 
-    txp->conn_close_frame               = *f;
-    txp->conn_close_frame.reason        = reason;
-    txp->conn_close_frame.reason_len    = reason_len;
-    txp->want_conn_close                = 1;
+    txp->conn_close_frame = *f;
+    txp->conn_close_frame.reason = reason;
+    txp->conn_close_frame.reason_len = reason_len;
+    txp->want_conn_close = 1;
     return 1;
 }
 
 void ossl_quic_tx_packetiser_set_msg_callback(OSSL_QUIC_TX_PACKETISER *txp,
-                                              ossl_msg_cb msg_callback,
-                                              SSL *msg_callback_ssl)
+    ossl_msg_cb msg_callback,
+    SSL *msg_callback_ssl)
 {
     txp->msg_callback = msg_callback;
     txp->msg_callback_ssl = msg_callback_ssl;
 }
 
 void ossl_quic_tx_packetiser_set_msg_callback_arg(OSSL_QUIC_TX_PACKETISER *txp,
-                                                  void *msg_callback_arg)
+    void *msg_callback_arg)
 {
     txp->msg_callback_arg = msg_callback_arg;
 }
 
 QUIC_PN ossl_quic_tx_packetiser_get_next_pn(OSSL_QUIC_TX_PACKETISER *txp,
-                                            uint32_t pn_space)
+    uint32_t pn_space)
 {
     if (pn_space >= QUIC_PN_SPACE_NUM)
         return UINT64_MAX;
@@ -3239,18 +3225,18 @@ OSSL_TIME ossl_quic_tx_packetiser_get_deadline(OSSL_QUIC_TX_PACKETISER *txp)
      * call will take care of selecting the correct packet archetype.
      */
     for (enc_level = QUIC_ENC_LEVEL_INITIAL;
-         enc_level < QUIC_ENC_LEVEL_NUM;
-         ++enc_level)
+        enc_level < QUIC_ENC_LEVEL_NUM;
+        ++enc_level)
         if (ossl_qtx_is_enc_level_provisioned(txp->args.qtx, enc_level)) {
             pn_space = ossl_quic_enc_level_to_pn_space(enc_level);
             deadline = ossl_time_min(deadline,
-                                     ossl_ackm_get_ack_deadline(txp->args.ackm, pn_space));
+                ossl_ackm_get_ack_deadline(txp->args.ackm, pn_space));
         }
 
     /* When will CC let us send more? */
     if (txp->args.cc_method->get_tx_allowance(txp->args.cc_data) == 0)
         deadline = ossl_time_min(deadline,
-                                 txp->args.cc_method->get_wakeup_deadline(txp->args.cc_data));
+            txp->args.cc_method->get_wakeup_deadline(txp->args.cc_data));
 
     return deadline;
 }
diff --git a/crypto/openssl/ssl/quic/quic_txpim.c b/crypto/openssl/ssl/quic/quic_txpim.c
index 04b25ee47a04..b1f47099e5c8 100644
--- a/crypto/openssl/ssl/quic/quic_txpim.c
+++ b/crypto/openssl/ssl/quic/quic_txpim.c
@@ -13,20 +13,20 @@
 typedef struct quic_txpim_pkt_ex_st QUIC_TXPIM_PKT_EX;
 
 struct quic_txpim_pkt_ex_st {
-    QUIC_TXPIM_PKT              public;
-    QUIC_TXPIM_PKT_EX          *prev, *next;
-    QUIC_TXPIM_CHUNK           *chunks;
-    size_t                      num_chunks, alloc_chunks;
-    unsigned int                chunks_need_sort : 1;
+    QUIC_TXPIM_PKT public;
+    QUIC_TXPIM_PKT_EX *prev, *next;
+    QUIC_TXPIM_CHUNK *chunks;
+    size_t num_chunks, alloc_chunks;
+    unsigned int chunks_need_sort : 1;
 };
 
 typedef struct quic_txpim_pkt_ex_list {
-    QUIC_TXPIM_PKT_EX          *head, *tail;
+    QUIC_TXPIM_PKT_EX *head, *tail;
 } QUIC_TXPIM_PKT_EX_LIST;
 
 struct quic_txpim_st {
-    QUIC_TXPIM_PKT_EX_LIST  free_list;
-    size_t                  in_use;
+    QUIC_TXPIM_PKT_EX_LIST free_list;
+    size_t in_use;
 };
 
 #define MAX_ALLOC_CHUNKS 512
@@ -108,14 +108,14 @@ static void txpim_clear(QUIC_TXPIM_PKT_EX *ex)
 {
     memset(&ex->public.ackm_pkt, 0, sizeof(ex->public.ackm_pkt));
     ossl_quic_txpim_pkt_clear_chunks(&ex->public);
-    ex->public.retx_head                   = NULL;
-    ex->public.fifd                        = NULL;
-    ex->public.had_handshake_done_frame    = 0;
-    ex->public.had_max_data_frame          = 0;
-    ex->public.had_max_streams_bidi_frame  = 0;
-    ex->public.had_max_streams_uni_frame   = 0;
-    ex->public.had_ack_frame               = 0;
-    ex->public.had_conn_close              = 0;
+    ex->public.retx_head = NULL;
+    ex->public.fifd = NULL;
+    ex->public.had_handshake_done_frame = 0;
+    ex->public.had_max_data_frame = 0;
+    ex->public.had_max_streams_bidi_frame = 0;
+    ex->public.had_max_streams_uni_frame = 0;
+    ex->public.had_ack_frame = 0;
+    ex->public.had_conn_close = 0;
 }
 
 QUIC_TXPIM_PKT *ossl_quic_txpim_pkt_alloc(QUIC_TXPIM *txpim)
@@ -141,7 +141,7 @@ void ossl_quic_txpim_pkt_release(QUIC_TXPIM *txpim, QUIC_TXPIM_PKT *fpkt)
 }
 
 void ossl_quic_txpim_pkt_add_cfq_item(QUIC_TXPIM_PKT *fpkt,
-                                      QUIC_CFQ_ITEM *item)
+    QUIC_CFQ_ITEM *item)
 {
     item->pkt_next = fpkt->retx_head;
     item->pkt_prev = NULL;
@@ -156,7 +156,7 @@ void ossl_quic_txpim_pkt_clear_chunks(QUIC_TXPIM_PKT *fpkt)
 }
 
 int ossl_quic_txpim_pkt_append_chunk(QUIC_TXPIM_PKT *fpkt,
-                                     const QUIC_TXPIM_CHUNK *chunk)
+    const QUIC_TXPIM_CHUNK *chunk)
 {
     QUIC_TXPIM_PKT_EX *ex = (QUIC_TXPIM_PKT_EX *)fpkt;
     QUIC_TXPIM_CHUNK *new_chunk;
@@ -170,16 +170,16 @@ int ossl_quic_txpim_pkt_append_chunk(QUIC_TXPIM_PKT *fpkt,
             return 0;
 
         new_chunk = OPENSSL_realloc(ex->chunks,
-                                    new_alloc_chunks * sizeof(QUIC_TXPIM_CHUNK));
+            new_alloc_chunks * sizeof(QUIC_TXPIM_CHUNK));
         if (new_chunk == NULL)
             return 0;
 
-        ex->chunks          = new_chunk;
-        ex->alloc_chunks    = new_alloc_chunks;
+        ex->chunks = new_chunk;
+        ex->alloc_chunks = new_alloc_chunks;
     }
 
-    ex->chunks[ex->num_chunks++]    = *chunk;
-    ex->chunks_need_sort            = 1;
+    ex->chunks[ex->num_chunks++] = *chunk;
+    ex->chunks_need_sort = 1;
     return 1;
 }
 
diff --git a/crypto/openssl/ssl/quic/quic_types.c b/crypto/openssl/ssl/quic/quic_types.c
index 4ff3ae6580b5..2c06e191e922 100644
--- a/crypto/openssl/ssl/quic/quic_types.c
+++ b/crypto/openssl/ssl/quic/quic_types.c
@@ -12,7 +12,7 @@
 #include <openssl/err.h>
 
 int ossl_quic_gen_rand_conn_id(OSSL_LIB_CTX *libctx, size_t len,
-                               QUIC_CONN_ID *cid)
+    QUIC_CONN_ID *cid)
 {
     if (len > QUIC_MAX_CONN_ID_LEN)
         return 0;
diff --git a/crypto/openssl/ssl/quic/quic_wire.c b/crypto/openssl/ssl/quic/quic_wire.c
index a7c7667797d9..66be80e78127 100644
--- a/crypto/openssl/ssl/quic/quic_wire.c
+++ b/crypto/openssl/ssl/quic/quic_wire.c
@@ -53,8 +53,8 @@ int ossl_quic_wire_encode_frame_ping(WPACKET *pkt)
 }
 
 int ossl_quic_wire_encode_frame_ack(WPACKET *pkt,
-                                    uint32_t ack_delay_exponent,
-                                    const OSSL_QUIC_FRAME_ACK *ack)
+    uint32_t ack_delay_exponent,
+    const OSSL_QUIC_FRAME_ACK *ack)
 {
     uint64_t frame_type = ack->ecn_present ? OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN
                                            : OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN;
@@ -67,68 +67,68 @@ int ossl_quic_wire_encode_frame_ack(WPACKET *pkt,
         return 0;
 
     delay = ossl_time_divide(ossl_time_divide(ack->delay_time, OSSL_TIME_US),
-                             (uint64_t)1 << ack_delay_exponent);
-    ack_delay_enc   = ossl_time2ticks(delay);
+        (uint64_t)1 << ack_delay_exponent);
+    ack_delay_enc = ossl_time2ticks(delay);
 
-    largest_ackd    = ack->ack_ranges[0].end;
+    largest_ackd = ack->ack_ranges[0].end;
     first_ack_range = ack->ack_ranges[0].end - ack->ack_ranges[0].start;
 
     if (!encode_frame_hdr(pkt, frame_type)
-            || !WPACKET_quic_write_vlint(pkt, largest_ackd)
-            || !WPACKET_quic_write_vlint(pkt, ack_delay_enc)
-            || !WPACKET_quic_write_vlint(pkt, num_ack_ranges - 1)
-            || !WPACKET_quic_write_vlint(pkt, first_ack_range))
+        || !WPACKET_quic_write_vlint(pkt, largest_ackd)
+        || !WPACKET_quic_write_vlint(pkt, ack_delay_enc)
+        || !WPACKET_quic_write_vlint(pkt, num_ack_ranges - 1)
+        || !WPACKET_quic_write_vlint(pkt, first_ack_range))
         return 0;
 
     for (i = 1; i < num_ack_ranges; ++i) {
         uint64_t gap, range_len;
 
-        gap         = ack->ack_ranges[i - 1].start - ack->ack_ranges[i].end - 2;
-        range_len   = ack->ack_ranges[i].end - ack->ack_ranges[i].start;
+        gap = ack->ack_ranges[i - 1].start - ack->ack_ranges[i].end - 2;
+        range_len = ack->ack_ranges[i].end - ack->ack_ranges[i].start;
 
         if (!WPACKET_quic_write_vlint(pkt, gap)
-                || !WPACKET_quic_write_vlint(pkt, range_len))
+            || !WPACKET_quic_write_vlint(pkt, range_len))
             return 0;
     }
 
     if (ack->ecn_present)
         if (!WPACKET_quic_write_vlint(pkt, ack->ect0)
-                || !WPACKET_quic_write_vlint(pkt, ack->ect1)
-                || !WPACKET_quic_write_vlint(pkt, ack->ecnce))
+            || !WPACKET_quic_write_vlint(pkt, ack->ect1)
+            || !WPACKET_quic_write_vlint(pkt, ack->ecnce))
             return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_encode_frame_reset_stream(WPACKET *pkt,
-                                             const OSSL_QUIC_FRAME_RESET_STREAM *f)
+    const OSSL_QUIC_FRAME_RESET_STREAM *f)
 {
     if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_RESET_STREAM)
-            || !WPACKET_quic_write_vlint(pkt, f->stream_id)
-            || !WPACKET_quic_write_vlint(pkt, f->app_error_code)
-            || !WPACKET_quic_write_vlint(pkt, f->final_size))
+        || !WPACKET_quic_write_vlint(pkt, f->stream_id)
+        || !WPACKET_quic_write_vlint(pkt, f->app_error_code)
+        || !WPACKET_quic_write_vlint(pkt, f->final_size))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_encode_frame_stop_sending(WPACKET *pkt,
-                                             const OSSL_QUIC_FRAME_STOP_SENDING *f)
+    const OSSL_QUIC_FRAME_STOP_SENDING *f)
 {
     if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_STOP_SENDING)
-            || !WPACKET_quic_write_vlint(pkt, f->stream_id)
-            || !WPACKET_quic_write_vlint(pkt, f->app_error_code))
+        || !WPACKET_quic_write_vlint(pkt, f->stream_id)
+        || !WPACKET_quic_write_vlint(pkt, f->app_error_code))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_encode_frame_crypto_hdr(WPACKET *pkt,
-                                           const OSSL_QUIC_FRAME_CRYPTO *f)
+    const OSSL_QUIC_FRAME_CRYPTO *f)
 {
     if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_CRYPTO)
-            || !WPACKET_quic_write_vlint(pkt, f->offset)
-            || !WPACKET_quic_write_vlint(pkt, f->len))
+        || !WPACKET_quic_write_vlint(pkt, f->offset)
+        || !WPACKET_quic_write_vlint(pkt, f->len))
         return 0;
 
     return 1;
@@ -148,13 +148,13 @@ size_t ossl_quic_wire_get_encoded_frame_len_crypto_hdr(const OSSL_QUIC_FRAME_CRY
 }
 
 void *ossl_quic_wire_encode_frame_crypto(WPACKET *pkt,
-                                         const OSSL_QUIC_FRAME_CRYPTO *f)
+    const OSSL_QUIC_FRAME_CRYPTO *f)
 {
     unsigned char *p = NULL;
 
     if (!ossl_quic_wire_encode_frame_crypto_hdr(pkt, f)
-            || f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? */
-            || !WPACKET_allocate_bytes(pkt, (size_t)f->len, &p))
+        || f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? */
+        || !WPACKET_allocate_bytes(pkt, (size_t)f->len, &p))
         return NULL;
 
     if (f->data != NULL)
@@ -164,19 +164,19 @@ void *ossl_quic_wire_encode_frame_crypto(WPACKET *pkt,
 }
 
 int ossl_quic_wire_encode_frame_new_token(WPACKET *pkt,
-                                          const unsigned char *token,
-                                          size_t token_len)
+    const unsigned char *token,
+    size_t token_len)
 {
     if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_NEW_TOKEN)
-            || !WPACKET_quic_write_vlint(pkt, token_len)
-            || !WPACKET_memcpy(pkt, token, token_len))
+        || !WPACKET_quic_write_vlint(pkt, token_len)
+        || !WPACKET_memcpy(pkt, token, token_len))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_encode_frame_stream_hdr(WPACKET *pkt,
-                                           const OSSL_QUIC_FRAME_STREAM *f)
+    const OSSL_QUIC_FRAME_STREAM *f)
 {
     uint64_t frame_type = OSSL_QUIC_FRAME_TYPE_STREAM;
 
@@ -188,7 +188,7 @@ int ossl_quic_wire_encode_frame_stream_hdr(WPACKET *pkt,
         frame_type |= OSSL_QUIC_FRAME_FLAG_STREAM_FIN;
 
     if (!encode_frame_hdr(pkt, frame_type)
-            || !WPACKET_quic_write_vlint(pkt, f->stream_id))
+        || !WPACKET_quic_write_vlint(pkt, f->stream_id))
         return 0;
 
     if (f->offset != 0 && !WPACKET_quic_write_vlint(pkt, f->offset))
@@ -229,13 +229,13 @@ size_t ossl_quic_wire_get_encoded_frame_len_stream_hdr(const OSSL_QUIC_FRAME_STR
 }
 
 void *ossl_quic_wire_encode_frame_stream(WPACKET *pkt,
-                                         const OSSL_QUIC_FRAME_STREAM *f)
+    const OSSL_QUIC_FRAME_STREAM *f)
 {
 
     unsigned char *p = NULL;
 
     if (!ossl_quic_wire_encode_frame_stream_hdr(pkt, f)
-            || f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? */)
+        || f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? */)
         return NULL;
 
     if (!WPACKET_allocate_bytes(pkt, (size_t)f->len, &p))
@@ -248,129 +248,125 @@ void *ossl_quic_wire_encode_frame_stream(WPACKET *pkt,
 }
 
 int ossl_quic_wire_encode_frame_max_data(WPACKET *pkt,
-                                         uint64_t max_data)
+    uint64_t max_data)
 {
     if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_MAX_DATA)
-            || !WPACKET_quic_write_vlint(pkt, max_data))
+        || !WPACKET_quic_write_vlint(pkt, max_data))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_encode_frame_max_stream_data(WPACKET *pkt,
-                                                uint64_t stream_id,
-                                                uint64_t max_data)
+    uint64_t stream_id,
+    uint64_t max_data)
 {
     if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA)
-            || !WPACKET_quic_write_vlint(pkt, stream_id)
-            || !WPACKET_quic_write_vlint(pkt, max_data))
+        || !WPACKET_quic_write_vlint(pkt, stream_id)
+        || !WPACKET_quic_write_vlint(pkt, max_data))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_encode_frame_max_streams(WPACKET *pkt,
-                                            char     is_uni,
-                                            uint64_t max_streams)
+    char is_uni,
+    uint64_t max_streams)
 {
-    if (!encode_frame_hdr(pkt, is_uni ? OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI
-                                      : OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI)
-            || !WPACKET_quic_write_vlint(pkt, max_streams))
+    if (!encode_frame_hdr(pkt, is_uni ? OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI : OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI)
+        || !WPACKET_quic_write_vlint(pkt, max_streams))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_encode_frame_data_blocked(WPACKET *pkt,
-                                             uint64_t max_data)
+    uint64_t max_data)
 {
     if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED)
-            || !WPACKET_quic_write_vlint(pkt, max_data))
+        || !WPACKET_quic_write_vlint(pkt, max_data))
         return 0;
 
     return 1;
 }
 
-
 int ossl_quic_wire_encode_frame_stream_data_blocked(WPACKET *pkt,
-                                                    uint64_t stream_id,
-                                                    uint64_t max_stream_data)
+    uint64_t stream_id,
+    uint64_t max_stream_data)
 {
     if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED)
-            || !WPACKET_quic_write_vlint(pkt, stream_id)
-            || !WPACKET_quic_write_vlint(pkt, max_stream_data))
+        || !WPACKET_quic_write_vlint(pkt, stream_id)
+        || !WPACKET_quic_write_vlint(pkt, max_stream_data))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_encode_frame_streams_blocked(WPACKET *pkt,
-                                                char is_uni,
-                                                uint64_t max_streams)
+    char is_uni,
+    uint64_t max_streams)
 {
-    if (!encode_frame_hdr(pkt, is_uni ? OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI
-                                      : OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI)
-            || !WPACKET_quic_write_vlint(pkt, max_streams))
+    if (!encode_frame_hdr(pkt, is_uni ? OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI : OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI)
+        || !WPACKET_quic_write_vlint(pkt, max_streams))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_encode_frame_new_conn_id(WPACKET *pkt,
-                                            const OSSL_QUIC_FRAME_NEW_CONN_ID *f)
+    const OSSL_QUIC_FRAME_NEW_CONN_ID *f)
 {
     if (f->conn_id.id_len < 1
         || f->conn_id.id_len > QUIC_MAX_CONN_ID_LEN)
         return 0;
 
     if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID)
-            || !WPACKET_quic_write_vlint(pkt, f->seq_num)
-            || !WPACKET_quic_write_vlint(pkt, f->retire_prior_to)
-            || !WPACKET_put_bytes_u8(pkt, f->conn_id.id_len)
-            || !WPACKET_memcpy(pkt, f->conn_id.id, f->conn_id.id_len)
-            || !WPACKET_memcpy(pkt, f->stateless_reset.token,
-                               sizeof(f->stateless_reset.token)))
+        || !WPACKET_quic_write_vlint(pkt, f->seq_num)
+        || !WPACKET_quic_write_vlint(pkt, f->retire_prior_to)
+        || !WPACKET_put_bytes_u8(pkt, f->conn_id.id_len)
+        || !WPACKET_memcpy(pkt, f->conn_id.id, f->conn_id.id_len)
+        || !WPACKET_memcpy(pkt, f->stateless_reset.token,
+            sizeof(f->stateless_reset.token)))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_encode_frame_retire_conn_id(WPACKET *pkt,
-                                               uint64_t seq_num)
+    uint64_t seq_num)
 {
     if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID)
-            || !WPACKET_quic_write_vlint(pkt, seq_num))
+        || !WPACKET_quic_write_vlint(pkt, seq_num))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_encode_frame_path_challenge(WPACKET *pkt,
-                                               uint64_t data)
+    uint64_t data)
 {
     if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE)
-            || !WPACKET_put_bytes_u64(pkt, data))
+        || !WPACKET_put_bytes_u64(pkt, data))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_encode_frame_path_response(WPACKET *pkt,
-                                              uint64_t data)
+    uint64_t data)
 {
     if (!encode_frame_hdr(pkt, OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE)
-            || !WPACKET_put_bytes_u64(pkt, data))
+        || !WPACKET_put_bytes_u64(pkt, data))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_encode_frame_conn_close(WPACKET *pkt,
-                                           const OSSL_QUIC_FRAME_CONN_CLOSE *f)
+    const OSSL_QUIC_FRAME_CONN_CLOSE *f)
 {
-    if (!encode_frame_hdr(pkt, f->is_app ? OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP
-                                         : OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT)
-            || !WPACKET_quic_write_vlint(pkt, f->error_code))
+    if (!encode_frame_hdr(pkt, f->is_app ? OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP : OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT)
+        || !WPACKET_quic_write_vlint(pkt, f->error_code))
         return 0;
 
     /*
@@ -381,7 +377,7 @@ int ossl_quic_wire_encode_frame_conn_close(WPACKET *pkt,
         return 0;
 
     if (!WPACKET_quic_write_vlint(pkt, f->reason_len)
-            || !WPACKET_memcpy(pkt, f->reason, f->reason_len))
+        || !WPACKET_memcpy(pkt, f->reason, f->reason_len))
         return 0;
 
     return 1;
@@ -393,9 +389,9 @@ int ossl_quic_wire_encode_frame_handshake_done(WPACKET *pkt)
 }
 
 unsigned char *ossl_quic_wire_encode_transport_param_bytes(WPACKET *pkt,
-                                                           uint64_t id,
-                                                           const unsigned char *value,
-                                                           size_t value_len)
+    uint64_t id,
+    const unsigned char *value,
+    size_t value_len)
 {
     unsigned char *b = NULL;
 
@@ -415,27 +411,28 @@ unsigned char *ossl_quic_wire_encode_transport_param_bytes(WPACKET *pkt,
 }
 
 int ossl_quic_wire_encode_transport_param_int(WPACKET *pkt,
-                                              uint64_t id,
-                                              uint64_t value)
+    uint64_t id,
+    uint64_t value)
 {
     if (!WPACKET_quic_write_vlint(pkt, id)
-            || !WPACKET_quic_write_vlint(pkt, ossl_quic_vlint_encode_len(value))
-            || !WPACKET_quic_write_vlint(pkt, value))
+        || !WPACKET_quic_write_vlint(pkt, ossl_quic_vlint_encode_len(value))
+        || !WPACKET_quic_write_vlint(pkt, value))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_encode_transport_param_cid(WPACKET *wpkt,
-                                              uint64_t id,
-                                              const QUIC_CONN_ID *cid)
+    uint64_t id,
+    const QUIC_CONN_ID *cid)
 {
     if (cid->id_len > QUIC_MAX_CONN_ID_LEN)
         return 0;
 
     if (ossl_quic_wire_encode_transport_param_bytes(wpkt, id,
-                                                    cid->id,
-                                                    cid->id_len) == NULL)
+            cid->id,
+            cid->id_len)
+        == NULL)
         return 0;
 
     return 1;
@@ -446,7 +443,7 @@ int ossl_quic_wire_encode_transport_param_cid(WPACKET *wpkt,
  * =========================
  */
 int ossl_quic_wire_peek_frame_header(PACKET *pkt, uint64_t *type,
-                                     int *was_minimal)
+    int *was_minimal)
 {
     return PACKET_peek_quic_vlint_ex(pkt, type, was_minimal);
 }
@@ -457,14 +454,14 @@ int ossl_quic_wire_skip_frame_header(PACKET *pkt, uint64_t *type)
 }
 
 static int expect_frame_header_mask(PACKET *pkt,
-                                    uint64_t expected_frame_type,
-                                    uint64_t mask_bits,
-                                    uint64_t *actual_frame_type)
+    uint64_t expected_frame_type,
+    uint64_t mask_bits,
+    uint64_t *actual_frame_type)
 {
     uint64_t actual_frame_type_;
 
     if (!ossl_quic_wire_skip_frame_header(pkt, &actual_frame_type_)
-            || (actual_frame_type_ & ~mask_bits) != expected_frame_type)
+        || (actual_frame_type_ & ~mask_bits) != expected_frame_type)
         return 0;
 
     if (actual_frame_type != NULL)
@@ -478,23 +475,23 @@ static int expect_frame_header(PACKET *pkt, uint64_t expected_frame_type)
     uint64_t actual_frame_type;
 
     if (!ossl_quic_wire_skip_frame_header(pkt, &actual_frame_type)
-            || actual_frame_type != expected_frame_type)
+        || actual_frame_type != expected_frame_type)
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_peek_frame_ack_num_ranges(const PACKET *orig_pkt,
-                                             uint64_t *total_ranges)
+    uint64_t *total_ranges)
 {
     PACKET pkt = *orig_pkt;
     uint64_t ack_range_count, i;
 
     if (!expect_frame_header_mask(&pkt, OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN,
-                                  1, NULL)
-            || !PACKET_skip_quic_vlint(&pkt)
-            || !PACKET_skip_quic_vlint(&pkt)
-            || !PACKET_get_quic_vlint(&pkt, &ack_range_count))
+            1, NULL)
+        || !PACKET_skip_quic_vlint(&pkt)
+        || !PACKET_skip_quic_vlint(&pkt)
+        || !PACKET_get_quic_vlint(&pkt, &ack_range_count))
         return 0;
 
     /*
@@ -515,19 +512,20 @@ int ossl_quic_wire_peek_frame_ack_num_ranges(const PACKET *orig_pkt,
 }
 
 int ossl_quic_wire_decode_frame_ack(PACKET *pkt,
-                                    uint32_t ack_delay_exponent,
-                                    OSSL_QUIC_FRAME_ACK *ack,
-                                    uint64_t *total_ranges) {
+    uint32_t ack_delay_exponent,
+    OSSL_QUIC_FRAME_ACK *ack,
+    uint64_t *total_ranges)
+{
     uint64_t frame_type, largest_ackd, ack_delay_raw;
     uint64_t ack_range_count, first_ack_range, start, end, i;
 
     /* This call matches both ACK_WITHOUT_ECN and ACK_WITH_ECN. */
     if (!expect_frame_header_mask(pkt, OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN,
-                                  1, &frame_type)
-            || !PACKET_get_quic_vlint(pkt, &largest_ackd)
-            || !PACKET_get_quic_vlint(pkt, &ack_delay_raw)
-            || !PACKET_get_quic_vlint(pkt, &ack_range_count)
-            || !PACKET_get_quic_vlint(pkt, &first_ack_range))
+            1, &frame_type)
+        || !PACKET_get_quic_vlint(pkt, &largest_ackd)
+        || !PACKET_get_quic_vlint(pkt, &ack_delay_raw)
+        || !PACKET_get_quic_vlint(pkt, &ack_range_count)
+        || !PACKET_get_quic_vlint(pkt, &first_ack_range))
         return 0;
 
     if (first_ack_range > largest_ackd)
@@ -542,14 +540,14 @@ int ossl_quic_wire_decode_frame_ack(PACKET *pkt,
         int err = 0;
         ack->delay_time
             = ossl_time_multiply(ossl_ticks2time(OSSL_TIME_US),
-                                 safe_mul_uint64_t(ack_delay_raw,
-                                                   (uint64_t)1 << ack_delay_exponent,
-                                                   &err));
+                safe_mul_uint64_t(ack_delay_raw,
+                    (uint64_t)1 << ack_delay_exponent,
+                    &err));
         if (err)
             ack->delay_time = ossl_time_infinite();
 
         if (ack->num_ack_ranges > 0) {
-            ack->ack_ranges[0].end   = largest_ackd;
+            ack->ack_ranges[0].end = largest_ackd;
             ack->ack_ranges[0].start = start;
         }
     }
@@ -558,7 +556,7 @@ int ossl_quic_wire_decode_frame_ack(PACKET *pkt,
         uint64_t gap, len;
 
         if (!PACKET_get_quic_vlint(pkt, &gap)
-                || !PACKET_get_quic_vlint(pkt, &len))
+            || !PACKET_get_quic_vlint(pkt, &len))
             return 0;
 
         end = start - gap - 2;
@@ -567,7 +565,7 @@ int ossl_quic_wire_decode_frame_ack(PACKET *pkt,
 
         if (ack != NULL && i + 1 < ack->num_ack_ranges) {
             ack->ack_ranges[i + 1].start = start = end - len;
-            ack->ack_ranges[i + 1].end   = end;
+            ack->ack_ranges[i + 1].end = end;
         }
     }
 
@@ -581,15 +579,15 @@ int ossl_quic_wire_decode_frame_ack(PACKET *pkt,
         uint64_t ect0, ect1, ecnce;
 
         if (!PACKET_get_quic_vlint(pkt, &ect0)
-                || !PACKET_get_quic_vlint(pkt, &ect1)
-                || !PACKET_get_quic_vlint(pkt, &ecnce))
+            || !PACKET_get_quic_vlint(pkt, &ect1)
+            || !PACKET_get_quic_vlint(pkt, &ecnce))
             return 0;
 
         if (ack != NULL) {
-            ack->ect0           = ect0;
-            ack->ect1           = ect1;
-            ack->ecnce          = ecnce;
-            ack->ecn_present    = 1;
+            ack->ect0 = ect0;
+            ack->ect1 = ect1;
+            ack->ecnce = ecnce;
+            ack->ecn_present = 1;
         }
     } else if (ack != NULL) {
         ack->ecn_present = 0;
@@ -599,36 +597,36 @@ int ossl_quic_wire_decode_frame_ack(PACKET *pkt,
 }
 
 int ossl_quic_wire_decode_frame_reset_stream(PACKET *pkt,
-                                             OSSL_QUIC_FRAME_RESET_STREAM *f)
+    OSSL_QUIC_FRAME_RESET_STREAM *f)
 {
     if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_RESET_STREAM)
-            || !PACKET_get_quic_vlint(pkt, &f->stream_id)
-            || !PACKET_get_quic_vlint(pkt, &f->app_error_code)
-            || !PACKET_get_quic_vlint(pkt, &f->final_size))
+        || !PACKET_get_quic_vlint(pkt, &f->stream_id)
+        || !PACKET_get_quic_vlint(pkt, &f->app_error_code)
+        || !PACKET_get_quic_vlint(pkt, &f->final_size))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_decode_frame_stop_sending(PACKET *pkt,
-                                             OSSL_QUIC_FRAME_STOP_SENDING *f)
+    OSSL_QUIC_FRAME_STOP_SENDING *f)
 {
     if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_STOP_SENDING)
-            || !PACKET_get_quic_vlint(pkt, &f->stream_id)
-            || !PACKET_get_quic_vlint(pkt, &f->app_error_code))
+        || !PACKET_get_quic_vlint(pkt, &f->stream_id)
+        || !PACKET_get_quic_vlint(pkt, &f->app_error_code))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_decode_frame_crypto(PACKET *pkt,
-                                       int nodata,
-                                       OSSL_QUIC_FRAME_CRYPTO *f)
+    int nodata,
+    OSSL_QUIC_FRAME_CRYPTO *f)
 {
     if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_CRYPTO)
-            || !PACKET_get_quic_vlint(pkt, &f->offset)
-            || !PACKET_get_quic_vlint(pkt, &f->len)
-            || f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? */)
+        || !PACKET_get_quic_vlint(pkt, &f->offset)
+        || !PACKET_get_quic_vlint(pkt, &f->len)
+        || f->len > SIZE_MAX /* sizeof(uint64_t) > sizeof(size_t)? */)
         return 0;
 
     if (f->offset + f->len > (((uint64_t)1) << 62) - 1)
@@ -650,21 +648,21 @@ int ossl_quic_wire_decode_frame_crypto(PACKET *pkt,
     return 1;
 }
 
-int ossl_quic_wire_decode_frame_new_token(PACKET               *pkt,
-                                          const unsigned char **token,
-                                          size_t               *token_len)
+int ossl_quic_wire_decode_frame_new_token(PACKET *pkt,
+    const unsigned char **token,
+    size_t *token_len)
 {
     uint64_t token_len_;
 
     if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_NEW_TOKEN)
-            || !PACKET_get_quic_vlint(pkt, &token_len_))
+        || !PACKET_get_quic_vlint(pkt, &token_len_))
         return 0;
 
     if (token_len_ > SIZE_MAX)
         return 0;
 
-    *token      = PACKET_data(pkt);
-    *token_len  = (size_t)token_len_;
+    *token = PACKET_data(pkt);
+    *token_len = (size_t)token_len_;
 
     if (!PACKET_forward(pkt, (size_t)token_len_))
         return 0;
@@ -673,16 +671,16 @@ int ossl_quic_wire_decode_frame_new_token(PACKET               *pkt,
 }
 
 int ossl_quic_wire_decode_frame_stream(PACKET *pkt,
-                                       int nodata,
-                                       OSSL_QUIC_FRAME_STREAM *f)
+    int nodata,
+    OSSL_QUIC_FRAME_STREAM *f)
 {
     uint64_t frame_type;
 
     /* This call matches all STREAM values (low 3 bits are masked). */
     if (!expect_frame_header_mask(pkt, OSSL_QUIC_FRAME_TYPE_STREAM,
-                                  OSSL_QUIC_FRAME_FLAG_STREAM_MASK,
-                                  &frame_type)
-            || !PACKET_get_quic_vlint(pkt, &f->stream_id))
+            OSSL_QUIC_FRAME_FLAG_STREAM_MASK,
+            &frame_type)
+        || !PACKET_get_quic_vlint(pkt, &f->stream_id))
         return 0;
 
     if ((frame_type & OSSL_QUIC_FRAME_FLAG_STREAM_OFF) != 0) {
@@ -693,7 +691,7 @@ int ossl_quic_wire_decode_frame_stream(PACKET *pkt,
     }
 
     f->has_explicit_len = ((frame_type & OSSL_QUIC_FRAME_FLAG_STREAM_LEN) != 0);
-    f->is_fin           = ((frame_type & OSSL_QUIC_FRAME_FLAG_STREAM_FIN) != 0);
+    f->is_fin = ((frame_type & OSSL_QUIC_FRAME_FLAG_STREAM_FIN) != 0);
 
     if (f->has_explicit_len) {
         if (!PACKET_get_quic_vlint(pkt, &f->len))
@@ -727,85 +725,85 @@ int ossl_quic_wire_decode_frame_stream(PACKET *pkt,
 }
 
 int ossl_quic_wire_decode_frame_max_data(PACKET *pkt,
-                                         uint64_t *max_data)
+    uint64_t *max_data)
 {
     if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_MAX_DATA)
-            || !PACKET_get_quic_vlint(pkt, max_data))
+        || !PACKET_get_quic_vlint(pkt, max_data))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_decode_frame_max_stream_data(PACKET *pkt,
-                                                uint64_t *stream_id,
-                                                uint64_t *max_stream_data)
+    uint64_t *stream_id,
+    uint64_t *max_stream_data)
 {
     if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA)
-            || !PACKET_get_quic_vlint(pkt, stream_id)
-            || !PACKET_get_quic_vlint(pkt, max_stream_data))
+        || !PACKET_get_quic_vlint(pkt, stream_id)
+        || !PACKET_get_quic_vlint(pkt, max_stream_data))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_decode_frame_max_streams(PACKET *pkt,
-                                            uint64_t *max_streams)
+    uint64_t *max_streams)
 {
     /* This call matches both MAX_STREAMS_BIDI and MAX_STREAMS_UNI. */
     if (!expect_frame_header_mask(pkt, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI,
-                                  1, NULL)
-            || !PACKET_get_quic_vlint(pkt, max_streams))
+            1, NULL)
+        || !PACKET_get_quic_vlint(pkt, max_streams))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_decode_frame_data_blocked(PACKET *pkt,
-                                             uint64_t *max_data)
+    uint64_t *max_data)
 {
     if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED)
-            || !PACKET_get_quic_vlint(pkt, max_data))
+        || !PACKET_get_quic_vlint(pkt, max_data))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_decode_frame_stream_data_blocked(PACKET *pkt,
-                                                    uint64_t *stream_id,
-                                                    uint64_t *max_stream_data)
+    uint64_t *stream_id,
+    uint64_t *max_stream_data)
 {
     if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED)
-            || !PACKET_get_quic_vlint(pkt, stream_id)
-            || !PACKET_get_quic_vlint(pkt, max_stream_data))
+        || !PACKET_get_quic_vlint(pkt, stream_id)
+        || !PACKET_get_quic_vlint(pkt, max_stream_data))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_decode_frame_streams_blocked(PACKET *pkt,
-                                                uint64_t *max_streams)
+    uint64_t *max_streams)
 {
     /* This call matches both STREAMS_BLOCKED_BIDI and STREAMS_BLOCKED_UNI. */
     if (!expect_frame_header_mask(pkt, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI,
-                                  1, NULL)
-            || !PACKET_get_quic_vlint(pkt, max_streams))
+            1, NULL)
+        || !PACKET_get_quic_vlint(pkt, max_streams))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_decode_frame_new_conn_id(PACKET *pkt,
-                                            OSSL_QUIC_FRAME_NEW_CONN_ID *f)
+    OSSL_QUIC_FRAME_NEW_CONN_ID *f)
 {
     unsigned int len;
 
     if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID)
-            || !PACKET_get_quic_vlint(pkt, &f->seq_num)
-            || !PACKET_get_quic_vlint(pkt, &f->retire_prior_to)
-            || f->seq_num < f->retire_prior_to
-            || !PACKET_get_1(pkt, &len)
-            || len < 1
-            || len > QUIC_MAX_CONN_ID_LEN)
+        || !PACKET_get_quic_vlint(pkt, &f->seq_num)
+        || !PACKET_get_quic_vlint(pkt, &f->retire_prior_to)
+        || f->seq_num < f->retire_prior_to
+        || !PACKET_get_1(pkt, &len)
+        || len < 1
+        || len > QUIC_MAX_CONN_ID_LEN)
         return 0;
 
     f->conn_id.id_len = (unsigned char)len;
@@ -817,51 +815,51 @@ int ossl_quic_wire_decode_frame_new_conn_id(PACKET *pkt,
         memset(f->conn_id.id + len, 0, QUIC_MAX_CONN_ID_LEN - len);
 
     if (!PACKET_copy_bytes(pkt, f->stateless_reset.token,
-                           sizeof(f->stateless_reset.token)))
+            sizeof(f->stateless_reset.token)))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_decode_frame_retire_conn_id(PACKET *pkt,
-                                               uint64_t *seq_num)
+    uint64_t *seq_num)
 {
     if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID)
-            || !PACKET_get_quic_vlint(pkt, seq_num))
+        || !PACKET_get_quic_vlint(pkt, seq_num))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_decode_frame_path_challenge(PACKET *pkt,
-                                               uint64_t *data)
+    uint64_t *data)
 {
     if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE)
-            || !PACKET_get_net_8(pkt, data))
+        || !PACKET_get_net_8(pkt, data))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_decode_frame_path_response(PACKET *pkt,
-                                              uint64_t *data)
+    uint64_t *data)
 {
     if (!expect_frame_header(pkt, OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE)
-            || !PACKET_get_net_8(pkt, data))
+        || !PACKET_get_net_8(pkt, data))
         return 0;
 
     return 1;
 }
 
 int ossl_quic_wire_decode_frame_conn_close(PACKET *pkt,
-                                           OSSL_QUIC_FRAME_CONN_CLOSE *f)
+    OSSL_QUIC_FRAME_CONN_CLOSE *f)
 {
     uint64_t frame_type, reason_len;
 
     /* This call matches both CONN_CLOSE_TRANSPORT and CONN_CLOSE_APP. */
     if (!expect_frame_header_mask(pkt, OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT,
-                                  1, &frame_type)
-            || !PACKET_get_quic_vlint(pkt, &f->error_code))
+            1, &frame_type)
+        || !PACKET_get_quic_vlint(pkt, &f->error_code))
         return 0;
 
     f->is_app = ((frame_type & 1) != 0);
@@ -874,11 +872,11 @@ int ossl_quic_wire_decode_frame_conn_close(PACKET *pkt,
     }
 
     if (!PACKET_get_quic_vlint(pkt, &reason_len)
-            || reason_len > SIZE_MAX)
+        || reason_len > SIZE_MAX)
         return 0;
 
     if (!PACKET_get_bytes(pkt, (const unsigned char **)&f->reason,
-                          (size_t)reason_len))
+            (size_t)reason_len))
         return 0;
 
     f->reason_len = (size_t)reason_len;
@@ -915,19 +913,19 @@ int ossl_quic_wire_peek_transport_param(PACKET *pkt, uint64_t *id)
 }
 
 const unsigned char *ossl_quic_wire_decode_transport_param_bytes(PACKET *pkt,
-                                                                 uint64_t *id,
-                                                                 size_t *len)
+    uint64_t *id,
+    size_t *len)
 {
     uint64_t len_;
     const unsigned char *b = NULL;
     uint64_t id_;
 
     if (!PACKET_get_quic_vlint(pkt, &id_)
-            || !PACKET_get_quic_vlint(pkt, &len_))
+        || !PACKET_get_quic_vlint(pkt, &len_))
         return NULL;
 
     if (len_ > SIZE_MAX
-            || !PACKET_get_bytes(pkt, (const unsigned char **)&b, (size_t)len_))
+        || !PACKET_get_bytes(pkt, (const unsigned char **)&b, (size_t)len_))
         return NULL;
 
     *len = (size_t)len_;
@@ -937,13 +935,13 @@ const unsigned char *ossl_quic_wire_decode_transport_param_bytes(PACKET *pkt,
 }
 
 int ossl_quic_wire_decode_transport_param_int(PACKET *pkt,
-                                              uint64_t *id,
-                                              uint64_t *value)
+    uint64_t *id,
+    uint64_t *value)
 {
     PACKET sub;
 
     sub.curr = ossl_quic_wire_decode_transport_param_bytes(pkt,
-                                                           id, &sub.remaining);
+        id, &sub.remaining);
     if (sub.curr == NULL)
         return 0;
 
@@ -953,12 +951,12 @@ int ossl_quic_wire_decode_transport_param_int(PACKET *pkt,
     if (PACKET_remaining(&sub) > 0)
         return 0;
 
-   return 1;
+    return 1;
 }
 
 int ossl_quic_wire_decode_transport_param_cid(PACKET *pkt,
-                                              uint64_t *id,
-                                              QUIC_CONN_ID *cid)
+    uint64_t *id,
+    QUIC_CONN_ID *cid)
 {
     const unsigned char *body;
     size_t len = 0;
@@ -973,7 +971,7 @@ int ossl_quic_wire_decode_transport_param_cid(PACKET *pkt,
 }
 
 int ossl_quic_wire_decode_transport_param_preferred_addr(PACKET *pkt,
-                                                         QUIC_PREFERRED_ADDR *p)
+    QUIC_PREFERRED_ADDR *p)
 {
     const unsigned char *body;
     uint64_t id;
@@ -999,12 +997,12 @@ int ossl_quic_wire_decode_transport_param_preferred_addr(PACKET *pkt,
         || cidl > QUIC_MAX_CONN_ID_LEN
         || !PACKET_copy_bytes(&pkt2, p->cid.id, cidl)
         || !PACKET_copy_bytes(&pkt2, p->stateless_reset.token,
-                              sizeof(p->stateless_reset.token)))
+            sizeof(p->stateless_reset.token)))
         return 0;
 
-    p->ipv4_port    = (uint16_t)ipv4_port;
-    p->ipv6_port    = (uint16_t)ipv6_port;
-    p->cid.id_len   = (unsigned char)cidl;
+    p->ipv4_port = (uint16_t)ipv4_port;
+    p->ipv6_port = (uint16_t)ipv6_port;
+    p->cid.id_len = (unsigned char)cidl;
     return 1;
 }
 
@@ -1012,38 +1010,40 @@ const char *
 ossl_quic_frame_type_to_string(uint64_t frame_type)
 {
     switch (frame_type) {
-#define X(name) case OSSL_QUIC_FRAME_TYPE_##name: return #name;
-    X(PADDING)
-    X(PING)
-    X(ACK_WITHOUT_ECN)
-    X(ACK_WITH_ECN)
-    X(RESET_STREAM)
-    X(STOP_SENDING)
-    X(CRYPTO)
-    X(NEW_TOKEN)
-    X(MAX_DATA)
-    X(MAX_STREAM_DATA)
-    X(MAX_STREAMS_BIDI)
-    X(MAX_STREAMS_UNI)
-    X(DATA_BLOCKED)
-    X(STREAM_DATA_BLOCKED)
-    X(STREAMS_BLOCKED_BIDI)
-    X(STREAMS_BLOCKED_UNI)
-    X(NEW_CONN_ID)
-    X(RETIRE_CONN_ID)
-    X(PATH_CHALLENGE)
-    X(PATH_RESPONSE)
-    X(CONN_CLOSE_TRANSPORT)
-    X(CONN_CLOSE_APP)
-    X(HANDSHAKE_DONE)
-    X(STREAM)
-    X(STREAM_FIN)
-    X(STREAM_LEN)
-    X(STREAM_LEN_FIN)
-    X(STREAM_OFF)
-    X(STREAM_OFF_FIN)
-    X(STREAM_OFF_LEN)
-    X(STREAM_OFF_LEN_FIN)
+#define X(name)                       \
+    case OSSL_QUIC_FRAME_TYPE_##name: \
+        return #name;
+        X(PADDING)
+        X(PING)
+        X(ACK_WITHOUT_ECN)
+        X(ACK_WITH_ECN)
+        X(RESET_STREAM)
+        X(STOP_SENDING)
+        X(CRYPTO)
+        X(NEW_TOKEN)
+        X(MAX_DATA)
+        X(MAX_STREAM_DATA)
+        X(MAX_STREAMS_BIDI)
+        X(MAX_STREAMS_UNI)
+        X(DATA_BLOCKED)
+        X(STREAM_DATA_BLOCKED)
+        X(STREAMS_BLOCKED_BIDI)
+        X(STREAMS_BLOCKED_UNI)
+        X(NEW_CONN_ID)
+        X(RETIRE_CONN_ID)
+        X(PATH_CHALLENGE)
+        X(PATH_RESPONSE)
+        X(CONN_CLOSE_TRANSPORT)
+        X(CONN_CLOSE_APP)
+        X(HANDSHAKE_DONE)
+        X(STREAM)
+        X(STREAM_FIN)
+        X(STREAM_LEN)
+        X(STREAM_LEN_FIN)
+        X(STREAM_OFF)
+        X(STREAM_OFF_FIN)
+        X(STREAM_OFF_LEN)
+        X(STREAM_OFF_LEN_FIN)
 #undef X
     default:
         return NULL;
@@ -1053,24 +1053,26 @@ ossl_quic_frame_type_to_string(uint64_t frame_type)
 const char *ossl_quic_err_to_string(uint64_t error_code)
 {
     switch (error_code) {
-#define X(name) case OSSL_QUIC_ERR_##name: return #name;
-    X(NO_ERROR)
-    X(INTERNAL_ERROR)
-    X(CONNECTION_REFUSED)
-    X(FLOW_CONTROL_ERROR)
-    X(STREAM_LIMIT_ERROR)
-    X(STREAM_STATE_ERROR)
-    X(FINAL_SIZE_ERROR)
-    X(FRAME_ENCODING_ERROR)
-    X(TRANSPORT_PARAMETER_ERROR)
-    X(CONNECTION_ID_LIMIT_ERROR)
-    X(PROTOCOL_VIOLATION)
-    X(INVALID_TOKEN)
-    X(APPLICATION_ERROR)
-    X(CRYPTO_BUFFER_EXCEEDED)
-    X(KEY_UPDATE_ERROR)
-    X(AEAD_LIMIT_REACHED)
-    X(NO_VIABLE_PATH)
+#define X(name)                \
+    case OSSL_QUIC_ERR_##name: \
+        return #name;
+        X(NO_ERROR)
+        X(INTERNAL_ERROR)
+        X(CONNECTION_REFUSED)
+        X(FLOW_CONTROL_ERROR)
+        X(STREAM_LIMIT_ERROR)
+        X(STREAM_STATE_ERROR)
+        X(FINAL_SIZE_ERROR)
+        X(FRAME_ENCODING_ERROR)
+        X(TRANSPORT_PARAMETER_ERROR)
+        X(CONNECTION_ID_LIMIT_ERROR)
+        X(PROTOCOL_VIOLATION)
+        X(INVALID_TOKEN)
+        X(APPLICATION_ERROR)
+        X(CRYPTO_BUFFER_EXCEEDED)
+        X(KEY_UPDATE_ERROR)
+        X(AEAD_LIMIT_REACHED)
+        X(NO_VIABLE_PATH)
 #undef X
     default:
         return NULL;
diff --git a/crypto/openssl/ssl/quic/quic_wire_pkt.c b/crypto/openssl/ssl/quic/quic_wire_pkt.c
index b6ee898eddf7..d0efc2d06808 100644
--- a/crypto/openssl/ssl/quic/quic_wire_pkt.c
+++ b/crypto/openssl/ssl/quic/quic_wire_pkt.c
@@ -12,27 +12,27 @@
 #include "internal/quic_wire_pkt.h"
 
 int ossl_quic_hdr_protector_init(QUIC_HDR_PROTECTOR *hpr,
-                                 OSSL_LIB_CTX *libctx,
-                                 const char *propq,
-                                 uint32_t cipher_id,
-                                 const unsigned char *quic_hp_key,
-                                 size_t quic_hp_key_len)
+    OSSL_LIB_CTX *libctx,
+    const char *propq,
+    uint32_t cipher_id,
+    const unsigned char *quic_hp_key,
+    size_t quic_hp_key_len)
 {
     const char *cipher_name = NULL;
 
     switch (cipher_id) {
-        case QUIC_HDR_PROT_CIPHER_AES_128:
-            cipher_name = "AES-128-ECB";
-            break;
-        case QUIC_HDR_PROT_CIPHER_AES_256:
-            cipher_name = "AES-256-ECB";
-            break;
-        case QUIC_HDR_PROT_CIPHER_CHACHA:
-            cipher_name = "ChaCha20";
-            break;
-        default:
-            ERR_raise(ERR_LIB_SSL, ERR_R_UNSUPPORTED);
-            return 0;
+    case QUIC_HDR_PROT_CIPHER_AES_128:
+        cipher_name = "AES-128-ECB";
+        break;
+    case QUIC_HDR_PROT_CIPHER_AES_256:
+        cipher_name = "AES-256-ECB";
+        break;
+    case QUIC_HDR_PROT_CIPHER_CHACHA:
+        cipher_name = "ChaCha20";
+        break;
+    default:
+        ERR_raise(ERR_LIB_SSL, ERR_R_UNSUPPORTED);
+        return 0;
     }
 
     hpr->cipher_ctx = EVP_CIPHER_CTX_new();
@@ -49,14 +49,14 @@ int ossl_quic_hdr_protector_init(QUIC_HDR_PROTECTOR *hpr,
     }
 
     if (!EVP_CipherInit_ex(hpr->cipher_ctx, hpr->cipher, NULL,
-                           quic_hp_key, NULL, 1)) {
+            quic_hp_key, NULL, 1)) {
         ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
         goto err;
     }
 
-    hpr->libctx     = libctx;
-    hpr->propq      = propq;
-    hpr->cipher_id  = cipher_id;
+    hpr->libctx = libctx;
+    hpr->propq = propq;
+    hpr->cipher_id = cipher_id;
     return 1;
 
 err:
@@ -74,12 +74,12 @@ void ossl_quic_hdr_protector_cleanup(QUIC_HDR_PROTECTOR *hpr)
 }
 
 static int hdr_generate_mask(QUIC_HDR_PROTECTOR *hpr,
-                             const unsigned char *sample, size_t sample_len,
-                             unsigned char *mask)
+    const unsigned char *sample, size_t sample_len,
+    unsigned char *mask)
 {
     int l = 0;
     unsigned char dst[16];
-    static const unsigned char zeroes[5] = {0};
+    static const unsigned char zeroes[5] = { 0 };
     size_t i;
 
     if (hpr->cipher_id == QUIC_HDR_PROT_CIPHER_AES_128
@@ -105,7 +105,7 @@ static int hdr_generate_mask(QUIC_HDR_PROTECTOR *hpr,
 
         if (!EVP_CipherInit_ex(hpr->cipher_ctx, NULL, NULL, NULL, sample, 1)
             || !EVP_CipherUpdate(hpr->cipher_ctx, mask, &l,
-                                 zeroes, sizeof(zeroes))) {
+                zeroes, sizeof(zeroes))) {
             ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
             return 0;
         }
@@ -124,20 +124,20 @@ static int hdr_generate_mask(QUIC_HDR_PROTECTOR *hpr,
 }
 
 int ossl_quic_hdr_protector_decrypt(QUIC_HDR_PROTECTOR *hpr,
-                                    QUIC_PKT_HDR_PTRS *ptrs)
+    QUIC_PKT_HDR_PTRS *ptrs)
 {
     return ossl_quic_hdr_protector_decrypt_fields(hpr,
-                                                  ptrs->raw_sample,
-                                                  ptrs->raw_sample_len,
-                                                  ptrs->raw_start,
-                                                  ptrs->raw_pn);
+        ptrs->raw_sample,
+        ptrs->raw_sample_len,
+        ptrs->raw_start,
+        ptrs->raw_pn);
 }
 
 int ossl_quic_hdr_protector_decrypt_fields(QUIC_HDR_PROTECTOR *hpr,
-                                           const unsigned char *sample,
-                                           size_t sample_len,
-                                           unsigned char *first_byte,
-                                           unsigned char *pn_bytes)
+    const unsigned char *sample,
+    size_t sample_len,
+    unsigned char *first_byte,
+    unsigned char *pn_bytes)
 {
     unsigned char mask[5], pn_len, i;
 
@@ -154,20 +154,20 @@ int ossl_quic_hdr_protector_decrypt_fields(QUIC_HDR_PROTECTOR *hpr,
 }
 
 int ossl_quic_hdr_protector_encrypt(QUIC_HDR_PROTECTOR *hpr,
-                                    QUIC_PKT_HDR_PTRS *ptrs)
+    QUIC_PKT_HDR_PTRS *ptrs)
 {
     return ossl_quic_hdr_protector_encrypt_fields(hpr,
-                                                  ptrs->raw_sample,
-                                                  ptrs->raw_sample_len,
-                                                  ptrs->raw_start,
-                                                  ptrs->raw_pn);
+        ptrs->raw_sample,
+        ptrs->raw_sample_len,
+        ptrs->raw_start,
+        ptrs->raw_pn);
 }
 
 int ossl_quic_hdr_protector_encrypt_fields(QUIC_HDR_PROTECTOR *hpr,
-                                           const unsigned char *sample,
-                                           size_t sample_len,
-                                           unsigned char *first_byte,
-                                           unsigned char *pn_bytes)
+    const unsigned char *sample,
+    size_t sample_len,
+    unsigned char *first_byte,
+    unsigned char *pn_bytes)
 {
     unsigned char mask[5], pn_len, i;
 
@@ -183,12 +183,12 @@ int ossl_quic_hdr_protector_encrypt_fields(QUIC_HDR_PROTECTOR *hpr,
 }
 
 int ossl_quic_wire_decode_pkt_hdr(PACKET *pkt,
-                                  size_t short_conn_id_len,
-                                  int partial,
-                                  int nodata,
-                                  QUIC_PKT_HDR *hdr,
-                                  QUIC_PKT_HDR_PTRS *ptrs,
-                                  uint64_t *fail_cause)
+    size_t short_conn_id_len,
+    int partial,
+    int nodata,
+    QUIC_PKT_HDR *hdr,
+    QUIC_PKT_HDR_PTRS *ptrs,
+    uint64_t *fail_cause)
 {
     unsigned int b0;
     unsigned char *pn = NULL;
@@ -198,19 +198,19 @@ int ossl_quic_wire_decode_pkt_hdr(PACKET *pkt,
         *fail_cause = QUIC_PKT_HDR_DECODE_DECODE_ERR;
 
     if (ptrs != NULL) {
-        ptrs->raw_start         = (unsigned char *)PACKET_data(pkt);
-        ptrs->raw_sample        = NULL;
-        ptrs->raw_sample_len    = 0;
-        ptrs->raw_pn            = NULL;
+        ptrs->raw_start = (unsigned char *)PACKET_data(pkt);
+        ptrs->raw_sample = NULL;
+        ptrs->raw_sample_len = 0;
+        ptrs->raw_pn = NULL;
     }
 
     if (l < QUIC_MIN_VALID_PKT_LEN
         || !PACKET_get_1(pkt, &b0))
         return 0;
 
-    hdr->partial    = partial;
-    hdr->unused     = 0;
-    hdr->reserved   = 0;
+    hdr->partial = partial;
+    hdr->unused = 0;
+    hdr->reserved = 0;
 
     if ((b0 & 0x80) == 0) {
         /* Short header. */
@@ -221,17 +221,17 @@ int ossl_quic_wire_decode_pkt_hdr(PACKET *pkt,
             || l < QUIC_MIN_VALID_PKT_LEN_CRYPTO)
             return 0;
 
-        hdr->type       = QUIC_PKT_TYPE_1RTT;
-        hdr->fixed      = 1;
-        hdr->spin_bit   = (b0 & 0x20) != 0;
+        hdr->type = QUIC_PKT_TYPE_1RTT;
+        hdr->fixed = 1;
+        hdr->spin_bit = (b0 & 0x20) != 0;
         if (partial) {
-            hdr->key_phase  = 0; /* protected, zero for now */
-            hdr->pn_len     = 0; /* protected, zero for now */
-            hdr->reserved   = 0; /* protected, zero for now */
+            hdr->key_phase = 0; /* protected, zero for now */
+            hdr->pn_len = 0; /* protected, zero for now */
+            hdr->reserved = 0; /* protected, zero for now */
         } else {
-            hdr->key_phase  = (b0 & 0x04) != 0;
-            hdr->pn_len     = (b0 & 0x03) + 1;
-            hdr->reserved   = (b0 & 0x18) >> 3;
+            hdr->key_phase = (b0 & 0x04) != 0;
+            hdr->pn_len = (b0 & 0x03) + 1;
+            hdr->reserved = (b0 & 0x18) >> 3;
         }
 
         /* Copy destination connection ID field to header structure. */
@@ -257,17 +257,17 @@ int ossl_quic_wire_decode_pkt_hdr(PACKET *pkt,
         }
 
         /* Fields not used in short-header packets. */
-        hdr->version            = 0;
+        hdr->version = 0;
         hdr->src_conn_id.id_len = 0;
-        hdr->token              = NULL;
-        hdr->token_len          = 0;
+        hdr->token = NULL;
+        hdr->token_len = 0;
 
         /*
          * Short-header packets always come last in a datagram, the length
          * is the remainder of the buffer.
          */
-        hdr->len                = PACKET_remaining(pkt);
-        hdr->data               = PACKET_data(pkt);
+        hdr->len = PACKET_remaining(pkt);
+        hdr->data = PACKET_data(pkt);
 
         /*
          * Skip over payload. Since this is a short header packet, which cannot
@@ -299,7 +299,7 @@ int ossl_quic_wire_decode_pkt_hdr(PACKET *pkt,
             || !PACKET_copy_bytes(pkt, hdr->src_conn_id.id, src_conn_id_len))
             return 0;
 
-        hdr->version            = (uint32_t)version;
+        hdr->version = (uint32_t)version;
         hdr->dst_conn_id.id_len = (unsigned char)dst_conn_id_len;
         hdr->src_conn_id.id_len = (unsigned char)src_conn_id_len;
 
@@ -309,11 +309,11 @@ int ossl_quic_wire_decode_pkt_hdr(PACKET *pkt,
              * identified by a version field of 0 and the type bits in the first
              * byte are ignored (they may take any value, and we ignore them).
              */
-            hdr->type       = QUIC_PKT_TYPE_VERSION_NEG;
-            hdr->fixed      = (b0 & 0x40) != 0;
+            hdr->type = QUIC_PKT_TYPE_VERSION_NEG;
+            hdr->fixed = (b0 & 0x40) != 0;
 
-            hdr->data       = PACKET_data(pkt);
-            hdr->len        = PACKET_remaining(pkt);
+            hdr->data = PACKET_data(pkt);
+            hdr->len = PACKET_remaining(pkt);
 
             /*
              * Version negotiation packets must contain an array of u32s, so it
@@ -323,14 +323,14 @@ int ossl_quic_wire_decode_pkt_hdr(PACKET *pkt,
                 return 0;
 
             /* Version negotiation packets are always fully decoded. */
-            hdr->partial    = 0;
+            hdr->partial = 0;
 
             /* Fields not used in version negotiation packets. */
-            hdr->pn_len             = 0;
-            hdr->spin_bit           = 0;
-            hdr->key_phase          = 0;
-            hdr->token              = NULL;
-            hdr->token_len          = 0;
+            hdr->pn_len = 0;
+            hdr->spin_bit = 0;
+            hdr->key_phase = 0;
+            hdr->token = NULL;
+            hdr->token_len = 0;
             memset(hdr->pn, 0, sizeof(hdr->pn));
 
             if (!PACKET_forward(pkt, hdr->len))
@@ -362,12 +362,12 @@ int ossl_quic_wire_decode_pkt_hdr(PACKET *pkt,
                 break;
             }
 
-            hdr->pn_len     = 0;
-            hdr->fixed      = 1;
+            hdr->pn_len = 0;
+            hdr->fixed = 1;
 
             /* Fields not used in long-header packets. */
-            hdr->spin_bit   = 0;
-            hdr->key_phase  = 0;
+            hdr->spin_bit = 0;
+            hdr->key_phase = 0;
 
             if (hdr->type == QUIC_PKT_TYPE_INITIAL) {
                 /* Initial packet. */
@@ -378,24 +378,24 @@ int ossl_quic_wire_decode_pkt_hdr(PACKET *pkt,
                     || !PACKET_get_bytes(pkt, &hdr->token, (size_t)token_len))
                     return 0;
 
-                hdr->token_len  = (size_t)token_len;
+                hdr->token_len = (size_t)token_len;
                 if (token_len == 0)
                     hdr->token = NULL;
             } else {
-                hdr->token      = NULL;
-                hdr->token_len  = 0;
+                hdr->token = NULL;
+                hdr->token_len = 0;
             }
 
             if (hdr->type == QUIC_PKT_TYPE_RETRY) {
                 /* Retry packet. */
-                hdr->data       = PACKET_data(pkt);
-                hdr->len        = PACKET_remaining(pkt);
+                hdr->data = PACKET_data(pkt);
+                hdr->len = PACKET_remaining(pkt);
 
                 /* Retry packets are always fully decoded. */
-                hdr->partial    = 0;
+                hdr->partial = 0;
 
                 /* Unused bits in Retry header. */
-                hdr->unused     = b0 & 0x0f;
+                hdr->unused = b0 & 0x0f;
 
                 /* Fields not used in Retry packets. */
                 memset(hdr->pn, 0, sizeof(hdr->pn));
@@ -406,11 +406,11 @@ int ossl_quic_wire_decode_pkt_hdr(PACKET *pkt,
                 /* Initial, 0-RTT or Handshake packet. */
                 uint64_t len;
 
-                hdr->pn_len     = partial ? 0 : ((b0 & 0x03) + 1);
-                hdr->reserved   = partial ? 0 : ((b0 & 0x0C) >> 2);
+                hdr->pn_len = partial ? 0 : ((b0 & 0x03) + 1);
+                hdr->reserved = partial ? 0 : ((b0 & 0x0C) >> 2);
 
                 if (!PACKET_get_quic_vlint(pkt, &len)
-                        || len < sizeof(hdr->pn))
+                    || len < sizeof(hdr->pn))
                     return 0;
 
                 if (!nodata && len > PACKET_remaining(pkt))
@@ -452,8 +452,8 @@ int ossl_quic_wire_decode_pkt_hdr(PACKET *pkt,
     if (ptrs != NULL) {
         ptrs->raw_pn = pn;
         if (pn != NULL) {
-            ptrs->raw_sample        = pn + 4;
-            ptrs->raw_sample_len    = PACKET_end(pkt) - ptrs->raw_sample;
+            ptrs->raw_sample = pn + 4;
+            ptrs->raw_sample_len = PACKET_end(pkt) - ptrs->raw_sample;
         }
     }
 
@@ -467,9 +467,9 @@ int ossl_quic_wire_decode_pkt_hdr(PACKET *pkt,
 }
 
 int ossl_quic_wire_encode_pkt_hdr(WPACKET *pkt,
-                                  size_t short_conn_id_len,
-                                  const QUIC_PKT_HDR *hdr,
-                                  QUIC_PKT_HDR_PTRS *ptrs)
+    size_t short_conn_id_len,
+    const QUIC_PKT_HDR *hdr,
+    QUIC_PKT_HDR_PTRS *ptrs)
 {
     unsigned char b0;
     size_t off_start, off_sample, off_pn;
@@ -482,10 +482,10 @@ int ossl_quic_wire_encode_pkt_hdr(WPACKET *pkt,
         /* ptrs would not be stable on non-static WPACKET */
         if (!ossl_assert(pkt->staticbuf != NULL))
             return 0;
-        ptrs->raw_start         = NULL;
-        ptrs->raw_sample        = NULL;
-        ptrs->raw_sample_len    = 0;
-        ptrs->raw_pn            = 0;
+        ptrs->raw_start = NULL;
+        ptrs->raw_sample = NULL;
+        ptrs->raw_sample_len = 0;
+        ptrs->raw_pn = 0;
     }
 
     /* Cannot serialize a partial header, or one whose DCID length is wrong. */
@@ -507,10 +507,10 @@ int ossl_quic_wire_encode_pkt_hdr(WPACKET *pkt,
             return 0;
 
         b0 = (hdr->spin_bit << 5)
-             | (hdr->key_phase << 2)
-             | (hdr->pn_len - 1)
-             | (hdr->reserved << 3)
-             | 0x40; /* fixed bit */
+            | (hdr->key_phase << 2)
+            | (hdr->pn_len - 1)
+            | (hdr->reserved << 3)
+            | 0x40; /* fixed bit */
 
         if (!WPACKET_put_bytes_u8(pkt, b0)
             || !WPACKET_memcpy(pkt, hdr->dst_conn_id.id, short_conn_id_len)
@@ -530,20 +530,28 @@ int ossl_quic_wire_encode_pkt_hdr(WPACKET *pkt,
             return 0;
 
         switch (hdr->type) {
-            case QUIC_PKT_TYPE_VERSION_NEG:
-                if (hdr->version != 0)
-                    return 0;
+        case QUIC_PKT_TYPE_VERSION_NEG:
+            if (hdr->version != 0)
+                return 0;
 
-                /* Version negotiation packets use zero for the type bits */
-                raw_type = 0;
-                break;
+            /* Version negotiation packets use zero for the type bits */
+            raw_type = 0;
+            break;
 
-            case QUIC_PKT_TYPE_INITIAL:     raw_type = 0; break;
-            case QUIC_PKT_TYPE_0RTT:        raw_type = 1; break;
-            case QUIC_PKT_TYPE_HANDSHAKE:   raw_type = 2; break;
-            case QUIC_PKT_TYPE_RETRY:       raw_type = 3; break;
-            default:
-                return 0;
+        case QUIC_PKT_TYPE_INITIAL:
+            raw_type = 0;
+            break;
+        case QUIC_PKT_TYPE_0RTT:
+            raw_type = 1;
+            break;
+        case QUIC_PKT_TYPE_HANDSHAKE:
+            raw_type = 2;
+            break;
+        case QUIC_PKT_TYPE_RETRY:
+            raw_type = 3;
+            break;
+        default:
+            return 0;
         }
 
         b0 = (raw_type << 4) | 0x80; /* long */
@@ -560,10 +568,10 @@ int ossl_quic_wire_encode_pkt_hdr(WPACKET *pkt,
             || !WPACKET_put_bytes_u32(pkt, hdr->version)
             || !WPACKET_put_bytes_u8(pkt, hdr->dst_conn_id.id_len)
             || !WPACKET_memcpy(pkt, hdr->dst_conn_id.id,
-                               hdr->dst_conn_id.id_len)
+                hdr->dst_conn_id.id_len)
             || !WPACKET_put_bytes_u8(pkt, hdr->src_conn_id.id_len)
             || !WPACKET_memcpy(pkt, hdr->src_conn_id.id,
-                               hdr->src_conn_id.id_len))
+                hdr->src_conn_id.id_len))
             return 0;
 
         if (hdr->type == QUIC_PKT_TYPE_VERSION_NEG) {
@@ -597,18 +605,18 @@ int ossl_quic_wire_encode_pkt_hdr(WPACKET *pkt,
     off_sample = off_pn + 4;
 
     if (ptrs != NULL) {
-        ptrs->raw_start         = start;
-        ptrs->raw_sample        = start + (off_sample - off_start);
+        ptrs->raw_start = start;
+        ptrs->raw_sample = start + (off_sample - off_start);
         ptrs->raw_sample_len
             = WPACKET_get_curr(pkt) + hdr->len - ptrs->raw_sample;
-        ptrs->raw_pn            = start + (off_pn - off_start);
+        ptrs->raw_pn = start + (off_pn - off_start);
     }
 
     return 1;
 }
 
 int ossl_quic_wire_get_encoded_pkt_hdr_len(size_t short_conn_id_len,
-                                           const QUIC_PKT_HDR *hdr)
+    const QUIC_PKT_HDR *hdr)
 {
     size_t len = 0, enclen;
 
@@ -670,9 +678,9 @@ int ossl_quic_wire_get_encoded_pkt_hdr_len(size_t short_conn_id_len,
 }
 
 int ossl_quic_wire_get_pkt_hdr_dst_conn_id(const unsigned char *buf,
-                                           size_t buf_len,
-                                           size_t short_conn_id_len,
-                                           QUIC_CONN_ID *dst_conn_id)
+    size_t buf_len,
+    size_t short_conn_id_len,
+    QUIC_CONN_ID *dst_conn_id)
 {
     unsigned char b0;
     size_t blen;
@@ -720,46 +728,46 @@ int ossl_quic_wire_get_pkt_hdr_dst_conn_id(const unsigned char *buf,
 }
 
 int ossl_quic_wire_decode_pkt_hdr_pn(const unsigned char *enc_pn,
-                                     size_t enc_pn_len,
-                                     QUIC_PN largest_pn,
-                                     QUIC_PN *res_pn)
+    size_t enc_pn_len,
+    QUIC_PN largest_pn,
+    QUIC_PN *res_pn)
 {
     int64_t expected_pn, truncated_pn, candidate_pn, pn_win, pn_hwin, pn_mask;
 
     switch (enc_pn_len) {
-        case 1:
-            truncated_pn = enc_pn[0];
-            break;
-        case 2:
-            truncated_pn = ((QUIC_PN)enc_pn[0] << 8)
-                         |  (QUIC_PN)enc_pn[1];
-            break;
-        case 3:
-            truncated_pn = ((QUIC_PN)enc_pn[0] << 16)
-                         | ((QUIC_PN)enc_pn[1] << 8)
-                         |  (QUIC_PN)enc_pn[2];
-            break;
-        case 4:
-            truncated_pn = ((QUIC_PN)enc_pn[0] << 24)
-                         | ((QUIC_PN)enc_pn[1] << 16)
-                         | ((QUIC_PN)enc_pn[2] << 8)
-                         |  (QUIC_PN)enc_pn[3];
-            break;
-        default:
-            return 0;
+    case 1:
+        truncated_pn = enc_pn[0];
+        break;
+    case 2:
+        truncated_pn = ((QUIC_PN)enc_pn[0] << 8)
+            | (QUIC_PN)enc_pn[1];
+        break;
+    case 3:
+        truncated_pn = ((QUIC_PN)enc_pn[0] << 16)
+            | ((QUIC_PN)enc_pn[1] << 8)
+            | (QUIC_PN)enc_pn[2];
+        break;
+    case 4:
+        truncated_pn = ((QUIC_PN)enc_pn[0] << 24)
+            | ((QUIC_PN)enc_pn[1] << 16)
+            | ((QUIC_PN)enc_pn[2] << 8)
+            | (QUIC_PN)enc_pn[3];
+        break;
+    default:
+        return 0;
     }
 
     /* Implemented as per RFC 9000 Section A.3. */
-    expected_pn     = largest_pn + 1;
-    pn_win          = ((int64_t)1) << (enc_pn_len * 8);
-    pn_hwin         = pn_win / 2;
-    pn_mask         = pn_win - 1;
-    candidate_pn    = (expected_pn & ~pn_mask) | truncated_pn;
+    expected_pn = largest_pn + 1;
+    pn_win = ((int64_t)1) << (enc_pn_len * 8);
+    pn_hwin = pn_win / 2;
+    pn_mask = pn_win - 1;
+    candidate_pn = (expected_pn & ~pn_mask) | truncated_pn;
     if (candidate_pn <= expected_pn - pn_hwin
         && candidate_pn < (((int64_t)1) << 62) - pn_win)
         *res_pn = candidate_pn + pn_win;
     else if (candidate_pn > expected_pn + pn_hwin
-             && candidate_pn >= pn_win)
+        && candidate_pn >= pn_win)
         *res_pn = candidate_pn - pn_win;
     else
         *res_pn = candidate_pn;
@@ -768,7 +776,7 @@ int ossl_quic_wire_decode_pkt_hdr_pn(const unsigned char *enc_pn,
 
 /* From RFC 9000 Section A.2. Simplified implementation. */
 int ossl_quic_wire_determine_pn_len(QUIC_PN pn,
-                                    QUIC_PN largest_acked)
+    QUIC_PN largest_acked)
 {
     uint64_t num_unacked
         = (largest_acked == QUIC_PN_INVALID) ? pn + 1 : pn - largest_acked;
@@ -780,46 +788,49 @@ int ossl_quic_wire_determine_pn_len(QUIC_PN pn,
      * num_unacked \in (2**23,      ] -> 4 bytes
      */
 
-    if (num_unacked <= (1U<<7))  return 1;
-    if (num_unacked <= (1U<<15)) return 2;
-    if (num_unacked <= (1U<<23)) return 3;
+    if (num_unacked <= (1U << 7))
+        return 1;
+    if (num_unacked <= (1U << 15))
+        return 2;
+    if (num_unacked <= (1U << 23))
+        return 3;
     return 4;
 }
 
 int ossl_quic_wire_encode_pkt_hdr_pn(QUIC_PN pn,
-                                     unsigned char *enc_pn,
-                                     size_t enc_pn_len)
+    unsigned char *enc_pn,
+    size_t enc_pn_len)
 {
     switch (enc_pn_len) {
-        case 1:
-            enc_pn[0] = (unsigned char)pn;
-            break;
-        case 2:
-            enc_pn[1] = (unsigned char)pn;
-            enc_pn[0] = (unsigned char)(pn >> 8);
-            break;
-        case 3:
-            enc_pn[2] = (unsigned char)pn;
-            enc_pn[1] = (unsigned char)(pn >> 8);
-            enc_pn[0] = (unsigned char)(pn >> 16);
-            break;
-        case 4:
-            enc_pn[3] = (unsigned char)pn;
-            enc_pn[2] = (unsigned char)(pn >> 8);
-            enc_pn[1] = (unsigned char)(pn >> 16);
-            enc_pn[0] = (unsigned char)(pn >> 24);
-            break;
-        default:
-            return 0;
+    case 1:
+        enc_pn[0] = (unsigned char)pn;
+        break;
+    case 2:
+        enc_pn[1] = (unsigned char)pn;
+        enc_pn[0] = (unsigned char)(pn >> 8);
+        break;
+    case 3:
+        enc_pn[2] = (unsigned char)pn;
+        enc_pn[1] = (unsigned char)(pn >> 8);
+        enc_pn[0] = (unsigned char)(pn >> 16);
+        break;
+    case 4:
+        enc_pn[3] = (unsigned char)pn;
+        enc_pn[2] = (unsigned char)(pn >> 8);
+        enc_pn[1] = (unsigned char)(pn >> 16);
+        enc_pn[0] = (unsigned char)(pn >> 24);
+        break;
+    default:
+        return 0;
     }
 
     return 1;
 }
 
 int ossl_quic_validate_retry_integrity_tag(OSSL_LIB_CTX *libctx,
-                                           const char *propq,
-                                           const QUIC_PKT_HDR *hdr,
-                                           const QUIC_CONN_ID *client_initial_dcid)
+    const char *propq,
+    const QUIC_PKT_HDR *hdr,
+    const QUIC_CONN_ID *client_initial_dcid)
 {
     unsigned char expected_tag[QUIC_RETRY_INTEGRITY_TAG_LEN];
     const unsigned char *actual_tag;
@@ -828,14 +839,14 @@ int ossl_quic_validate_retry_integrity_tag(OSSL_LIB_CTX *libctx,
         return 0;
 
     if (!ossl_quic_calculate_retry_integrity_tag(libctx, propq,
-                                                 hdr, client_initial_dcid,
-                                                 expected_tag))
+            hdr, client_initial_dcid,
+            expected_tag))
         return 0;
 
     actual_tag = hdr->data + hdr->len - QUIC_RETRY_INTEGRITY_TAG_LEN;
 
     return !CRYPTO_memcmp(expected_tag, actual_tag,
-                          QUIC_RETRY_INTEGRITY_TAG_LEN);
+        QUIC_RETRY_INTEGRITY_TAG_LEN);
 }
 
 /* RFC 9001 s. 5.8 */
@@ -850,10 +861,10 @@ static const unsigned char retry_integrity_nonce[] = {
 };
 
 int ossl_quic_calculate_retry_integrity_tag(OSSL_LIB_CTX *libctx,
-                                            const char *propq,
-                                            const QUIC_PKT_HDR *hdr,
-                                            const QUIC_CONN_ID *client_initial_dcid,
-                                            unsigned char *tag)
+    const char *propq,
+    const QUIC_PKT_HDR *hdr,
+    const QUIC_CONN_ID *client_initial_dcid,
+    unsigned char *tag)
 {
     EVP_CIPHER *cipher = NULL;
     EVP_CIPHER_CTX *cctx = NULL;
@@ -892,14 +903,14 @@ int ossl_quic_calculate_retry_integrity_tag(OSSL_LIB_CTX *libctx,
     /* Prepend original DCID to the packet. */
     if (!WPACKET_put_bytes_u8(&wpkt, client_initial_dcid->id_len)
         || !WPACKET_memcpy(&wpkt, client_initial_dcid->id,
-                           client_initial_dcid->id_len)) {
+            client_initial_dcid->id_len)) {
         ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
         goto err;
     }
 
     /* Encode main retry header. */
     if (!ossl_quic_wire_encode_pkt_hdr(&wpkt, hdr2.dst_conn_id.id_len,
-                                       &hdr2, NULL))
+            &hdr2, NULL))
         goto err;
 
     if (!WPACKET_get_total_written(&wpkt, &hdr_enc_len)) {
@@ -920,7 +931,7 @@ int ossl_quic_calculate_retry_integrity_tag(OSSL_LIB_CTX *libctx,
     }
 
     if (!EVP_CipherInit_ex(cctx, cipher, NULL,
-                           retry_integrity_key, retry_integrity_nonce, /*enc=*/1)) {
+            retry_integrity_key, retry_integrity_nonce, /*enc=*/1)) {
         ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
         goto err;
     }
@@ -933,7 +944,8 @@ int ossl_quic_calculate_retry_integrity_tag(OSSL_LIB_CTX *libctx,
 
     /* Feed packet body as AAD data. */
     if (EVP_CipherUpdate(cctx, NULL, &l, hdr->data,
-                         hdr->len - QUIC_RETRY_INTEGRITY_TAG_LEN) != 1) {
+            hdr->len - QUIC_RETRY_INTEGRITY_TAG_LEN)
+        != 1) {
         ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
         goto err;
     }
@@ -945,8 +957,9 @@ int ossl_quic_calculate_retry_integrity_tag(OSSL_LIB_CTX *libctx,
     }
 
     if (EVP_CIPHER_CTX_ctrl(cctx, EVP_CTRL_AEAD_GET_TAG,
-                            QUIC_RETRY_INTEGRITY_TAG_LEN,
-                            tag) != 1) {
+            QUIC_RETRY_INTEGRITY_TAG_LEN,
+            tag)
+        != 1) {
         ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
         goto err;
     }
diff --git a/crypto/openssl/ssl/quic/uint_set.c b/crypto/openssl/ssl/quic/uint_set.c
index faca906003b0..e217816a395b 100644
--- a/crypto/openssl/ssl/quic/uint_set.c
+++ b/crypto/openssl/ssl/quic/uint_set.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2022-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy
@@ -103,7 +103,7 @@ static uint64_t u64_max(uint64_t x, uint64_t y)
  * b.
  */
 static int uint_range_overlaps(const UINT_RANGE *a,
-                               const UINT_RANGE *b)
+    const UINT_RANGE *b)
 {
     return u64_min(a->end, b->end)
         >= u64_max(a->start, b->start);
@@ -118,7 +118,7 @@ static UINT_SET_ITEM *create_set_item(uint64_t start, uint64_t end)
 
     ossl_list_uint_set_init_elem(x);
     x->range.start = start;
-    x->range.end   = end;
+    x->range.end = end;
     return x;
 }
 
@@ -219,7 +219,7 @@ int ossl_uint_set_insert(UINT_SET *s, const UINT_RANGE *range)
             }
             break;
         } else if (end < z->range.start
-                    && (zprev == NULL || start > zprev->range.end)) {
+            && (zprev == NULL || start > zprev->range.end)) {
             if (z->range.start == end + 1) {
                 /* We can extend the following range backwards. */
                 z->range.start = start;
@@ -303,6 +303,8 @@ int ossl_uint_set_remove(UINT_SET *s, const UINT_RANGE *range)
              * handled by the above cases.
              */
             y = create_set_item(end + 1, z->range.end);
+            if (y == NULL)
+                return 0;
             ossl_list_uint_set_insert_after(s, z, y);
             z->range.end = start - 1;
             break;
diff --git a/crypto/openssl/ssl/record/methods/dtls_meth.c b/crypto/openssl/ssl/record/methods/dtls_meth.c
index 99cb532d03c3..8cbd7678e193 100644
--- a/crypto/openssl/ssl/record/methods/dtls_meth.c
+++ b/crypto/openssl/ssl/record/methods/dtls_meth.c
@@ -46,20 +46,20 @@ static int dtls_record_replay_check(OSSL_RECORD_LAYER *rl, DTLS_BITMAP *bitmap)
     cmp = satsub64be(seq, bitmap->max_seq_num);
     if (cmp > 0) {
         ossl_tls_rl_record_set_seq_num(&rl->rrec[0], seq);
-        return 1;               /* this record in new */
+        return 1; /* this record in new */
     }
     shift = -cmp;
     if (shift >= sizeof(bitmap->map) * 8)
-        return 0;               /* stale, outside the window */
+        return 0; /* stale, outside the window */
     else if (bitmap->map & ((uint64_t)1 << shift))
-        return 0;               /* record previously received */
+        return 0; /* record previously received */
 
     ossl_tls_rl_record_set_seq_num(&rl->rrec[0], seq);
     return 1;
 }
 
 static void dtls_record_bitmap_update(OSSL_RECORD_LAYER *rl,
-                                      DTLS_BITMAP *bitmap)
+    DTLS_BITMAP *bitmap)
 {
     int cmp;
     unsigned int shift;
@@ -81,7 +81,7 @@ static void dtls_record_bitmap_update(OSSL_RECORD_LAYER *rl,
 }
 
 static DTLS_BITMAP *dtls_get_bitmap(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rr,
-                                    unsigned int *is_next_epoch)
+    unsigned int *is_next_epoch)
 {
     *is_next_epoch = 0;
 
@@ -171,7 +171,7 @@ static int dtls_process_record(OSSL_RECORD_LAYER *rl, DTLS_BITMAP *bitmap)
         i = rl->funcs->mac(rl, rr, md, 0 /* not send */);
         if (i == 0 || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0) {
             RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC,
-                        SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
+                SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
             return 0;
         }
         /*
@@ -207,15 +207,17 @@ static int dtls_process_record(OSSL_RECORD_LAYER *rl, DTLS_BITMAP *bitmap)
         goto end;
     }
     ERR_clear_last_mark();
-    OSSL_TRACE_BEGIN(TLS) {
+    OSSL_TRACE_BEGIN(TLS)
+    {
         BIO_printf(trc_out, "dec %zd\n", rr->length);
         BIO_dump_indent(trc_out, rr->data, rr->length, 4);
-    } OSSL_TRACE_END(TLS);
+    }
+    OSSL_TRACE_END(TLS);
 
     /* r->length is now the compressed data plus mac */
     if (!rl->use_etm
-            && (rl->enc_ctx != NULL)
-            && (EVP_MD_CTX_get0_md(rl->md_ctx) != NULL)) {
+        && (rl->enc_ctx != NULL)
+        && (EVP_MD_CTX_get0_md(rl->md_ctx) != NULL)) {
         /* rl->md_ctx != NULL => mac_size != -1 */
 
         i = rl->funcs->mac(rl, rr, md, 0 /* not send */);
@@ -237,7 +239,7 @@ static int dtls_process_record(OSSL_RECORD_LAYER *rl, DTLS_BITMAP *bitmap)
     if (rl->compctx != NULL) {
         if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH) {
             RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW,
-                        SSL_R_COMPRESSED_LENGTH_TOO_LONG);
+                SSL_R_COMPRESSED_LENGTH_TOO_LONG);
             goto end;
         }
         if (!tls_do_uncompress(rl, rr)) {
@@ -272,14 +274,14 @@ static int dtls_process_record(OSSL_RECORD_LAYER *rl, DTLS_BITMAP *bitmap)
     dtls_record_bitmap_update(rl, bitmap);
 
     ret = 1;
- end:
+end:
     if (macbuf.alloced)
         OPENSSL_free(macbuf.mac);
     return ret;
 }
 
 static int dtls_rlayer_buffer_record(OSSL_RECORD_LAYER *rl, struct pqueue_st *queue,
-                                     unsigned char *priority)
+    unsigned char *priority)
 {
     DTLS_RLAYER_RECORD_DATA *rdata;
     pitem *item;
@@ -348,7 +350,7 @@ static int dtls_copy_rlayer_record(OSSL_RECORD_LAYER *rl, pitem *item)
 }
 
 static int dtls_retrieve_rlayer_buffered_record(OSSL_RECORD_LAYER *rl,
-                                                struct pqueue_st *queue)
+    struct pqueue_st *queue)
 {
     pitem *item;
 
@@ -397,7 +399,7 @@ int dtls_get_more_records(OSSL_RECORD_LAYER *rl)
         }
     }
 
- again:
+again:
     /* if we're renegotiating, then there may be buffered records */
     if (dtls_retrieve_rlayer_buffered_record(rl, rl->processed_rcds)) {
         rl->num_recs = 1;
@@ -407,14 +409,13 @@ int dtls_get_more_records(OSSL_RECORD_LAYER *rl)
     /* get something from the wire */
 
     /* check if we have the header */
-    if ((rl->rstate != SSL_ST_READ_BODY) ||
-        (rl->packet_length < DTLS1_RT_HEADER_LENGTH)) {
+    if ((rl->rstate != SSL_ST_READ_BODY) || (rl->packet_length < DTLS1_RT_HEADER_LENGTH)) {
         rret = rl->funcs->read_n(rl, DTLS1_RT_HEADER_LENGTH,
-                                 TLS_BUFFER_get_len(&rl->rbuf), 0, 1, &n);
+            TLS_BUFFER_get_len(&rl->rbuf), 0, 1, &n);
         /* read timeout is handled by dtls1_read_bytes */
         if (rret < OSSL_RECORD_RETURN_SUCCESS) {
             /* RLAYERfatal() already called if appropriate */
-            return rret;         /* error or non-blocking */
+            return rret; /* error or non-blocking */
         }
 
         /* this packet contained a partial record, dump it */
@@ -443,7 +444,7 @@ int dtls_get_more_records(OSSL_RECORD_LAYER *rl)
 
         if (rl->msg_callback != NULL)
             rl->msg_callback(0, rr->rec_version, SSL3_RT_HEADER, rl->packet, DTLS1_RT_HEADER_LENGTH,
-                             rl->cbarg);
+                rl->cbarg);
 
         /*
          * Lets check the version. We tolerate alerts that don't have the exact
@@ -458,9 +459,7 @@ int dtls_get_more_records(OSSL_RECORD_LAYER *rl)
             }
         }
 
-        if (ssl_major !=
-                (rl->version == DTLS_ANY_VERSION ? DTLS1_VERSION_MAJOR
-                                                 : rl->version >> 8)) {
+        if (ssl_major != (rl->version == DTLS_ANY_VERSION ? DTLS1_VERSION_MAJOR : rl->version >> 8)) {
             /* wrong version, silently discard record */
             rr->length = 0;
             rl->packet_length = 0;
@@ -518,7 +517,7 @@ int dtls_get_more_records(OSSL_RECORD_LAYER *rl)
     if (bitmap == NULL) {
         rr->length = 0;
         rl->packet_length = 0; /* dump this record */
-        goto again;             /* get another record */
+        goto again; /* get another record */
     }
 #ifndef OPENSSL_NO_SCTP
     /* Only do replay check if no SCTP bio */
@@ -528,7 +527,7 @@ int dtls_get_more_records(OSSL_RECORD_LAYER *rl)
         if (!dtls_record_replay_check(rl, bitmap)) {
             rr->length = 0;
             rl->packet_length = 0; /* dump this record */
-            goto again;         /* get another record */
+            goto again; /* get another record */
         }
 #ifndef OPENSSL_NO_SCTP
     }
@@ -546,7 +545,8 @@ int dtls_get_more_records(OSSL_RECORD_LAYER *rl)
     if (is_next_epoch) {
         if (rl->in_init) {
             if (dtls_rlayer_buffer_record(rl, rl->unprocessed_rcds,
-                                          rr->seq_num) < 0) {
+                    rr->seq_num)
+                < 0) {
                 /* RLAYERfatal() already called */
                 return OSSL_RECORD_RETURN_FATAL;
             }
@@ -563,7 +563,7 @@ int dtls_get_more_records(OSSL_RECORD_LAYER *rl)
         }
         rr->length = 0;
         rl->packet_length = 0; /* dump this record */
-        goto again;             /* get another record */
+        goto again; /* get another record */
     }
 
     if (rl->funcs->post_process_record && !rl->funcs->post_process_record(rl, rr)) {
@@ -606,7 +606,7 @@ static int dtls_free(OSSL_RECORD_LAYER *rl)
             rdata = (DTLS_RLAYER_RECORD_DATA *)item->data;
             /* Push to the next record layer */
             ret &= BIO_write_ex(rl->next, rdata->packet, rdata->packet_length,
-                                &written);
+                &written);
             OPENSSL_free(rdata->rbuf.buf);
             OPENSSL_free(item->data);
             pitem_free(item);
@@ -614,7 +614,7 @@ static int dtls_free(OSSL_RECORD_LAYER *rl)
         pqueue_free(rl->unprocessed_rcds);
     }
 
-    if (rl->processed_rcds!= NULL) {
+    if (rl->processed_rcds != NULL) {
         while ((item = pqueue_pop(rl->processed_rcds)) != NULL) {
             rdata = (DTLS_RLAYER_RECORD_DATA *)item->data;
             OPENSSL_free(rdata->rbuf.buf);
@@ -629,25 +629,25 @@ static int dtls_free(OSSL_RECORD_LAYER *rl)
 
 static int
 dtls_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
-                      int role, int direction, int level, uint16_t epoch,
-                      unsigned char *secret, size_t secretlen,
-                      unsigned char *key, size_t keylen, unsigned char *iv,
-                      size_t ivlen, unsigned char *mackey, size_t mackeylen,
-                      const EVP_CIPHER *ciph, size_t taglen,
-                      int mactype,
-                      const EVP_MD *md, COMP_METHOD *comp,
-                      const EVP_MD *kdfdigest, BIO *prev, BIO *transport,
-                      BIO *next, BIO_ADDR *local, BIO_ADDR *peer,
-                      const OSSL_PARAM *settings, const OSSL_PARAM *options,
-                      const OSSL_DISPATCH *fns, void *cbarg, void *rlarg,
-                      OSSL_RECORD_LAYER **retrl)
+    int role, int direction, int level, uint16_t epoch,
+    unsigned char *secret, size_t secretlen,
+    unsigned char *key, size_t keylen, unsigned char *iv,
+    size_t ivlen, unsigned char *mackey, size_t mackeylen,
+    const EVP_CIPHER *ciph, size_t taglen,
+    int mactype,
+    const EVP_MD *md, COMP_METHOD *comp,
+    const EVP_MD *kdfdigest, BIO *prev, BIO *transport,
+    BIO *next, BIO_ADDR *local, BIO_ADDR *peer,
+    const OSSL_PARAM *settings, const OSSL_PARAM *options,
+    const OSSL_DISPATCH *fns, void *cbarg, void *rlarg,
+    OSSL_RECORD_LAYER **retrl)
 {
     int ret;
 
     ret = tls_int_new_record_layer(libctx, propq, vers, role, direction, level,
-                                   ciph, taglen, md, comp, prev,
-                                   transport, next, settings,
-                                   options, fns, cbarg, retrl);
+        ciph, taglen, md, comp, prev,
+        transport, next, settings,
+        options, fns, cbarg, retrl);
 
     if (ret != OSSL_RECORD_RETURN_SUCCESS)
         return ret;
@@ -656,7 +656,7 @@ dtls_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
     (*retrl)->processed_rcds = pqueue_new();
 
     if ((*retrl)->unprocessed_rcds == NULL
-            || (*retrl)->processed_rcds == NULL) {
+        || (*retrl)->processed_rcds == NULL) {
         dtls_free(*retrl);
         *retrl = NULL;
         ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB);
@@ -684,10 +684,10 @@ dtls_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
     }
 
     ret = (*retrl)->funcs->set_crypto_state(*retrl, level, key, keylen, iv,
-                                            ivlen, mackey, mackeylen, ciph,
-                                            taglen, mactype, md, comp);
+        ivlen, mackey, mackeylen, ciph,
+        taglen, mactype, md, comp);
 
- err:
+err:
     if (ret != OSSL_RECORD_RETURN_SUCCESS) {
         dtls_free(*retrl);
         *retrl = NULL;
@@ -696,10 +696,10 @@ dtls_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
 }
 
 int dtls_prepare_record_header(OSSL_RECORD_LAYER *rl,
-                               WPACKET *thispkt,
-                               OSSL_RECORD_TEMPLATE *templ,
-                               uint8_t rectype,
-                               unsigned char **recdata)
+    WPACKET *thispkt,
+    OSSL_RECORD_TEMPLATE *templ,
+    uint8_t rectype,
+    unsigned char **recdata)
 {
     size_t maxcomplen;
 
@@ -710,15 +710,15 @@ int dtls_prepare_record_header(OSSL_RECORD_LAYER *rl,
         maxcomplen += SSL3_RT_MAX_COMPRESSED_OVERHEAD;
 
     if (!WPACKET_put_bytes_u8(thispkt, rectype)
-            || !WPACKET_put_bytes_u16(thispkt, templ->version)
-            || !WPACKET_put_bytes_u16(thispkt, rl->epoch)
-            || !WPACKET_memcpy(thispkt, &(rl->sequence[2]), 6)
-            || !WPACKET_start_sub_packet_u16(thispkt)
-            || (rl->eivlen > 0
-                && !WPACKET_allocate_bytes(thispkt, rl->eivlen, NULL))
-            || (maxcomplen > 0
-                && !WPACKET_reserve_bytes(thispkt, maxcomplen,
-                                          recdata))) {
+        || !WPACKET_put_bytes_u16(thispkt, templ->version)
+        || !WPACKET_put_bytes_u16(thispkt, rl->epoch)
+        || !WPACKET_memcpy(thispkt, &(rl->sequence[2]), 6)
+        || !WPACKET_start_sub_packet_u16(thispkt)
+        || (rl->eivlen > 0
+            && !WPACKET_allocate_bytes(thispkt, rl->eivlen, NULL))
+        || (maxcomplen > 0
+            && !WPACKET_reserve_bytes(thispkt, maxcomplen,
+                recdata))) {
         RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
@@ -727,13 +727,13 @@ int dtls_prepare_record_header(OSSL_RECORD_LAYER *rl,
 }
 
 int dtls_post_encryption_processing(OSSL_RECORD_LAYER *rl,
-                                    size_t mac_size,
-                                    OSSL_RECORD_TEMPLATE *thistempl,
-                                    WPACKET *thispkt,
-                                    TLS_RL_RECORD *thiswr)
+    size_t mac_size,
+    OSSL_RECORD_TEMPLATE *thistempl,
+    WPACKET *thispkt,
+    TLS_RL_RECORD *thiswr)
 {
     if (!tls_post_encryption_processing_default(rl, mac_size, thistempl,
-                                                thispkt, thiswr)) {
+            thispkt, thiswr)) {
         /* RLAYERfatal() already called */
         return 0;
     }
@@ -745,8 +745,7 @@ static size_t dtls_get_max_record_overhead(OSSL_RECORD_LAYER *rl)
 {
     size_t blocksize = 0;
 
-    if (rl->enc_ctx != NULL &&
-        (EVP_CIPHER_CTX_get_mode(rl->enc_ctx) == EVP_CIPH_CBC_MODE))
+    if (rl->enc_ctx != NULL && (EVP_CIPHER_CTX_get_mode(rl->enc_ctx) == EVP_CIPH_CBC_MODE))
         blocksize = EVP_CIPHER_CTX_get_block_size(rl->enc_ctx);
 
     /*
@@ -756,8 +755,7 @@ static size_t dtls_get_max_record_overhead(OSSL_RECORD_LAYER *rl)
      * ciphers or AEAD ciphers we don't now the digest (or there isn't one) so
      * we just trust that the taglen is correct.
      */
-    assert(rl->enc_ctx == NULL  || ((blocksize == 0 || rl->eivlen > 0)
-                                    && rl->taglen > 0));
+    assert(rl->enc_ctx == NULL || ((blocksize == 0 || rl->eivlen > 0) && rl->taglen > 0));
     assert(rl->md == NULL || (int)rl->taglen == EVP_MD_size(rl->md));
 
     /*
diff --git a/crypto/openssl/ssl/record/methods/ktls_meth.c b/crypto/openssl/ssl/record/methods/ktls_meth.c
index 6f2594768391..bfdcc24687f2 100644
--- a/crypto/openssl/ssl/record/methods/ktls_meth.c
+++ b/crypto/openssl/ssl/record/methods/ktls_meth.c
@@ -18,7 +18,7 @@
 static struct record_functions_st ossl_ktls_funcs;
 
 #if defined(__FreeBSD__)
-# include "crypto/cryptodev.h"
+#include "crypto/cryptodev.h"
 
 /*-
  * Check if a given cipher is supported by the KTLS interface.
@@ -27,9 +27,9 @@ static struct record_functions_st ossl_ktls_funcs;
  * supports the cipher suite used at all.
  */
 static int ktls_int_check_supported_cipher(OSSL_RECORD_LAYER *rl,
-                                           const EVP_CIPHER *c,
-                                           const EVP_MD *md,
-                                           size_t taglen)
+    const EVP_CIPHER *c,
+    const EVP_MD *md,
+    size_t taglen)
 {
     switch (rl->version) {
     case TLS1_VERSION:
@@ -44,15 +44,15 @@ static int ktls_int_check_supported_cipher(OSSL_RECORD_LAYER *rl,
     }
 
     if (EVP_CIPHER_is_a(c, "AES-128-GCM")
-            || EVP_CIPHER_is_a(c, "AES-256-GCM")
-# ifdef OPENSSL_KTLS_CHACHA20_POLY1305
-            || EVP_CIPHER_is_a(c, "CHACHA20-POLY1305")
-# endif
-       )
+        || EVP_CIPHER_is_a(c, "AES-256-GCM")
+#ifdef OPENSSL_KTLS_CHACHA20_POLY1305
+        || EVP_CIPHER_is_a(c, "CHACHA20-POLY1305")
+#endif
+    )
         return 1;
 
     if (!EVP_CIPHER_is_a(c, "AES-128-CBC")
-            && !EVP_CIPHER_is_a(c, "AES-256-CBC"))
+        && !EVP_CIPHER_is_a(c, "AES-256-CBC"))
         return 0;
 
     if (rl->use_etm)
@@ -62,35 +62,34 @@ static int ktls_int_check_supported_cipher(OSSL_RECORD_LAYER *rl,
         return 0;
 
     if (EVP_MD_is_a(md, "SHA1")
-            || EVP_MD_is_a(md, "SHA2-256")
-            || EVP_MD_is_a(md, "SHA2-384"))
+        || EVP_MD_is_a(md, "SHA2-256")
+        || EVP_MD_is_a(md, "SHA2-384"))
         return 1;
 
     return 0;
 }
 
 /* Function to configure kernel TLS structure */
-static
-int ktls_configure_crypto(OSSL_LIB_CTX *libctx, int version, const EVP_CIPHER *c,
-                          EVP_MD *md, void *rl_sequence,
-                          ktls_crypto_info_t *crypto_info, int is_tx,
-                          unsigned char *iv, size_t ivlen,
-                          unsigned char *key, size_t keylen,
-                          unsigned char *mac_key, size_t mac_secret_size)
+static int ktls_configure_crypto(OSSL_LIB_CTX *libctx, int version, const EVP_CIPHER *c,
+    EVP_MD *md, void *rl_sequence,
+    ktls_crypto_info_t *crypto_info, int is_tx,
+    unsigned char *iv, size_t ivlen,
+    unsigned char *key, size_t keylen,
+    unsigned char *mac_key, size_t mac_secret_size)
 {
     memset(crypto_info, 0, sizeof(*crypto_info));
     if (EVP_CIPHER_is_a(c, "AES-128-GCM")
-            || EVP_CIPHER_is_a(c, "AES-256-GCM")) {
+        || EVP_CIPHER_is_a(c, "AES-256-GCM")) {
         crypto_info->cipher_algorithm = CRYPTO_AES_NIST_GCM_16;
         crypto_info->iv_len = ivlen;
     } else
-# ifdef OPENSSL_KTLS_CHACHA20_POLY1305
-    if (EVP_CIPHER_is_a(c, "CHACHA20-POLY1305")) {
+#ifdef OPENSSL_KTLS_CHACHA20_POLY1305
+        if (EVP_CIPHER_is_a(c, "CHACHA20-POLY1305")) {
         crypto_info->cipher_algorithm = CRYPTO_CHACHA20_POLY1305;
         crypto_info->iv_len = ivlen;
     } else
-# endif
-    if (EVP_CIPHER_is_a(c, "AES-128-CBC") || EVP_CIPHER_is_a(c, "AES-256-CBC")) {
+#endif
+        if (EVP_CIPHER_is_a(c, "AES-128-CBC") || EVP_CIPHER_is_a(c, "AES-256-CBC")) {
         if (md == NULL)
             return 0;
         if (EVP_MD_is_a(md, "SHA1"))
@@ -113,23 +112,23 @@ int ktls_configure_crypto(OSSL_LIB_CTX *libctx, int version, const EVP_CIPHER *c
     crypto_info->iv = iv;
     crypto_info->tls_vmajor = (version >> 8) & 0x000000ff;
     crypto_info->tls_vminor = (version & 0x000000ff);
-# ifdef TCP_RXTLS_ENABLE
+#ifdef TCP_RXTLS_ENABLE
     memcpy(crypto_info->rec_seq, rl_sequence, sizeof(crypto_info->rec_seq));
-# else
+#else
     if (!is_tx)
         return 0;
-# endif
+#endif
     return 1;
 };
 
-#endif                         /* __FreeBSD__ */
+#endif /* __FreeBSD__ */
 
 #if defined(OPENSSL_SYS_LINUX)
 /* Function to check supported ciphers in Linux */
 static int ktls_int_check_supported_cipher(OSSL_RECORD_LAYER *rl,
-                                           const EVP_CIPHER *c,
-                                           const EVP_MD *md,
-                                           size_t taglen)
+    const EVP_CIPHER *c,
+    const EVP_MD *md,
+    size_t taglen)
 {
     switch (rl->version) {
     case TLS1_2_VERSION:
@@ -145,23 +144,23 @@ static int ktls_int_check_supported_cipher(OSSL_RECORD_LAYER *rl,
      * Check that cipher is AES_GCM_128, AES_GCM_256, AES_CCM_128
      * or Chacha20-Poly1305
      */
-# ifdef OPENSSL_KTLS_AES_CCM_128
+#ifdef OPENSSL_KTLS_AES_CCM_128
     if (EVP_CIPHER_is_a(c, "AES-128-CCM")) {
         if (taglen != EVP_CCM_TLS_TAG_LEN)
             return 0;
         return 1;
     } else
-# endif
-    if (0
-# ifdef OPENSSL_KTLS_AES_GCM_128
-        || EVP_CIPHER_is_a(c, "AES-128-GCM")
-# endif
-# ifdef OPENSSL_KTLS_AES_GCM_256
-        || EVP_CIPHER_is_a(c, "AES-256-GCM")
-# endif
-# ifdef OPENSSL_KTLS_CHACHA20_POLY1305
-        || EVP_CIPHER_is_a(c, "ChaCha20-Poly1305")
-# endif
+#endif
+        if (0
+#ifdef OPENSSL_KTLS_AES_GCM_128
+            || EVP_CIPHER_is_a(c, "AES-128-GCM")
+#endif
+#ifdef OPENSSL_KTLS_AES_GCM_256
+            || EVP_CIPHER_is_a(c, "AES-256-GCM")
+#endif
+#ifdef OPENSSL_KTLS_CHACHA20_POLY1305
+            || EVP_CIPHER_is_a(c, "ChaCha20-Poly1305")
+#endif
         ) {
         return 1;
     }
@@ -169,42 +168,41 @@ static int ktls_int_check_supported_cipher(OSSL_RECORD_LAYER *rl,
 }
 
 /* Function to configure kernel TLS structure */
-static
-int ktls_configure_crypto(OSSL_LIB_CTX *libctx, int version, const EVP_CIPHER *c,
-                          const EVP_MD *md, void *rl_sequence,
-                          ktls_crypto_info_t *crypto_info, int is_tx,
-                          unsigned char *iv, size_t ivlen,
-                          unsigned char *key, size_t keylen,
-                          unsigned char *mac_key, size_t mac_secret_size)
+static int ktls_configure_crypto(OSSL_LIB_CTX *libctx, int version, const EVP_CIPHER *c,
+    const EVP_MD *md, void *rl_sequence,
+    ktls_crypto_info_t *crypto_info, int is_tx,
+    unsigned char *iv, size_t ivlen,
+    unsigned char *key, size_t keylen,
+    unsigned char *mac_key, size_t mac_secret_size)
 {
     unsigned char geniv[EVP_GCM_TLS_EXPLICIT_IV_LEN];
     unsigned char *eiv = NULL;
 
-# ifdef OPENSSL_NO_KTLS_RX
+#ifdef OPENSSL_NO_KTLS_RX
     if (!is_tx)
         return 0;
-# endif
+#endif
 
     if (EVP_CIPHER_get_mode(c) == EVP_CIPH_GCM_MODE
-            || EVP_CIPHER_get_mode(c) == EVP_CIPH_CCM_MODE) {
+        || EVP_CIPHER_get_mode(c) == EVP_CIPH_CCM_MODE) {
         if (!ossl_assert(EVP_GCM_TLS_FIXED_IV_LEN == EVP_CCM_TLS_FIXED_IV_LEN)
-                || !ossl_assert(EVP_GCM_TLS_EXPLICIT_IV_LEN
-                                == EVP_CCM_TLS_EXPLICIT_IV_LEN))
+            || !ossl_assert(EVP_GCM_TLS_EXPLICIT_IV_LEN
+                == EVP_CCM_TLS_EXPLICIT_IV_LEN))
             return 0;
         if (version == TLS1_2_VERSION) {
             if (!ossl_assert(ivlen == EVP_GCM_TLS_FIXED_IV_LEN))
                 return 0;
             if (is_tx) {
                 if (RAND_bytes_ex(libctx, geniv,
-                                EVP_GCM_TLS_EXPLICIT_IV_LEN, 0) <= 0)
+                        EVP_GCM_TLS_EXPLICIT_IV_LEN, 0)
+                    <= 0)
                     return 0;
             } else {
                 memset(geniv, 0, EVP_GCM_TLS_EXPLICIT_IV_LEN);
             }
             eiv = geniv;
         } else {
-            if (!ossl_assert(ivlen == EVP_GCM_TLS_FIXED_IV_LEN
-                                      + EVP_GCM_TLS_EXPLICIT_IV_LEN))
+            if (!ossl_assert(ivlen == EVP_GCM_TLS_FIXED_IV_LEN + EVP_GCM_TLS_EXPLICIT_IV_LEN))
                 return 0;
             eiv = iv + TLS_CIPHER_AES_GCM_128_SALT_SIZE;
         }
@@ -212,12 +210,12 @@ int ktls_configure_crypto(OSSL_LIB_CTX *libctx, int version, const EVP_CIPHER *c
 
     memset(crypto_info, 0, sizeof(*crypto_info));
     switch (EVP_CIPHER_get_nid(c)) {
-# ifdef OPENSSL_KTLS_AES_GCM_128
+#ifdef OPENSSL_KTLS_AES_GCM_128
     case NID_aes_128_gcm:
         if (!ossl_assert(TLS_CIPHER_AES_GCM_128_SALT_SIZE
-                         == EVP_GCM_TLS_FIXED_IV_LEN)
-                || !ossl_assert(TLS_CIPHER_AES_GCM_128_IV_SIZE
-                                == EVP_GCM_TLS_EXPLICIT_IV_LEN))
+                == EVP_GCM_TLS_FIXED_IV_LEN)
+            || !ossl_assert(TLS_CIPHER_AES_GCM_128_IV_SIZE
+                == EVP_GCM_TLS_EXPLICIT_IV_LEN))
             return 0;
         crypto_info->gcm128.info.cipher_type = TLS_CIPHER_AES_GCM_128;
         crypto_info->gcm128.info.version = version;
@@ -226,15 +224,15 @@ int ktls_configure_crypto(OSSL_LIB_CTX *libctx, int version, const EVP_CIPHER *c
         memcpy(crypto_info->gcm128.salt, iv, TLS_CIPHER_AES_GCM_128_SALT_SIZE);
         memcpy(crypto_info->gcm128.key, key, keylen);
         memcpy(crypto_info->gcm128.rec_seq, rl_sequence,
-               TLS_CIPHER_AES_GCM_128_REC_SEQ_SIZE);
+            TLS_CIPHER_AES_GCM_128_REC_SEQ_SIZE);
         return 1;
-# endif
-# ifdef OPENSSL_KTLS_AES_GCM_256
+#endif
+#ifdef OPENSSL_KTLS_AES_GCM_256
     case NID_aes_256_gcm:
         if (!ossl_assert(TLS_CIPHER_AES_GCM_256_SALT_SIZE
-                         == EVP_GCM_TLS_FIXED_IV_LEN)
-                || !ossl_assert(TLS_CIPHER_AES_GCM_256_IV_SIZE
-                                == EVP_GCM_TLS_EXPLICIT_IV_LEN))
+                == EVP_GCM_TLS_FIXED_IV_LEN)
+            || !ossl_assert(TLS_CIPHER_AES_GCM_256_IV_SIZE
+                == EVP_GCM_TLS_EXPLICIT_IV_LEN))
             return 0;
         crypto_info->gcm256.info.cipher_type = TLS_CIPHER_AES_GCM_256;
         crypto_info->gcm256.info.version = version;
@@ -243,16 +241,16 @@ int ktls_configure_crypto(OSSL_LIB_CTX *libctx, int version, const EVP_CIPHER *c
         memcpy(crypto_info->gcm256.salt, iv, TLS_CIPHER_AES_GCM_256_SALT_SIZE);
         memcpy(crypto_info->gcm256.key, key, keylen);
         memcpy(crypto_info->gcm256.rec_seq, rl_sequence,
-               TLS_CIPHER_AES_GCM_256_REC_SEQ_SIZE);
+            TLS_CIPHER_AES_GCM_256_REC_SEQ_SIZE);
 
         return 1;
-# endif
-# ifdef OPENSSL_KTLS_AES_CCM_128
+#endif
+#ifdef OPENSSL_KTLS_AES_CCM_128
     case NID_aes_128_ccm:
         if (!ossl_assert(TLS_CIPHER_AES_CCM_128_SALT_SIZE
-                         == EVP_CCM_TLS_FIXED_IV_LEN)
-                || !ossl_assert(TLS_CIPHER_AES_CCM_128_IV_SIZE
-                                == EVP_CCM_TLS_EXPLICIT_IV_LEN))
+                == EVP_CCM_TLS_FIXED_IV_LEN)
+            || !ossl_assert(TLS_CIPHER_AES_CCM_128_IV_SIZE
+                == EVP_CCM_TLS_EXPLICIT_IV_LEN))
             return 0;
         crypto_info->ccm128.info.cipher_type = TLS_CIPHER_AES_CCM_128;
         crypto_info->ccm128.info.version = version;
@@ -261,10 +259,10 @@ int ktls_configure_crypto(OSSL_LIB_CTX *libctx, int version, const EVP_CIPHER *c
         memcpy(crypto_info->ccm128.salt, iv, TLS_CIPHER_AES_CCM_128_SALT_SIZE);
         memcpy(crypto_info->ccm128.key, key, keylen);
         memcpy(crypto_info->ccm128.rec_seq, rl_sequence,
-               TLS_CIPHER_AES_CCM_128_REC_SEQ_SIZE);
+            TLS_CIPHER_AES_CCM_128_REC_SEQ_SIZE);
         return 1;
-# endif
-# ifdef OPENSSL_KTLS_CHACHA20_POLY1305
+#endif
+#ifdef OPENSSL_KTLS_CHACHA20_POLY1305
     case NID_chacha20_poly1305:
         if (!ossl_assert(ivlen == TLS_CIPHER_CHACHA20_POLY1305_IV_SIZE))
             return 0;
@@ -275,26 +273,25 @@ int ktls_configure_crypto(OSSL_LIB_CTX *libctx, int version, const EVP_CIPHER *c
         memcpy(crypto_info->chacha20poly1305.iv, iv, ivlen);
         memcpy(crypto_info->chacha20poly1305.key, key, keylen);
         memcpy(crypto_info->chacha20poly1305.rec_seq, rl_sequence,
-               TLS_CIPHER_CHACHA20_POLY1305_REC_SEQ_SIZE);
+            TLS_CIPHER_CHACHA20_POLY1305_REC_SEQ_SIZE);
         return 1;
-# endif
+#endif
     default:
         return 0;
     }
-
 }
 
 #endif /* OPENSSL_SYS_LINUX */
 
 static int ktls_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
-                                 unsigned char *key, size_t keylen,
-                                 unsigned char *iv, size_t ivlen,
-                                 unsigned char *mackey, size_t mackeylen,
-                                 const EVP_CIPHER *ciph,
-                                 size_t taglen,
-                                 int mactype,
-                                 const EVP_MD *md,
-                                 COMP_METHOD *comp)
+    unsigned char *key, size_t keylen,
+    unsigned char *iv, size_t ivlen,
+    unsigned char *mackey, size_t mackeylen,
+    const EVP_CIPHER *ciph,
+    size_t taglen,
+    int mactype,
+    const EVP_MD *md,
+    COMP_METHOD *comp)
 {
     ktls_crypto_info_t crypto_info;
 
@@ -326,16 +323,15 @@ static int ktls_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
     }
 
     if (!ktls_configure_crypto(rl->libctx, rl->version, ciph, md, rl->sequence,
-                               &crypto_info,
-                               rl->direction == OSSL_RECORD_DIRECTION_WRITE,
-                               iv, ivlen, key, keylen, mackey, mackeylen))
-       return OSSL_RECORD_RETURN_NON_FATAL_ERR;
+            &crypto_info,
+            rl->direction == OSSL_RECORD_DIRECTION_WRITE,
+            iv, ivlen, key, keylen, mackey, mackeylen))
+        return OSSL_RECORD_RETURN_NON_FATAL_ERR;
 
     if (!BIO_set_ktls(rl->bio, &crypto_info, rl->direction))
         return OSSL_RECORD_RETURN_NON_FATAL_ERR;
 
-    if (rl->direction == OSSL_RECORD_DIRECTION_WRITE &&
-        (rl->options & SSL_OP_ENABLE_KTLS_TX_ZEROCOPY_SENDFILE) != 0)
+    if (rl->direction == OSSL_RECORD_DIRECTION_WRITE && (rl->options & SSL_OP_ENABLE_KTLS_TX_ZEROCOPY_SENDFILE) != 0)
         /* Ignore errors. The application opts in to using the zerocopy
          * optimization. If the running kernel doesn't support it, just
          * continue without the optimization.
@@ -346,7 +342,7 @@ static int ktls_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
 }
 
 static int ktls_read_n(OSSL_RECORD_LAYER *rl, size_t n, size_t max, int extend,
-                       int clearold, size_t *readbytes)
+    int clearold, size_t *readbytes)
 {
     int ret;
 
@@ -356,15 +352,15 @@ static int ktls_read_n(OSSL_RECORD_LAYER *rl, size_t n, size_t max, int extend,
         switch (errno) {
         case EBADMSG:
             RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC,
-                        SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
+                SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
             break;
         case EMSGSIZE:
             RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW,
-                        SSL_R_PACKET_LENGTH_TOO_LONG);
+                SSL_R_PACKET_LENGTH_TOO_LONG);
             break;
         case EINVAL:
             RLAYERfatal(rl, SSL_AD_PROTOCOL_VERSION,
-                        SSL_R_WRONG_VERSION_NUMBER);
+                SSL_R_WRONG_VERSION_NUMBER);
             break;
         default:
             break;
@@ -375,8 +371,8 @@ static int ktls_read_n(OSSL_RECORD_LAYER *rl, size_t n, size_t max, int extend,
 }
 
 static int ktls_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *inrecs,
-                       size_t n_recs, int sending, SSL_MAC_BUF *mac,
-                       size_t macsize)
+    size_t n_recs, int sending, SSL_MAC_BUF *mac,
+    size_t macsize)
 {
     return 1;
 }
@@ -401,25 +397,25 @@ static int ktls_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec)
 
 static int
 ktls_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
-                      int role, int direction, int level, uint16_t epoch,
-                      unsigned char *secret, size_t secretlen,
-                      unsigned char *key, size_t keylen, unsigned char *iv,
-                      size_t ivlen, unsigned char *mackey, size_t mackeylen,
-                      const EVP_CIPHER *ciph, size_t taglen,
-                      int mactype,
-                      const EVP_MD *md, COMP_METHOD *comp,
-                      const EVP_MD *kdfdigest, BIO *prev, BIO *transport,
-                      BIO *next, BIO_ADDR *local, BIO_ADDR *peer,
-                      const OSSL_PARAM *settings, const OSSL_PARAM *options,
-                      const OSSL_DISPATCH *fns, void *cbarg, void *rlarg,
-                      OSSL_RECORD_LAYER **retrl)
+    int role, int direction, int level, uint16_t epoch,
+    unsigned char *secret, size_t secretlen,
+    unsigned char *key, size_t keylen, unsigned char *iv,
+    size_t ivlen, unsigned char *mackey, size_t mackeylen,
+    const EVP_CIPHER *ciph, size_t taglen,
+    int mactype,
+    const EVP_MD *md, COMP_METHOD *comp,
+    const EVP_MD *kdfdigest, BIO *prev, BIO *transport,
+    BIO *next, BIO_ADDR *local, BIO_ADDR *peer,
+    const OSSL_PARAM *settings, const OSSL_PARAM *options,
+    const OSSL_DISPATCH *fns, void *cbarg, void *rlarg,
+    OSSL_RECORD_LAYER **retrl)
 {
     int ret;
 
     ret = tls_int_new_record_layer(libctx, propq, vers, role, direction, level,
-                                   ciph, taglen, md, comp, prev,
-                                   transport, next, settings,
-                                   options, fns, cbarg, retrl);
+        ciph, taglen, md, comp, prev,
+        transport, next, settings,
+        options, fns, cbarg, retrl);
 
     if (ret != OSSL_RECORD_RETURN_SUCCESS)
         return ret;
@@ -427,8 +423,8 @@ ktls_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
     (*retrl)->funcs = &ossl_ktls_funcs;
 
     ret = (*retrl)->funcs->set_crypto_state(*retrl, level, key, keylen, iv,
-                                            ivlen, mackey, mackeylen, ciph,
-                                            taglen, mactype, md, comp);
+        ivlen, mackey, mackeylen, ciph,
+        taglen, mactype, md, comp);
 
     if (ret != OSSL_RECORD_RETURN_SUCCESS) {
         tls_free(*retrl);
@@ -444,8 +440,8 @@ ktls_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
 }
 
 static int ktls_allocate_write_buffers(OSSL_RECORD_LAYER *rl,
-                                       OSSL_RECORD_TEMPLATE *templates,
-                                       size_t numtempl, size_t *prefix)
+    OSSL_RECORD_TEMPLATE *templates,
+    size_t numtempl, size_t *prefix)
 {
     if (!ossl_assert(numtempl == 1))
         return 0;
@@ -460,12 +456,12 @@ static int ktls_allocate_write_buffers(OSSL_RECORD_LAYER *rl,
 }
 
 static int ktls_initialise_write_packets(OSSL_RECORD_LAYER *rl,
-                                         OSSL_RECORD_TEMPLATE *templates,
-                                         size_t numtempl,
-                                         OSSL_RECORD_TEMPLATE *prefixtempl,
-                                         WPACKET *pkt,
-                                         TLS_BUFFER *bufs,
-                                         size_t *wpinited)
+    OSSL_RECORD_TEMPLATE *templates,
+    size_t numtempl,
+    OSSL_RECORD_TEMPLATE *prefixtempl,
+    WPACKET *pkt,
+    TLS_BUFFER *bufs,
+    size_t *wpinited)
 {
     TLS_BUFFER *wb;
 
@@ -477,11 +473,11 @@ static int ktls_initialise_write_packets(OSSL_RECORD_LAYER *rl,
     wb->type = templates[0].type;
 
     /*
-    * ktls doesn't modify the buffer, but to avoid a warning we need
-    * to discard the const qualifier.
-    * This doesn't leak memory because the buffers have never been allocated
-    * with KTLS
-    */
+     * ktls doesn't modify the buffer, but to avoid a warning we need
+     * to discard the const qualifier.
+     * This doesn't leak memory because the buffers have never been allocated
+     * with KTLS
+     */
     TLS_BUFFER_set_buf(wb, (unsigned char *)templates[0].buf);
     TLS_BUFFER_set_offset(wb, 0);
     TLS_BUFFER_set_app_buffer(wb, 1);
@@ -490,10 +486,10 @@ static int ktls_initialise_write_packets(OSSL_RECORD_LAYER *rl,
 }
 
 static int ktls_prepare_record_header(OSSL_RECORD_LAYER *rl,
-                                      WPACKET *thispkt,
-                                      OSSL_RECORD_TEMPLATE *templ,
-                                      uint8_t rectype,
-                                      unsigned char **recdata)
+    WPACKET *thispkt,
+    OSSL_RECORD_TEMPLATE *templ,
+    uint8_t rectype,
+    unsigned char **recdata)
 {
     /* The kernel writes the record header, so nothing to do */
     *recdata = NULL;
@@ -502,19 +498,19 @@ static int ktls_prepare_record_header(OSSL_RECORD_LAYER *rl,
 }
 
 static int ktls_prepare_for_encryption(OSSL_RECORD_LAYER *rl,
-                                       size_t mac_size,
-                                       WPACKET *thispkt,
-                                       TLS_RL_RECORD *thiswr)
+    size_t mac_size,
+    WPACKET *thispkt,
+    TLS_RL_RECORD *thiswr)
 {
     /* No encryption, so nothing to do */
     return 1;
 }
 
 static int ktls_post_encryption_processing(OSSL_RECORD_LAYER *rl,
-                                           size_t mac_size,
-                                           OSSL_RECORD_TEMPLATE *templ,
-                                           WPACKET *thispkt,
-                                           TLS_RL_RECORD *thiswr)
+    size_t mac_size,
+    OSSL_RECORD_TEMPLATE *templ,
+    WPACKET *thispkt,
+    TLS_RL_RECORD *thiswr)
 {
     /* The kernel does anything that is needed, so nothing to do here */
     return 1;
diff --git a/crypto/openssl/ssl/record/methods/recmethod_local.h b/crypto/openssl/ssl/record/methods/recmethod_local.h
index 364a3a01bbe2..4ffce8d66385 100644
--- a/crypto/openssl/ssl/record/methods/recmethod_local.h
+++ b/crypto/openssl/ssl/record/methods/recmethod_local.h
@@ -80,15 +80,14 @@ typedef struct tls_rl_record_st {
 
 /* Macros/functions provided by the TLS_RL_RECORD component */
 
-#define TLS_RL_RECORD_set_type(r, t)              ((r)->type = (t))
-#define TLS_RL_RECORD_set_rec_version(r, v)       ((r)->rec_version = (v))
-#define TLS_RL_RECORD_get_length(r)               ((r)->length)
-#define TLS_RL_RECORD_set_length(r, l)            ((r)->length = (l))
-#define TLS_RL_RECORD_add_length(r, l)            ((r)->length += (l))
-#define TLS_RL_RECORD_set_data(r, d)              ((r)->data = (d))
-#define TLS_RL_RECORD_set_input(r, i)             ((r)->input = (i))
-#define TLS_RL_RECORD_reset_input(r)              ((r)->input = (r)->data)
-
+#define TLS_RL_RECORD_set_type(r, t) ((r)->type = (t))
+#define TLS_RL_RECORD_set_rec_version(r, v) ((r)->rec_version = (v))
+#define TLS_RL_RECORD_get_length(r) ((r)->length)
+#define TLS_RL_RECORD_set_length(r, l) ((r)->length = (l))
+#define TLS_RL_RECORD_add_length(r, l) ((r)->length += (l))
+#define TLS_RL_RECORD_set_data(r, d) ((r)->data = (d))
+#define TLS_RL_RECORD_set_input(r, i) ((r)->input = (i))
+#define TLS_RL_RECORD_reset_input(r) ((r)->input = (r)->data)
 
 /* Protocol version specific function pointers */
 struct record_functions_st {
@@ -98,14 +97,14 @@ struct record_functions_st {
      * alternative record layer.
      */
     int (*set_crypto_state)(OSSL_RECORD_LAYER *rl, int level,
-                            unsigned char *key, size_t keylen,
-                            unsigned char *iv, size_t ivlen,
-                            unsigned char *mackey, size_t mackeylen,
-                            const EVP_CIPHER *ciph,
-                            size_t taglen,
-                            int mactype,
-                            const EVP_MD *md,
-                            COMP_METHOD *comp);
+        unsigned char *key, size_t keylen,
+        unsigned char *iv, size_t ivlen,
+        unsigned char *mackey, size_t mackeylen,
+        const EVP_CIPHER *ciph,
+        size_t taglen,
+        int mactype,
+        const EVP_MD *md,
+        COMP_METHOD *comp);
 
     /*
      * Returns:
@@ -114,10 +113,10 @@ struct record_functions_st {
      *    1: Success or MtE decryption failed (MAC will be randomised)
      */
     int (*cipher)(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs, size_t n_recs,
-                  int sending, SSL_MAC_BUF *macs, size_t macsize);
+        int sending, SSL_MAC_BUF *macs, size_t macsize);
     /* Returns 1 for success or 0 for error */
     int (*mac)(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec, unsigned char *md,
-               int sending);
+        int sending);
 
     /* Return 1 for success or 0 for error */
     int (*set_protocol_version)(OSSL_RECORD_LAYER *rl, int version);
@@ -125,7 +124,7 @@ struct record_functions_st {
     /* Read related functions */
 
     int (*read_n)(OSSL_RECORD_LAYER *rl, size_t n, size_t max, int extend,
-                  int clearold, size_t *readbytes);
+        int clearold, size_t *readbytes);
 
     int (*get_more_records)(OSSL_RECORD_LAYER *rl);
 
@@ -138,16 +137,16 @@ struct record_functions_st {
     /* Write related functions */
 
     size_t (*get_max_records)(OSSL_RECORD_LAYER *rl, uint8_t type, size_t len,
-                              size_t maxfrag, size_t *preffrag);
+        size_t maxfrag, size_t *preffrag);
 
     /* Return 1 for success or 0 for error */
     int (*write_records)(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates,
-                         size_t numtempl);
+        size_t numtempl);
 
     /* Allocate the rl->wbuf buffers. Return 1 for success or 0 for error */
     int (*allocate_write_buffers)(OSSL_RECORD_LAYER *rl,
-                                  OSSL_RECORD_TEMPLATE *templates,
-                                  size_t numtempl, size_t *prefix);
+        OSSL_RECORD_TEMPLATE *templates,
+        size_t numtempl, size_t *prefix);
 
     /*
      * Initialise the packets in the |pkt| array using the buffers in |rl->wbuf|.
@@ -158,27 +157,27 @@ struct record_functions_st {
      * initialised. This must be 0 on entry and will be filled in even on error.
      */
     int (*initialise_write_packets)(OSSL_RECORD_LAYER *rl,
-                                    OSSL_RECORD_TEMPLATE *templates,
-                                    size_t numtempl,
-                                    OSSL_RECORD_TEMPLATE *prefixtempl,
-                                    WPACKET *pkt,
-                                    TLS_BUFFER *bufs,
-                                    size_t *wpinited);
+        OSSL_RECORD_TEMPLATE *templates,
+        size_t numtempl,
+        OSSL_RECORD_TEMPLATE *prefixtempl,
+        WPACKET *pkt,
+        TLS_BUFFER *bufs,
+        size_t *wpinited);
 
     /* Get the actual record type to be used for a given template */
     uint8_t (*get_record_type)(OSSL_RECORD_LAYER *rl,
-                               OSSL_RECORD_TEMPLATE *template);
+        OSSL_RECORD_TEMPLATE *template);
 
     /* Write the record header data to the WPACKET */
     int (*prepare_record_header)(OSSL_RECORD_LAYER *rl, WPACKET *thispkt,
-                                 OSSL_RECORD_TEMPLATE *templ,
-                                 uint8_t rectype,
-                                 unsigned char **recdata);
+        OSSL_RECORD_TEMPLATE *templ,
+        uint8_t rectype,
+        unsigned char **recdata);
 
     int (*add_record_padding)(OSSL_RECORD_LAYER *rl,
-                              OSSL_RECORD_TEMPLATE *thistempl,
-                              WPACKET *thispkt,
-                              TLS_RL_RECORD *thiswr);
+        OSSL_RECORD_TEMPLATE *thistempl,
+        WPACKET *thispkt,
+        TLS_RL_RECORD *thiswr);
 
     /*
      * This applies any mac that might be necessary, ensures that we have enough
@@ -186,19 +185,19 @@ struct record_functions_st {
      * TLS_RL_RECORD ready for that encryption.
      */
     int (*prepare_for_encryption)(OSSL_RECORD_LAYER *rl,
-                                  size_t mac_size,
-                                  WPACKET *thispkt,
-                                  TLS_RL_RECORD *thiswr);
+        size_t mac_size,
+        WPACKET *thispkt,
+        TLS_RL_RECORD *thiswr);
 
     /*
      * Any updates required to the record after encryption has been applied. For
      * example, adding a MAC if using encrypt-then-mac
      */
     int (*post_encryption_processing)(OSSL_RECORD_LAYER *rl,
-                                      size_t mac_size,
-                                      OSSL_RECORD_TEMPLATE *thistempl,
-                                      WPACKET *thispkt,
-                                      TLS_RL_RECORD *thiswr);
+        size_t mac_size,
+        OSSL_RECORD_TEMPLATE *thistempl,
+        WPACKET *thispkt,
+        TLS_RL_RECORD *thiswr);
 
     /*
      * Some record layer implementations need to do some custom preparation of
@@ -335,8 +334,8 @@ struct ossl_record_layer_st {
     int tlstree;
 
     /* TLSv1.3 fields */
-    unsigned char *iv;     /* static IV */
-    unsigned char *nonce;  /* part of static IV followed by sequence number */
+    unsigned char *iv; /* static IV */
+    unsigned char *nonce; /* part of static IV followed by sequence number */
     int allow_plain_alerts;
 
     /* TLS "any" fields */
@@ -387,47 +386,47 @@ extern const struct record_functions_st dtls_1_funcs;
 extern const struct record_functions_st dtls_any_funcs;
 
 void ossl_rlayer_fatal(OSSL_RECORD_LAYER *rl, int al, int reason,
-                       const char *fmt, ...);
+    const char *fmt, ...);
 
 #define RLAYERfatal(rl, al, r) RLAYERfatal_data((rl), (al), (r), NULL)
-#define RLAYERfatal_data                                           \
-    (ERR_new(),                                                    \
-     ERR_set_debug(OPENSSL_FILE, OPENSSL_LINE, OPENSSL_FUNC),      \
-     ossl_rlayer_fatal)
+#define RLAYERfatal_data                                         \
+    (ERR_new(),                                                  \
+        ERR_set_debug(OPENSSL_FILE, OPENSSL_LINE, OPENSSL_FUNC), \
+        ossl_rlayer_fatal)
 
 #define RLAYER_USE_EXPLICIT_IV(rl) ((rl)->version == TLS1_1_VERSION \
-                                    || (rl)->version == TLS1_2_VERSION \
-                                    || (rl)->version == DTLS1_BAD_VER \
-                                    || (rl)->version == DTLS1_VERSION \
-                                    || (rl)->version == DTLS1_2_VERSION)
+    || (rl)->version == TLS1_2_VERSION                              \
+    || (rl)->version == DTLS1_BAD_VER                               \
+    || (rl)->version == DTLS1_VERSION                               \
+    || (rl)->version == DTLS1_2_VERSION)
 
 void ossl_tls_rl_record_set_seq_num(TLS_RL_RECORD *r,
-                                    const unsigned char *seq_num);
+    const unsigned char *seq_num);
 
 int ossl_set_tls_provider_parameters(OSSL_RECORD_LAYER *rl,
-                                     EVP_CIPHER_CTX *ctx,
-                                     const EVP_CIPHER *ciph,
-                                     const EVP_MD *md);
+    EVP_CIPHER_CTX *ctx,
+    const EVP_CIPHER *ciph,
+    const EVP_MD *md);
 
 int tls_increment_sequence_ctr(OSSL_RECORD_LAYER *rl);
 int tls_alloc_buffers(OSSL_RECORD_LAYER *rl);
 int tls_free_buffers(OSSL_RECORD_LAYER *rl);
 
 int tls_default_read_n(OSSL_RECORD_LAYER *rl, size_t n, size_t max, int extend,
-                       int clearold, size_t *readbytes);
+    int clearold, size_t *readbytes);
 int tls_get_more_records(OSSL_RECORD_LAYER *rl);
 int dtls_get_more_records(OSSL_RECORD_LAYER *rl);
 
 int dtls_prepare_record_header(OSSL_RECORD_LAYER *rl,
-                               WPACKET *thispkt,
-                               OSSL_RECORD_TEMPLATE *templ,
-                               uint8_t rectype,
-                               unsigned char **recdata);
+    WPACKET *thispkt,
+    OSSL_RECORD_TEMPLATE *templ,
+    uint8_t rectype,
+    unsigned char **recdata);
 int dtls_post_encryption_processing(OSSL_RECORD_LAYER *rl,
-                                    size_t mac_size,
-                                    OSSL_RECORD_TEMPLATE *thistempl,
-                                    WPACKET *thispkt,
-                                    TLS_RL_RECORD *thiswr);
+    size_t mac_size,
+    OSSL_RECORD_TEMPLATE *thistempl,
+    WPACKET *thispkt,
+    TLS_RL_RECORD *thiswr);
 
 int tls_default_set_protocol_version(OSSL_RECORD_LAYER *rl, int version);
 int tls_default_validate_record_header(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *re);
@@ -436,29 +435,28 @@ int tls_do_uncompress(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec);
 int tls_default_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec);
 int tls13_common_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec);
 
-int
-tls_int_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
-                         int role, int direction, int level,
-                         const EVP_CIPHER *ciph, size_t taglen,
-                         const EVP_MD *md, COMP_METHOD *comp, BIO *prev,
-                         BIO *transport, BIO *next,
-                         const OSSL_PARAM *settings, const OSSL_PARAM *options,
-                         const OSSL_DISPATCH *fns, void *cbarg,
-                         OSSL_RECORD_LAYER **retrl);
+int tls_int_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
+    int role, int direction, int level,
+    const EVP_CIPHER *ciph, size_t taglen,
+    const EVP_MD *md, COMP_METHOD *comp, BIO *prev,
+    BIO *transport, BIO *next,
+    const OSSL_PARAM *settings, const OSSL_PARAM *options,
+    const OSSL_DISPATCH *fns, void *cbarg,
+    OSSL_RECORD_LAYER **retrl);
 int tls_free(OSSL_RECORD_LAYER *rl);
 int tls_unprocessed_read_pending(OSSL_RECORD_LAYER *rl);
 int tls_processed_read_pending(OSSL_RECORD_LAYER *rl);
 size_t tls_app_data_pending(OSSL_RECORD_LAYER *rl);
 size_t tls_get_max_records(OSSL_RECORD_LAYER *rl, uint8_t type, size_t len,
-                           size_t maxfrag, size_t *preffrag);
+    size_t maxfrag, size_t *preffrag);
 int tls_write_records(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates,
-                      size_t numtempl);
+    size_t numtempl);
 int tls_retry_write_records(OSSL_RECORD_LAYER *rl);
 int tls_get_alert_code(OSSL_RECORD_LAYER *rl);
 int tls_set1_bio(OSSL_RECORD_LAYER *rl, BIO *bio);
 int tls_read_record(OSSL_RECORD_LAYER *rl, void **rechandle, int *rversion,
-                    uint8_t *type, const unsigned char **data, size_t *datalen,
-                    uint16_t *epoch, unsigned char *seq_num);
+    uint8_t *type, const unsigned char **data, size_t *datalen,
+    uint16_t *epoch, unsigned char *seq_num);
 int tls_release_record(OSSL_RECORD_LAYER *rl, void *rechandle, size_t length);
 int tls_default_set_protocol_version(OSSL_RECORD_LAYER *rl, int version);
 int tls_set_protocol_version(OSSL_RECORD_LAYER *rl, int version);
@@ -466,74 +464,74 @@ void tls_set_plain_alerts(OSSL_RECORD_LAYER *rl, int allow);
 void tls_set_first_handshake(OSSL_RECORD_LAYER *rl, int first);
 void tls_set_max_pipelines(OSSL_RECORD_LAYER *rl, size_t max_pipelines);
 void tls_get_state(OSSL_RECORD_LAYER *rl, const char **shortstr,
-                   const char **longstr);
+    const char **longstr);
 int tls_set_options(OSSL_RECORD_LAYER *rl, const OSSL_PARAM *options);
 const COMP_METHOD *tls_get_compression(OSSL_RECORD_LAYER *rl);
 void tls_set_max_frag_len(OSSL_RECORD_LAYER *rl, size_t max_frag_len);
 int tls_setup_read_buffer(OSSL_RECORD_LAYER *rl);
 int tls_setup_write_buffer(OSSL_RECORD_LAYER *rl, size_t numwpipes,
-                           size_t firstlen, size_t nextlen);
+    size_t firstlen, size_t nextlen);
 
 int tls_write_records_multiblock(OSSL_RECORD_LAYER *rl,
-                                 OSSL_RECORD_TEMPLATE *templates,
-                                 size_t numtempl);
+    OSSL_RECORD_TEMPLATE *templates,
+    size_t numtempl);
 
 size_t tls_get_max_records_default(OSSL_RECORD_LAYER *rl, uint8_t type,
-                                   size_t len,
-                                   size_t maxfrag, size_t *preffrag);
+    size_t len,
+    size_t maxfrag, size_t *preffrag);
 size_t tls_get_max_records_multiblock(OSSL_RECORD_LAYER *rl, uint8_t type,
-                                      size_t len, size_t maxfrag,
-                                      size_t *preffrag);
+    size_t len, size_t maxfrag,
+    size_t *preffrag);
 int tls_allocate_write_buffers_default(OSSL_RECORD_LAYER *rl,
-                                       OSSL_RECORD_TEMPLATE *templates,
-                                       size_t numtempl, size_t *prefix);
+    OSSL_RECORD_TEMPLATE *templates,
+    size_t numtempl, size_t *prefix);
 int tls_initialise_write_packets_default(OSSL_RECORD_LAYER *rl,
-                                         OSSL_RECORD_TEMPLATE *templates,
-                                         size_t numtempl,
-                                         OSSL_RECORD_TEMPLATE *prefixtempl,
-                                         WPACKET *pkt,
-                                         TLS_BUFFER *bufs,
-                                         size_t *wpinited);
+    OSSL_RECORD_TEMPLATE *templates,
+    size_t numtempl,
+    OSSL_RECORD_TEMPLATE *prefixtempl,
+    WPACKET *pkt,
+    TLS_BUFFER *bufs,
+    size_t *wpinited);
 int tls1_allocate_write_buffers(OSSL_RECORD_LAYER *rl,
-                                OSSL_RECORD_TEMPLATE *templates,
-                                size_t numtempl, size_t *prefix);
+    OSSL_RECORD_TEMPLATE *templates,
+    size_t numtempl, size_t *prefix);
 int tls1_initialise_write_packets(OSSL_RECORD_LAYER *rl,
-                                  OSSL_RECORD_TEMPLATE *templates,
-                                  size_t numtempl,
-                                  OSSL_RECORD_TEMPLATE *prefixtempl,
-                                  WPACKET *pkt,
-                                  TLS_BUFFER *bufs,
-                                  size_t *wpinited);
+    OSSL_RECORD_TEMPLATE *templates,
+    size_t numtempl,
+    OSSL_RECORD_TEMPLATE *prefixtempl,
+    WPACKET *pkt,
+    TLS_BUFFER *bufs,
+    size_t *wpinited);
 int tls_prepare_record_header_default(OSSL_RECORD_LAYER *rl,
-                                      WPACKET *thispkt,
-                                      OSSL_RECORD_TEMPLATE *templ,
-                                      uint8_t rectype,
-                                      unsigned char **recdata);
+    WPACKET *thispkt,
+    OSSL_RECORD_TEMPLATE *templ,
+    uint8_t rectype,
+    unsigned char **recdata);
 int tls_prepare_for_encryption_default(OSSL_RECORD_LAYER *rl,
-                                       size_t mac_size,
-                                       WPACKET *thispkt,
-                                       TLS_RL_RECORD *thiswr);
+    size_t mac_size,
+    WPACKET *thispkt,
+    TLS_RL_RECORD *thiswr);
 int tls_post_encryption_processing_default(OSSL_RECORD_LAYER *rl,
-                                           size_t mac_size,
-                                           OSSL_RECORD_TEMPLATE *thistempl,
-                                           WPACKET *thispkt,
-                                           TLS_RL_RECORD *thiswr);
+    size_t mac_size,
+    OSSL_RECORD_TEMPLATE *thistempl,
+    WPACKET *thispkt,
+    TLS_RL_RECORD *thiswr);
 int tls_write_records_default(OSSL_RECORD_LAYER *rl,
-                              OSSL_RECORD_TEMPLATE *templates,
-                              size_t numtempl);
+    OSSL_RECORD_TEMPLATE *templates,
+    size_t numtempl);
 
 /* Macros/functions provided by the TLS_BUFFER component */
 
-#define TLS_BUFFER_get_buf(b)              ((b)->buf)
-#define TLS_BUFFER_set_buf(b, n)           ((b)->buf = (n))
-#define TLS_BUFFER_get_len(b)              ((b)->len)
-#define TLS_BUFFER_get_left(b)             ((b)->left)
-#define TLS_BUFFER_set_left(b, l)          ((b)->left = (l))
-#define TLS_BUFFER_sub_left(b, l)          ((b)->left -= (l))
-#define TLS_BUFFER_get_offset(b)           ((b)->offset)
-#define TLS_BUFFER_set_offset(b, o)        ((b)->offset = (o))
-#define TLS_BUFFER_add_offset(b, o)        ((b)->offset += (o))
-#define TLS_BUFFER_set_app_buffer(b, l)    ((b)->app_buffer = (l))
-#define TLS_BUFFER_is_app_buffer(b)        ((b)->app_buffer)
+#define TLS_BUFFER_get_buf(b) ((b)->buf)
+#define TLS_BUFFER_set_buf(b, n) ((b)->buf = (n))
+#define TLS_BUFFER_get_len(b) ((b)->len)
+#define TLS_BUFFER_get_left(b) ((b)->left)
+#define TLS_BUFFER_set_left(b, l) ((b)->left = (l))
+#define TLS_BUFFER_sub_left(b, l) ((b)->left -= (l))
+#define TLS_BUFFER_get_offset(b) ((b)->offset)
+#define TLS_BUFFER_set_offset(b, o) ((b)->offset = (o))
+#define TLS_BUFFER_add_offset(b, o) ((b)->offset += (o))
+#define TLS_BUFFER_set_app_buffer(b, l) ((b)->app_buffer = (l))
+#define TLS_BUFFER_is_app_buffer(b) ((b)->app_buffer)
 
 void ossl_tls_buffer_release(TLS_BUFFER *b);
diff --git a/crypto/openssl/ssl/record/methods/ssl3_cbc.c b/crypto/openssl/ssl/record/methods/ssl3_cbc.c
index a8282989ed39..48be4885bbb8 100644
--- a/crypto/openssl/ssl/record/methods/ssl3_cbc.c
+++ b/crypto/openssl/ssl/record/methods/ssl3_cbc.c
@@ -24,7 +24,7 @@
 
 #include <openssl/evp.h>
 #ifndef FIPS_MODULE
-# include <openssl/md5.h>
+#include <openssl/md5.h>
 #endif
 #include <openssl/sha.h>
 
@@ -50,11 +50,11 @@
  * u32toLE serializes an unsigned, 32-bit number (n) as four bytes at (p) in
  * little-endian order. The value of p is advanced by four.
  */
-# define u32toLE(n, p) \
-         (*((p)++) = (unsigned char)(n      ), \
-          *((p)++) = (unsigned char)(n >>  8), \
-          *((p)++) = (unsigned char)(n >> 16), \
-          *((p)++) = (unsigned char)(n >> 24))
+#define u32toLE(n, p)                        \
+    (*((p)++) = (unsigned char)(n),          \
+        *((p)++) = (unsigned char)(n >> 8),  \
+        *((p)++) = (unsigned char)(n >> 16), \
+        *((p)++) = (unsigned char)(n >> 24))
 
 /*
  * These functions serialize the state of a hash and thus perform the
@@ -101,7 +101,7 @@ static void tls1_sha512_final_raw(void *ctx, unsigned char *md_out)
         l2n8(sha512->h[i], md_out);
 }
 
-#undef  LARGEST_DIGEST_CTX
+#undef LARGEST_DIGEST_CTX
 #define LARGEST_DIGEST_CTX SHA512_CTX
 
 /*-
@@ -124,26 +124,26 @@ static void tls1_sha512_final_raw(void *ctx, unsigned char *md_out)
  * Returns 1 on success or 0 on error
  */
 int ssl3_cbc_digest_record(const EVP_MD *md,
-                           unsigned char *md_out,
-                           size_t *md_out_size,
-                           const unsigned char *header,
-                           const unsigned char *data,
-                           size_t data_size,
-                           size_t data_plus_mac_plus_padding_size,
-                           const unsigned char *mac_secret,
-                           size_t mac_secret_length, char is_sslv3)
+    unsigned char *md_out,
+    size_t *md_out_size,
+    const unsigned char *header,
+    const unsigned char *data,
+    size_t data_size,
+    size_t data_plus_mac_plus_padding_size,
+    const unsigned char *mac_secret,
+    size_t mac_secret_length, char is_sslv3)
 {
     union {
         OSSL_UNION_ALIGN;
         unsigned char c[sizeof(LARGEST_DIGEST_CTX)];
     } md_state;
-    void (*md_final_raw) (void *ctx, unsigned char *md_out);
-    void (*md_transform) (void *ctx, const unsigned char *block);
+    void (*md_final_raw)(void *ctx, unsigned char *md_out);
+    void (*md_transform)(void *ctx, const unsigned char *block);
     size_t md_size, md_block_size = 64;
     size_t sslv3_pad_length = 40, header_length, variance_blocks,
-        len, max_mac_bytes, num_blocks,
-        num_starting_blocks, k, mac_end_offset, c, index_a, index_b;
-    size_t bits;          /* at most 18 bits */
+           len, max_mac_bytes, num_blocks,
+           num_starting_blocks, k, mac_end_offset, c, index_a, index_b;
+    size_t bits; /* at most 18 bits */
     unsigned char length_bytes[MAX_HASH_BIT_COUNT_BYTES];
     /* hmac_pad is the masked HMAC key. */
     unsigned char hmac_pad[MAX_HASH_BLOCK_SIZE];
@@ -174,8 +174,7 @@ int ssl3_cbc_digest_record(const EVP_MD *md,
         if (MD5_Init((MD5_CTX *)md_state.c) <= 0)
             return 0;
         md_final_raw = tls1_md5_final_raw;
-        md_transform =
-            (void (*)(void *ctx, const unsigned char *block))MD5_Transform;
+        md_transform = (void (*)(void *ctx, const unsigned char *block))MD5_Transform;
         md_size = 16;
         sslv3_pad_length = 48;
         length_is_big_endian = 0;
@@ -184,29 +183,25 @@ int ssl3_cbc_digest_record(const EVP_MD *md,
         if (SHA1_Init((SHA_CTX *)md_state.c) <= 0)
             return 0;
         md_final_raw = tls1_sha1_final_raw;
-        md_transform =
-            (void (*)(void *ctx, const unsigned char *block))SHA1_Transform;
+        md_transform = (void (*)(void *ctx, const unsigned char *block))SHA1_Transform;
         md_size = 20;
     } else if (EVP_MD_is_a(md, "SHA2-224")) {
         if (SHA224_Init((SHA256_CTX *)md_state.c) <= 0)
             return 0;
         md_final_raw = tls1_sha256_final_raw;
-        md_transform =
-            (void (*)(void *ctx, const unsigned char *block))SHA256_Transform;
+        md_transform = (void (*)(void *ctx, const unsigned char *block))SHA256_Transform;
         md_size = 224 / 8;
     } else if (EVP_MD_is_a(md, "SHA2-256")) {
         if (SHA256_Init((SHA256_CTX *)md_state.c) <= 0)
             return 0;
         md_final_raw = tls1_sha256_final_raw;
-        md_transform =
-            (void (*)(void *ctx, const unsigned char *block))SHA256_Transform;
+        md_transform = (void (*)(void *ctx, const unsigned char *block))SHA256_Transform;
         md_size = 32;
     } else if (EVP_MD_is_a(md, "SHA2-384")) {
         if (SHA384_Init((SHA512_CTX *)md_state.c) <= 0)
             return 0;
         md_final_raw = tls1_sha512_final_raw;
-        md_transform =
-            (void (*)(void *ctx, const unsigned char *block))SHA512_Transform;
+        md_transform = (void (*)(void *ctx, const unsigned char *block))SHA512_Transform;
         md_size = 384 / 8;
         md_block_size = 128;
         md_length_size = 16;
@@ -214,8 +209,7 @@ int ssl3_cbc_digest_record(const EVP_MD *md,
         if (SHA512_Init((SHA512_CTX *)md_state.c) <= 0)
             return 0;
         md_final_raw = tls1_sha512_final_raw;
-        md_transform =
-            (void (*)(void *ctx, const unsigned char *block))SHA512_Transform;
+        md_transform = (void (*)(void *ctx, const unsigned char *block))SHA512_Transform;
         md_size = 64;
         md_block_size = 128;
         md_length_size = 16;
@@ -230,17 +224,17 @@ int ssl3_cbc_digest_record(const EVP_MD *md,
     }
 
     if (!ossl_assert(md_length_size <= MAX_HASH_BIT_COUNT_BYTES)
-            || !ossl_assert(md_block_size <= MAX_HASH_BLOCK_SIZE)
-            || !ossl_assert(md_size <= EVP_MAX_MD_SIZE))
+        || !ossl_assert(md_block_size <= MAX_HASH_BLOCK_SIZE)
+        || !ossl_assert(md_size <= EVP_MAX_MD_SIZE))
         return 0;
 
     header_length = 13;
     if (is_sslv3) {
         header_length = mac_secret_length
-                        + sslv3_pad_length
-                        + 8  /* sequence number */
-                        + 1  /* record type */
-                        + 2; /* record length */
+            + sslv3_pad_length
+            + 8 /* sequence number */
+            + 1 /* record type */
+            + 2; /* record length */
     }
 
     /*
@@ -260,7 +254,8 @@ int ssl3_cbc_digest_record(const EVP_MD *md,
      */
     variance_blocks = is_sslv3 ? 2
                                : (((255 + 1 + md_size + md_block_size - 1)
-                                   / md_block_size) + 1);
+                                      / md_block_size)
+                                     + 1);
     /*
      * From now on we're dealing with the MAC, which conceptually has 13
      * bytes of `header' before the start of the data (TLS) or 71/75 bytes
@@ -273,9 +268,7 @@ int ssl3_cbc_digest_record(const EVP_MD *md,
      */
     max_mac_bytes = len - md_size - 1;
     /* num_blocks is the maximum number of hash blocks. */
-    num_blocks =
-        (max_mac_bytes + 1 + md_length_size + md_block_size -
-         1) / md_block_size;
+    num_blocks = (max_mac_bytes + 1 + md_length_size + md_block_size - 1) / md_block_size;
     /*
      * In order to calculate the MAC in constant time we have to handle the
      * final blocks specially because the padding value could cause the end
@@ -398,7 +391,7 @@ int ssl3_cbc_digest_record(const EVP_MD *md,
      * constant time, to |mac_out|.
      */
     for (i = num_starting_blocks; i <= num_starting_blocks + variance_blocks;
-         i++) {
+        i++) {
         unsigned char block[MAX_HASH_BLOCK_SIZE];
         unsigned char is_block_a = constant_time_eq_8_s(i, index_a);
         unsigned char is_block_b = constant_time_eq_8_s(i, index_b);
@@ -438,9 +431,7 @@ int ssl3_cbc_digest_record(const EVP_MD *md,
             if (j >= md_block_size - md_length_size) {
                 /* If this is index_b, write a length byte. */
                 b = constant_time_select_8(is_block_b,
-                                           length_bytes[j -
-                                                        (md_block_size -
-                                                         md_length_size)], b);
+                    length_bytes[j - (md_block_size - md_length_size)], b);
             }
             block[j] = b;
         }
@@ -480,7 +471,7 @@ int ssl3_cbc_digest_record(const EVP_MD *md,
         *md_out_size = md_out_size_u;
 
     ret = 1;
- err:
+err:
     EVP_MD_CTX_free(md_ctx);
     return ret;
 }
diff --git a/crypto/openssl/ssl/record/methods/ssl3_meth.c b/crypto/openssl/ssl/record/methods/ssl3_meth.c
index 6b5a1bed23eb..3f28346027e3 100644
--- a/crypto/openssl/ssl/record/methods/ssl3_meth.c
+++ b/crypto/openssl/ssl/record/methods/ssl3_meth.c
@@ -15,14 +15,14 @@
 #include "recmethod_local.h"
 
 static int ssl3_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
-                                 unsigned char *key, size_t keylen,
-                                 unsigned char *iv, size_t ivlen,
-                                 unsigned char *mackey, size_t mackeylen,
-                                 const EVP_CIPHER *ciph,
-                                 size_t taglen,
-                                 int mactype,
-                                 const EVP_MD *md,
-                                 COMP_METHOD *comp)
+    unsigned char *key, size_t keylen,
+    unsigned char *iv, size_t ivlen,
+    unsigned char *mackey, size_t mackeylen,
+    const EVP_CIPHER *ciph,
+    size_t taglen,
+    int mactype,
+    const EVP_MD *md,
+    COMP_METHOD *comp)
 {
     EVP_CIPHER_CTX *ciph_ctx;
     int enc = (rl->direction == OSSL_RECORD_DIRECTION_WRITE) ? 1 : 0;
@@ -69,7 +69,7 @@ static int ssl3_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
      * different to that in ciph if we have an ENGINE in use
      */
     if (EVP_CIPHER_get0_provider(EVP_CIPHER_CTX_get0_cipher(ciph_ctx)) != NULL
-            && !ossl_set_tls_provider_parameters(rl, ciph_ctx, ciph, md)) {
+        && !ossl_set_tls_provider_parameters(rl, ciph_ctx, ciph, md)) {
         /* ERR_raise already called */
         return OSSL_RECORD_RETURN_FATAL;
     }
@@ -93,8 +93,8 @@ static int ssl3_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
  *    1: Success or Mac-then-encrypt decryption failed (MAC will be randomised)
  */
 static int ssl3_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *inrecs,
-                       size_t n_recs, int sending, SSL_MAC_BUF *mac,
-                       size_t macsize)
+    size_t n_recs, int sending, SSL_MAC_BUF *mac,
+    size_t macsize)
 {
     TLS_RL_RECORD *rec;
     EVP_CIPHER_CTX *ds;
@@ -154,7 +154,7 @@ static int ssl3_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *inrecs,
         int outlen;
 
         if (!EVP_CipherUpdate(ds, rec->data, &outlen, rec->input,
-                              (unsigned int)l))
+                (unsigned int)l))
             return 0;
         rec->length = outlen;
 
@@ -166,8 +166,8 @@ static int ssl3_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *inrecs,
             mac->alloced = 0;
 
             *p++ = OSSL_PARAM_construct_octet_ptr(OSSL_CIPHER_PARAM_TLS_MAC,
-                                                  (void **)&mac->mac,
-                                                  macsize);
+                (void **)&mac->mac,
+                macsize);
             *p = OSSL_PARAM_construct_end();
 
             if (!EVP_CIPHER_CTX_get_params(ds, params)) {
@@ -185,13 +185,13 @@ static int ssl3_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *inrecs,
 
         if (!sending)
             return ssl3_cbc_remove_padding_and_mac(&rec->length,
-                                        rec->orig_len,
-                                        rec->data,
-                                        (mac != NULL) ? &mac->mac : NULL,
-                                        (mac != NULL) ? &mac->alloced : NULL,
-                                        bs,
-                                        macsize,
-                                        rl->libctx);
+                rec->orig_len,
+                rec->data,
+                (mac != NULL) ? &mac->mac : NULL,
+                (mac != NULL) ? &mac->alloced : NULL,
+                bs,
+                macsize,
+                rl->libctx);
     }
 
     return 1;
@@ -216,7 +216,7 @@ static const unsigned char ssl3_pad_2[48] = {
 };
 
 static int ssl3_mac(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec, unsigned char *md,
-                    int sending)
+    int sending)
 {
     unsigned char *mac_sec, *seq = rl->sequence;
     const EVP_MD_CTX *hash;
@@ -268,10 +268,11 @@ static int ssl3_mac(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec, unsigned char *md
 
         /* Final param == is SSLv3 */
         if (ssl3_cbc_digest_record(EVP_MD_CTX_get0_md(hash),
-                                   md, &md_size,
-                                   header, rec->input,
-                                   rec->length, rec->orig_len,
-                                   mac_sec, md_size, 1) <= 0)
+                md, &md_size,
+                header, rec->input,
+                rec->length, rec->orig_len,
+                mac_sec, md_size, 1)
+            <= 0)
             return 0;
 #endif
     } else {
diff --git a/crypto/openssl/ssl/record/methods/tls13_meth.c b/crypto/openssl/ssl/record/methods/tls13_meth.c
index 6bbba84d0d89..f35e0a5b4a31 100644
--- a/crypto/openssl/ssl/record/methods/tls13_meth.c
+++ b/crypto/openssl/ssl/record/methods/tls13_meth.c
@@ -14,14 +14,14 @@
 #include "recmethod_local.h"
 
 static int tls13_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
-                                  unsigned char *key, size_t keylen,
-                                  unsigned char *iv, size_t ivlen,
-                                  unsigned char *mackey, size_t mackeylen,
-                                  const EVP_CIPHER *ciph,
-                                  size_t taglen,
-                                  int mactype,
-                                  const EVP_MD *md,
-                                  COMP_METHOD *comp)
+    unsigned char *key, size_t keylen,
+    unsigned char *iv, size_t ivlen,
+    unsigned char *mackey, size_t mackeylen,
+    const EVP_CIPHER *ciph,
+    size_t taglen,
+    int mactype,
+    const EVP_MD *md,
+    COMP_METHOD *comp)
 {
     EVP_CIPHER_CTX *ciph_ctx;
     EVP_MAC_CTX *mac_ctx;
@@ -51,7 +51,7 @@ static int tls13_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
         }
         EVP_MAC_free(mac);
         *p++ = OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST,
-                                                (char *)EVP_MD_name(md), 0);
+            (char *)EVP_MD_name(md), 0);
         *p = OSSL_PARAM_construct_end();
         if (!EVP_MAC_init(mac_ctx, key, keylen, params)) {
             ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
@@ -70,21 +70,23 @@ static int tls13_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
 
     if (EVP_CipherInit_ex(ciph_ctx, ciph, NULL, NULL, NULL, enc) <= 0
         || EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_IVLEN, ivlen,
-                               NULL) <= 0
+               NULL)
+            <= 0
         || (mode == EVP_CIPH_CCM_MODE
             && EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_TAG, taglen,
-                                   NULL) <= 0)
+                   NULL)
+                <= 0)
         || EVP_CipherInit_ex(ciph_ctx, NULL, NULL, key, NULL, enc) <= 0) {
         ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
         return OSSL_RECORD_RETURN_FATAL;
     }
- end:
+end:
     return OSSL_RECORD_RETURN_SUCCESS;
 }
 
 static int tls13_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
-                        size_t n_recs, int sending, SSL_MAC_BUF *mac,
-                        size_t macsize)
+    size_t n_recs, int sending, SSL_MAC_BUF *mac,
+    size_t macsize)
 {
     EVP_CIPHER_CTX *enc_ctx;
     unsigned char recheader[SSL3_RT_HEADER_LENGTH];
@@ -169,12 +171,12 @@ static int tls13_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
 
     /* Set up the AAD */
     if (!WPACKET_init_static_len(&wpkt, recheader, sizeof(recheader), 0)
-            || !WPACKET_put_bytes_u8(&wpkt, rec->type)
-            || !WPACKET_put_bytes_u16(&wpkt, rec->rec_version)
-            || !WPACKET_put_bytes_u16(&wpkt, rec->length + rl->taglen)
-            || !WPACKET_get_total_written(&wpkt, &hdrlen)
-            || hdrlen != SSL3_RT_HEADER_LENGTH
-            || !WPACKET_finish(&wpkt)) {
+        || !WPACKET_put_bytes_u8(&wpkt, rec->type)
+        || !WPACKET_put_bytes_u16(&wpkt, rec->rec_version)
+        || !WPACKET_put_bytes_u16(&wpkt, rec->length + rl->taglen)
+        || !WPACKET_get_total_written(&wpkt, &hdrlen)
+        || hdrlen != SSL3_RT_HEADER_LENGTH
+        || !WPACKET_finish(&wpkt)) {
         RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         WPACKET_cleanup(&wpkt);
         return 0;
@@ -196,7 +198,8 @@ static int tls13_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
             memcpy(rec->data + rec->length, tag, rl->taglen);
             rec->length += rl->taglen;
         } else if (CRYPTO_memcmp(tag, rec->data + rec->length,
-                                 rl->taglen) != 0) {
+                       rl->taglen)
+            != 0) {
             goto end_mac;
         }
         ret = 1;
@@ -213,9 +216,7 @@ static int tls13_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
     mode = EVP_CIPHER_get_mode(cipher);
 
     if (EVP_CipherInit_ex(enc_ctx, NULL, NULL, NULL, nonce, sending) <= 0
-        || (!sending && EVP_CIPHER_CTX_ctrl(enc_ctx, EVP_CTRL_AEAD_SET_TAG,
-                                            rl->taglen,
-                                            rec->data + rec->length) <= 0)) {
+        || (!sending && EVP_CIPHER_CTX_ctrl(enc_ctx, EVP_CTRL_AEAD_SET_TAG, rl->taglen, rec->data + rec->length) <= 0)) {
         RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
@@ -225,20 +226,24 @@ static int tls13_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
      * any AAD.
      */
     if ((mode == EVP_CIPH_CCM_MODE
-                 && EVP_CipherUpdate(enc_ctx, NULL, &lenu, NULL,
-                                     (unsigned int)rec->length) <= 0)
-            || EVP_CipherUpdate(enc_ctx, NULL, &lenu, recheader,
-                                sizeof(recheader)) <= 0
-            || EVP_CipherUpdate(enc_ctx, rec->data, &lenu, rec->input,
-                                (unsigned int)rec->length) <= 0
-            || EVP_CipherFinal_ex(enc_ctx, rec->data + lenu, &lenf) <= 0
-            || (size_t)(lenu + lenf) != rec->length) {
+            && EVP_CipherUpdate(enc_ctx, NULL, &lenu, NULL,
+                   (unsigned int)rec->length)
+                <= 0)
+        || EVP_CipherUpdate(enc_ctx, NULL, &lenu, recheader,
+               sizeof(recheader))
+            <= 0
+        || EVP_CipherUpdate(enc_ctx, rec->data, &lenu, rec->input,
+               (unsigned int)rec->length)
+            <= 0
+        || EVP_CipherFinal_ex(enc_ctx, rec->data + lenu, &lenf) <= 0
+        || (size_t)(lenu + lenf) != rec->length) {
         return 0;
     }
     if (sending) {
         /* Add the tag */
         if (EVP_CIPHER_CTX_ctrl(enc_ctx, EVP_CTRL_AEAD_GET_TAG, rl->taglen,
-                                rec->data + rec->length) <= 0) {
+                rec->data + rec->length)
+            <= 0) {
             RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return 0;
         }
@@ -249,12 +254,12 @@ static int tls13_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
 }
 
 static int tls13_validate_record_header(OSSL_RECORD_LAYER *rl,
-                                        TLS_RL_RECORD *rec)
+    TLS_RL_RECORD *rec)
 {
     if (rec->type != SSL3_RT_APPLICATION_DATA
-            && (rec->type != SSL3_RT_CHANGE_CIPHER_SPEC
-                || !rl->is_first_handshake)
-            && (rec->type != SSL3_RT_ALERT || !rl->allow_plain_alerts)) {
+        && (rec->type != SSL3_RT_CHANGE_CIPHER_SPEC
+            || !rl->is_first_handshake)
+        && (rec->type != SSL3_RT_ALERT || !rl->allow_plain_alerts)) {
         RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_BAD_RECORD_TYPE);
         return 0;
     }
@@ -266,7 +271,7 @@ static int tls13_validate_record_header(OSSL_RECORD_LAYER *rl,
 
     if (rec->length > SSL3_RT_MAX_TLS13_ENCRYPTED_LENGTH) {
         RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW,
-                    SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
+            SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
         return 0;
     }
     return 1;
@@ -279,9 +284,9 @@ static int tls13_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec)
         size_t end;
 
         if (rec->length == 0
-                || rec->type != SSL3_RT_APPLICATION_DATA) {
+            || rec->type != SSL3_RT_APPLICATION_DATA) {
             RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE,
-                        SSL_R_BAD_RECORD_TYPE);
+                SSL_R_BAD_RECORD_TYPE);
             return 0;
         }
 
@@ -307,7 +312,7 @@ static int tls13_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec)
 }
 
 static uint8_t tls13_get_record_type(OSSL_RECORD_LAYER *rl,
-                                     OSSL_RECORD_TEMPLATE *template)
+    OSSL_RECORD_TEMPLATE *template)
 {
     if (rl->allow_plain_alerts && template->type == SSL3_RT_ALERT)
         return SSL3_RT_ALERT;
@@ -321,9 +326,9 @@ static uint8_t tls13_get_record_type(OSSL_RECORD_LAYER *rl,
 }
 
 static int tls13_add_record_padding(OSSL_RECORD_LAYER *rl,
-                                    OSSL_RECORD_TEMPLATE *thistempl,
-                                    WPACKET *thispkt,
-                                    TLS_RL_RECORD *thiswr)
+    OSSL_RECORD_TEMPLATE *thistempl,
+    WPACKET *thispkt,
+    TLS_RL_RECORD *thiswr)
 {
     size_t rlen;
 
@@ -353,7 +358,7 @@ static int tls13_add_record_padding(OSSL_RECORD_LAYER *rl,
          * a change that could break some application that has
          * a client and server that both know what padding they
          * like, and that dislike any other padding. That'd need
-         * one of those to have been updated though so the 
+         * one of those to have been updated though so the
          * probability may be low enough that we could change
          * the "else if" below to just an "if" and pick the
          * larger of the library and callback's idea of padding.
@@ -373,7 +378,7 @@ static int tls13_add_record_padding(OSSL_RECORD_LAYER *rl,
             else if (thistempl->type == SSL3_RT_ALERT && rl->hs_padding > 0)
                 bp = rl->hs_padding;
             else if (thistempl->type == SSL3_RT_APPLICATION_DATA
-                     && rl->block_padding > 0)
+                && rl->block_padding > 0)
                 bp = rl->block_padding;
             if (bp > 0) {
                 mask = bp - 1;
@@ -395,7 +400,7 @@ static int tls13_add_record_padding(OSSL_RECORD_LAYER *rl,
                 padding = max_padding;
             if (!WPACKET_memset(thispkt, 0, padding)) {
                 RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR,
-                            ERR_R_INTERNAL_ERROR);
+                    ERR_R_INTERNAL_ERROR);
                 return 0;
             }
             TLS_RL_RECORD_add_length(thiswr, padding);
diff --git a/crypto/openssl/ssl/record/methods/tls1_meth.c b/crypto/openssl/ssl/record/methods/tls1_meth.c
index 9275e19fbd3f..ed4a436dffc1 100644
--- a/crypto/openssl/ssl/record/methods/tls1_meth.c
+++ b/crypto/openssl/ssl/record/methods/tls1_meth.c
@@ -17,14 +17,14 @@
 #include "recmethod_local.h"
 
 static int tls1_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
-                                 unsigned char *key, size_t keylen,
-                                 unsigned char *iv, size_t ivlen,
-                                 unsigned char *mackey, size_t mackeylen,
-                                 const EVP_CIPHER *ciph,
-                                 size_t taglen,
-                                 int mactype,
-                                 const EVP_MD *md,
-                                 COMP_METHOD *comp)
+    unsigned char *key, size_t keylen,
+    unsigned char *iv, size_t ivlen,
+    unsigned char *mackey, size_t mackeylen,
+    const EVP_CIPHER *ciph,
+    size_t taglen,
+    int mactype,
+    const EVP_MD *md,
+    COMP_METHOD *comp)
 {
     EVP_CIPHER_CTX *ciph_ctx;
     EVP_PKEY *mac_key;
@@ -62,8 +62,8 @@ static int tls1_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
     if ((EVP_CIPHER_get_flags(ciph) & EVP_CIPH_FLAG_AEAD_CIPHER) == 0) {
         if (mactype == EVP_PKEY_HMAC) {
             mac_key = EVP_PKEY_new_raw_private_key_ex(rl->libctx, "HMAC",
-                                                      rl->propq, mackey,
-                                                      mackeylen);
+                rl->propq, mackey,
+                mackeylen);
         } else {
             /*
              * If its not HMAC then the only other types of MAC we support are
@@ -71,12 +71,13 @@ static int tls1_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
              * a MAC key.
              */
             mac_key = EVP_PKEY_new_mac_key(mactype, NULL, mackey,
-                                           (int)mackeylen);
+                (int)mackeylen);
         }
         if (mac_key == NULL
             || EVP_DigestSignInit_ex(rl->md_ctx, NULL, EVP_MD_get0_name(md),
-                                     rl->libctx, rl->propq, mac_key,
-                                     NULL) <= 0) {
+                   rl->libctx, rl->propq, mac_key,
+                   NULL)
+                <= 0) {
             EVP_PKEY_free(mac_key);
             ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
             return OSSL_RECORD_RETURN_FATAL;
@@ -86,20 +87,24 @@ static int tls1_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
 
     if (EVP_CIPHER_get_mode(ciph) == EVP_CIPH_GCM_MODE) {
         if (!EVP_CipherInit_ex(ciph_ctx, ciph, NULL, key, NULL, enc)
-                || EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_GCM_SET_IV_FIXED,
-                                       (int)ivlen, iv) <= 0) {
+            || EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_GCM_SET_IV_FIXED,
+                   (int)ivlen, iv)
+                <= 0) {
             ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
             return OSSL_RECORD_RETURN_FATAL;
         }
     } else if (EVP_CIPHER_get_mode(ciph) == EVP_CIPH_CCM_MODE) {
         if (!EVP_CipherInit_ex(ciph_ctx, ciph, NULL, NULL, NULL, enc)
-                || EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_IVLEN, 12,
-                                       NULL) <= 0
-                || EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_TAG,
-                                       (int)taglen, NULL) <= 0
-                || EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_CCM_SET_IV_FIXED,
-                                       (int)ivlen, iv) <= 0
-                || !EVP_CipherInit_ex(ciph_ctx, NULL, NULL, key, NULL, enc)) {
+            || EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_IVLEN, 12,
+                   NULL)
+                <= 0
+            || EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_TAG,
+                   (int)taglen, NULL)
+                <= 0
+            || EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_CCM_SET_IV_FIXED,
+                   (int)ivlen, iv)
+                <= 0
+            || !EVP_CipherInit_ex(ciph_ctx, NULL, NULL, key, NULL, enc)) {
             ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
             return OSSL_RECORD_RETURN_FATAL;
         }
@@ -113,7 +118,8 @@ static int tls1_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
     if ((EVP_CIPHER_get_flags(ciph) & EVP_CIPH_FLAG_AEAD_CIPHER) != 0
         && mackeylen != 0
         && EVP_CIPHER_CTX_ctrl(ciph_ctx, EVP_CTRL_AEAD_SET_MAC_KEY,
-                               (int)mackeylen, mackey) <= 0) {
+               (int)mackeylen, mackey)
+            <= 0) {
         ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
         return OSSL_RECORD_RETURN_FATAL;
     }
@@ -123,7 +129,7 @@ static int tls1_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
      * different to that in ciph if we have an ENGINE in use
      */
     if (EVP_CIPHER_get0_provider(EVP_CIPHER_CTX_get0_cipher(ciph_ctx)) != NULL
-            && !ossl_set_tls_provider_parameters(rl, ciph_ctx, ciph, md)) {
+        && !ossl_set_tls_provider_parameters(rl, ciph_ctx, ciph, md)) {
         /* ERR_raise already called */
         return OSSL_RECORD_RETURN_FATAL;
     }
@@ -165,8 +171,8 @@ static int tls1_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
  *    1: Success or Mac-then-encrypt decryption failed (MAC will be randomised)
  */
 static int tls1_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
-                       size_t n_recs, int sending, SSL_MAC_BUF *macs,
-                       size_t macsize)
+    size_t n_recs, int sending, SSL_MAC_BUF *macs,
+    size_t macsize)
 {
     EVP_CIPHER_CTX *ds;
     size_t reclen[SSL_MAX_PIPELINES];
@@ -213,7 +219,8 @@ static int tls1_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
                     RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                     return 0;
                 } else if (RAND_bytes_ex(rl->libctx, recs[ctr].input,
-                                         ivlen, 0) <= 0) {
+                               ivlen, 0)
+                    <= 0) {
                     RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                     return 0;
                 }
@@ -236,7 +243,8 @@ static int tls1_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
 
     if (n_recs > 1) {
         if ((EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(ds))
-                 & EVP_CIPH_FLAG_PIPELINE) == 0) {
+                & EVP_CIPH_FLAG_PIPELINE)
+            == 0) {
             /*
              * We shouldn't have been called with pipeline data if the
              * cipher doesn't support pipelining
@@ -249,7 +257,8 @@ static int tls1_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
         reclen[ctr] = recs[ctr].length;
 
         if ((EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(ds))
-                 & EVP_CIPH_FLAG_AEAD_CIPHER) != 0) {
+                & EVP_CIPH_FLAG_AEAD_CIPHER)
+            != 0) {
             unsigned char *seq;
 
             seq = rl->sequence;
@@ -274,7 +283,7 @@ static int tls1_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
             buf[ctr][11] = (unsigned char)(recs[ctr].length >> 8);
             buf[ctr][12] = (unsigned char)(recs[ctr].length & 0xff);
             pad = EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_AEAD_TLS1_AAD,
-                                      EVP_AEAD_TLS1_AAD_LEN, buf[ctr]);
+                EVP_AEAD_TLS1_AAD_LEN, buf[ctr]);
             if (pad <= 0) {
                 RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 return 0;
@@ -318,7 +327,8 @@ static int tls1_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
             data[ctr] = recs[ctr].data;
 
         if (EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_SET_PIPELINE_OUTPUT_BUFS,
-                                (int)n_recs, data) <= 0) {
+                (int)n_recs, data)
+            <= 0) {
             RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_PIPELINE_FAILURE);
             return 0;
         }
@@ -327,9 +337,11 @@ static int tls1_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
             data[ctr] = recs[ctr].input;
 
         if (EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_SET_PIPELINE_INPUT_BUFS,
-                                (int)n_recs, data) <= 0
+                (int)n_recs, data)
+                <= 0
             || EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_SET_PIPELINE_INPUT_LENS,
-                                   (int)n_recs, reclen) <= 0) {
+                   (int)n_recs, reclen)
+                <= 0) {
             RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_PIPELINE_FAILURE);
             return 0;
         }
@@ -347,7 +359,8 @@ static int tls1_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
             decrement_seq = 1;
 
         if (EVP_CIPHER_CTX_ctrl(ds, EVP_CTRL_TLSTREE, decrement_seq,
-                                rl->sequence) <= 0) {
+                rl->sequence)
+            <= 0) {
 
             RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return 0;
@@ -364,7 +377,7 @@ static int tls1_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
         }
 
         if (!EVP_CipherUpdate(ds, recs[0].data, &outlen, recs[0].input,
-                              (unsigned int)reclen[0]))
+                (unsigned int)reclen[0]))
             return 0;
         recs[0].length = outlen;
 
@@ -394,14 +407,14 @@ static int tls1_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
                 macs[0].alloced = 0;
 
                 *p++ = OSSL_PARAM_construct_octet_ptr(OSSL_CIPHER_PARAM_TLS_MAC,
-                                                      (void **)&macs[0].mac,
-                                                      macsize);
+                    (void **)&macs[0].mac,
+                    macsize);
                 *p = OSSL_PARAM_construct_end();
 
                 if (!EVP_CIPHER_CTX_get_params(ds, params)) {
                     /* Shouldn't normally happen */
                     RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR,
-                                ERR_R_INTERNAL_ERROR);
+                        ERR_R_INTERNAL_ERROR);
                     return 0;
                 }
             }
@@ -410,11 +423,12 @@ static int tls1_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
         /* Legacy cipher */
 
         tmpr = EVP_Cipher(ds, recs[0].data, recs[0].input,
-                          (unsigned int)reclen[0]);
+            (unsigned int)reclen[0]);
         if ((EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(ds))
-                 & EVP_CIPH_FLAG_CUSTOM_CIPHER) != 0
-            ? (tmpr < 0)
-            : (tmpr == 0)) {
+                & EVP_CIPH_FLAG_CUSTOM_CIPHER)
+                    != 0
+                ? (tmpr < 0)
+                : (tmpr == 0)) {
             /* AEAD can fail to verify MAC */
             return 0;
         }
@@ -444,16 +458,17 @@ static int tls1_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
                  * with a random MAC if padding is invalid
                  */
                 if (!tls1_cbc_remove_padding_and_mac(&recs[ctr].length,
-                                        recs[ctr].orig_len,
-                                        recs[ctr].data,
-                                        (macs != NULL) ? &macs[ctr].mac : NULL,
-                                        (macs != NULL) ? &macs[ctr].alloced
-                                                       : NULL,
-                                        bs,
-                                        pad ? (size_t)pad : macsize,
-                                        (EVP_CIPHER_get_flags(enc)
-                                        & EVP_CIPH_FLAG_AEAD_CIPHER) != 0,
-                                        rl->libctx))
+                        recs[ctr].orig_len,
+                        recs[ctr].data,
+                        (macs != NULL) ? &macs[ctr].mac : NULL,
+                        (macs != NULL) ? &macs[ctr].alloced
+                                       : NULL,
+                        bs,
+                        pad ? (size_t)pad : macsize,
+                        (EVP_CIPHER_get_flags(enc)
+                            & EVP_CIPH_FLAG_AEAD_CIPHER)
+                            != 0,
+                        rl->libctx))
                     return 0;
             }
         }
@@ -462,7 +477,7 @@ static int tls1_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
 }
 
 static int tls1_mac(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec, unsigned char *md,
-                    int sending)
+    int sending)
 {
     unsigned char *seq = rl->sequence;
     EVP_MD_CTX *hash;
@@ -490,8 +505,8 @@ static int tls1_mac(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec, unsigned char *md
     }
 
     if (!rl->isdtls
-            && rl->tlstree
-            && EVP_MD_CTX_ctrl(mac_ctx, EVP_MD_CTRL_TLSTREE, 0, seq) <= 0)
+        && rl->tlstree
+        && EVP_MD_CTX_ctrl(mac_ctx, EVP_MD_CTRL_TLSTREE, 0, seq) <= 0)
         goto end;
 
     if (rl->isdtls) {
@@ -517,11 +532,11 @@ static int tls1_mac(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec, unsigned char *md
         OSSL_PARAM tls_hmac_params[2], *p = tls_hmac_params;
 
         *p++ = OSSL_PARAM_construct_size_t(OSSL_MAC_PARAM_TLS_DATA_SIZE,
-                                           &rec->orig_len);
+            &rec->orig_len);
         *p++ = OSSL_PARAM_construct_end();
 
         if (!EVP_PKEY_CTX_set_params(EVP_MD_CTX_get_pkey_ctx(mac_ctx),
-                                     tls_hmac_params))
+                tls_hmac_params))
             goto end;
     }
 
@@ -530,65 +545,69 @@ static int tls1_mac(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec, unsigned char *md
         || EVP_DigestSignFinal(mac_ctx, md, &md_size) <= 0)
         goto end;
 
-    OSSL_TRACE_BEGIN(TLS) {
+    OSSL_TRACE_BEGIN(TLS)
+    {
         BIO_printf(trc_out, "seq:\n");
         BIO_dump_indent(trc_out, seq, 8, 4);
         BIO_printf(trc_out, "rec:\n");
         BIO_dump_indent(trc_out, rec->data, rec->length, 4);
-    } OSSL_TRACE_END(TLS);
+    }
+    OSSL_TRACE_END(TLS);
 
     if (!rl->isdtls && !tls_increment_sequence_ctr(rl)) {
         /* RLAYERfatal already called */
         goto end;
     }
 
-    OSSL_TRACE_BEGIN(TLS) {
+    OSSL_TRACE_BEGIN(TLS)
+    {
         BIO_printf(trc_out, "md:\n");
         BIO_dump_indent(trc_out, md, md_size, 4);
-    } OSSL_TRACE_END(TLS);
+    }
+    OSSL_TRACE_END(TLS);
     ret = 1;
- end:
+end:
     EVP_MD_CTX_free(hmac);
     return ret;
 }
 
 #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD != 0
-# ifndef OPENSSL_NO_COMP
-#  define MAX_PREFIX_LEN ((SSL3_ALIGN_PAYLOAD - 1) \
-                           + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \
-                           + SSL3_RT_HEADER_LENGTH \
-                           + SSL3_RT_MAX_COMPRESSED_OVERHEAD)
-# else
-#  define MAX_PREFIX_LEN ((SSL3_ALIGN_PAYLOAD - 1) \
-                           + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \
-                           + SSL3_RT_HEADER_LENGTH)
-# endif /* OPENSSL_NO_COMP */
+#ifndef OPENSSL_NO_COMP
+#define MAX_PREFIX_LEN ((SSL3_ALIGN_PAYLOAD - 1) \
+    + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD        \
+    + SSL3_RT_HEADER_LENGTH                      \
+    + SSL3_RT_MAX_COMPRESSED_OVERHEAD)
+#else
+#define MAX_PREFIX_LEN ((SSL3_ALIGN_PAYLOAD - 1) \
+    + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD        \
+    + SSL3_RT_HEADER_LENGTH)
+#endif /* OPENSSL_NO_COMP */
+#else
+#ifndef OPENSSL_NO_COMP
+#define MAX_PREFIX_LEN (SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \
+    + SSL3_RT_HEADER_LENGTH                                 \
+    + SSL3_RT_MAX_COMPRESSED_OVERHEAD)
 #else
-# ifndef OPENSSL_NO_COMP
-#  define MAX_PREFIX_LEN (SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \
-                           + SSL3_RT_HEADER_LENGTH \
-                           + SSL3_RT_MAX_COMPRESSED_OVERHEAD)
-# else
-#  define MAX_PREFIX_LEN (SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \
-                           + SSL3_RT_HEADER_LENGTH)
-# endif /* OPENSSL_NO_COMP */
+#define MAX_PREFIX_LEN (SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD \
+    + SSL3_RT_HEADER_LENGTH)
+#endif /* OPENSSL_NO_COMP */
 #endif
 
 /* This function is also used by the SSLv3 implementation */
 int tls1_allocate_write_buffers(OSSL_RECORD_LAYER *rl,
-                                OSSL_RECORD_TEMPLATE *templates,
-                                size_t numtempl, size_t *prefix)
+    OSSL_RECORD_TEMPLATE *templates,
+    size_t numtempl, size_t *prefix)
 {
     /* Do we need to add an empty record prefix? */
     *prefix = rl->need_empty_fragments
-              && templates[0].type == SSL3_RT_APPLICATION_DATA;
+        && templates[0].type == SSL3_RT_APPLICATION_DATA;
 
     /*
      * In the prefix case we can allocate a much smaller buffer. Otherwise we
      * just allocate the default buffer size
      */
     if (!tls_setup_write_buffer(rl, numtempl + *prefix,
-                                *prefix ? MAX_PREFIX_LEN : 0, 0)) {
+            *prefix ? MAX_PREFIX_LEN : 0, 0)) {
         /* RLAYERfatal() already called */
         return 0;
     }
@@ -598,12 +617,12 @@ int tls1_allocate_write_buffers(OSSL_RECORD_LAYER *rl,
 
 /* This function is also used by the SSLv3 implementation */
 int tls1_initialise_write_packets(OSSL_RECORD_LAYER *rl,
-                                  OSSL_RECORD_TEMPLATE *templates,
-                                  size_t numtempl,
-                                  OSSL_RECORD_TEMPLATE *prefixtempl,
-                                  WPACKET *pkt,
-                                  TLS_BUFFER *bufs,
-                                  size_t *wpinited)
+    OSSL_RECORD_TEMPLATE *templates,
+    size_t numtempl,
+    OSSL_RECORD_TEMPLATE *prefixtempl,
+    WPACKET *pkt,
+    TLS_BUFFER *bufs,
+    size_t *wpinited)
 {
     size_t align = 0;
     TLS_BUFFER *wb;
@@ -611,7 +630,7 @@ int tls1_initialise_write_packets(OSSL_RECORD_LAYER *rl,
 
     /* Do we need to add an empty record prefix? */
     prefix = rl->need_empty_fragments
-             && templates[0].type == SSL3_RT_APPLICATION_DATA;
+        && templates[0].type == SSL3_RT_APPLICATION_DATA;
 
     if (prefix) {
         /*
@@ -628,12 +647,12 @@ int tls1_initialise_write_packets(OSSL_RECORD_LAYER *rl,
 #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD != 0
         align = (size_t)TLS_BUFFER_get_buf(wb) + SSL3_RT_HEADER_LENGTH;
         align = SSL3_ALIGN_PAYLOAD - 1
-                - ((align - 1) % SSL3_ALIGN_PAYLOAD);
+            - ((align - 1) % SSL3_ALIGN_PAYLOAD);
 #endif
         TLS_BUFFER_set_offset(wb, align);
 
         if (!WPACKET_init_static_len(&pkt[0], TLS_BUFFER_get_buf(wb),
-                                     TLS_BUFFER_get_len(wb), 0)) {
+                TLS_BUFFER_get_len(wb), 0)) {
             RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return 0;
         }
@@ -645,9 +664,9 @@ int tls1_initialise_write_packets(OSSL_RECORD_LAYER *rl,
     }
 
     return tls_initialise_write_packets_default(rl, templates, numtempl,
-                                                NULL,
-                                                pkt + prefix, bufs + prefix,
-                                                wpinited);
+        NULL,
+        pkt + prefix, bufs + prefix,
+        wpinited);
 }
 
 /* TLSv1.0, TLSv1.1 and TLSv1.2 all use the same funcs */
diff --git a/crypto/openssl/ssl/record/methods/tls_common.c b/crypto/openssl/ssl/record/methods/tls_common.c
index b9c79099462d..bf035b13d54f 100644
--- a/crypto/openssl/ssl/record/methods/tls_common.c
+++ b/crypto/openssl/ssl/record/methods/tls_common.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022-2025 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2022-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy
@@ -40,13 +40,13 @@ static void TLS_RL_RECORD_release(TLS_RL_RECORD *r, size_t num_recs)
 }
 
 void ossl_tls_rl_record_set_seq_num(TLS_RL_RECORD *r,
-                                    const unsigned char *seq_num)
+    const unsigned char *seq_num)
 {
     memcpy(r->seq_num, seq_num, SEQ_NUM_SIZE);
 }
 
 void ossl_rlayer_fatal(OSSL_RECORD_LAYER *rl, int al, int reason,
-                       const char *fmt, ...)
+    const char *fmt, ...)
 {
     va_list args;
 
@@ -58,9 +58,9 @@ void ossl_rlayer_fatal(OSSL_RECORD_LAYER *rl, int al, int reason,
 }
 
 int ossl_set_tls_provider_parameters(OSSL_RECORD_LAYER *rl,
-                                     EVP_CIPHER_CTX *ctx,
-                                     const EVP_CIPHER *ciph,
-                                     const EVP_MD *md)
+    EVP_CIPHER_CTX *ctx,
+    const EVP_CIPHER *ciph,
+    const EVP_MD *md)
 {
     /*
      * Provided cipher, the TLS padding/MAC removal is performed provider
@@ -71,15 +71,15 @@ int ossl_set_tls_provider_parameters(OSSL_RECORD_LAYER *rl,
     int imacsize = -1;
 
     if ((EVP_CIPHER_get_flags(ciph) & EVP_CIPH_FLAG_AEAD_CIPHER) == 0
-            && !rl->use_etm)
+        && !rl->use_etm)
         imacsize = EVP_MD_get_size(md);
     if (imacsize > 0)
         macsize = (size_t)imacsize;
 
     *pprm++ = OSSL_PARAM_construct_int(OSSL_CIPHER_PARAM_TLS_VERSION,
-                                       &rl->version);
+        &rl->version);
     *pprm++ = OSSL_PARAM_construct_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE,
-                                          &macsize);
+        &macsize);
     *pprm = OSSL_PARAM_construct_end();
 
     if (!EVP_CIPHER_CTX_set_params(ctx, params)) {
@@ -116,7 +116,7 @@ static int tls_allow_compression(OSSL_RECORD_LAYER *rl)
         return 0;
 
     return rl->security == NULL
-           || rl->security(rl->cbarg, SSL_SECOP_COMPRESSION, 0, 0, NULL);
+        || rl->security(rl->cbarg, SSL_SECOP_COMPRESSION, 0, 0, NULL);
 }
 #endif
 
@@ -140,7 +140,7 @@ static void tls_release_write_buffer_int(OSSL_RECORD_LAYER *rl, size_t start)
 }
 
 int tls_setup_write_buffer(OSSL_RECORD_LAYER *rl, size_t numwpipes,
-                           size_t firstlen, size_t nextlen)
+    size_t firstlen, size_t nextlen)
 {
     unsigned char *p;
     size_t maxalign = 0, headerlen;
@@ -164,7 +164,7 @@ int tls_setup_write_buffer(OSSL_RECORD_LAYER *rl, size_t numwpipes,
 #endif
 
         defltlen = maxalign + headerlen + rl->eivlen + rl->max_frag_len
-                   + contenttypelen + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD;
+            + contenttypelen + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD;
 #ifndef OPENSSL_NO_COMP
         if (tls_allow_compression(rl))
             defltlen += SSL3_RT_MAX_COMPRESSED_OVERHEAD;
@@ -188,7 +188,7 @@ int tls_setup_write_buffer(OSSL_RECORD_LAYER *rl, size_t numwpipes,
 
         if (thiswb->len != len) {
             OPENSSL_free(thiswb->buf);
-            thiswb->buf = NULL;         /* force reallocation */
+            thiswb->buf = NULL; /* force reallocation */
         }
 
         p = thiswb->buf;
@@ -245,7 +245,7 @@ int tls_setup_read_buffer(OSSL_RECORD_LAYER *rl)
 
     if (b->buf == NULL) {
         len = rl->max_frag_len
-              + SSL3_RT_MAX_ENCRYPTED_OVERHEAD + headerlen + maxalign;
+            + SSL3_RT_MAX_ENCRYPTED_OVERHEAD + headerlen + maxalign;
 #ifndef OPENSSL_NO_COMP
         if (tls_allow_compression(rl))
             len += SSL3_RT_MAX_COMPRESSED_OVERHEAD;
@@ -292,7 +292,7 @@ static int tls_release_read_buffer(OSSL_RECORD_LAYER *rl)
  * Return values are as per SSL_read()
  */
 int tls_default_read_n(OSSL_RECORD_LAYER *rl, size_t n, size_t max, int extend,
-                       int clearold, size_t *readbytes)
+    int clearold, size_t *readbytes)
 {
     /*
      * If extend == 0, obtain new n-byte packet; if extend == 1, increase
@@ -443,7 +443,7 @@ int tls_default_read_n(OSSL_RECORD_LAYER *rl, size_t n, size_t max, int extend,
          */
         if (rl->isdtls) {
             if (n > left)
-                n = left;       /* makes the while condition false */
+                n = left; /* makes the while condition false */
         }
     }
 
@@ -495,13 +495,13 @@ static int tls_record_app_data_waiting(OSSL_RECORD_LAYER *rl)
 }
 
 static int rlayer_early_data_count_ok(OSSL_RECORD_LAYER *rl, size_t length,
-                                      size_t overhead, int send)
+    size_t overhead, int send)
 {
     uint32_t max_early_data = rl->max_early_data;
 
     if (max_early_data == 0) {
         RLAYERfatal(rl, send ? SSL_AD_INTERNAL_ERROR : SSL_AD_UNEXPECTED_MESSAGE,
-                    SSL_R_TOO_MUCH_EARLY_DATA);
+            SSL_R_TOO_MUCH_EARLY_DATA);
         return 0;
     }
 
@@ -510,7 +510,7 @@ static int rlayer_early_data_count_ok(OSSL_RECORD_LAYER *rl, size_t length,
 
     if (rl->early_data_count + length > max_early_data) {
         RLAYERfatal(rl, send ? SSL_AD_INTERNAL_ERROR : SSL_AD_UNEXPECTED_MESSAGE,
-                    SSL_R_TOO_MUCH_EARLY_DATA);
+            SSL_R_TOO_MUCH_EARLY_DATA);
         return 0;
     }
     rl->early_data_count += length;
@@ -526,7 +526,7 @@ static int rlayer_early_data_count_ok(OSSL_RECORD_LAYER *rl, size_t length,
  */
 #define MAX_EMPTY_RECORDS 32
 
-#define SSL2_RT_HEADER_LENGTH   2
+#define SSL2_RT_HEADER_LENGTH 2
 
 /*-
  * Call this to buffer new input records in rl->rrec.
@@ -575,14 +575,13 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
         thisrr = &rr[num_recs];
 
         /* check if we have the header */
-        if ((rl->rstate != SSL_ST_READ_BODY) ||
-            (rl->packet_length < SSL3_RT_HEADER_LENGTH)) {
+        if ((rl->rstate != SSL_ST_READ_BODY) || (rl->packet_length < SSL3_RT_HEADER_LENGTH)) {
             size_t sslv2len;
             unsigned int type;
 
             rret = rl->funcs->read_n(rl, SSL3_RT_HEADER_LENGTH,
-                                     TLS_BUFFER_get_len(rbuf), 0,
-                                     num_recs == 0 ? 1 : 0, &n);
+                TLS_BUFFER_get_len(rbuf), 0,
+                num_recs == 0 ? 1 : 0, &n);
 
             if (rret < OSSL_RECORD_RETURN_SUCCESS)
                 return rret; /* error or non-blocking */
@@ -596,7 +595,7 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
             }
             sslv2pkt = pkt;
             if (!PACKET_get_net_2_len(&sslv2pkt, &sslv2len)
-                    || !PACKET_get_1(&sslv2pkt, &type)) {
+                || !PACKET_get_1(&sslv2pkt, &type)) {
                 RLAYERfatal(rl, SSL_AD_DECODE_ERROR, ERR_R_INTERNAL_ERROR);
                 return OSSL_RECORD_RETURN_FATAL;
             }
@@ -604,9 +603,9 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
              * The first record received by the server may be a V2ClientHello.
              */
             if (rl->role == OSSL_RECORD_ROLE_SERVER
-                    && rl->is_first_record
-                    && (sslv2len & 0x8000) != 0
-                    && (type == SSL2_MT_CLIENT_HELLO)) {
+                && rl->is_first_record
+                && (sslv2len & 0x8000) != 0
+                && (type == SSL2_MT_CLIENT_HELLO)) {
                 /*
                  *  SSLv2 style record
                  *
@@ -621,10 +620,15 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
 
                 thisrr->length = sslv2len & 0x7fff;
 
+                if (!rl->funcs->validate_record_header(rl, thisrr)) {
+                    /* RLAYERfatal already called */
+                    return OSSL_RECORD_RETURN_FATAL;
+                }
+
                 if (thisrr->length > TLS_BUFFER_get_len(rbuf)
-                                     - SSL2_RT_HEADER_LENGTH) {
+                        - SSL2_RT_HEADER_LENGTH) {
                     RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW,
-                                SSL_R_PACKET_LENGTH_TOO_LONG);
+                        SSL_R_PACKET_LENGTH_TOO_LONG);
                     return OSSL_RECORD_RETURN_FATAL;
                 }
             } else {
@@ -632,8 +636,8 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
 
                 /* Pull apart the header into the TLS_RL_RECORD */
                 if (!PACKET_get_1(&pkt, &type)
-                        || !PACKET_get_net_2(&pkt, &version)
-                        || !PACKET_get_net_2_len(&pkt, &thisrr->length)) {
+                    || !PACKET_get_net_2(&pkt, &version)
+                    || !PACKET_get_net_2_len(&pkt, &thisrr->length)) {
                     if (rl->msg_callback != NULL)
                         rl->msg_callback(0, 0, SSL3_RT_HEADER, p, 5, rl->cbarg);
                     RLAYERfatal(rl, SSL_AD_DECODE_ERROR, ERR_R_INTERNAL_ERROR);
@@ -650,24 +654,23 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
                  */
                 if (thisrr->rec_version == SSL2_VERSION) {
                     RLAYERfatal(rl, SSL_AD_PROTOCOL_VERSION,
-                                SSL_R_WRONG_VERSION_NUMBER);
+                        SSL_R_WRONG_VERSION_NUMBER);
                     return OSSL_RECORD_RETURN_FATAL;
                 }
 
                 if (rl->msg_callback != NULL)
                     rl->msg_callback(0, version, SSL3_RT_HEADER, p, 5, rl->cbarg);
 
-                if (thisrr->length >
-                    TLS_BUFFER_get_len(rbuf) - SSL3_RT_HEADER_LENGTH) {
-                    RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW,
-                                SSL_R_PACKET_LENGTH_TOO_LONG);
+                if (!rl->funcs->validate_record_header(rl, thisrr)) {
+                    /* RLAYERfatal already called */
                     return OSSL_RECORD_RETURN_FATAL;
                 }
-            }
 
-            if (!rl->funcs->validate_record_header(rl, thisrr)) {
-                /* RLAYERfatal already called */
-                return OSSL_RECORD_RETURN_FATAL;
+                if (thisrr->length > TLS_BUFFER_get_len(rbuf) - SSL3_RT_HEADER_LENGTH) {
+                    RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW,
+                        SSL_R_PACKET_LENGTH_TOO_LONG);
+                    return OSSL_RECORD_RETURN_FATAL;
+                }
             }
 
             /* now rl->rstate == SSL_ST_READ_BODY */
@@ -679,7 +682,7 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
          */
         if (thisrr->rec_version == SSL2_VERSION) {
             more = thisrr->length + SSL2_RT_HEADER_LENGTH
-                   - SSL3_RT_HEADER_LENGTH;
+                - SSL3_RT_HEADER_LENGTH;
         } else {
             more = thisrr->length;
         }
@@ -689,7 +692,7 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
 
             rret = rl->funcs->read_n(rl, more, more, 1, 0, &n);
             if (rret < OSSL_RECORD_RETURN_SUCCESS)
-                return rret;     /* error or non-blocking io */
+                return rret; /* error or non-blocking io */
         }
 
         /* set state for later operations */
@@ -728,24 +731,25 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
         rl->packet_length = 0;
         rl->is_first_record = 0;
     } while (num_recs < max_recs
-             && thisrr->type == SSL3_RT_APPLICATION_DATA
-             && RLAYER_USE_EXPLICIT_IV(rl)
-             && rl->enc_ctx != NULL
-             && (EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(rl->enc_ctx))
-                 & EVP_CIPH_FLAG_PIPELINE) != 0
-             && tls_record_app_data_waiting(rl));
+        && thisrr->type == SSL3_RT_APPLICATION_DATA
+        && RLAYER_USE_EXPLICIT_IV(rl)
+        && rl->enc_ctx != NULL
+        && (EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(rl->enc_ctx))
+               & EVP_CIPH_FLAG_PIPELINE)
+            != 0
+        && tls_record_app_data_waiting(rl));
 
     if (num_recs == 1
-            && thisrr->type == SSL3_RT_CHANGE_CIPHER_SPEC
-               /* The following can happen in tlsany_meth after HRR */
-            && rl->version == TLS1_3_VERSION
-            && rl->is_first_handshake) {
+        && thisrr->type == SSL3_RT_CHANGE_CIPHER_SPEC
+        /* The following can happen in tlsany_meth after HRR */
+        && rl->version == TLS1_3_VERSION
+        && rl->is_first_handshake) {
         /*
          * CCS messages must be exactly 1 byte long, containing the value 0x01
          */
         if (thisrr->length != 1 || thisrr->data[0] != 0x01) {
             RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE,
-                        SSL_R_INVALID_CCS_MESSAGE);
+                SSL_R_INVALID_CCS_MESSAGE);
             return OSSL_RECORD_RETURN_FATAL;
         }
         /*
@@ -754,11 +758,11 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
          */
         if (rl->msg_callback != NULL)
             rl->msg_callback(0, TLS1_3_VERSION, SSL3_RT_CHANGE_CIPHER_SPEC,
-                             thisrr->data, 1, rl->cbarg);
+                thisrr->data, 1, rl->cbarg);
         thisrr->type = SSL3_RT_HANDSHAKE;
         if (++(rl->empty_record_count) > MAX_EMPTY_RECORDS) {
             RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE,
-                        SSL_R_UNEXPECTED_CCS_MESSAGE);
+                SSL_R_UNEXPECTED_CCS_MESSAGE);
             return OSSL_RECORD_RETURN_FATAL;
         }
         rl->num_recs = 0;
@@ -800,7 +804,7 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
             i = rl->funcs->mac(rl, thisrr, md, 0 /* not send */);
             if (i == 0 || CRYPTO_memcmp(md, mac, mac_size) != 0) {
                 RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC,
-                            SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
+                    SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
                 return OSSL_RECORD_RETURN_FATAL;
             }
         }
@@ -835,8 +839,8 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
             goto end;
         }
         if (num_recs == 1
-                && rl->skip_early_data != NULL
-                && rl->skip_early_data(rl->cbarg)) {
+            && rl->skip_early_data != NULL
+            && rl->skip_early_data(rl->cbarg)) {
             /*
              * Valid early_data that we cannot decrypt will fail here. We treat
              * it like an empty record.
@@ -851,7 +855,7 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
             thisrr = &rr[0];
 
             if (!rlayer_early_data_count_ok(rl, thisrr->length,
-                                            EARLY_DATA_CIPHERTEXT_OVERHEAD, 0)) {
+                    EARLY_DATA_CIPHERTEXT_OVERHEAD, 0)) {
                 /* RLAYERfatal() already called */
                 goto end;
             }
@@ -867,20 +871,22 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
         }
         ERR_clear_last_mark();
         RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC,
-                    SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
+            SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
         goto end;
     } else {
         ERR_clear_last_mark();
     }
-    OSSL_TRACE_BEGIN(TLS) {
+    OSSL_TRACE_BEGIN(TLS)
+    {
         BIO_printf(trc_out, "dec %lu\n", (unsigned long)rr[0].length);
         BIO_dump_indent(trc_out, rr[0].data, rr[0].length, 4);
-    } OSSL_TRACE_END(TLS);
+    }
+    OSSL_TRACE_END(TLS);
 
     /* r->length is now the compressed data plus mac */
     if (rl->enc_ctx != NULL
-            && !rl->use_etm
-            && EVP_MD_CTX_get0_md(rl->md_ctx) != NULL) {
+        && !rl->use_etm
+        && EVP_MD_CTX_get0_md(rl->md_ctx) != NULL) {
         for (j = 0; j < num_recs; j++) {
             SSL_MAC_BUF *thismb = &macbufs[j];
 
@@ -893,8 +899,7 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
             if (thisrr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + mac_size)
                 enc_err = 0;
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
-            if (enc_err == 0 && mac_size > 0 && thismb != NULL &&
-                thismb->mac != NULL && (md[0] ^ thismb->mac[0]) != 0xFF) {
+            if (enc_err == 0 && mac_size > 0 && thismb != NULL && thismb->mac != NULL && (md[0] ^ thismb->mac[0]) != 0xFF) {
                 enc_err = 1;
             }
 #endif
@@ -914,7 +919,7 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
          * visible to an attacker (e.g. via a logfile)
          */
         RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC,
-                    SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
+            SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
         goto end;
     }
 
@@ -937,7 +942,7 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
          * be > SSL3_RT_MAX_PLAIN_LENGTH (and rl->max_frag_len must be ignored)
          */
         if (rl->max_frag_len != SSL3_RT_MAX_PLAIN_LENGTH
-                && thisrr->length > rl->max_frag_len) {
+            && thisrr->length > rl->max_frag_len) {
             RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_DATA_LENGTH_TOO_LONG);
             goto end;
         }
@@ -955,7 +960,7 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
         if (thisrr->length == 0) {
             if (++(rl->empty_record_count) > MAX_EMPTY_RECORDS) {
                 RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE,
-                            SSL_R_RECORD_TOO_SMALL);
+                    SSL_R_RECORD_TOO_SMALL);
                 goto end;
             }
         } else {
@@ -966,7 +971,7 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
     if (rl->level == OSSL_RECORD_PROTECTION_LEVEL_EARLY) {
         thisrr = &rr[0];
         if (thisrr->type == SSL3_RT_APPLICATION_DATA
-                && !rlayer_early_data_count_ok(rl, thisrr->length, 0, 0)) {
+            && !rlayer_early_data_count_ok(rl, thisrr->length, 0, 0)) {
             /* RLAYERfatal already called */
             goto end;
         }
@@ -976,7 +981,7 @@ int tls_get_more_records(OSSL_RECORD_LAYER *rl)
     rl->curr_rec = 0;
     rl->num_released = 0;
     ret = OSSL_RECORD_RETURN_SUCCESS;
- end:
+end:
     if (macbufs != NULL) {
         for (j = 0; j < num_recs; j++) {
             if (macbufs[j].alloced)
@@ -1008,7 +1013,7 @@ int tls_default_validate_record_header(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec
 
     if (rec->length > len) {
         RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW,
-                    SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
+            SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
         return 0;
     }
 
@@ -1021,8 +1026,8 @@ int tls_do_compress(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *wr)
     int i;
 
     i = COMP_compress_block(rl->compctx, wr->data,
-                            (int)(wr->length + SSL3_RT_MAX_COMPRESSED_OVERHEAD),
-                            wr->input, (int)wr->length);
+        (int)(wr->length + SSL3_RT_MAX_COMPRESSED_OVERHEAD),
+        wr->input, (int)wr->length);
     if (i < 0)
         return 0;
 
@@ -1047,7 +1052,7 @@ int tls_do_uncompress(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec)
         return 0;
 
     i = COMP_expand_block(rl->compctx, rec->comp, SSL3_RT_MAX_PLAIN_LENGTH,
-                          rec->data, (int)rec->length);
+        rec->data, (int)rec->length);
     if (i < 0)
         return 0;
     else
@@ -1065,12 +1070,12 @@ int tls_default_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec)
     if (rl->compctx != NULL) {
         if (rec->length > SSL3_RT_MAX_COMPRESSED_LENGTH) {
             RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW,
-                        SSL_R_COMPRESSED_LENGTH_TOO_LONG);
+                SSL_R_COMPRESSED_LENGTH_TOO_LONG);
             return 0;
         }
         if (!tls_do_uncompress(rl, rec)) {
             RLAYERfatal(rl, SSL_AD_DECOMPRESSION_FAILURE,
-                        SSL_R_BAD_DECOMPRESSION);
+                SSL_R_BAD_DECOMPRESSION);
             return 0;
         }
     }
@@ -1087,8 +1092,8 @@ int tls_default_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec)
 int tls13_common_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec)
 {
     if (rec->type != SSL3_RT_APPLICATION_DATA
-            && rec->type != SSL3_RT_ALERT
-            && rec->type != SSL3_RT_HANDSHAKE) {
+        && rec->type != SSL3_RT_ALERT
+        && rec->type != SSL3_RT_HANDSHAKE) {
         RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_BAD_RECORD_TYPE);
         return 0;
     }
@@ -1097,7 +1102,7 @@ int tls13_common_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec)
         unsigned char ctype = (unsigned char)rec->type;
 
         rl->msg_callback(0, rl->version, SSL3_RT_INNER_CONTENT_TYPE, &ctype,
-                         1, rl->cbarg);
+            1, rl->cbarg);
     }
 
     /*
@@ -1105,7 +1110,7 @@ int tls13_common_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec)
      * length.
      */
     if ((rec->type == SSL3_RT_HANDSHAKE || rec->type == SSL3_RT_ALERT)
-            && rec->length == 0) {
+        && rec->length == 0) {
         RLAYERfatal(rl, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_BAD_LENGTH);
         return 0;
     }
@@ -1114,8 +1119,8 @@ int tls13_common_post_process_record(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec)
 }
 
 int tls_read_record(OSSL_RECORD_LAYER *rl, void **rechandle, int *rversion,
-                    uint8_t *type, const unsigned char **data, size_t *datalen,
-                    uint16_t *epoch, unsigned char *seq_num)
+    uint8_t *type, const unsigned char **data, size_t *datalen,
+    uint16_t *epoch, unsigned char *seq_num)
 {
     TLS_RL_RECORD *rec;
 
@@ -1163,7 +1168,7 @@ int tls_release_record(OSSL_RECORD_LAYER *rl, void *rechandle, size_t length)
     TLS_RL_RECORD *rec = &rl->rrec[rl->num_released];
 
     if (!ossl_assert(rl->num_released < rl->curr_rec)
-            || !ossl_assert(rechandle == rec)) {
+        || !ossl_assert(rechandle == rec)) {
         /* Should not happen */
         RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_INVALID_RECORD);
         return OSSL_RECORD_RETURN_FATAL;
@@ -1187,8 +1192,8 @@ int tls_release_record(OSSL_RECORD_LAYER *rl, void *rechandle, size_t length)
     rl->num_released++;
 
     if (rl->curr_rec == rl->num_released
-            && (rl->mode & SSL_MODE_RELEASE_BUFFERS) != 0
-            && TLS_BUFFER_get_left(&rl->rbuf) == 0)
+        && (rl->mode & SSL_MODE_RELEASE_BUFFERS) != 0
+        && TLS_BUFFER_get_left(&rl->rbuf) == 0)
         tls_release_read_buffer(rl);
 
     return OSSL_RECORD_RETURN_SUCCESS;
@@ -1212,20 +1217,20 @@ int tls_set_options(OSSL_RECORD_LAYER *rl, const OSSL_PARAM *options)
 
     if (rl->direction == OSSL_RECORD_DIRECTION_READ) {
         p = OSSL_PARAM_locate_const(options,
-                                    OSSL_LIBSSL_RECORD_LAYER_READ_BUFFER_LEN);
+            OSSL_LIBSSL_RECORD_LAYER_READ_BUFFER_LEN);
         if (p != NULL && !OSSL_PARAM_get_size_t(p, &rl->rbuf.default_len)) {
             ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER);
             return 0;
         }
     } else {
         p = OSSL_PARAM_locate_const(options,
-                                    OSSL_LIBSSL_RECORD_LAYER_PARAM_BLOCK_PADDING);
+            OSSL_LIBSSL_RECORD_LAYER_PARAM_BLOCK_PADDING);
         if (p != NULL && !OSSL_PARAM_get_size_t(p, &rl->block_padding)) {
             ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER);
             return 0;
         }
         p = OSSL_PARAM_locate_const(options,
-                                    OSSL_LIBSSL_RECORD_LAYER_PARAM_HS_PADDING);
+            OSSL_LIBSSL_RECORD_LAYER_PARAM_HS_PADDING);
         if (p != NULL && !OSSL_PARAM_get_size_t(p, &rl->hs_padding)) {
             ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER);
             return 0;
@@ -1240,7 +1245,7 @@ int tls_set_options(OSSL_RECORD_LAYER *rl, const OSSL_PARAM *options)
          * we don't support that at this stage.
          */
         p = OSSL_PARAM_locate_const(options,
-                                    OSSL_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD);
+            OSSL_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD);
         if (p != NULL && !OSSL_PARAM_get_int(p, &rl->read_ahead)) {
             ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER);
             return 0;
@@ -1250,15 +1255,14 @@ int tls_set_options(OSSL_RECORD_LAYER *rl, const OSSL_PARAM *options)
     return 1;
 }
 
-int
-tls_int_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
-                         int role, int direction, int level,
-                         const EVP_CIPHER *ciph, size_t taglen,
-                         const EVP_MD *md, COMP_METHOD *comp, BIO *prev,
-                         BIO *transport, BIO *next, const OSSL_PARAM *settings,
-                         const OSSL_PARAM *options,
-                         const OSSL_DISPATCH *fns, void *cbarg,
-                         OSSL_RECORD_LAYER **retrl)
+int tls_int_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
+    int role, int direction, int level,
+    const EVP_CIPHER *ciph, size_t taglen,
+    const EVP_MD *md, COMP_METHOD *comp, BIO *prev,
+    BIO *transport, BIO *next, const OSSL_PARAM *settings,
+    const OSSL_PARAM *options,
+    const OSSL_DISPATCH *fns, void *cbarg,
+    OSSL_RECORD_LAYER **retrl)
 {
     OSSL_RECORD_LAYER *rl = OPENSSL_zalloc(sizeof(*rl));
     const OSSL_PARAM *p;
@@ -1283,25 +1287,29 @@ tls_int_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
                     goto err;
                 }
             } else if (strcmp(p->key,
-                              OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_FRAG_LEN) == 0) {
+                           OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_FRAG_LEN)
+                == 0) {
                 if (!OSSL_PARAM_get_uint(p, &rl->max_frag_len)) {
                     ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER);
                     goto err;
                 }
             } else if (strcmp(p->key,
-                              OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_EARLY_DATA) == 0) {
+                           OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_EARLY_DATA)
+                == 0) {
                 if (!OSSL_PARAM_get_uint32(p, &rl->max_early_data)) {
                     ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER);
                     goto err;
                 }
             } else if (strcmp(p->key,
-                              OSSL_LIBSSL_RECORD_LAYER_PARAM_STREAM_MAC) == 0) {
+                           OSSL_LIBSSL_RECORD_LAYER_PARAM_STREAM_MAC)
+                == 0) {
                 if (!OSSL_PARAM_get_int(p, &rl->stream_mac)) {
                     ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER);
                     goto err;
                 }
             } else if (strcmp(p->key,
-                              OSSL_LIBSSL_RECORD_LAYER_PARAM_TLSTREE) == 0) {
+                           OSSL_LIBSSL_RECORD_LAYER_PARAM_TLSTREE)
+                == 0) {
                 if (!OSSL_PARAM_get_int(p, &rl->tlstree)) {
                     ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_GET_PARAMETER);
                     goto err;
@@ -1368,9 +1376,9 @@ tls_int_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
     }
 
     if ((rl->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS) == 0
-            && rl->version <= TLS1_VERSION
-            && !EVP_CIPHER_is_a(ciph, "NULL")
-            && !EVP_CIPHER_is_a(ciph, "RC4")) {
+        && rl->version <= TLS1_VERSION
+        && !EVP_CIPHER_is_a(ciph, "NULL")
+        && !EVP_CIPHER_is_a(ciph, "RC4")) {
         /*
          * Enable vulnerability countermeasure for CBC ciphers with known-IV
          * problem (http://www.openssl.org/~bodo/tls-cbc.txt)
@@ -1380,32 +1388,32 @@ tls_int_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
 
     *retrl = rl;
     return OSSL_RECORD_RETURN_SUCCESS;
- err:
+err:
     tls_int_free(rl);
     return OSSL_RECORD_RETURN_FATAL;
 }
 
 static int
 tls_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
-                     int role, int direction, int level, uint16_t epoch,
-                     unsigned char *secret, size_t secretlen,
-                     unsigned char *key, size_t keylen, unsigned char *iv,
-                     size_t ivlen, unsigned char *mackey, size_t mackeylen,
-                     const EVP_CIPHER *ciph, size_t taglen,
-                     int mactype,
-                     const EVP_MD *md, COMP_METHOD *comp,
-                     const EVP_MD *kdfdigest, BIO *prev, BIO *transport,
-                     BIO *next, BIO_ADDR *local, BIO_ADDR *peer,
-                     const OSSL_PARAM *settings, const OSSL_PARAM *options,
-                     const OSSL_DISPATCH *fns, void *cbarg, void *rlarg,
-                     OSSL_RECORD_LAYER **retrl)
+    int role, int direction, int level, uint16_t epoch,
+    unsigned char *secret, size_t secretlen,
+    unsigned char *key, size_t keylen, unsigned char *iv,
+    size_t ivlen, unsigned char *mackey, size_t mackeylen,
+    const EVP_CIPHER *ciph, size_t taglen,
+    int mactype,
+    const EVP_MD *md, COMP_METHOD *comp,
+    const EVP_MD *kdfdigest, BIO *prev, BIO *transport,
+    BIO *next, BIO_ADDR *local, BIO_ADDR *peer,
+    const OSSL_PARAM *settings, const OSSL_PARAM *options,
+    const OSSL_DISPATCH *fns, void *cbarg, void *rlarg,
+    OSSL_RECORD_LAYER **retrl)
 {
     int ret;
 
     ret = tls_int_new_record_layer(libctx, propq, vers, role, direction, level,
-                                   ciph, taglen, md, comp, prev,
-                                   transport, next, settings,
-                                   options, fns, cbarg, retrl);
+        ciph, taglen, md, comp, prev,
+        transport, next, settings,
+        options, fns, cbarg, retrl);
 
     if (ret != OSSL_RECORD_RETURN_SUCCESS)
         return ret;
@@ -1433,10 +1441,10 @@ tls_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
     }
 
     ret = (*retrl)->funcs->set_crypto_state(*retrl, level, key, keylen, iv,
-                                            ivlen, mackey, mackeylen, ciph,
-                                            taglen, mactype, md, comp);
+        ivlen, mackey, mackeylen, ciph,
+        taglen, mactype, md, comp);
 
- err:
+err:
     if (ret != OSSL_RECORD_RETURN_SUCCESS) {
         tls_int_free(*retrl);
         *retrl = NULL;
@@ -1517,18 +1525,19 @@ size_t tls_app_data_pending(OSSL_RECORD_LAYER *rl)
 }
 
 size_t tls_get_max_records_default(OSSL_RECORD_LAYER *rl, uint8_t type,
-                                   size_t len,
-                                   size_t maxfrag, size_t *preffrag)
+    size_t len,
+    size_t maxfrag, size_t *preffrag)
 {
     /*
      * If we have a pipeline capable cipher, and we have been configured to use
      * it, then return the preferred number of pipelines.
      */
     if (rl->max_pipelines > 0
-            && rl->enc_ctx != NULL
-            && (EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(rl->enc_ctx))
-                & EVP_CIPH_FLAG_PIPELINE) != 0
-            && RLAYER_USE_EXPLICIT_IV(rl)) {
+        && rl->enc_ctx != NULL
+        && (EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(rl->enc_ctx))
+               & EVP_CIPH_FLAG_PIPELINE)
+            != 0
+        && RLAYER_USE_EXPLICIT_IV(rl)) {
         size_t pipes;
 
         if (len == 0)
@@ -1542,15 +1551,15 @@ size_t tls_get_max_records_default(OSSL_RECORD_LAYER *rl, uint8_t type,
 }
 
 size_t tls_get_max_records(OSSL_RECORD_LAYER *rl, uint8_t type, size_t len,
-                           size_t maxfrag, size_t *preffrag)
+    size_t maxfrag, size_t *preffrag)
 {
     return rl->funcs->get_max_records(rl, type, len, maxfrag, preffrag);
 }
 
 int tls_allocate_write_buffers_default(OSSL_RECORD_LAYER *rl,
-                                         OSSL_RECORD_TEMPLATE *templates,
-                                         size_t numtempl,
-                                         size_t *prefix)
+    OSSL_RECORD_TEMPLATE *templates,
+    size_t numtempl,
+    size_t *prefix)
 {
     if (!tls_setup_write_buffer(rl, numtempl, 0, 0)) {
         /* RLAYERfatal() already called */
@@ -1561,12 +1570,12 @@ int tls_allocate_write_buffers_default(OSSL_RECORD_LAYER *rl,
 }
 
 int tls_initialise_write_packets_default(OSSL_RECORD_LAYER *rl,
-                                         OSSL_RECORD_TEMPLATE *templates,
-                                         size_t numtempl,
-                                         OSSL_RECORD_TEMPLATE *prefixtempl,
-                                         WPACKET *pkt,
-                                         TLS_BUFFER *bufs,
-                                         size_t *wpinited)
+    OSSL_RECORD_TEMPLATE *templates,
+    size_t numtempl,
+    OSSL_RECORD_TEMPLATE *prefixtempl,
+    WPACKET *pkt,
+    TLS_BUFFER *bufs,
+    size_t *wpinited)
 {
     WPACKET *thispkt;
     size_t j, align;
@@ -1582,12 +1591,12 @@ int tls_initialise_write_packets_default(OSSL_RECORD_LAYER *rl,
         align = (size_t)TLS_BUFFER_get_buf(wb);
         align += rl->isdtls ? DTLS1_RT_HEADER_LENGTH : SSL3_RT_HEADER_LENGTH;
         align = SSL3_ALIGN_PAYLOAD - 1
-                - ((align - 1) % SSL3_ALIGN_PAYLOAD);
+            - ((align - 1) % SSL3_ALIGN_PAYLOAD);
 #endif
         TLS_BUFFER_set_offset(wb, align);
 
         if (!WPACKET_init_static_len(thispkt, TLS_BUFFER_get_buf(wb),
-                                     TLS_BUFFER_get_len(wb), 0)) {
+                TLS_BUFFER_get_len(wb), 0)) {
             RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return 0;
         }
@@ -1602,10 +1611,10 @@ int tls_initialise_write_packets_default(OSSL_RECORD_LAYER *rl,
 }
 
 int tls_prepare_record_header_default(OSSL_RECORD_LAYER *rl,
-                                      WPACKET *thispkt,
-                                      OSSL_RECORD_TEMPLATE *templ,
-                                      uint8_t rectype,
-                                      unsigned char **recdata)
+    WPACKET *thispkt,
+    OSSL_RECORD_TEMPLATE *templ,
+    uint8_t rectype,
+    unsigned char **recdata)
 {
     size_t maxcomplen;
 
@@ -1616,13 +1625,13 @@ int tls_prepare_record_header_default(OSSL_RECORD_LAYER *rl,
         maxcomplen += SSL3_RT_MAX_COMPRESSED_OVERHEAD;
 
     if (!WPACKET_put_bytes_u8(thispkt, rectype)
-            || !WPACKET_put_bytes_u16(thispkt, templ->version)
-            || !WPACKET_start_sub_packet_u16(thispkt)
-            || (rl->eivlen > 0
-                && !WPACKET_allocate_bytes(thispkt, rl->eivlen, NULL))
-            || (maxcomplen > 0
-                && !WPACKET_reserve_bytes(thispkt, maxcomplen,
-                                          recdata))) {
+        || !WPACKET_put_bytes_u16(thispkt, templ->version)
+        || !WPACKET_start_sub_packet_u16(thispkt)
+        || (rl->eivlen > 0
+            && !WPACKET_allocate_bytes(thispkt, rl->eivlen, NULL))
+        || (maxcomplen > 0
+            && !WPACKET_reserve_bytes(thispkt, maxcomplen,
+                recdata))) {
         RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
@@ -1631,9 +1640,9 @@ int tls_prepare_record_header_default(OSSL_RECORD_LAYER *rl,
 }
 
 int tls_prepare_for_encryption_default(OSSL_RECORD_LAYER *rl,
-                                       size_t mac_size,
-                                       WPACKET *thispkt,
-                                       TLS_RL_RECORD *thiswr)
+    size_t mac_size,
+    WPACKET *thispkt,
+    TLS_RL_RECORD *thiswr)
 {
     size_t len;
     unsigned char *recordstart;
@@ -1648,7 +1657,7 @@ int tls_prepare_for_encryption_default(OSSL_RECORD_LAYER *rl,
         unsigned char *mac;
 
         if (!WPACKET_allocate_bytes(thispkt, mac_size, &mac)
-                || !rl->funcs->mac(rl, thiswr, mac, 1)) {
+            || !rl->funcs->mac(rl, thiswr, mac, 1)) {
             RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return 0;
         }
@@ -1660,13 +1669,12 @@ int tls_prepare_for_encryption_default(OSSL_RECORD_LAYER *rl,
      * max encrypted overhead does not need to include an allocation for that
      * MAC
      */
-    if (!WPACKET_reserve_bytes(thispkt, SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD
-                               - mac_size, NULL)
-            /*
-             * We also need next the amount of bytes written to this
-             * sub-packet
-             */
-            || !WPACKET_get_length(thispkt, &len)) {
+    if (!WPACKET_reserve_bytes(thispkt, SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD - mac_size, NULL)
+        /*
+         * We also need next the amount of bytes written to this
+         * sub-packet
+         */
+        || !WPACKET_get_length(thispkt, &len)) {
         RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
@@ -1681,10 +1689,10 @@ int tls_prepare_for_encryption_default(OSSL_RECORD_LAYER *rl,
 }
 
 int tls_post_encryption_processing_default(OSSL_RECORD_LAYER *rl,
-                                           size_t mac_size,
-                                           OSSL_RECORD_TEMPLATE *thistempl,
-                                           WPACKET *thispkt,
-                                           TLS_RL_RECORD *thiswr)
+    size_t mac_size,
+    OSSL_RECORD_TEMPLATE *thistempl,
+    WPACKET *thispkt,
+    TLS_RL_RECORD *thiswr)
 {
     size_t origlen, len;
     size_t headerlen = rl->isdtls ? DTLS1_RT_HEADER_LENGTH
@@ -1692,15 +1700,16 @@ int tls_post_encryption_processing_default(OSSL_RECORD_LAYER *rl,
 
     /* Allocate bytes for the encryption overhead */
     if (!WPACKET_get_length(thispkt, &origlen)
-               /* Check we allowed enough room for the encryption growth */
-            || !ossl_assert(origlen + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD
-                            - mac_size >= thiswr->length)
-            /* Encryption should never shrink the data! */
-            || origlen > thiswr->length
-            || (thiswr->length > origlen
-                && !WPACKET_allocate_bytes(thispkt,
-                                           thiswr->length - origlen,
-                                           NULL))) {
+        /* Check we allowed enough room for the encryption growth */
+        || !ossl_assert(origlen + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD
+                - mac_size
+            >= thiswr->length)
+        /* Encryption should never shrink the data! */
+        || origlen > thiswr->length
+        || (thiswr->length > origlen
+            && !WPACKET_allocate_bytes(thispkt,
+                thiswr->length - origlen,
+                NULL))) {
         RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
@@ -1708,7 +1717,7 @@ int tls_post_encryption_processing_default(OSSL_RECORD_LAYER *rl,
         unsigned char *mac;
 
         if (!WPACKET_allocate_bytes(thispkt, mac_size, &mac)
-                || !rl->funcs->mac(rl, thiswr, mac, 1)) {
+            || !rl->funcs->mac(rl, thiswr, mac, 1)) {
             RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return 0;
         }
@@ -1717,7 +1726,7 @@ int tls_post_encryption_processing_default(OSSL_RECORD_LAYER *rl,
     }
 
     if (!WPACKET_get_length(thispkt, &len)
-            || !WPACKET_close(thispkt)) {
+        || !WPACKET_close(thispkt)) {
         RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
@@ -1727,13 +1736,13 @@ int tls_post_encryption_processing_default(OSSL_RECORD_LAYER *rl,
 
         recordstart = WPACKET_get_curr(thispkt) - len - headerlen;
         rl->msg_callback(1, thiswr->rec_version, SSL3_RT_HEADER, recordstart,
-                         headerlen, rl->cbarg);
+            headerlen, rl->cbarg);
 
         if (rl->version == TLS1_3_VERSION && rl->enc_ctx != NULL) {
             unsigned char ctype = thistempl->type;
 
             rl->msg_callback(1, thiswr->rec_version, SSL3_RT_INNER_CONTENT_TYPE,
-                             &ctype, 1, rl->cbarg);
+                &ctype, 1, rl->cbarg);
         }
     }
 
@@ -1748,8 +1757,8 @@ int tls_post_encryption_processing_default(OSSL_RECORD_LAYER *rl,
 }
 
 int tls_write_records_default(OSSL_RECORD_LAYER *rl,
-                              OSSL_RECORD_TEMPLATE *templates,
-                              size_t numtempl)
+    OSSL_RECORD_TEMPLATE *templates,
+    size_t numtempl)
 {
     WPACKET pkt[SSL_MAX_PIPELINES + 1];
     TLS_RL_RECORD wr[SSL_MAX_PIPELINES + 1];
@@ -1775,8 +1784,8 @@ int tls_write_records_default(OSSL_RECORD_LAYER *rl,
     }
 
     if (!rl->funcs->initialise_write_packets(rl, templates, numtempl,
-                                             &prefixtempl, pkt, rl->wbuf,
-                                             &wpinited)) {
+            &prefixtempl, pkt, rl->wbuf,
+            &wpinited)) {
         /* RLAYERfatal() already called */
         goto err;
     }
@@ -1804,7 +1813,7 @@ int tls_write_records_default(OSSL_RECORD_LAYER *rl,
         TLS_RL_RECORD_set_rec_version(thiswr, thistempl->version);
 
         if (!rl->funcs->prepare_record_header(rl, thispkt, thistempl, rectype,
-                                              &compressdata)) {
+                &compressdata)) {
             /* RLAYERfatal() already called */
             goto err;
         }
@@ -1823,7 +1832,7 @@ int tls_write_records_default(OSSL_RECORD_LAYER *rl,
         /* first we compress */
         if (rl->compctx != NULL) {
             if (!tls_do_compress(rl, thiswr)
-                    || !WPACKET_allocate_bytes(thispkt, thiswr->length, NULL)) {
+                || !WPACKET_allocate_bytes(thispkt, thiswr->length, NULL)) {
                 RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_COMPRESSION_FAILURE);
                 goto err;
             }
@@ -1836,8 +1845,8 @@ int tls_write_records_default(OSSL_RECORD_LAYER *rl,
         }
 
         if (rl->funcs->add_record_padding != NULL
-                && !rl->funcs->add_record_padding(rl, thistempl, thispkt,
-                                                  thiswr)) {
+            && !rl->funcs->add_record_padding(rl, thistempl, thispkt,
+                thiswr)) {
             /* RLAYERfatal() already called */
             goto err;
         }
@@ -1870,7 +1879,7 @@ int tls_write_records_default(OSSL_RECORD_LAYER *rl,
         thistempl = (j < prefix) ? &prefixtempl : &templates[j - prefix];
 
         if (!rl->funcs->post_encryption_processing(rl, mac_size, thistempl,
-                                                   thispkt, thiswr)) {
+                thispkt, thiswr)) {
             /* RLAYERfatal() already called */
             goto err;
         }
@@ -1880,18 +1889,18 @@ int tls_write_records_default(OSSL_RECORD_LAYER *rl,
     }
 
     ret = 1;
- err:
+err:
     for (j = 0; j < wpinited; j++)
         WPACKET_cleanup(&pkt[j]);
     return ret;
 }
 
 int tls_write_records(OSSL_RECORD_LAYER *rl, OSSL_RECORD_TEMPLATE *templates,
-                      size_t numtempl)
+    size_t numtempl)
 {
     /* Check we don't have pending data waiting to write */
     if (!ossl_assert(rl->nextwbuf >= rl->numwpipes
-                     || TLS_BUFFER_get_left(&rl->wbuf[rl->nextwbuf]) == 0)) {
+            || TLS_BUFFER_get_left(&rl->wbuf[rl->nextwbuf]) == 0)) {
         RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
         return OSSL_RECORD_RETURN_FATAL;
     }
@@ -1925,10 +1934,8 @@ int tls_retry_write_records(OSSL_RECORD_LAYER *rl)
                 if (ret != OSSL_RECORD_RETURN_SUCCESS)
                     return ret;
             }
-            i = BIO_write(rl->bio, (char *)
-                          &(TLS_BUFFER_get_buf(thiswb)
-                            [TLS_BUFFER_get_offset(thiswb)]),
-                          (unsigned int)TLS_BUFFER_get_left(thiswb));
+            i = BIO_write(rl->bio, (char *)&(TLS_BUFFER_get_buf(thiswb)[TLS_BUFFER_get_offset(thiswb)]),
+                (unsigned int)TLS_BUFFER_get_left(thiswb));
             if (i >= 0) {
                 tmpwrit = i;
                 if (i == 0 && BIO_should_retry(rl->bio))
@@ -1940,7 +1947,7 @@ int tls_retry_write_records(OSSL_RECORD_LAYER *rl)
                     ret = OSSL_RECORD_RETURN_RETRY;
                 } else {
                     ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                                   "tls_retry_write_records failure");
+                        "tls_retry_write_records failure");
                     ret = OSSL_RECORD_RETURN_FATAL;
                 }
             }
@@ -1964,7 +1971,7 @@ int tls_retry_write_records(OSSL_RECORD_LAYER *rl)
                 continue;
 
             if (rl->nextwbuf == rl->numwpipes
-                    && (rl->mode & SSL_MODE_RELEASE_BUFFERS) != 0)
+                && (rl->mode & SSL_MODE_RELEASE_BUFFERS) != 0)
                 tls_release_write_buffer(rl);
             return OSSL_RECORD_RETURN_SUCCESS;
         } else if (i <= 0) {
@@ -1975,9 +1982,8 @@ int tls_retry_write_records(OSSL_RECORD_LAYER *rl)
                  */
                 TLS_BUFFER_set_left(thiswb, 0);
                 if (++(rl->nextwbuf) == rl->numwpipes
-                        && (rl->mode & SSL_MODE_RELEASE_BUFFERS) != 0)
+                    && (rl->mode & SSL_MODE_RELEASE_BUFFERS) != 0)
                     tls_release_write_buffer(rl);
-
             }
             return ret;
         }
@@ -2033,7 +2039,7 @@ void tls_set_max_pipelines(OSSL_RECORD_LAYER *rl, size_t max_pipelines)
 }
 
 void tls_get_state(OSSL_RECORD_LAYER *rl, const char **shortstr,
-                   const char **longstr)
+    const char **longstr)
 {
     const char *shrt, *lng;
 
@@ -2138,8 +2144,8 @@ int tls_free_buffers(OSSL_RECORD_LAYER *rl)
              * looks like real pending data and it is an error.
              */
             if (rl->nextwbuf != 0
-                    || rl->numwpipes != 1
-                    || TLS_BUFFER_get_left(&rl->wbuf[0]) != 0)
+                || rl->numwpipes != 1
+                || TLS_BUFFER_get_left(&rl->wbuf[0]) != 0)
                 return 0;
         }
         tls_release_write_buffer(rl);
@@ -2150,9 +2156,9 @@ int tls_free_buffers(OSSL_RECORD_LAYER *rl)
 
     /* If we have pending data to be read then fail */
     if (rl->curr_rec < rl->num_recs
-            || rl->curr_rec != rl->num_released
-            || TLS_BUFFER_get_left(&rl->rbuf) != 0
-            || rl->rstate == SSL_ST_READ_BODY)
+        || rl->curr_rec != rl->num_released
+        || TLS_BUFFER_get_left(&rl->rbuf) != 0
+        || rl->rstate == SSL_ST_READ_BODY)
         return 0;
 
     return tls_release_read_buffer(rl);
diff --git a/crypto/openssl/ssl/record/methods/tls_multib.c b/crypto/openssl/ssl/record/methods/tls_multib.c
index 3c2c30ef162a..e0a6dc6a579c 100644
--- a/crypto/openssl/ssl/record/methods/tls_multib.c
+++ b/crypto/openssl/ssl/record/methods/tls_multib.c
@@ -12,35 +12,33 @@
 #include "recmethod_local.h"
 
 #if defined(OPENSSL_SMALL_FOOTPRINT) \
-    || !(defined(AES_ASM) && (defined(__x86_64) \
-                              || defined(__x86_64__) \
-                              || defined(_M_AMD64) \
-                              || defined(_M_X64)))
-# undef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
-# define EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK 0
+    || !(defined(AES_ASM) && (defined(__x86_64) || defined(__x86_64__) || defined(_M_AMD64) || defined(_M_X64)))
+#undef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
+#define EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK 0
 #endif
 
 static int tls_is_multiblock_capable(OSSL_RECORD_LAYER *rl, uint8_t type,
-                                     size_t len, size_t fraglen)
+    size_t len, size_t fraglen)
 {
 #if !defined(OPENSSL_NO_MULTIBLOCK) && EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
     if (type == SSL3_RT_APPLICATION_DATA
-            && len >= 4 * fraglen
-            && rl->compctx == NULL
-            && rl->msg_callback == NULL
-            && !rl->use_etm
-            && RLAYER_USE_EXPLICIT_IV(rl)
-            && !BIO_get_ktls_send(rl->bio)
-            && (EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(rl->enc_ctx))
-                & EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK) != 0)
+        && len >= 4 * fraglen
+        && rl->compctx == NULL
+        && rl->msg_callback == NULL
+        && !rl->use_etm
+        && RLAYER_USE_EXPLICIT_IV(rl)
+        && !BIO_get_ktls_send(rl->bio)
+        && (EVP_CIPHER_get_flags(EVP_CIPHER_CTX_get0_cipher(rl->enc_ctx))
+               & EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)
+            != 0)
         return 1;
 #endif
     return 0;
 }
 
 size_t tls_get_max_records_multiblock(OSSL_RECORD_LAYER *rl, uint8_t type,
-                                      size_t len, size_t maxfrag,
-                                      size_t *preffrag)
+    size_t len, size_t maxfrag,
+    size_t *preffrag)
 {
     if (tls_is_multiblock_capable(rl, type, len, *preffrag)) {
         /* minimize address aliasing conflicts */
@@ -63,8 +61,8 @@ size_t tls_get_max_records_multiblock(OSSL_RECORD_LAYER *rl, uint8_t type,
  * -1 on fatal error.
  */
 static int tls_write_records_multiblock_int(OSSL_RECORD_LAYER *rl,
-                                            OSSL_RECORD_TEMPLATE *templates,
-                                            size_t numtempl)
+    OSSL_RECORD_TEMPLATE *templates,
+    size_t numtempl)
 {
 #if !defined(OPENSSL_NO_MULTIBLOCK) && EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
     size_t i;
@@ -84,15 +82,15 @@ static int tls_write_records_multiblock_int(OSSL_RECORD_LAYER *rl,
      */
     for (i = 1; i < numtempl; i++) {
         if (templates[i - 1].type != templates[i].type
-                || templates[i - 1].buflen != templates[i].buflen
-                || templates[i - 1].buf + templates[i - 1].buflen
-                   != templates[i].buf)
+            || templates[i - 1].buflen != templates[i].buflen
+            || templates[i - 1].buf + templates[i - 1].buflen
+                != templates[i].buf)
             return 0;
     }
 
     totlen = templates[0].buflen * numtempl;
     if (!tls_is_multiblock_capable(rl, templates[0].type, totlen,
-                                   templates[0].buflen))
+            templates[0].buflen))
         return 0;
 
     /*
@@ -109,8 +107,8 @@ static int tls_write_records_multiblock_int(OSSL_RECORD_LAYER *rl,
      * buffer sizes will be spotted and the buffer reallocated.
      */
     packlen = EVP_CIPHER_CTX_ctrl(rl->enc_ctx,
-                                  EVP_CTRL_TLS1_1_MULTIBLOCK_MAX_BUFSIZE,
-                                  (int)templates[0].buflen, NULL);
+        EVP_CTRL_TLS1_1_MULTIBLOCK_MAX_BUFSIZE,
+        (int)templates[0].buflen, NULL);
     packlen *= numtempl;
     if (!tls_setup_write_buffer(rl, 1, packlen, packlen)) {
         /* RLAYERfatal() already called */
@@ -130,8 +128,8 @@ static int tls_write_records_multiblock_int(OSSL_RECORD_LAYER *rl,
     mb_param.len = totlen;
 
     packleni = EVP_CIPHER_CTX_ctrl(rl->enc_ctx,
-                                   EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
-                                   sizeof(mb_param), &mb_param);
+        EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
+        sizeof(mb_param), &mb_param);
     packlen = (size_t)packleni;
     if (packleni <= 0 || packlen > wb->len) { /* never happens */
         RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
@@ -143,8 +141,9 @@ static int tls_write_records_multiblock_int(OSSL_RECORD_LAYER *rl,
     mb_param.len = totlen;
 
     if (EVP_CIPHER_CTX_ctrl(rl->enc_ctx,
-                            EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
-                            sizeof(mb_param), &mb_param) <= 0) {
+            EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
+            sizeof(mb_param), &mb_param)
+        <= 0) {
         RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return -1;
     }
@@ -152,21 +151,22 @@ static int tls_write_records_multiblock_int(OSSL_RECORD_LAYER *rl,
     rl->sequence[7] += mb_param.interleave;
     if (rl->sequence[7] < mb_param.interleave) {
         int j = 6;
-        while (j >= 0 && (++rl->sequence[j--]) == 0) ;
+        while (j >= 0 && (++rl->sequence[j--]) == 0)
+            ;
     }
 
     wb->offset = 0;
     wb->left = packlen;
 
     return 1;
-#else  /* !defined(OPENSSL_NO_MULTIBLOCK) && EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK */
+#else /* !defined(OPENSSL_NO_MULTIBLOCK) && EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK */
     return 0;
 #endif
 }
 
 int tls_write_records_multiblock(OSSL_RECORD_LAYER *rl,
-                                 OSSL_RECORD_TEMPLATE *templates,
-                                 size_t numtempl)
+    OSSL_RECORD_TEMPLATE *templates,
+    size_t numtempl)
 {
     int ret;
 
diff --git a/crypto/openssl/ssl/record/methods/tls_pad.c b/crypto/openssl/ssl/record/methods/tls_pad.c
index 23198f3a4935..8e92ae95109d 100644
--- a/crypto/openssl/ssl/record/methods/tls_pad.c
+++ b/crypto/openssl/ssl/record/methods/tls_pad.c
@@ -24,14 +24,14 @@
  */
 
 static int ssl3_cbc_copy_mac(size_t *reclen,
-                             size_t origreclen,
-                             unsigned char *recdata,
-                             unsigned char **mac,
-                             int *alloced,
-                             size_t block_size,
-                             size_t mac_size,
-                             size_t good,
-                             OSSL_LIB_CTX *libctx);
+    size_t origreclen,
+    unsigned char *recdata,
+    unsigned char **mac,
+    int *alloced,
+    size_t block_size,
+    size_t mac_size,
+    size_t good,
+    OSSL_LIB_CTX *libctx);
 
 /*-
  * ssl3_cbc_remove_padding removes padding from the decrypted, SSLv3, CBC
@@ -51,16 +51,16 @@ static int ssl3_cbc_copy_mac(size_t *reclen,
  *      MAC returned is random.
  */
 int ssl3_cbc_remove_padding_and_mac(size_t *reclen,
-                                    size_t origreclen,
-                                    unsigned char *recdata,
-                                    unsigned char **mac,
-                                    int *alloced,
-                                    size_t block_size, size_t mac_size,
-                                    OSSL_LIB_CTX *libctx)
+    size_t origreclen,
+    unsigned char *recdata,
+    unsigned char **mac,
+    int *alloced,
+    size_t block_size, size_t mac_size,
+    OSSL_LIB_CTX *libctx)
 {
     size_t padding_length;
     size_t good;
-    const size_t overhead = 1 /* padding length byte */  + mac_size;
+    const size_t overhead = 1 /* padding length byte */ + mac_size;
 
     /*
      * These lengths are all public so we can test them in non-constant time.
@@ -75,7 +75,7 @@ int ssl3_cbc_remove_padding_and_mac(size_t *reclen,
     *reclen -= good & (padding_length + 1);
 
     return ssl3_cbc_copy_mac(reclen, origreclen, recdata, mac, alloced,
-                             block_size, mac_size, good, libctx);
+        block_size, mac_size, good, libctx);
 }
 
 /*-
@@ -96,18 +96,18 @@ int ssl3_cbc_remove_padding_and_mac(size_t *reclen,
  *      MAC returned is random.
  */
 int tls1_cbc_remove_padding_and_mac(size_t *reclen,
-                                    size_t origreclen,
-                                    unsigned char *recdata,
-                                    unsigned char **mac,
-                                    int *alloced,
-                                    size_t block_size, size_t mac_size,
-                                    int aead,
-                                    OSSL_LIB_CTX *libctx)
+    size_t origreclen,
+    unsigned char *recdata,
+    unsigned char **mac,
+    int *alloced,
+    size_t block_size, size_t mac_size,
+    int aead,
+    OSSL_LIB_CTX *libctx)
 {
     size_t good = -1;
     size_t padding_length, to_check, i;
     size_t overhead = ((block_size == 1) ? 0 : 1) /* padding length byte */
-                      + mac_size;
+        + mac_size;
 
     /*
      * These lengths are all public so we can test them in non-constant
@@ -136,7 +136,7 @@ int tls1_cbc_remove_padding_and_mac(size_t *reclen,
          * maximum amount of padding possible. (Again, the length of the record
          * is public information so we can use it.)
          */
-        to_check = 256;        /* maximum amount of padding, inc length byte. */
+        to_check = 256; /* maximum amount of padding, inc length byte. */
         if (to_check > *reclen)
             to_check = *reclen;
 
@@ -159,7 +159,7 @@ int tls1_cbc_remove_padding_and_mac(size_t *reclen,
     }
 
     return ssl3_cbc_copy_mac(reclen, origreclen, recdata, mac, alloced,
-                             block_size, mac_size, good, libctx);
+        block_size, mac_size, good, libctx);
 }
 
 /*-
@@ -180,14 +180,14 @@ int tls1_cbc_remove_padding_and_mac(size_t *reclen,
 #define CBC_MAC_ROTATE_IN_PLACE
 
 static int ssl3_cbc_copy_mac(size_t *reclen,
-                             size_t origreclen,
-                             unsigned char *recdata,
-                             unsigned char **mac,
-                             int *alloced,
-                             size_t block_size,
-                             size_t mac_size,
-                             size_t good,
-                             OSSL_LIB_CTX *libctx)
+    size_t origreclen,
+    unsigned char *recdata,
+    unsigned char **mac,
+    int *alloced,
+    size_t block_size,
+    size_t mac_size,
+    size_t good,
+    OSSL_LIB_CTX *libctx)
 {
 #if defined(CBC_MAC_ROTATE_IN_PLACE)
     unsigned char rotated_mac_buf[64 + EVP_MAX_MD_SIZE];
@@ -214,7 +214,7 @@ static int ssl3_cbc_copy_mac(size_t *reclen,
     size_t rotate_offset;
 
     if (!ossl_assert(origreclen >= mac_size
-                     && mac_size <= EVP_MAX_MD_SIZE))
+            && mac_size <= EVP_MAX_MD_SIZE))
         return 0;
 
     /* If no MAC then nothing to be done */
@@ -286,8 +286,8 @@ static int ssl3_cbc_copy_mac(size_t *reclen,
 
         /* If the padding wasn't good we emit a random MAC */
         out[j++] = constant_time_select_8((unsigned char)(good & 0xff),
-                                          aux3,
-                                          randmac[i]);
+            aux3,
+            randmac[i]);
         rotate_offset &= constant_time_lt_s(rotate_offset, mac_size);
     }
 #else
@@ -302,7 +302,7 @@ static int ssl3_cbc_copy_mac(size_t *reclen,
 
         /* If the padding wasn't good we emit a random MAC */
         out[i] = constant_time_select_8((unsigned char)(good & 0xff), out[i],
-                                        randmac[i]);
+            randmac[i]);
     }
 #endif
 
diff --git a/crypto/openssl/ssl/record/methods/tlsany_meth.c b/crypto/openssl/ssl/record/methods/tlsany_meth.c
index bbe873aaf516..996172543979 100644
--- a/crypto/openssl/ssl/record/methods/tlsany_meth.c
+++ b/crypto/openssl/ssl/record/methods/tlsany_meth.c
@@ -12,17 +12,17 @@
 #include "../record_local.h"
 #include "recmethod_local.h"
 
-#define MIN_SSL2_RECORD_LEN     9
+#define MIN_SSL2_RECORD_LEN 9
 
 static int tls_any_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
-                                    unsigned char *key, size_t keylen,
-                                    unsigned char *iv, size_t ivlen,
-                                    unsigned char *mackey, size_t mackeylen,
-                                    const EVP_CIPHER *ciph,
-                                    size_t taglen,
-                                    int mactype,
-                                    const EVP_MD *md,
-                                    COMP_METHOD *comp)
+    unsigned char *key, size_t keylen,
+    unsigned char *iv, size_t ivlen,
+    unsigned char *mackey, size_t mackeylen,
+    const EVP_CIPHER *ciph,
+    size_t taglen,
+    int mactype,
+    const EVP_MD *md,
+    COMP_METHOD *comp)
 {
     if (level != OSSL_RECORD_PROTECTION_LEVEL_NONE) {
         ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
@@ -35,8 +35,8 @@ static int tls_any_set_crypto_state(OSSL_RECORD_LAYER *rl, int level,
 }
 
 static int tls_any_cipher(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *recs,
-                          size_t n_recs, int sending, SSL_MAC_BUF *macs,
-                          size_t macsize)
+    size_t n_recs, int sending, SSL_MAC_BUF *macs,
+    size_t macsize)
 {
     return 1;
 }
@@ -64,29 +64,22 @@ static int tls_validate_record_header(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec)
                      * we have.
                      */
                     p = rl->packet;
-                    if (HAS_PREFIX((char *)p, "GET ") ||
-                        HAS_PREFIX((char *)p, "POST ") ||
-                        HAS_PREFIX((char *)p, "HEAD ") ||
-                        HAS_PREFIX((char *)p, "PATCH") ||
-                        HAS_PREFIX((char *)p, "OPTIO") ||
-                        HAS_PREFIX((char *)p, "DELET") ||
-                        HAS_PREFIX((char *)p, "TRACE") ||
-                        HAS_PREFIX((char *)p, "PUT ")) {
+                    if (HAS_PREFIX((char *)p, "GET ") || HAS_PREFIX((char *)p, "POST ") || HAS_PREFIX((char *)p, "HEAD ") || HAS_PREFIX((char *)p, "PATCH") || HAS_PREFIX((char *)p, "OPTIO") || HAS_PREFIX((char *)p, "DELET") || HAS_PREFIX((char *)p, "TRACE") || HAS_PREFIX((char *)p, "PUT ")) {
                         RLAYERfatal(rl, SSL_AD_NO_ALERT, SSL_R_HTTP_REQUEST);
                         return 0;
                     } else if (HAS_PREFIX((char *)p, "CONNE")) {
                         RLAYERfatal(rl, SSL_AD_NO_ALERT,
-                                    SSL_R_HTTPS_PROXY_REQUEST);
+                            SSL_R_HTTPS_PROXY_REQUEST);
                         return 0;
                     }
 
                     /* Doesn't look like TLS - don't send an alert */
                     RLAYERfatal(rl, SSL_AD_NO_ALERT,
-                                SSL_R_WRONG_VERSION_NUMBER);
+                        SSL_R_WRONG_VERSION_NUMBER);
                     return 0;
                 } else {
                     RLAYERfatal(rl, SSL_AD_PROTOCOL_VERSION,
-                                SSL_R_WRONG_VERSION_NUMBER);
+                        SSL_R_WRONG_VERSION_NUMBER);
                     return 0;
                 }
             }
@@ -108,14 +101,14 @@ static int tls_validate_record_header(OSSL_RECORD_LAYER *rl, TLS_RL_RECORD *rec)
                      * end.
                      */
                     RLAYERfatal(rl, SSL_AD_NO_ALERT,
-                                SSL_R_WRONG_VERSION_NUMBER);
+                        SSL_R_WRONG_VERSION_NUMBER);
                     return 0;
                 }
                 /* Send back error using their minor version number */
                 rl->version = (unsigned short)rec->rec_version;
             }
             RLAYERfatal(rl, SSL_AD_PROTOCOL_VERSION,
-                        SSL_R_WRONG_VERSION_NUMBER);
+                SSL_R_WRONG_VERSION_NUMBER);
             return 0;
         }
     }
@@ -141,9 +134,9 @@ static int tls_any_set_protocol_version(OSSL_RECORD_LAYER *rl, int vers)
 }
 
 static int tls_any_prepare_for_encryption(OSSL_RECORD_LAYER *rl,
-                                          size_t mac_size,
-                                          WPACKET *thispkt,
-                                          TLS_RL_RECORD *thiswr)
+    size_t mac_size,
+    WPACKET *thispkt,
+    TLS_RL_RECORD *thiswr)
 {
     /* No encryption, so nothing to do */
     return 1;
diff --git a/crypto/openssl/ssl/record/rec_layer_d1.c b/crypto/openssl/ssl/record/rec_layer_d1.c
index 111fbaf7d3a4..a6ddbbffe460 100644
--- a/crypto/openssl/ssl/record/rec_layer_d1.c
+++ b/crypto/openssl/ssl/record/rec_layer_d1.c
@@ -118,11 +118,9 @@ static int dtls_buffer_record(SSL_CONNECTION *s, TLS_RECORD *rec)
 
 #ifndef OPENSSL_NO_SCTP
     /* Store bio_dgram_sctp_rcvinfo struct */
-    if (BIO_dgram_is_sctp(s->rbio) &&
-        (ossl_statem_get_state(s) == TLS_ST_SR_FINISHED
-         || ossl_statem_get_state(s) == TLS_ST_CR_FINISHED)) {
+    if (BIO_dgram_is_sctp(s->rbio) && (ossl_statem_get_state(s) == TLS_ST_SR_FINISHED || ossl_statem_get_state(s) == TLS_ST_CR_FINISHED)) {
         BIO_ctrl(s->rbio, BIO_CTRL_DGRAM_SCTP_GET_RCVINFO,
-                 sizeof(rdata->recordinfo), &rdata->recordinfo);
+            sizeof(rdata->recordinfo), &rdata->recordinfo);
     }
 #endif
 
@@ -158,7 +156,7 @@ static void dtls_unbuffer_record(SSL_CONNECTION *s)
         /* Restore bio_dgram_sctp_rcvinfo struct */
         if (BIO_dgram_is_sctp(s->rbio)) {
             BIO_ctrl(s->rbio, BIO_CTRL_DGRAM_SCTP_SET_RCVINFO,
-                     sizeof(rdata->recordinfo), &rdata->recordinfo);
+                sizeof(rdata->recordinfo), &rdata->recordinfo);
         }
 #endif
 
@@ -197,21 +195,19 @@ static void dtls_unbuffer_record(SSL_CONNECTION *s)
  *             none of our business
  */
 int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
-                     unsigned char *buf, size_t len,
-                     int peek, size_t *readbytes)
+    unsigned char *buf, size_t len,
+    int peek, size_t *readbytes)
 {
     int i, j, ret;
     size_t n;
     TLS_RECORD *rr;
-    void (*cb) (const SSL *ssl, int type2, int val) = NULL;
+    void (*cb)(const SSL *ssl, int type2, int val) = NULL;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 
     if (sc == NULL)
         return -1;
 
-    if ((type && (type != SSL3_RT_APPLICATION_DATA) &&
-         (type != SSL3_RT_HANDSHAKE)) ||
-        (peek && (type != SSL3_RT_APPLICATION_DATA))) {
+    if ((type && (type != SSL3_RT_APPLICATION_DATA) && (type != SSL3_RT_HANDSHAKE)) || (peek && (type != SSL3_RT_APPLICATION_DATA))) {
         SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return -1;
     }
@@ -226,7 +222,7 @@ int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
             return -1;
     }
 
- start:
+start:
     sc->rwstate = SSL_NOTHING;
 
     /*
@@ -251,17 +247,17 @@ int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
             rr = &sc->rlayer.tlsrecs[sc->rlayer.num_recs];
 
             ret = HANDLE_RLAYER_READ_RETURN(sc,
-                    sc->rlayer.rrlmethod->read_record(sc->rlayer.rrl,
-                                                      &rr->rechandle,
-                                                      &rr->version, &rr->type,
-                                                      &rr->data, &rr->length,
-                                                      &rr->epoch, rr->seq_num));
+                sc->rlayer.rrlmethod->read_record(sc->rlayer.rrl,
+                    &rr->rechandle,
+                    &rr->version, &rr->type,
+                    &rr->data, &rr->length,
+                    &rr->epoch, rr->seq_num));
             if (ret <= 0) {
                 ret = dtls1_read_failed(sc, ret);
                 /*
-                * Anything other than a timeout is an error. SSLfatal() already
-                * called if appropriate.
-                */
+                 * Anything other than a timeout is an error. SSLfatal() already
+                 * called if appropriate.
+                 */
                 if (ret <= 0)
                     return ret;
                 else
@@ -270,7 +266,7 @@ int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
             rr->off = 0;
             sc->rlayer.num_recs++;
         } while (sc->rlayer.rrlmethod->processed_read_pending(sc->rlayer.rrl)
-                 && sc->rlayer.num_recs < SSL_MAX_PIPELINES);
+            && sc->rlayer.num_recs < SSL_MAX_PIPELINES);
     }
     rr = &sc->rlayer.tlsrecs[sc->rlayer.curr_rec];
 
@@ -284,7 +280,7 @@ int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
     /* we now have a packet which can be read and processed */
 
     if (sc->s3.change_cipher_spec /* set when we receive ChangeCipherSpec,
-                                  * reset by ssl3_get_finished */
+                                   * reset by ssl3_get_finished */
         && (rr->type != SSL3_RT_HANDSHAKE)) {
         /*
          * We now have application data between CCS and Finished. Most likely
@@ -324,9 +320,9 @@ int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
          * doing a handshake for the first time
          */
         if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA)
-                && (SSL_IS_FIRST_HANDSHAKE(sc))) {
+            && (SSL_IS_FIRST_HANDSHAKE(sc))) {
             SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE,
-                     SSL_R_APP_DATA_IN_HANDSHAKE);
+                SSL_R_APP_DATA_IN_HANDSHAKE);
             return -1;
         }
 
@@ -363,8 +359,7 @@ int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
          * app data. If there was an alert and there is no message to read
          * anymore, finally set shutdown.
          */
-        if (BIO_dgram_is_sctp(SSL_get_rbio(s)) &&
-            sc->d1->shutdown_received
+        if (BIO_dgram_is_sctp(SSL_get_rbio(s)) && sc->d1->shutdown_received
             && BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s)) <= 0) {
             sc->shutdown |= SSL_RECEIVED_SHUTDOWN;
             return 0;
@@ -385,16 +380,16 @@ int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
         PACKET alert;
 
         if (!PACKET_buf_init(&alert, alert_bytes, rr->length)
-                || !PACKET_get_1(&alert, &alert_level)
-                || !PACKET_get_1(&alert, &alert_descr)
-                || PACKET_remaining(&alert) != 0) {
+            || !PACKET_get_1(&alert, &alert_level)
+            || !PACKET_get_1(&alert, &alert_descr)
+            || PACKET_remaining(&alert) != 0) {
             SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_INVALID_ALERT);
             return -1;
         }
 
         if (sc->msg_callback)
             sc->msg_callback(0, sc->version, SSL3_RT_ALERT, alert_bytes, 2, s,
-                             sc->msg_callback_arg);
+                sc->msg_callback_arg);
 
         if (sc->info_callback != NULL)
             cb = sc->info_callback;
@@ -414,7 +409,7 @@ int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
             sc->rlayer.alert_count++;
             if (sc->rlayer.alert_count == MAX_WARN_ALERT_COUNT) {
                 SSLfatal(sc, SSL_AD_UNEXPECTED_MESSAGE,
-                         SSL_R_TOO_MANY_WARN_ALERTS);
+                    SSL_R_TOO_MANY_WARN_ALERTS);
                 return -1;
             }
 
@@ -425,8 +420,7 @@ int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
                  * after a close_notify alert. We have to check this first so
                  * that nothing gets discarded.
                  */
-                if (BIO_dgram_is_sctp(SSL_get_rbio(s)) &&
-                    BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s)) > 0) {
+                if (BIO_dgram_is_sctp(SSL_get_rbio(s)) && BIO_dgram_sctp_msg_waiting(SSL_get_rbio(s)) > 0) {
                     sc->d1->shutdown_received = 1;
                     sc->rwstate = SSL_READING;
                     BIO_clear_retry_flags(SSL_get_rbio(s));
@@ -452,8 +446,8 @@ int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
             sc->rwstate = SSL_NOTHING;
             sc->s3.fatal_alert = alert_descr;
             SSLfatal_data(sc, SSL_AD_NO_ALERT,
-                          SSL_AD_REASON_OFFSET + alert_descr,
-                          "SSL alert number %d", alert_descr);
+                SSL_AD_REASON_OFFSET + alert_descr,
+                "SSL alert number %d", alert_descr);
             sc->shutdown |= SSL_RECEIVED_SHUTDOWN;
             if (!ssl_release_record(sc, rr, 0))
                 return -1;
@@ -468,7 +462,7 @@ int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
     }
 
     if (sc->shutdown & SSL_SENT_SHUTDOWN) { /* but we have not received a
-                                            * shutdown */
+                                             * shutdown */
         sc->rwstate = SSL_NOTHING;
         if (!ssl_release_record(sc, rr, 0))
             return -1;
@@ -496,7 +490,7 @@ int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
          * at least enough record bytes for a message header
          */
         if (rr->epoch != sc->rlayer.d->r_epoch
-                || rr->length < DTLS1_HM_HEADER_LENGTH) {
+            || rr->length < DTLS1_HM_HEADER_LENGTH) {
             if (!ssl_release_record(sc, rr, 0))
                 return -1;
             goto start;
@@ -599,9 +593,7 @@ int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
          * application data at this point (session renegotiation not yet
          * started), we will indulge it.
          */
-        if (sc->s3.in_read_app_data &&
-            (sc->s3.total_renegotiations != 0) &&
-            ossl_statem_app_data_allowed(sc)) {
+        if (sc->s3.in_read_app_data && (sc->s3.total_renegotiations != 0) && ossl_statem_app_data_allowed(sc)) {
             sc->s3.in_read_app_data = 2;
             return -1;
         } else {
@@ -617,7 +609,7 @@ int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
  * not all data has been sent or non-blocking IO.
  */
 int dtls1_write_bytes(SSL_CONNECTION *s, uint8_t type, const void *buf,
-                      size_t len, size_t *written)
+    size_t len, size_t *written)
 {
     int i;
 
@@ -631,7 +623,7 @@ int dtls1_write_bytes(SSL_CONNECTION *s, uint8_t type, const void *buf,
 }
 
 int do_dtls1_write(SSL_CONNECTION *sc, uint8_t type, const unsigned char *buf,
-                   size_t len, size_t *written)
+    size_t len, size_t *written)
 {
     int i;
     OSSL_RECORD_TEMPLATE tmpl;
@@ -661,7 +653,7 @@ int do_dtls1_write(SSL_CONNECTION *sc, uint8_t type, const unsigned char *buf,
      * header: otherwise some clients will ignore it.
      */
     if (s->method->version == DTLS_ANY_VERSION
-            && sc->max_proto_version != DTLS1_BAD_VER)
+        && sc->max_proto_version != DTLS1_BAD_VER)
         tmpl.version = DTLS1_VERSION;
     else
         tmpl.version = sc->version;
@@ -669,7 +661,7 @@ int do_dtls1_write(SSL_CONNECTION *sc, uint8_t type, const unsigned char *buf,
     tmpl.buflen = len;
 
     ret = HANDLE_RLAYER_WRITE_RETURN(sc,
-              sc->rlayer.wrlmethod->write_records(sc->rlayer.wrl, &tmpl, 1));
+        sc->rlayer.wrlmethod->write_records(sc->rlayer.wrl, &tmpl, 1));
 
     if (ret > 0)
         *written = (int)len;
@@ -692,7 +684,8 @@ void dtls1_increment_epoch(SSL_CONNECTION *s, int rw)
     }
 }
 
-uint16_t dtls1_get_epoch(SSL_CONNECTION *s, int rw) {
+uint16_t dtls1_get_epoch(SSL_CONNECTION *s, int rw)
+{
     uint16_t epoch;
 
     if (rw & SSL3_CC_READ)
diff --git a/crypto/openssl/ssl/record/rec_layer_s3.c b/crypto/openssl/ssl/record/rec_layer_s3.c
index 889b12dd66d0..ba407478b412 100644
--- a/crypto/openssl/ssl/record/rec_layer_s3.c
+++ b/crypto/openssl/ssl/record/rec_layer_s3.c
@@ -36,9 +36,8 @@ int RECORD_LAYER_clear(RECORD_LAYER *rl)
     /* Clear any buffered records we no longer need */
     while (rl->curr_rec < rl->num_recs)
         ret &= ssl_release_record(rl->s,
-                                  &(rl->tlsrecs[rl->curr_rec++]),
-                                  0);
-
+            &(rl->tlsrecs[rl->curr_rec++]),
+            0);
 
     rl->wnum = 0;
     memset(rl->handshake_fragment, 0, sizeof(rl->handshake_fragment));
@@ -78,20 +77,22 @@ int RECORD_LAYER_reset(RECORD_LAYER *rl)
 
     /* We try and reset both record layers even if one fails */
     ret &= ssl_set_new_record_layer(rl->s,
-                                    SSL_CONNECTION_IS_DTLS(rl->s)
-                                        ? DTLS_ANY_VERSION : TLS_ANY_VERSION,
-                                    OSSL_RECORD_DIRECTION_READ,
-                                    OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0,
-                                    NULL, 0, NULL, 0, NULL,  0, NULL, 0,
-                                    NID_undef, NULL, NULL, NULL);
+        SSL_CONNECTION_IS_DTLS(rl->s)
+            ? DTLS_ANY_VERSION
+            : TLS_ANY_VERSION,
+        OSSL_RECORD_DIRECTION_READ,
+        OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0,
+        NULL, 0, NULL, 0, NULL, 0, NULL, 0,
+        NID_undef, NULL, NULL, NULL);
 
     ret &= ssl_set_new_record_layer(rl->s,
-                                    SSL_CONNECTION_IS_DTLS(rl->s)
-                                        ? DTLS_ANY_VERSION : TLS_ANY_VERSION,
-                                    OSSL_RECORD_DIRECTION_WRITE,
-                                    OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0,
-                                    NULL, 0, NULL, 0, NULL,  0, NULL, 0,
-                                    NID_undef, NULL, NULL, NULL);
+        SSL_CONNECTION_IS_DTLS(rl->s)
+            ? DTLS_ANY_VERSION
+            : TLS_ANY_VERSION,
+        OSSL_RECORD_DIRECTION_WRITE,
+        OSSL_RECORD_PROTECTION_LEVEL_NONE, NULL, 0,
+        NULL, 0, NULL, 0, NULL, 0, NULL, 0,
+        NID_undef, NULL, NULL, NULL);
 
     /* SSLfatal already called in the event of failure */
     return ret;
@@ -107,7 +108,7 @@ int RECORD_LAYER_read_pending(const RECORD_LAYER *rl)
 int RECORD_LAYER_processed_read_pending(const RECORD_LAYER *rl)
 {
     return (rl->curr_rec < rl->num_recs)
-           || rl->rrlmethod->processed_read_pending(rl->rrl);
+        || rl->rrlmethod->processed_read_pending(rl->rrl);
 }
 
 int RECORD_LAYER_write_pending(const RECORD_LAYER *rl)
@@ -127,7 +128,7 @@ static uint32_t ossl_get_max_early_data(SSL_CONNECTION *s)
      */
     if (!s->server && sess->ext.max_early_data == 0) {
         if (!ossl_assert(s->psksession != NULL
-                         && s->psksession->ext.max_early_data > 0)) {
+                && s->psksession->ext.max_early_data > 0)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return 0;
         }
@@ -140,13 +141,14 @@ static uint32_t ossl_get_max_early_data(SSL_CONNECTION *s)
         max_early_data = s->recv_max_early_data;
     else
         max_early_data = s->recv_max_early_data < sess->ext.max_early_data
-                         ? s->recv_max_early_data : sess->ext.max_early_data;
+            ? s->recv_max_early_data
+            : sess->ext.max_early_data;
 
     return max_early_data;
 }
 
 static int ossl_early_data_count_ok(SSL_CONNECTION *s, size_t length,
-                                    size_t overhead, int send)
+    size_t overhead, int send)
 {
     uint32_t max_early_data;
 
@@ -154,7 +156,7 @@ static int ossl_early_data_count_ok(SSL_CONNECTION *s, size_t length,
 
     if (max_early_data == 0) {
         SSLfatal(s, send ? SSL_AD_INTERNAL_ERROR : SSL_AD_UNEXPECTED_MESSAGE,
-                 SSL_R_TOO_MUCH_EARLY_DATA);
+            SSL_R_TOO_MUCH_EARLY_DATA);
         return 0;
     }
 
@@ -163,7 +165,7 @@ static int ossl_early_data_count_ok(SSL_CONNECTION *s, size_t length,
 
     if (s->early_data_count + length > max_early_data) {
         SSLfatal(s, send ? SSL_AD_INTERNAL_ERROR : SSL_AD_UNEXPECTED_MESSAGE,
-                 SSL_R_TOO_MUCH_EARLY_DATA);
+            SSL_R_TOO_MUCH_EARLY_DATA);
         return 0;
     }
     s->early_data_count += length;
@@ -248,7 +250,7 @@ const char *SSL_rstate_string(const SSL *s)
 }
 
 static int tls_write_check_pending(SSL_CONNECTION *s, uint8_t type,
-                                   const unsigned char *buf, size_t len)
+    const unsigned char *buf, size_t len)
 {
     if (s->rlayer.wpend_tot == 0)
         return 0;
@@ -269,7 +271,7 @@ static int tls_write_check_pending(SSL_CONNECTION *s, uint8_t type,
  * not all data has been sent or non-blocking IO.
  */
 int ssl3_write_bytes(SSL *ssl, uint8_t type, const void *buf_, size_t len,
-                     size_t *written)
+    size_t *written)
 {
     const unsigned char *buf = buf_;
     size_t tot;
@@ -301,7 +303,7 @@ int ssl3_write_bytes(SSL *ssl, uint8_t type, const void *buf_, size_t len,
     }
 
     if (s->early_data_state == SSL_EARLY_DATA_WRITING
-            && !ossl_early_data_count_ok(s, len, 0, 1)) {
+        && !ossl_early_data_count_ok(s, len, 0, 1)) {
         /* SSLfatal() already called */
         return -1;
     }
@@ -313,8 +315,7 @@ int ssl3_write_bytes(SSL *ssl, uint8_t type, const void *buf_, size_t len,
      * into init unless we have writes pending - in which case we should finish
      * doing that first.
      */
-    if (s->rlayer.wpend_tot == 0 && (s->key_update != SSL_KEY_UPDATE_NONE
-                                     || s->ext.extra_tickets_expected > 0))
+    if (s->rlayer.wpend_tot == 0 && (s->key_update != SSL_KEY_UPDATE_NONE || s->ext.extra_tickets_expected > 0))
         ossl_statem_set_in_init(s, 1);
 
     /*
@@ -323,7 +324,7 @@ int ssl3_write_bytes(SSL *ssl, uint8_t type, const void *buf_, size_t len,
      * messages yet.
      */
     if (SSL_in_init(ssl) && !ossl_statem_get_in_handshake(s)
-            && s->early_data_state != SSL_EARLY_DATA_UNAUTH_WRITING) {
+        && s->early_data_state != SSL_EARLY_DATA_UNAUTH_WRITING) {
         i = s->handshake_func(ssl);
         /* SSLfatal() already called */
         if (i < 0)
@@ -340,7 +341,7 @@ int ssl3_write_bytes(SSL *ssl, uint8_t type, const void *buf_, size_t len,
     } else if (i > 0) {
         /* Retry needed */
         i = HANDLE_RLAYER_WRITE_RETURN(s,
-                s->rlayer.wrlmethod->retry_write_records(s->rlayer.wrl));
+            s->rlayer.wrlmethod->retry_write_records(s->rlayer.wrl));
         if (i <= 0) {
             s->rlayer.wnum = tot;
             return i;
@@ -359,7 +360,7 @@ int ssl3_write_bytes(SSL *ssl, uint8_t type, const void *buf_, size_t len,
         s->rlayer.wpend_buf = buf;
     }
 
-    if (tot == len) {           /* done? */
+    if (tot == len) { /* done? */
         *written = tot;
         return 1;
     }
@@ -381,8 +382,8 @@ int ssl3_write_bytes(SSL *ssl, uint8_t type, const void *buf_, size_t len,
     split_send_fragment = ssl_get_split_send_fragment(s);
 
     if (max_send_fragment == 0
-            || split_send_fragment == 0
-            || split_send_fragment > max_send_fragment) {
+        || split_send_fragment == 0
+        || split_send_fragment > max_send_fragment) {
         /*
          * We should have prevented this when we set/get the split and max send
          * fragments so we shouldn't get here
@@ -397,9 +398,9 @@ int ssl3_write_bytes(SSL *ssl, uint8_t type, const void *buf_, size_t len,
      */
     recversion = (s->version == TLS1_3_VERSION) ? TLS1_2_VERSION : s->version;
     if (SSL_get_state(ssl) == TLS_ST_CW_CLNT_HELLO
-            && !s->renegotiate
-            && TLS1_get_version(ssl) > TLS1_VERSION
-            && s->hello_retry_request == SSL_HRR_NONE)
+        && !s->renegotiate
+        && TLS1_get_version(ssl) > TLS1_VERSION
+        && s->hello_retry_request == SSL_HRR_NONE)
         recversion = TLS1_VERSION;
 
     for (;;) {
@@ -407,18 +408,18 @@ int ssl3_write_bytes(SSL *ssl, uint8_t type, const void *buf_, size_t len,
         size_t j, lensofar = 0;
 
         /*
-        * Ask the record layer how it would like to split the amount of data
-        * that we have, and how many of those records it would like in one go.
-        */
+         * Ask the record layer how it would like to split the amount of data
+         * that we have, and how many of those records it would like in one go.
+         */
         maxpipes = s->rlayer.wrlmethod->get_max_records(s->rlayer.wrl, type, n,
-                                                        max_send_fragment,
-                                                        &split_send_fragment);
+            max_send_fragment,
+            &split_send_fragment);
         /*
-        * If max_pipelines is 0 then this means "undefined" and we default to
-        * whatever the record layer wants to do. Otherwise we use the smallest
-        * value from the number requested by the record layer, and max number
-        * configured by the user.
-        */
+         * If max_pipelines is 0 then this means "undefined" and we default to
+         * whatever the record layer wants to do. Otherwise we use the smallest
+         * value from the number requested by the record layer, and max number
+         * configured by the user.
+         */
         if (s->max_pipelines > 0 && maxpipes > s->max_pipelines)
             maxpipes = s->max_pipelines;
 
@@ -475,8 +476,8 @@ int ssl3_write_bytes(SSL *ssl, uint8_t type, const void *buf_, size_t len,
         }
 
         if (s->rlayer.wpend_tot == n
-                || (type == SSL3_RT_APPLICATION_DATA
-                    && (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE) != 0)) {
+            || (type == SSL3_RT_APPLICATION_DATA
+                && (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE) != 0)) {
             *written = tot + s->rlayer.wpend_tot;
             s->rlayer.wpend_tot = 0;
             return 1;
@@ -488,7 +489,7 @@ int ssl3_write_bytes(SSL *ssl, uint8_t type, const void *buf_, size_t len,
 }
 
 int ossl_tls_handle_rlayer_return(SSL_CONNECTION *s, int writing, int ret,
-                                  char *file, int line)
+    char *file, int line)
 {
     SSL *ssl = SSL_CONNECTION_GET_SSL(s);
 
@@ -506,7 +507,7 @@ int ossl_tls_handle_rlayer_return(SSL_CONNECTION *s, int writing, int ret,
                 ERR_new();
                 ERR_set_debug(file, line, 0);
                 ossl_statem_fatal(s, SSL_AD_INTERNAL_ERROR,
-                                  ERR_R_INTERNAL_ERROR, NULL);
+                    ERR_R_INTERNAL_ERROR, NULL);
                 ret = OSSL_RECORD_RETURN_FATAL;
             } else if ((s->options & SSL_OP_IGNORE_UNEXPECTED_EOF) != 0) {
                 SSL_set_shutdown(ssl, SSL_RECEIVED_SHUTDOWN);
@@ -519,7 +520,7 @@ int ossl_tls_handle_rlayer_return(SSL_CONNECTION *s, int writing, int ret,
                  * applications for control flow decisions.
                  */
                 ossl_statem_fatal(s, SSL_AD_DECODE_ERROR,
-                                  SSL_R_UNEXPECTED_EOF_WHILE_READING, NULL);
+                    SSL_R_UNEXPECTED_EOF_WHILE_READING, NULL);
             }
         } else if (ret == OSSL_RECORD_RETURN_FATAL) {
             int al = s->rlayer.rrlmethod->get_alert_code(s->rlayer.rrl);
@@ -564,8 +565,9 @@ int ssl_release_record(SSL_CONNECTION *s, TLS_RECORD *rr, size_t length)
         /* The record layer allocated the buffers for this record */
         if (HANDLE_RLAYER_READ_RETURN(s,
                 s->rlayer.rrlmethod->release_record(s->rlayer.rrl,
-                                                    rr->rechandle,
-                                                    length)) <= 0) {
+                    rr->rechandle,
+                    length))
+            <= 0) {
             /* RLAYER_fatal already called */
             return 0;
         }
@@ -618,13 +620,13 @@ int ssl_release_record(SSL_CONNECTION *s, TLS_RECORD *rr, size_t length)
  *             none of our business
  */
 int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type,
-                    unsigned char *buf, size_t len,
-                    int peek, size_t *readbytes)
+    unsigned char *buf, size_t len,
+    int peek, size_t *readbytes)
 {
     int i, j, ret;
     size_t n, curr_rec, totalbytes;
     TLS_RECORD *rr;
-    void (*cb) (const SSL *ssl, int type2, int val) = NULL;
+    void (*cb)(const SSL *ssl, int type2, int val) = NULL;
     int is_tls13;
     SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
 
@@ -639,7 +641,7 @@ int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type,
     }
 
     if ((type == SSL3_RT_HANDSHAKE) && (s->rlayer.handshake_fragment_len > 0))
-        /* (partially) satisfy request from storage */
+    /* (partially) satisfy request from storage */
     {
         unsigned char *src = s->rlayer.handshake_fragment;
         unsigned char *dst = buf;
@@ -677,7 +679,7 @@ int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type,
         if (i == 0)
             return -1;
     }
- start:
+start:
     s->rwstate = SSL_NOTHING;
 
     /*-
@@ -694,11 +696,11 @@ int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type,
             rr = &s->rlayer.tlsrecs[s->rlayer.num_recs];
 
             ret = HANDLE_RLAYER_READ_RETURN(s,
-                    s->rlayer.rrlmethod->read_record(s->rlayer.rrl,
-                                                     &rr->rechandle,
-                                                     &rr->version, &rr->type,
-                                                     &rr->data, &rr->length,
-                                                     NULL, NULL));
+                s->rlayer.rrlmethod->read_record(s->rlayer.rrl,
+                    &rr->rechandle,
+                    &rr->version, &rr->type,
+                    &rr->data, &rr->length,
+                    NULL, NULL));
             if (ret <= 0) {
                 /* SSLfatal() already called if appropriate */
                 return ret;
@@ -706,15 +708,15 @@ int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type,
             rr->off = 0;
             s->rlayer.num_recs++;
         } while (s->rlayer.rrlmethod->processed_read_pending(s->rlayer.rrl)
-                 && s->rlayer.num_recs < SSL_MAX_PIPELINES);
+            && s->rlayer.num_recs < SSL_MAX_PIPELINES);
     }
     rr = &s->rlayer.tlsrecs[s->rlayer.curr_rec];
 
     if (s->rlayer.handshake_fragment_len > 0
-            && rr->type != SSL3_RT_HANDSHAKE
-            && SSL_CONNECTION_IS_TLS13(s)) {
+        && rr->type != SSL3_RT_HANDSHAKE
+        && SSL_CONNECTION_IS_TLS13(s)) {
         SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
-                 SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA);
+            SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA);
         return -1;
     }
 
@@ -731,7 +733,7 @@ int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type,
                                   * reset by ssl3_get_finished */
         && (rr->type != SSL3_RT_HANDSHAKE)) {
         SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
-                 SSL_R_DATA_BETWEEN_CCS_AND_FINISHED);
+            SSL_R_DATA_BETWEEN_CCS_AND_FINISHED);
         return -1;
     }
 
@@ -759,7 +761,7 @@ int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type,
          * doing a handshake for the first time
          */
         if (SSL_in_init(ssl) && type == SSL3_RT_APPLICATION_DATA
-                && SSL_IS_FIRST_HANDSHAKE(s)) {
+            && SSL_IS_FIRST_HANDSHAKE(s)) {
             SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_APP_DATA_IN_HANDSHAKE);
             return -1;
         }
@@ -811,8 +813,8 @@ int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type,
             }
             totalbytes += n;
         } while (type == SSL3_RT_APPLICATION_DATA
-                    && curr_rec < s->rlayer.num_recs
-                    && totalbytes < len);
+            && curr_rec < s->rlayer.num_recs
+            && totalbytes < len);
         if (totalbytes == 0) {
             /* We must have read empty records. Get more data */
             goto start;
@@ -865,16 +867,16 @@ int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type,
         PACKET alert;
 
         if (!PACKET_buf_init(&alert, alert_bytes, rr->length)
-                || !PACKET_get_1(&alert, &alert_level)
-                || !PACKET_get_1(&alert, &alert_descr)
-                || PACKET_remaining(&alert) != 0) {
+            || !PACKET_get_1(&alert, &alert_level)
+            || !PACKET_get_1(&alert, &alert_descr)
+            || PACKET_remaining(&alert) != 0) {
             SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_INVALID_ALERT);
             return -1;
         }
 
         if (s->msg_callback)
             s->msg_callback(0, s->version, SSL3_RT_ALERT, alert_bytes, 2, ssl,
-                            s->msg_callback_arg);
+                s->msg_callback_arg);
 
         if (s->info_callback != NULL)
             cb = s->info_callback;
@@ -887,7 +889,7 @@ int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type,
         }
 
         if ((!is_tls13 && alert_level == SSL3_AL_WARNING)
-                || (is_tls13 && alert_descr == SSL_AD_USER_CANCELLED)) {
+            || (is_tls13 && alert_descr == SSL_AD_USER_CANCELLED)) {
             s->s3.warn_alert = alert_descr;
             if (!ssl_release_record(s, rr, 0))
                 return -1;
@@ -895,7 +897,7 @@ int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type,
             s->rlayer.alert_count++;
             if (s->rlayer.alert_count == MAX_WARN_ALERT_COUNT) {
                 SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
-                         SSL_R_TOO_MANY_WARN_ALERTS);
+                    SSL_R_TOO_MANY_WARN_ALERTS);
                 return -1;
             }
         }
@@ -907,15 +909,15 @@ int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type,
         if (is_tls13 && alert_descr == SSL_AD_USER_CANCELLED) {
             goto start;
         } else if (alert_descr == SSL_AD_CLOSE_NOTIFY
-                && (is_tls13 || alert_level == SSL3_AL_WARNING)) {
+            && (is_tls13 || alert_level == SSL3_AL_WARNING)) {
             s->shutdown |= SSL_RECEIVED_SHUTDOWN;
             return 0;
         } else if (alert_level == SSL3_AL_FATAL || is_tls13) {
             s->rwstate = SSL_NOTHING;
             s->s3.fatal_alert = alert_descr;
             SSLfatal_data(s, SSL_AD_NO_ALERT,
-                          SSL_AD_REASON_OFFSET + alert_descr,
-                          "SSL alert number %d", alert_descr);
+                SSL_AD_REASON_OFFSET + alert_descr,
+                "SSL alert number %d", alert_descr);
             s->shutdown |= SSL_RECEIVED_SHUTDOWN;
             if (!ssl_release_record(s, rr, 0))
                 return -1;
@@ -976,7 +978,7 @@ int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type,
             if (!ssl_release_record(s, rr, 0))
                 return -1;
             SSLfatal(s, SSL_AD_NO_ALERT,
-                     SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY);
+                SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY);
             return -1;
         }
     }
@@ -1009,7 +1011,7 @@ int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type,
             return -1;
 
         if (*dest_len < dest_maxlen)
-            goto start;     /* fragment was too small */
+            goto start; /* fragment was too small */
     }
 
     if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) {
@@ -1022,7 +1024,7 @@ int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type,
      * protocol violation)
      */
     if ((s->rlayer.handshake_fragment_len >= 4)
-            && !ossl_statem_get_in_handshake(s)) {
+        && !ossl_statem_get_in_handshake(s)) {
         int ined = (s->early_data_state == SSL_EARLY_DATA_READING);
 
         /* We found handshake data, so we're going back into init */
@@ -1106,7 +1108,7 @@ int ssl3_read_bytes(SSL *ssl, uint8_t type, uint8_t *recvd_type,
              * record.
              */
             if (!ossl_early_data_count_ok(s, rr->length,
-                                          EARLY_DATA_CIPHERTEXT_OVERHEAD, 0)) {
+                    EARLY_DATA_CIPHERTEXT_OVERHEAD, 0)) {
                 /* SSLfatal() already called */
                 return -1;
             }
@@ -1133,20 +1135,20 @@ int RECORD_LAYER_is_sslv2_record(RECORD_LAYER *rl)
 
 static OSSL_FUNC_rlayer_msg_callback_fn rlayer_msg_callback_wrapper;
 static void rlayer_msg_callback_wrapper(int write_p, int version,
-                                        int content_type, const void *buf,
-                                        size_t len, void *cbarg)
+    int content_type, const void *buf,
+    size_t len, void *cbarg)
 {
     SSL_CONNECTION *s = cbarg;
     SSL *ssl = SSL_CONNECTION_GET_USER_SSL(s);
 
     if (s->msg_callback != NULL)
         s->msg_callback(write_p, version, content_type, buf, len, ssl,
-                        s->msg_callback_arg);
+            s->msg_callback_arg);
 }
 
 static OSSL_FUNC_rlayer_security_fn rlayer_security_wrapper;
 static int rlayer_security_wrapper(void *cbarg, int op, int bits, int nid,
-                                   void *other)
+    void *other)
 {
     SSL_CONNECTION *s = cbarg;
 
@@ -1160,7 +1162,7 @@ static size_t rlayer_padding_wrapper(void *cbarg, int type, size_t len)
     SSL *ssl = SSL_CONNECTION_GET_USER_SSL(s);
 
     return s->rlayer.record_padding_cb(ssl, type, len,
-                                       s->rlayer.record_padding_arg);
+        s->rlayer.record_padding_arg);
 }
 
 static const OSSL_DISPATCH rlayer_dispatch[] = {
@@ -1172,16 +1174,16 @@ static const OSSL_DISPATCH rlayer_dispatch[] = {
 };
 
 void ossl_ssl_set_custom_record_layer(SSL_CONNECTION *s,
-                                      const OSSL_RECORD_METHOD *meth,
-                                      void *rlarg)
+    const OSSL_RECORD_METHOD *meth,
+    void *rlarg)
 {
     s->rlayer.custom_rlmethod = meth;
     s->rlayer.rlarg = rlarg;
 }
 
 static const OSSL_RECORD_METHOD *ssl_select_next_record_layer(SSL_CONNECTION *s,
-                                                              int direction,
-                                                              int level)
+    int direction,
+    int level)
 {
     if (s->rlayer.custom_rlmethod != NULL)
         return s->rlayer.custom_rlmethod;
@@ -1196,8 +1198,8 @@ static const OSSL_RECORD_METHOD *ssl_select_next_record_layer(SSL_CONNECTION *s,
 #ifndef OPENSSL_NO_KTLS
     /* KTLS does not support renegotiation */
     if (level == OSSL_RECORD_PROTECTION_LEVEL_APPLICATION
-            && (s->options & SSL_OP_ENABLE_KTLS) != 0
-            && (SSL_CONNECTION_IS_TLS13(s) || SSL_IS_FIRST_HANDSHAKE(s)))
+        && (s->options & SSL_OP_ENABLE_KTLS) != 0
+        && (SSL_CONNECTION_IS_TLS13(s) || SSL_IS_FIRST_HANDSHAKE(s)))
         return &ossl_ktls_record_method;
 #endif
 
@@ -1239,17 +1241,17 @@ static int ssl_post_record_layer_select(SSL_CONNECTION *s, int direction)
 }
 
 int ssl_set_new_record_layer(SSL_CONNECTION *s, int version,
-                             int direction, int level,
-                             unsigned char *secret, size_t secretlen,
-                             unsigned char *key, size_t keylen,
-                             unsigned char *iv,  size_t ivlen,
-                             unsigned char *mackey, size_t mackeylen,
-                             const EVP_CIPHER *ciph, size_t taglen,
-                             int mactype, const EVP_MD *md,
-                             const SSL_COMP *comp, const EVP_MD *kdfdigest)
+    int direction, int level,
+    unsigned char *secret, size_t secretlen,
+    unsigned char *key, size_t keylen,
+    unsigned char *iv, size_t ivlen,
+    unsigned char *mackey, size_t mackeylen,
+    const EVP_CIPHER *ciph, size_t taglen,
+    int mactype, const EVP_MD *md,
+    const SSL_COMP *comp, const EVP_MD *kdfdigest)
 {
     OSSL_PARAM options[5], *opts = options;
-    OSSL_PARAM settings[6], *set =  settings;
+    OSSL_PARAM settings[6], *set = settings;
     const OSSL_RECORD_METHOD **thismethod;
     OSSL_RECORD_LAYER **thisrl, *newrl = NULL;
     BIO *thisbio;
@@ -1257,8 +1259,8 @@ int ssl_set_new_record_layer(SSL_CONNECTION *s, int version,
     const OSSL_RECORD_METHOD *meth;
     int use_etm, stream_mac = 0, tlstree = 0;
     unsigned int maxfrag = (direction == OSSL_RECORD_DIRECTION_WRITE)
-                           ? ssl_get_max_send_fragment(s)
-                           : SSL3_RT_MAX_PLAIN_LENGTH;
+        ? ssl_get_max_send_fragment(s)
+        : SSL3_RT_MAX_PLAIN_LENGTH;
     int use_early_data = 0;
     uint32_t max_early_data;
     COMP_METHOD *compm = (comp == NULL) ? NULL : comp->method;
@@ -1285,19 +1287,19 @@ int ssl_set_new_record_layer(SSL_CONNECTION *s, int version,
 
     /* Parameters that *may* be supported by a record layer if passed */
     *opts++ = OSSL_PARAM_construct_uint64(OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS,
-                                          &s->options);
+        &s->options);
     *opts++ = OSSL_PARAM_construct_uint32(OSSL_LIBSSL_RECORD_LAYER_PARAM_MODE,
-                                          &s->mode);
+        &s->mode);
     if (direction == OSSL_RECORD_DIRECTION_READ) {
         *opts++ = OSSL_PARAM_construct_size_t(OSSL_LIBSSL_RECORD_LAYER_READ_BUFFER_LEN,
-                                              &s->rlayer.default_read_buf_len);
+            &s->rlayer.default_read_buf_len);
         *opts++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD,
-                                           &s->rlayer.read_ahead);
+            &s->rlayer.read_ahead);
     } else {
         *opts++ = OSSL_PARAM_construct_size_t(OSSL_LIBSSL_RECORD_LAYER_PARAM_BLOCK_PADDING,
-                                              &s->rlayer.block_padding);
+            &s->rlayer.block_padding);
         *opts++ = OSSL_PARAM_construct_size_t(OSSL_LIBSSL_RECORD_LAYER_PARAM_HS_PADDING,
-                                              &s->rlayer.hs_padding);
+            &s->rlayer.hs_padding);
     }
     *opts = OSSL_PARAM_construct_end();
 
@@ -1320,29 +1322,28 @@ int ssl_set_new_record_layer(SSL_CONNECTION *s, int version,
 
     if (use_etm)
         *set++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_USE_ETM,
-                                          &use_etm);
+            &use_etm);
 
     if (stream_mac)
         *set++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_STREAM_MAC,
-                                          &stream_mac);
+            &stream_mac);
 
     if (tlstree)
         *set++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_TLSTREE,
-                                          &tlstree);
+            &tlstree);
 
     /*
      * We only need to do this for the read side. The write side should already
      * have the correct value due to the ssl_get_max_send_fragment() call above
      */
     if (direction == OSSL_RECORD_DIRECTION_READ
-            && s->session != NULL
-            && USE_MAX_FRAGMENT_LENGTH_EXT(s->session))
+        && s->session != NULL
+        && USE_MAX_FRAGMENT_LENGTH_EXT(s->session))
         maxfrag = GET_MAX_FRAGMENT_LENGTH(s->session);
 
-
     if (maxfrag != SSL3_RT_MAX_PLAIN_LENGTH)
         *set++ = OSSL_PARAM_construct_uint(OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_FRAG_LEN,
-                                           &maxfrag);
+            &maxfrag);
 
     /*
      * The record layer must check the amount of early data sent or received
@@ -1351,7 +1352,7 @@ int ssl_set_new_record_layer(SSL_CONNECTION *s, int version,
      */
     if (s->server && direction == OSSL_RECORD_DIRECTION_READ) {
         use_early_data = (level == OSSL_RECORD_PROTECTION_LEVEL_EARLY
-                          || level == OSSL_RECORD_PROTECTION_LEVEL_HANDSHAKE);
+            || level == OSSL_RECORD_PROTECTION_LEVEL_HANDSHAKE);
     } else if (!s->server && direction == OSSL_RECORD_DIRECTION_WRITE) {
         use_early_data = (level == OSSL_RECORD_PROTECTION_LEVEL_EARLY);
     }
@@ -1360,7 +1361,7 @@ int ssl_set_new_record_layer(SSL_CONNECTION *s, int version,
 
         if (max_early_data != 0)
             *set++ = OSSL_PARAM_construct_uint32(OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_EARLY_DATA,
-                                                 &max_early_data);
+                &max_early_data);
     }
 
     *set = OSSL_PARAM_construct_end();
@@ -1376,7 +1377,7 @@ int ssl_set_new_record_layer(SSL_CONNECTION *s, int version,
         if (direction == OSSL_RECORD_DIRECTION_READ) {
             prev = s->rlayer.rrlnext;
             if (SSL_CONNECTION_IS_DTLS(s)
-                    && level != OSSL_RECORD_PROTECTION_LEVEL_NONE)
+                && level != OSSL_RECORD_PROTECTION_LEVEL_NONE)
                 epoch = dtls1_get_epoch(s, SSL3_CC_READ); /* new epoch */
 
 #ifndef OPENSSL_NO_DGRAM
@@ -1393,7 +1394,7 @@ int ssl_set_new_record_layer(SSL_CONNECTION *s, int version,
             s->rlayer.rrlnext = next;
         } else {
             if (SSL_CONNECTION_IS_DTLS(s)
-                    && level != OSSL_RECORD_PROTECTION_LEVEL_NONE)
+                && level != OSSL_RECORD_PROTECTION_LEVEL_NONE)
                 epoch = dtls1_get_epoch(s, SSL3_CC_WRITE); /* new epoch */
         }
 
@@ -1418,13 +1419,13 @@ int ssl_set_new_record_layer(SSL_CONNECTION *s, int version,
         }
 
         rlret = meth->new_record_layer(sctx->libctx, sctx->propq, version,
-                                       s->server, direction, level, epoch,
-                                       secret, secretlen, key, keylen, iv,
-                                       ivlen, mackey, mackeylen, ciph, taglen,
-                                       mactype, md, compm, kdfdigest, prev,
-                                       thisbio, next, NULL, NULL, settings,
-                                       options, rlayer_dispatch_tmp, s,
-                                       s->rlayer.rlarg, &newrl);
+            s->server, direction, level, epoch,
+            secret, secretlen, key, keylen, iv,
+            ivlen, mackey, mackeylen, ciph, taglen,
+            mactype, md, compm, kdfdigest, prev,
+            thisbio, next, NULL, NULL, settings,
+            options, rlayer_dispatch_tmp, s,
+            s->rlayer.rlarg, &newrl);
         BIO_free(prev);
         switch (rlret) {
         case OSSL_RECORD_RETURN_FATAL:
@@ -1462,8 +1463,8 @@ int ssl_set_new_record_layer(SSL_CONNECTION *s, int version,
      * free the record layer object (see dtls1_hm_fragment_free)
      */
     if (!SSL_CONNECTION_IS_DTLS(s)
-            || direction == OSSL_RECORD_DIRECTION_READ
-            || pqueue_peek(s->d1->sent_messages) == NULL) {
+        || direction == OSSL_RECORD_DIRECTION_READ
+        || pqueue_peek(s->d1->sent_messages) == NULL) {
         if (*thismethod != NULL && !(*thismethod)->free(*thisrl)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return 0;
@@ -1479,7 +1480,7 @@ int ssl_set_new_record_layer(SSL_CONNECTION *s, int version,
 int ssl_set_record_protocol_version(SSL_CONNECTION *s, int vers)
 {
     if (!ossl_assert(s->rlayer.rrlmethod != NULL)
-            || !ossl_assert(s->rlayer.wrlmethod != NULL))
+        || !ossl_assert(s->rlayer.wrlmethod != NULL))
         return 0;
     s->rlayer.rrlmethod->set_protocol_version(s->rlayer.rrl, s->version);
     s->rlayer.wrlmethod->set_protocol_version(s->rlayer.wrl, s->version);
diff --git a/crypto/openssl/ssl/record/record.h b/crypto/openssl/ssl/record/record.h
index 13f09fda8ccb..8e7b88384524 100644
--- a/crypto/openssl/ssl/record/record.h
+++ b/crypto/openssl/ssl/record/record.h
@@ -17,7 +17,7 @@
  *                                                                           *
  *****************************************************************************/
 
-#define SEQ_NUM_SIZE                            8
+#define SEQ_NUM_SIZE 8
 
 typedef struct tls_record_st {
     void *rechandle;
@@ -131,8 +131,8 @@ typedef struct record_layer_st {
  *                                                                           *
  *****************************************************************************/
 
-#define RECORD_LAYER_set_read_ahead(rl, ra)     ((rl)->read_ahead = (ra))
-#define RECORD_LAYER_get_read_ahead(rl)         ((rl)->read_ahead)
+#define RECORD_LAYER_set_read_ahead(rl, ra) ((rl)->read_ahead = (ra))
+#define RECORD_LAYER_get_read_ahead(rl) ((rl)->read_ahead)
 
 void RECORD_LAYER_init(RECORD_LAYER *rl, SSL_CONNECTION *s);
 int RECORD_LAYER_clear(RECORD_LAYER *rl);
@@ -143,54 +143,50 @@ int RECORD_LAYER_write_pending(const RECORD_LAYER *rl);
 int RECORD_LAYER_is_sslv2_record(RECORD_LAYER *rl);
 __owur size_t ssl3_pending(const SSL *s);
 __owur int ssl3_write_bytes(SSL *s, uint8_t type, const void *buf, size_t len,
-                            size_t *written);
+    size_t *written);
 __owur int ssl3_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
-                           unsigned char *buf, size_t len, int peek,
-                           size_t *readbytes);
+    unsigned char *buf, size_t len, int peek,
+    size_t *readbytes);
 
 int DTLS_RECORD_LAYER_new(RECORD_LAYER *rl);
 void DTLS_RECORD_LAYER_free(RECORD_LAYER *rl);
 void DTLS_RECORD_LAYER_clear(RECORD_LAYER *rl);
 __owur int dtls1_read_bytes(SSL *s, uint8_t type, uint8_t *recvd_type,
-                            unsigned char *buf, size_t len, int peek,
-                            size_t *readbytes);
+    unsigned char *buf, size_t len, int peek,
+    size_t *readbytes);
 __owur int dtls1_write_bytes(SSL_CONNECTION *s, uint8_t type, const void *buf,
-                             size_t len, size_t *written);
+    size_t len, size_t *written);
 int do_dtls1_write(SSL_CONNECTION *s, uint8_t type, const unsigned char *buf,
-                   size_t len, size_t *written);
+    size_t len, size_t *written);
 void dtls1_increment_epoch(SSL_CONNECTION *s, int rw);
 uint16_t dtls1_get_epoch(SSL_CONNECTION *s, int rw);
 int ssl_release_record(SSL_CONNECTION *s, TLS_RECORD *rr, size_t length);
 
-# define HANDLE_RLAYER_READ_RETURN(s, ret) \
+#define HANDLE_RLAYER_READ_RETURN(s, ret) \
     ossl_tls_handle_rlayer_return(s, 0, ret, OPENSSL_FILE, OPENSSL_LINE)
 
-# define HANDLE_RLAYER_WRITE_RETURN(s, ret) \
+#define HANDLE_RLAYER_WRITE_RETURN(s, ret) \
     ossl_tls_handle_rlayer_return(s, 1, ret, OPENSSL_FILE, OPENSSL_LINE)
 
 int ossl_tls_handle_rlayer_return(SSL_CONNECTION *s, int writing, int ret,
-                                  char *file, int line);
+    char *file, int line);
 
 int ssl_set_new_record_layer(SSL_CONNECTION *s, int version,
-                             int direction, int level,
-                             unsigned char *secret, size_t secretlen,
-                             unsigned char *key, size_t keylen,
-                             unsigned char *iv,  size_t ivlen,
-                             unsigned char *mackey, size_t mackeylen,
-                             const EVP_CIPHER *ciph, size_t taglen,
-                             int mactype, const EVP_MD *md,
-                             const SSL_COMP *comp, const EVP_MD *kdfdigest);
+    int direction, int level,
+    unsigned char *secret, size_t secretlen,
+    unsigned char *key, size_t keylen,
+    unsigned char *iv, size_t ivlen,
+    unsigned char *mackey, size_t mackeylen,
+    const EVP_CIPHER *ciph, size_t taglen,
+    int mactype, const EVP_MD *md,
+    const SSL_COMP *comp, const EVP_MD *kdfdigest);
 int ssl_set_record_protocol_version(SSL_CONNECTION *s, int vers);
 
-# define OSSL_FUNC_RLAYER_SKIP_EARLY_DATA        1
+#define OSSL_FUNC_RLAYER_SKIP_EARLY_DATA 1
 OSSL_CORE_MAKE_FUNC(int, rlayer_skip_early_data, (void *cbarg))
-# define OSSL_FUNC_RLAYER_MSG_CALLBACK           2
-OSSL_CORE_MAKE_FUNC(void, rlayer_msg_callback, (int write_p, int version,
-                                                int content_type,
-                                                const void *buf, size_t len,
-                                                void *cbarg))
-# define OSSL_FUNC_RLAYER_SECURITY               3
-OSSL_CORE_MAKE_FUNC(int, rlayer_security, (void *cbarg, int op, int bits,
-                                           int nid, void *other))
-# define OSSL_FUNC_RLAYER_PADDING                4
+#define OSSL_FUNC_RLAYER_MSG_CALLBACK 2
+OSSL_CORE_MAKE_FUNC(void, rlayer_msg_callback, (int write_p, int version, int content_type, const void *buf, size_t len, void *cbarg))
+#define OSSL_FUNC_RLAYER_SECURITY 3
+OSSL_CORE_MAKE_FUNC(int, rlayer_security, (void *cbarg, int op, int bits, int nid, void *other))
+#define OSSL_FUNC_RLAYER_PADDING 4
 OSSL_CORE_MAKE_FUNC(size_t, rlayer_padding, (void *cbarg, int type, size_t len))
diff --git a/crypto/openssl/ssl/record/record_local.h b/crypto/openssl/ssl/record/record_local.h
index 1acb588f8c98..bd7608db53cd 100644
--- a/crypto/openssl/ssl/record/record_local.h
+++ b/crypto/openssl/ssl/record/record_local.h
@@ -14,4 +14,4 @@
  *                                                                           *
  *****************************************************************************/
 
-#define MAX_WARN_ALERT_COUNT    5
+#define MAX_WARN_ALERT_COUNT 5
diff --git a/crypto/openssl/ssl/rio/poll_builder.c b/crypto/openssl/ssl/rio/poll_builder.c
index bd9317a8b8bb..28d93ee1947a 100644
--- a/crypto/openssl/ssl/rio/poll_builder.c
+++ b/crypto/openssl/ssl/rio/poll_builder.c
@@ -22,11 +22,11 @@ int ossl_rio_poll_builder_init(RIO_POLL_BUILDER *rpb)
     FD_ZERO(&rpb->rfd);
     FD_ZERO(&rpb->wfd);
     FD_ZERO(&rpb->efd);
-    rpb->hwm_fd     = -1;
+    rpb->hwm_fd = -1;
 #elif RIO_POLL_METHOD == RIO_POLL_METHOD_POLL
-    rpb->pfd_heap   = NULL;
-    rpb->pfd_num    = 0;
-    rpb->pfd_alloc  = OSSL_NELEM(rpb->pfds);
+    rpb->pfd_heap = NULL;
+    rpb->pfd_num = 0;
+    rpb->pfd_alloc = OSSL_NELEM(rpb->pfds);
 #endif
     return 1;
 }
@@ -63,14 +63,14 @@ static int rpb_ensure_alloc(RIO_POLL_BUILDER *rpb, size_t alloc)
         /* Copy the contents of the stacked array. */
         memcpy(pfd_heap_new, rpb->pfds, sizeof(rpb->pfds));
     }
-    rpb->pfd_heap   = pfd_heap_new;
-    rpb->pfd_alloc  = alloc;
+    rpb->pfd_heap = pfd_heap_new;
+    rpb->pfd_alloc = alloc;
     return 1;
 }
 #endif
 
 int ossl_rio_poll_builder_add_fd(RIO_POLL_BUILDER *rpb, int fd,
-                                 int want_read, int want_write)
+    int want_read, int want_write)
 {
 #if RIO_POLL_METHOD == RIO_POLL_METHOD_POLL
     size_t i;
@@ -83,14 +83,14 @@ int ossl_rio_poll_builder_add_fd(RIO_POLL_BUILDER *rpb, int fd,
 
 #if RIO_POLL_METHOD == RIO_POLL_METHOD_SELECT
 
-# ifndef OPENSSL_SYS_WINDOWS
+#ifndef OPENSSL_SYS_WINDOWS
     /*
      * On Windows there is no relevant limit to the magnitude of a fd value (see
      * above). On *NIX the fd_set uses a bitmap and we must check the limit.
      */
     if (fd >= FD_SETSIZE)
         return 0;
-# endif
+#endif
 
     if (want_read)
         openssl_fdset(fd, &rpb->rfd);
@@ -118,11 +118,10 @@ int ossl_rio_poll_builder_add_fd(RIO_POLL_BUILDER *rpb, int fd,
         pfds = rpb->pfd_heap;
     }
 
-    assert((rpb->pfd_heap != NULL && rpb->pfd_heap == pfds) ||
-           (rpb->pfd_heap == NULL && rpb->pfds == pfds));
+    assert((rpb->pfd_heap != NULL && rpb->pfd_heap == pfds) || (rpb->pfd_heap == NULL && rpb->pfds == pfds));
     assert(i <= rpb->pfd_num && rpb->pfd_num <= rpb->pfd_alloc);
-    pfds[i].fd      = fd;
-    pfds[i].events  = 0;
+    pfds[i].fd = fd;
+    pfds[i].events = 0;
 
     if (want_read)
         pfds[i].events |= POLLIN;
@@ -157,7 +156,7 @@ int ossl_rio_poll_builder_poll(RIO_POLL_BUILDER *rpb, OSSL_TIME deadline)
              * now > deadline.
              */
             timeout = ossl_time_to_timeval(ossl_time_subtract(deadline,
-                                                              ossl_time_now()));
+                ossl_time_now()));
 
         rc = select(rpb->hwm_fd + 1, &rpb->rfd, &rpb->wfd, &rpb->efd, p_timeout);
     } while (rc == -1 && get_last_socket_error_is_eintr());
@@ -169,10 +168,10 @@ int ossl_rio_poll_builder_poll(RIO_POLL_BUILDER *rpb, OSSL_TIME deadline)
             timeout_ms = -1;
         else
             timeout_ms = ossl_time2ms(ossl_time_subtract(deadline,
-                                                         ossl_time_now()));
+                ossl_time_now()));
 
         rc = poll(rpb->pfd_heap != NULL ? rpb->pfd_heap : rpb->pfds,
-                  rpb->pfd_num, timeout_ms);
+            rpb->pfd_num, timeout_ms);
     } while (rc == -1 && get_last_socket_error_is_eintr());
 #endif
 
diff --git a/crypto/openssl/ssl/rio/poll_builder.h b/crypto/openssl/ssl/rio/poll_builder.h
index 0a03f89df74d..1fe13eacbaba 100644
--- a/crypto/openssl/ssl/rio/poll_builder.h
+++ b/crypto/openssl/ssl/rio/poll_builder.h
@@ -7,10 +7,10 @@
  * https://www.openssl.org/source/license.html
  */
 #ifndef OSSL_POLL_BUILDER_H
-# define OSSL_POLL_BUILDER_H
+#define OSSL_POLL_BUILDER_H
 
-# include "poll_method.h"
-# include "internal/time.h"
+#include "poll_method.h"
+#include "internal/time.h"
 
 /*
  * RIO_POLL_BUILDER
@@ -23,19 +23,19 @@
  * FDs.
  */
 typedef struct rio_poll_builder_st {
-# if RIO_POLL_METHOD == RIO_POLL_METHOD_NONE
-    int             unused_dummy; /* make microsoft compiler happy */
-# elif RIO_POLL_METHOD == RIO_POLL_METHOD_SELECT
-    fd_set          rfd, wfd, efd;
-    int             hwm_fd;
-# elif RIO_POLL_METHOD == RIO_POLL_METHOD_POLL
-#  define RIO_NUM_STACK_PFDS  32
-    struct pollfd   *pfd_heap;
-    struct pollfd   pfds[RIO_NUM_STACK_PFDS];
-    size_t          pfd_num, pfd_alloc;
-# else
-#  error Unknown RIO poll method
-# endif
+#if RIO_POLL_METHOD == RIO_POLL_METHOD_NONE
+    int unused_dummy; /* make microsoft compiler happy */
+#elif RIO_POLL_METHOD == RIO_POLL_METHOD_SELECT
+    fd_set rfd, wfd, efd;
+    int hwm_fd;
+#elif RIO_POLL_METHOD == RIO_POLL_METHOD_POLL
+#define RIO_NUM_STACK_PFDS 32
+    struct pollfd *pfd_heap;
+    struct pollfd pfds[RIO_NUM_STACK_PFDS];
+    size_t pfd_num, pfd_alloc;
+#else
+#error Unknown RIO poll method
+#endif
 } RIO_POLL_BUILDER;
 
 /*
@@ -62,7 +62,7 @@ void ossl_rio_poll_builder_cleanup(RIO_POLL_BUILDER *rpb);
  * Returns 1 on success and 0 on failure.
  */
 int ossl_rio_poll_builder_add_fd(RIO_POLL_BUILDER *rpb, int fd,
-                                 int want_read, int want_write);
+    int want_read, int want_write);
 
 /*
  * Polls the set of file descriptors added to a poll builder. deadline is a
diff --git a/crypto/openssl/ssl/rio/poll_immediate.c b/crypto/openssl/ssl/rio/poll_immediate.c
index 234ee81bdbb0..24b82f3a6a43 100644
--- a/crypto/openssl/ssl/rio/poll_immediate.c
+++ b/crypto/openssl/ssl/rio/poll_immediate.c
@@ -21,39 +21,39 @@
  * accessing pollfd structures (see Github issue #24236). That interferes
  * with our use of these names here. We simply undef them.
  */
-# undef revents
-# undef events
+#undef revents
+#undef events
 #endif
 
 #define ITEM_N(items, stride, n) \
-    (*(SSL_POLL_ITEM *)((char *)(items) + (n)*(stride)))
+    (*(SSL_POLL_ITEM *)((char *)(items) + (n) * (stride)))
 
-#define FAIL_FROM(n)                                                        \
-    do {                                                                    \
-        size_t j;                                                           \
-                                                                            \
-        for (j = (n); j < num_items; ++j)                                   \
-            ITEM_N(items, stride, j).revents = 0;                           \
-                                                                            \
-        ok = 0;                                                             \
-        goto out;                                                           \
+#define FAIL_FROM(n)                              \
+    do {                                          \
+        size_t j;                                 \
+                                                  \
+        for (j = (n); j < num_items; ++j)         \
+            ITEM_N(items, stride, j).revents = 0; \
+                                                  \
+        ok = 0;                                   \
+        goto out;                                 \
     } while (0)
 
-#define FAIL_ITEM(idx)                                                      \
-    do {                                                                    \
-        size_t idx_ = (idx);                                                \
-                                                                            \
-        ITEM_N(items, stride, idx_).revents = SSL_POLL_EVENT_F;             \
-        ++result_count;                                                     \
-        FAIL_FROM(idx_ + 1);                                                \
+#define FAIL_ITEM(idx)                                          \
+    do {                                                        \
+        size_t idx_ = (idx);                                    \
+                                                                \
+        ITEM_N(items, stride, idx_).revents = SSL_POLL_EVENT_F; \
+        ++result_count;                                         \
+        FAIL_FROM(idx_ + 1);                                    \
     } while (0)
 
 #ifndef OPENSSL_NO_QUIC
 static int poll_translate_ssl_quic(SSL *ssl,
-                                   QUIC_REACTOR_WAIT_CTX *wctx,
-                                   RIO_POLL_BUILDER *rpb,
-                                   uint64_t events,
-                                   int *abort_blocking)
+    QUIC_REACTOR_WAIT_CTX *wctx,
+    RIO_POLL_BUILDER *rpb,
+    uint64_t events,
+    int *abort_blocking)
 {
     BIO_POLL_DESCRIPTOR rd, wd;
     int fd1 = -1, fd2 = -1, fd_nfy = -1;
@@ -62,40 +62,40 @@ static int poll_translate_ssl_quic(SSL *ssl,
     if (SSL_net_read_desired(ssl)) {
         if (!SSL_get_rpoll_descriptor(ssl, &rd)) {
             ERR_raise_data(ERR_LIB_SSL, SSL_R_POLL_REQUEST_NOT_SUPPORTED,
-                           "SSL_poll requires the network BIOs underlying "
-                           "a QUIC SSL object provide poll descriptors");
+                "SSL_poll requires the network BIOs underlying "
+                "a QUIC SSL object provide poll descriptors");
             return 0;
         }
 
         if (rd.type != BIO_POLL_DESCRIPTOR_TYPE_SOCK_FD) {
             ERR_raise_data(ERR_LIB_SSL, SSL_R_POLL_REQUEST_NOT_SUPPORTED,
-                           "SSL_poll requires the poll descriptors of the "
-                           "network BIOs underlying a QUIC SSL object be "
-                           "of socket type");
+                "SSL_poll requires the poll descriptors of the "
+                "network BIOs underlying a QUIC SSL object be "
+                "of socket type");
             return 0;
         }
 
-        fd1   = rd.value.fd;
+        fd1 = rd.value.fd;
         fd1_r = 1;
     }
 
     if (SSL_net_write_desired(ssl)) {
         if (!SSL_get_wpoll_descriptor(ssl, &wd)) {
             ERR_raise_data(ERR_LIB_SSL, SSL_R_POLL_REQUEST_NOT_SUPPORTED,
-                           "SSL_poll requires the network BIOs underlying "
-                           "a QUIC SSL object provide poll descriptors");
+                "SSL_poll requires the network BIOs underlying "
+                "a QUIC SSL object provide poll descriptors");
             return 0;
         }
 
         if (wd.type != BIO_POLL_DESCRIPTOR_TYPE_SOCK_FD) {
             ERR_raise_data(ERR_LIB_SSL, SSL_R_POLL_REQUEST_NOT_SUPPORTED,
-                           "SSL_poll requires the poll descriptors of the "
-                           "network BIOs underlying a QUIC SSL object be "
-                           "of socket type");
+                "SSL_poll requires the poll descriptors of the "
+                "network BIOs underlying a QUIC SSL object be "
+                "of socket type");
             return 0;
         }
 
-        fd2   = wd.value.fd;
+        fd2 = wd.value.fd;
         fd2_w = 1;
     }
 
@@ -109,7 +109,7 @@ static int poll_translate_ssl_quic(SSL *ssl,
             return 0;
 
     if (fd2 != -1 && fd2_w)
-        if (!ossl_rio_poll_builder_add_fd(rpb, fd2, /*r = */0, fd2_w))
+        if (!ossl_rio_poll_builder_add_fd(rpb, fd2, /*r = */ 0, fd2_w))
             return 0;
 
     /*
@@ -123,7 +123,7 @@ static int poll_translate_ssl_quic(SSL *ssl,
     if (fd_nfy != -1) {
         uint64_t revents = 0;
 
-        if (!ossl_rio_poll_builder_add_fd(rpb, fd_nfy, /*r = */1, /*w = */0))
+        if (!ossl_rio_poll_builder_add_fd(rpb, fd_nfy, /*r = */ 1, /*w = */ 0))
             return 0;
 
         /* Tell QUIC domain we need to receive notifications. */
@@ -137,7 +137,7 @@ static int poll_translate_ssl_quic(SSL *ssl,
          * we needed to block). We now need to do another readout, in which case
          * blocking is to be aborted.
          */
-        if (!ossl_quic_conn_poll_events(ssl, events, /*do_tick = */0, &revents)) {
+        if (!ossl_quic_conn_poll_events(ssl, events, /*do_tick = */ 0, &revents)) {
             ossl_quic_leave_blocking_section(ssl, wctx);
             return 0;
         }
@@ -153,16 +153,16 @@ static int poll_translate_ssl_quic(SSL *ssl,
 }
 
 static void postpoll_translation_cleanup_ssl_quic(SSL *ssl,
-                                                  QUIC_REACTOR_WAIT_CTX *wctx)
+    QUIC_REACTOR_WAIT_CTX *wctx)
 {
     if (ossl_quic_get_notifier_fd(ssl) != -1)
         ossl_quic_leave_blocking_section(ssl, wctx);
 }
 
 static void postpoll_translation_cleanup(SSL_POLL_ITEM *items,
-                                         size_t num_items,
-                                         size_t stride,
-                                         QUIC_REACTOR_WAIT_CTX *wctx)
+    size_t num_items,
+    size_t stride,
+    QUIC_REACTOR_WAIT_CTX *wctx)
 {
     SSL_POLL_ITEM *item;
     SSL *ssl;
@@ -178,13 +178,13 @@ static void postpoll_translation_cleanup(SSL_POLL_ITEM *items,
                 break;
 
             switch (ssl->type) {
-# ifndef OPENSSL_NO_QUIC
+#ifndef OPENSSL_NO_QUIC
             case SSL_TYPE_QUIC_LISTENER:
             case SSL_TYPE_QUIC_CONNECTION:
             case SSL_TYPE_QUIC_XSO:
                 postpoll_translation_cleanup_ssl_quic(ssl, wctx);
                 break;
-# endif
+#endif
             default:
                 break;
             }
@@ -196,13 +196,13 @@ static void postpoll_translation_cleanup(SSL_POLL_ITEM *items,
 }
 
 static int poll_translate(SSL_POLL_ITEM *items,
-                          size_t num_items,
-                          size_t stride,
-                          QUIC_REACTOR_WAIT_CTX *wctx,
-                          RIO_POLL_BUILDER *rpb,
-                          OSSL_TIME *p_earliest_wakeup_deadline,
-                          int *abort_blocking,
-                          size_t *p_result_count)
+    size_t num_items,
+    size_t stride,
+    QUIC_REACTOR_WAIT_CTX *wctx,
+    RIO_POLL_BUILDER *rpb,
+    OSSL_TIME *p_earliest_wakeup_deadline,
+    int *abort_blocking,
+    size_t *p_result_count)
 {
     int ok = 1;
     SSL_POLL_ITEM *item;
@@ -224,12 +224,12 @@ static int poll_translate(SSL_POLL_ITEM *items,
                 break;
 
             switch (ssl->type) {
-# ifndef OPENSSL_NO_QUIC
+#ifndef OPENSSL_NO_QUIC
             case SSL_TYPE_QUIC_LISTENER:
             case SSL_TYPE_QUIC_CONNECTION:
             case SSL_TYPE_QUIC_XSO:
                 if (!poll_translate_ssl_quic(ssl, wctx, rpb, item->events,
-                                             abort_blocking))
+                        abort_blocking))
                     FAIL_ITEM(i);
 
                 if (*abort_blocking)
@@ -241,30 +241,31 @@ static int poll_translate(SSL_POLL_ITEM *items,
                 if (!is_infinite)
                     earliest_wakeup_deadline
                         = ossl_time_min(earliest_wakeup_deadline,
-                                        ossl_time_add(ossl_time_now(),
-                                                      ossl_time_from_timeval(timeout)));
+                            ossl_time_add(ossl_time_now(),
+                                ossl_time_from_timeval(timeout)));
 
                 break;
-# endif
+#endif
 
             default:
                 ERR_raise_data(ERR_LIB_SSL, SSL_R_POLL_REQUEST_NOT_SUPPORTED,
-                               "SSL_poll currently only supports QUIC SSL "
-                               "objects");
+                    "SSL_poll currently only supports QUIC SSL "
+                    "objects");
                 FAIL_ITEM(i);
             }
             break;
 
         case BIO_POLL_DESCRIPTOR_TYPE_SOCK_FD:
             ERR_raise_data(ERR_LIB_SSL, SSL_R_POLL_REQUEST_NOT_SUPPORTED,
-                           "SSL_poll currently does not support polling "
-                           "sockets");
+                "SSL_poll currently does not support polling "
+                "sockets");
             FAIL_ITEM(i);
 
         default:
             ERR_raise_data(ERR_LIB_SSL, SSL_R_POLL_REQUEST_NOT_SUPPORTED,
-                           "SSL_poll does not support unknown poll descriptor "
-                           "type %d", item->desc.type);
+                "SSL_poll does not support unknown poll descriptor "
+                "type %d",
+                item->desc.type);
             FAIL_ITEM(i);
         }
     }
@@ -279,10 +280,10 @@ out:
 }
 
 static int poll_block(SSL_POLL_ITEM *items,
-                      size_t num_items,
-                      size_t stride,
-                      OSSL_TIME user_deadline,
-                      size_t *p_result_count)
+    size_t num_items,
+    size_t stride,
+    OSSL_TIME user_deadline,
+    size_t *p_result_count)
 {
     int ok = 0, abort_blocking = 0;
     RIO_POLL_BUILDER rpb;
@@ -314,16 +315,16 @@ static int poll_block(SSL_POLL_ITEM *items,
     ossl_rio_poll_builder_init(&rpb);
 
     if (!poll_translate(items, num_items, stride, &wctx, &rpb,
-                        &earliest_wakeup_deadline,
-                        &abort_blocking,
-                        p_result_count))
+            &earliest_wakeup_deadline,
+            &abort_blocking,
+            p_result_count))
         goto out;
 
     if (abort_blocking)
         goto out;
 
     earliest_wakeup_deadline = ossl_time_min(earliest_wakeup_deadline,
-                                             user_deadline);
+        user_deadline);
 
     ok = ossl_rio_poll_builder_poll(&rpb, earliest_wakeup_deadline);
 
@@ -337,10 +338,10 @@ out:
 #endif
 
 static int poll_readout(SSL_POLL_ITEM *items,
-                        size_t num_items,
-                        size_t stride,
-                        int do_tick,
-                        size_t *p_result_count)
+    size_t num_items,
+    size_t stride,
+    int do_tick,
+    size_t *p_result_count)
 {
     int ok = 1;
     size_t i, result_count = 0;
@@ -352,9 +353,9 @@ static int poll_readout(SSL_POLL_ITEM *items,
     uint64_t revents;
 
     for (i = 0; i < num_items; ++i) {
-        item    = &ITEM_N(items, stride, i);
+        item = &ITEM_N(items, stride, i);
 #ifndef OPENSSL_NO_QUIC
-        events  = item->events;
+        events = item->events;
 #endif
         revents = 0;
 
@@ -382,20 +383,21 @@ static int poll_readout(SSL_POLL_ITEM *items,
 
             default:
                 ERR_raise_data(ERR_LIB_SSL, SSL_R_POLL_REQUEST_NOT_SUPPORTED,
-                               "SSL_poll currently only supports QUIC SSL "
-                               "objects");
+                    "SSL_poll currently only supports QUIC SSL "
+                    "objects");
                 FAIL_ITEM(i);
             }
             break;
         case BIO_POLL_DESCRIPTOR_TYPE_SOCK_FD:
             ERR_raise_data(ERR_LIB_SSL, SSL_R_POLL_REQUEST_NOT_SUPPORTED,
-                           "SSL_poll currently does not support polling "
-                           "sockets");
+                "SSL_poll currently does not support polling "
+                "sockets");
             FAIL_ITEM(i);
         default:
             ERR_raise_data(ERR_LIB_SSL, SSL_R_POLL_REQUEST_NOT_SUPPORTED,
-                           "SSL_poll does not support unknown poll descriptor "
-                           "type %d", item->desc.type);
+                "SSL_poll does not support unknown poll descriptor "
+                "type %d",
+                item->desc.type);
             FAIL_ITEM(i);
         }
 
@@ -410,11 +412,11 @@ out:
 }
 
 int SSL_poll(SSL_POLL_ITEM *items,
-             size_t num_items,
-             size_t stride,
-             const struct timeval *timeout,
-             uint64_t flags,
-             size_t *p_result_count)
+    size_t num_items,
+    size_t stride,
+    const struct timeval *timeout,
+    uint64_t flags,
+    size_t *p_result_count)
 {
     int ok = 1;
     size_t result_count = 0;
@@ -436,7 +438,7 @@ int SSL_poll(SSL_POLL_ITEM *items,
         deadline = ossl_time_zero();
     else
         deadline = ossl_time_add(ossl_time_now(),
-                                 ossl_time_from_timeval(*timeout));
+            ossl_time_from_timeval(*timeout));
 
     /* Loop until we have something to report. */
     for (;;) {
diff --git a/crypto/openssl/ssl/rio/poll_method.h b/crypto/openssl/ssl/rio/poll_method.h
index d5af8663c23d..1e173fe4f8b5 100644
--- a/crypto/openssl/ssl/rio/poll_method.h
+++ b/crypto/openssl/ssl/rio/poll_method.h
@@ -7,23 +7,23 @@
  * https://www.openssl.org/source/license.html
  */
 #ifndef OSSL_POLL_METHOD_H
-# define OSSL_POLL_METHOD_H
+#define OSSL_POLL_METHOD_H
 
-# include "internal/common.h"
-# include "internal/sockets.h"
+#include "internal/common.h"
+#include "internal/sockets.h"
 
-# define RIO_POLL_METHOD_SELECT         1
-# define RIO_POLL_METHOD_POLL           2
-# define RIO_POLL_METHOD_NONE           3
+#define RIO_POLL_METHOD_SELECT 1
+#define RIO_POLL_METHOD_POLL 2
+#define RIO_POLL_METHOD_NONE 3
 
-# ifndef RIO_POLL_METHOD
-#  if defined(OPENSSL_SYS_UEFI)
-#   define RIO_POLL_METHOD              RIO_POLL_METHOD_NONE
-#  elif !defined(OPENSSL_SYS_WINDOWS) && defined(POLLIN)
-#   define RIO_POLL_METHOD              RIO_POLL_METHOD_POLL
-#  else
-#   define RIO_POLL_METHOD              RIO_POLL_METHOD_SELECT
-#  endif
-# endif
+#ifndef RIO_POLL_METHOD
+#if defined(OPENSSL_SYS_UEFI)
+#define RIO_POLL_METHOD RIO_POLL_METHOD_NONE
+#elif !defined(OPENSSL_SYS_WINDOWS) && defined(POLLIN)
+#define RIO_POLL_METHOD RIO_POLL_METHOD_POLL
+#else
+#define RIO_POLL_METHOD RIO_POLL_METHOD_SELECT
+#endif
+#endif
 
 #endif
diff --git a/crypto/openssl/ssl/rio/rio_notifier.c b/crypto/openssl/ssl/rio/rio_notifier.c
index 6dbb2bdc4766..ea40790d627b 100644
--- a/crypto/openssl/ssl/rio/rio_notifier.c
+++ b/crypto/openssl/ssl/rio/rio_notifier.c
@@ -64,7 +64,7 @@ static ossl_inline int ensure_wsa_startup(void)
 static int create_socket(int domain, int socktype, int protocol)
 {
     int fd;
-# if defined(OPENSSL_SYS_WINDOWS)
+#if defined(OPENSSL_SYS_WINDOWS)
     static const int on = 1;
 
     /*
@@ -76,47 +76,47 @@ static int create_socket(int domain, int socktype, int protocol)
      * so we can get away with not including it for older platforms
      */
 
-#  ifdef WSA_FLAG_NO_HANDLE_INHERIT
+#ifdef WSA_FLAG_NO_HANDLE_INHERIT
     fd = (int)WSASocketA(domain, socktype, protocol, NULL, 0,
-                         WSA_FLAG_NO_HANDLE_INHERIT);
+        WSA_FLAG_NO_HANDLE_INHERIT);
 
     /*
      * Its also possible that someone is building a binary on a newer windows
      * SDK, but running it on a runtime that doesn't support inheritance
-     * supression.  In that case the above will return INVALID_SOCKET, and
+     * suppression.  In that case the above will return INVALID_SOCKET, and
      * our response for those older platforms is to try the call again
      * without the flag
      */
     if (fd == INVALID_SOCKET)
         fd = (int)WSASocketA(domain, socktype, protocol, NULL, 0, 0);
-#  else
+#else
     fd = (int)WSASocketA(domain, socktype, protocol, NULL, 0, 0);
-#  endif
+#endif
     if (fd == INVALID_SOCKET) {
         int err = get_last_socket_error();
 
         ERR_raise_data(ERR_LIB_SYS, err,
-                       "calling WSASocketA() = %d", err);
+            "calling WSASocketA() = %d", err);
         return INVALID_SOCKET;
     }
 
     /* Prevent interference with the socket from other processes on Windows. */
     if (setsockopt(fd, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (void *)&on, sizeof(on)) < 0) {
         ERR_raise_data(ERR_LIB_SYS, get_last_socket_error(),
-                       "calling setsockopt()");
+            "calling setsockopt()");
         BIO_closesocket(fd);
         return INVALID_SOCKET;
     }
 
-# else
-#  if defined(SOCK_CLOEXEC)
+#else
+#if defined(SOCK_CLOEXEC)
     socktype |= SOCK_CLOEXEC;
-#  endif
+#endif
 
     fd = BIO_socket(domain, socktype, protocol, 0);
     if (fd == INVALID_SOCKET) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling BIO_socket()");
+            "calling BIO_socket()");
         return INVALID_SOCKET;
     }
 
@@ -126,11 +126,11 @@ static int create_socket(int domain, int socktype, int protocol)
      */
     if (!set_cloexec(fd)) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling set_cloexec()");
+            "calling set_cloexec()");
         BIO_closesocket(fd);
         return INVALID_SOCKET;
     }
-# endif
+#endif
 
     return fd;
 }
@@ -142,36 +142,36 @@ static int create_socket(int domain, int socktype, int protocol)
  *
  * Win32 does not support socketpair(2), and Win32 pipes are not compatible with
  * Winsock select(2). This means our only means of making select(2) wakeable is
- * to artifically create a loopback TCP connection and send bytes to it.
+ * to artificially create a loopback TCP connection and send bytes to it.
  */
 int ossl_rio_notifier_init(RIO_NOTIFIER *nfy)
 {
     int rc, lfd = -1, rfd = -1, wfd = -1;
-    struct sockaddr_in sa = {0}, accept_sa;
+    struct sockaddr_in sa = { 0 }, accept_sa;
     socklen_t sa_len = sizeof(sa), accept_sa_len = sizeof(accept_sa);
 
-# if defined(OPENSSL_SYS_WINDOWS)
+#if defined(OPENSSL_SYS_WINDOWS)
     if (!ensure_wsa_startup()) {
         ERR_raise_data(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR,
-                       "Cannot start Windows sockets");
+            "Cannot start Windows sockets");
         return 0;
     }
-# endif
+#endif
     /* Create a close-on-exec socket. */
     lfd = create_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
     if (lfd == INVALID_SOCKET) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling create_socket()");
+            "calling create_socket()");
         return 0;
     }
 
     /* Bind the socket to a random loopback port. */
-    sa.sin_family       = AF_INET;
-    sa.sin_addr.s_addr  = htonl(INADDR_LOOPBACK);
+    sa.sin_family = AF_INET;
+    sa.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
     rc = bind(lfd, (const struct sockaddr *)&sa, sizeof(sa));
     if (rc < 0) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling bind()");
+            "calling bind()");
         goto err;
     }
 
@@ -179,7 +179,7 @@ int ossl_rio_notifier_init(RIO_NOTIFIER *nfy)
     rc = getsockname(lfd, (struct sockaddr *)&sa, &sa_len);
     if (rc < 0) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling getsockname()");
+            "calling getsockname()");
         goto err;
     }
 
@@ -187,7 +187,7 @@ int ossl_rio_notifier_init(RIO_NOTIFIER *nfy)
     rc = listen(lfd, 1);
     if (rc < 0) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling listen()");
+            "calling listen()");
         goto err;
     }
 
@@ -195,7 +195,7 @@ int ossl_rio_notifier_init(RIO_NOTIFIER *nfy)
     wfd = create_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
     if (wfd == INVALID_SOCKET) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling create_socket()");
+            "calling create_socket()");
         goto err;
     }
 
@@ -205,7 +205,7 @@ int ossl_rio_notifier_init(RIO_NOTIFIER *nfy)
      */
     if (!BIO_set_tcp_ndelay(wfd, 1)) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling BIO_set_tcp_ndelay()");
+            "calling BIO_set_tcp_ndelay()");
         goto err;
     }
 
@@ -215,7 +215,7 @@ int ossl_rio_notifier_init(RIO_NOTIFIER *nfy)
     rc = connect(wfd, (struct sockaddr *)&sa, sizeof(sa));
     if (rc < 0) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling connect()");
+            "calling connect()");
         goto err;
     }
 
@@ -225,14 +225,14 @@ int ossl_rio_notifier_init(RIO_NOTIFIER *nfy)
     rfd = accept(lfd, (struct sockaddr *)&accept_sa, &accept_sa_len);
     if (rfd == INVALID_SOCKET) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling accept()");
+            "calling accept()");
         goto err;
     }
 
     rc = getsockname(wfd, (struct sockaddr *)&sa, &sa_len);
     if (rc < 0) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling getsockname()");
+            "calling getsockname()");
         goto err;
     }
 
@@ -246,20 +246,20 @@ int ossl_rio_notifier_init(RIO_NOTIFIER *nfy)
      */
     if (accept_sa.sin_family != AF_INET || accept_sa.sin_port != sa.sin_port) {
         ERR_raise_data(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR,
-                       "connected address differs from accepted address");
+            "connected address differs from accepted address");
         goto err;
     }
 
     /* Make both sides of the connection non-blocking. */
     if (!BIO_socket_nbio(rfd, 1)) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling BIO_socket_nbio()");
+            "calling BIO_socket_nbio()");
         goto err;
     }
 
     if (!BIO_socket_nbio(wfd, 1)) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling BIO_socket_nbio()");
+            "calling BIO_socket_nbio()");
         goto err;
     }
 
@@ -283,40 +283,40 @@ int ossl_rio_notifier_init(RIO_NOTIFIER *nfy)
 {
     int fds[2], domain = AF_INET, type = SOCK_STREAM;
 
-# if defined(SOCK_CLOEXEC)
+#if defined(SOCK_CLOEXEC)
     type |= SOCK_CLOEXEC;
-# endif
-# if defined(SOCK_NONBLOCK)
+#endif
+#if defined(SOCK_NONBLOCK)
     type |= SOCK_NONBLOCK;
-# endif
+#endif
 
-# if defined(OPENSSL_SYS_UNIX) && defined(AF_UNIX)
+#if defined(OPENSSL_SYS_UNIX) && defined(AF_UNIX)
     domain = AF_UNIX;
-# endif
+#endif
 
     if (socketpair(domain, type, 0, fds) < 0) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling socketpair()");
+            "calling socketpair()");
         return 0;
     }
 
     if (!set_cloexec(fds[0]) || !set_cloexec(fds[1])) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling set_cloexec()");
+            "calling set_cloexec()");
         goto err;
     }
 
-# if !defined(SOCK_NONBLOCK)
+#if !defined(SOCK_NONBLOCK)
     if (!BIO_socket_nbio(fds[0], 1) || !BIO_socket_nbio(fds[1], 1)) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling BIO_socket_nbio()");
+            "calling BIO_socket_nbio()");
         goto err;
     }
-# endif
+#endif
 
     if (domain == AF_INET && !BIO_set_tcp_ndelay(fds[1], 1)) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling BIO_set_tcp_ndelay()");
+            "calling BIO_set_tcp_ndelay()");
         goto err;
     }
 
@@ -370,7 +370,7 @@ int ossl_rio_notifier_unsignal(RIO_NOTIFIER *nfy)
     do
         rd = readsocket(nfy->rfd, (void *)buf, sizeof(buf));
     while (rd == sizeof(buf)
-           || (rd < 0 && get_last_socket_error_is_eintr()));
+        || (rd < 0 && get_last_socket_error_is_eintr()));
 
     if (rd < 0 && !BIO_fd_non_fatal_error(get_last_socket_error()))
         return 0;
diff --git a/crypto/openssl/ssl/s3_enc.c b/crypto/openssl/ssl/s3_enc.c
index 159b9e60fea9..307f6dc9418b 100644
--- a/crypto/openssl/ssl/s3_enc.c
+++ b/crypto/openssl/ssl/s3_enc.c
@@ -28,7 +28,7 @@ static int ssl3_generate_key_block(SSL_CONNECTION *s, unsigned char *km, int num
     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
 
 #ifdef CHARSET_EBCDIC
-    c = os_toascii[c];          /* 'A' in ASCII */
+    c = os_toascii[c]; /* 'A' in ASCII */
 #endif
     k = 0;
     md5 = ssl_evp_md_fetch(sctx->libctx, NID_md5, sctx->propq);
@@ -52,13 +52,13 @@ static int ssl3_generate_key_block(SSL_CONNECTION *s, unsigned char *km, int num
         if (!EVP_DigestInit_ex(s1, sha1, NULL)
             || !EVP_DigestUpdate(s1, buf, k)
             || !EVP_DigestUpdate(s1, s->session->master_key,
-                                 s->session->master_key_length)
+                s->session->master_key_length)
             || !EVP_DigestUpdate(s1, s->s3.server_random, SSL3_RANDOM_SIZE)
             || !EVP_DigestUpdate(s1, s->s3.client_random, SSL3_RANDOM_SIZE)
             || !EVP_DigestFinal_ex(s1, smd, NULL)
             || !EVP_DigestInit_ex(m5, md5, NULL)
             || !EVP_DigestUpdate(m5, s->session->master_key,
-                                 s->session->master_key_length)
+                s->session->master_key_length)
             || !EVP_DigestUpdate(m5, smd, SHA_DIGEST_LENGTH)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             goto err;
@@ -80,7 +80,7 @@ static int ssl3_generate_key_block(SSL_CONNECTION *s, unsigned char *km, int num
     }
     OPENSSL_cleanse(smd, sizeof(smd));
     ret = 1;
- err:
+err:
     EVP_MD_CTX_free(m5);
     EVP_MD_CTX_free(s1);
     ssl_evp_md_free(md5);
@@ -122,8 +122,7 @@ int ssl3_change_cipher_state(SSL_CONNECTION *s, int which)
     key_len = EVP_CIPHER_get_key_length(ciph);
     iv_len = EVP_CIPHER_get_iv_length(ciph);
 
-    if ((which == SSL3_CHANGE_CIPHER_CLIENT_WRITE) ||
-        (which == SSL3_CHANGE_CIPHER_SERVER_READ)) {
+    if ((which == SSL3_CHANGE_CIPHER_CLIENT_WRITE) || (which == SSL3_CHANGE_CIPHER_SERVER_READ)) {
         mac_secret = &(p[0]);
         n = md_len + md_len;
         key = &(p[n]);
@@ -146,16 +145,16 @@ int ssl3_change_cipher_state(SSL_CONNECTION *s, int which)
     }
 
     if (!ssl_set_new_record_layer(s, SSL3_VERSION,
-                                  direction,
-                                  OSSL_RECORD_PROTECTION_LEVEL_APPLICATION,
-                                  NULL, 0, key, key_len, iv, iv_len, mac_secret,
-                                  md_len, ciph, 0, NID_undef, md, comp, NULL)) {
+            direction,
+            OSSL_RECORD_PROTECTION_LEVEL_APPLICATION,
+            NULL, 0, key, key_len, iv, iv_len, mac_secret,
+            md_len, ciph, 0, NID_undef, md, comp, NULL)) {
         /* SSLfatal already called */
         goto err;
     }
 
     return 1;
- err:
+err:
     return 0;
 }
 
@@ -172,7 +171,7 @@ int ssl3_setup_key_block(SSL_CONNECTION *s)
         return 1;
 
     if (!ssl_cipher_get_evp(SSL_CONNECTION_GET_CTX(s), s->session, &c, &hash,
-                            NULL, NULL, &comp, 0)) {
+            NULL, NULL, &comp, 0)) {
         /* Error is already recorded */
         SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR);
         return 0;
@@ -292,7 +291,7 @@ int ssl3_digest_cached_records(SSL_CONNECTION *s, int keep)
         md = ssl_handshake_md(s);
         if (md == NULL) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                     SSL_R_NO_SUITABLE_DIGEST_ALGORITHM);
+                SSL_R_NO_SUITABLE_DIGEST_ALGORITHM);
             return 0;
         }
         if (!EVP_DigestInit_ex(s->s3.handshake_dgst, md, NULL)
@@ -310,17 +309,17 @@ int ssl3_digest_cached_records(SSL_CONNECTION *s, int keep)
 }
 
 void ssl3_digest_master_key_set_params(const SSL_SESSION *session,
-                                       OSSL_PARAM params[])
+    OSSL_PARAM params[])
 {
     int n = 0;
     params[n++] = OSSL_PARAM_construct_octet_string(OSSL_DIGEST_PARAM_SSL3_MS,
-                                                    (void *)session->master_key,
-                                                    session->master_key_length);
+        (void *)session->master_key,
+        session->master_key_length);
     params[n++] = OSSL_PARAM_construct_end();
 }
 
 size_t ssl3_final_finish_mac(SSL_CONNECTION *s, const char *sender, size_t len,
-                             unsigned char *p)
+    unsigned char *p)
 {
     int ret;
     EVP_MD_CTX *ctx = NULL;
@@ -361,20 +360,20 @@ size_t ssl3_final_finish_mac(SSL_CONNECTION *s, const char *sender, size_t len,
         if (EVP_DigestUpdate(ctx, sender, len) <= 0
             || EVP_MD_CTX_set_params(ctx, digest_cmd_params) <= 0
             || EVP_DigestFinal_ex(ctx, p, NULL) <= 0) {
-                SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
-                ret = 0;
+            SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
+            ret = 0;
         }
     }
 
- err:
+err:
     EVP_MD_CTX_free(ctx);
 
     return ret;
 }
 
 int ssl3_generate_master_secret(SSL_CONNECTION *s, unsigned char *out,
-                                unsigned char *p,
-                                size_t len, size_t *secret_size)
+    unsigned char *p,
+    size_t len, size_t *secret_size)
 {
     static const unsigned char *const salt[3] = {
 #ifndef CHARSET_EBCDIC
@@ -400,12 +399,15 @@ int ssl3_generate_master_secret(SSL_CONNECTION *s, unsigned char *out,
     for (i = 0; i < 3; i++) {
         if (EVP_DigestInit_ex(ctx, SSL_CONNECTION_GET_CTX(s)->sha1, NULL) <= 0
             || EVP_DigestUpdate(ctx, salt[i],
-                                strlen((const char *)salt[i])) <= 0
+                   strlen((const char *)salt[i]))
+                <= 0
             || EVP_DigestUpdate(ctx, p, len) <= 0
             || EVP_DigestUpdate(ctx, &(s->s3.client_random[0]),
-                                SSL3_RANDOM_SIZE) <= 0
+                   SSL3_RANDOM_SIZE)
+                <= 0
             || EVP_DigestUpdate(ctx, &(s->s3.server_random[0]),
-                                SSL3_RANDOM_SIZE) <= 0
+                   SSL3_RANDOM_SIZE)
+                <= 0
             || EVP_DigestFinal_ex(ctx, buf, &n) <= 0
             || EVP_DigestInit_ex(ctx, SSL_CONNECTION_GET_CTX(s)->md5, NULL) <= 0
             || EVP_DigestUpdate(ctx, p, len) <= 0
@@ -476,7 +478,7 @@ int ssl3_alert_code(int code)
     case SSL_AD_USER_CANCELLED:
         return SSL3_AD_HANDSHAKE_FAILURE;
     case SSL_AD_NO_RENEGOTIATION:
-        return -1;            /* Don't send it :-) */
+        return -1; /* Don't send it :-) */
     case SSL_AD_UNSUPPORTED_EXTENSION:
         return SSL3_AD_HANDSHAKE_FAILURE;
     case SSL_AD_CERTIFICATE_UNOBTAINABLE:
diff --git a/crypto/openssl/ssl/s3_lib.c b/crypto/openssl/ssl/s3_lib.c
index 14373cdfa029..213ec84b171d 100644
--- a/crypto/openssl/ssl/s3_lib.c
+++ b/crypto/openssl/ssl/s3_lib.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 1995-2025 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
  * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
  * Copyright 2005 Nokia. All rights reserved.
  *
@@ -23,9 +23,9 @@
 #include "internal/cryptlib.h"
 #include "internal/ssl_unwrap.h"
 
-#define TLS13_NUM_CIPHERS       OSSL_NELEM(tls13_ciphers)
-#define SSL3_NUM_CIPHERS        OSSL_NELEM(ssl3_ciphers)
-#define SSL3_NUM_SCSVS          OSSL_NELEM(ssl3_scsvs)
+#define TLS13_NUM_CIPHERS OSSL_NELEM(tls13_ciphers)
+#define SSL3_NUM_CIPHERS OSSL_NELEM(ssl3_ciphers)
+#define SSL3_NUM_SCSVS OSSL_NELEM(ssl3_scsvs)
 
 /* TLSv1.3 downgrade protection sentinel values */
 const unsigned char tls11downgrade[] = {
@@ -46,13 +46,16 @@ static SSL_CIPHER tls13_ciphers[] = {
         SSL_aANY,
         SSL_AES128GCM,
         SSL_AEAD,
-        TLS1_3_VERSION, TLS1_3_VERSION,
-        0, 0,
+        TLS1_3_VERSION,
+        TLS1_3_VERSION,
+        0,
+        0,
         SSL_HIGH,
         SSL_HANDSHAKE_MAC_SHA256 | SSL_QUIC,
         128,
         128,
-    }, {
+    },
+    {
         1,
         TLS1_3_RFC_AES_256_GCM_SHA384,
         TLS1_3_RFC_AES_256_GCM_SHA384,
@@ -61,8 +64,10 @@ static SSL_CIPHER tls13_ciphers[] = {
         SSL_aANY,
         SSL_AES256GCM,
         SSL_AEAD,
-        TLS1_3_VERSION, TLS1_3_VERSION,
-        0, 0,
+        TLS1_3_VERSION,
+        TLS1_3_VERSION,
+        0,
+        0,
         SSL_HIGH,
         SSL_HANDSHAKE_MAC_SHA384 | SSL_QUIC,
         256,
@@ -77,8 +82,10 @@ static SSL_CIPHER tls13_ciphers[] = {
         SSL_aANY,
         SSL_CHACHA20POLY1305,
         SSL_AEAD,
-        TLS1_3_VERSION, TLS1_3_VERSION,
-        0, 0,
+        TLS1_3_VERSION,
+        TLS1_3_VERSION,
+        0,
+        0,
         SSL_HIGH,
         SSL_HANDSHAKE_MAC_SHA256 | SSL_QUIC,
         256,
@@ -93,13 +100,16 @@ static SSL_CIPHER tls13_ciphers[] = {
         SSL_aANY,
         SSL_AES128CCM,
         SSL_AEAD,
-        TLS1_3_VERSION, TLS1_3_VERSION,
-        0, 0,
+        TLS1_3_VERSION,
+        TLS1_3_VERSION,
+        0,
+        0,
         SSL_NOT_DEFAULT | SSL_HIGH,
         SSL_HANDSHAKE_MAC_SHA256,
         128,
         128,
-    }, {
+    },
+    {
         1,
         TLS1_3_RFC_AES_128_CCM_8_SHA256,
         TLS1_3_RFC_AES_128_CCM_8_SHA256,
@@ -108,8 +118,10 @@ static SSL_CIPHER tls13_ciphers[] = {
         SSL_aANY,
         SSL_AES128CCM8,
         SSL_AEAD,
-        TLS1_3_VERSION, TLS1_3_VERSION,
-        0, 0,
+        TLS1_3_VERSION,
+        TLS1_3_VERSION,
+        0,
+        0,
         SSL_NOT_DEFAULT | SSL_MEDIUM,
         SSL_HANDSHAKE_MAC_SHA256,
         64, /* CCM8 uses a short tag, so we have a low security strength */
@@ -125,13 +137,16 @@ static SSL_CIPHER tls13_ciphers[] = {
         SSL_aANY,
         SSL_eNULL,
         SSL_SHA256,
-        TLS1_3_VERSION, TLS1_3_VERSION,
-        0, 0,
+        TLS1_3_VERSION,
+        TLS1_3_VERSION,
+        0,
+        0,
         SSL_NOT_DEFAULT | SSL_STRONG_NONE,
         SSL_HANDSHAKE_MAC_SHA256,
         0,
         256,
-    }, {
+    },
+    {
         1,
         TLS1_3_RFC_SHA384_SHA384,
         TLS1_3_RFC_SHA384_SHA384,
@@ -140,8 +155,10 @@ static SSL_CIPHER tls13_ciphers[] = {
         SSL_aANY,
         SSL_eNULL,
         SSL_SHA384,
-        TLS1_3_VERSION, TLS1_3_VERSION,
-        0, 0,
+        TLS1_3_VERSION,
+        TLS1_3_VERSION,
+        0,
+        0,
         SSL_NOT_DEFAULT | SSL_STRONG_NONE,
         SSL_HANDSHAKE_MAC_SHA384,
         0,
@@ -163,3113 +180,3495 @@ static SSL_CIPHER tls13_ciphers[] = {
 static SSL_CIPHER ssl3_ciphers[] = {
 #ifndef OPENSSL_NO_INTEGRITY_ONLY_CIPHERS
     {
-     1,
-     SSL3_TXT_RSA_NULL_MD5,
-     SSL3_RFC_RSA_NULL_MD5,
-     SSL3_CK_RSA_NULL_MD5,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_eNULL,
-     SSL_MD5,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     0,
-     0,
-     },
+        1,
+        SSL3_TXT_RSA_NULL_MD5,
+        SSL3_RFC_RSA_NULL_MD5,
+        SSL3_CK_RSA_NULL_MD5,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_eNULL,
+        SSL_MD5,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        0,
+        0,
+    },
     {
-     1,
-     SSL3_TXT_RSA_NULL_SHA,
-     SSL3_RFC_RSA_NULL_SHA,
-     SSL3_CK_RSA_NULL_SHA,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_eNULL,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     0,
-     0,
-     },
+        1,
+        SSL3_TXT_RSA_NULL_SHA,
+        SSL3_RFC_RSA_NULL_SHA,
+        SSL3_CK_RSA_NULL_SHA,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_eNULL,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        0,
+        0,
+    },
 #endif
 #ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
     {
-     1,
-     SSL3_TXT_RSA_DES_192_CBC3_SHA,
-     SSL3_RFC_RSA_DES_192_CBC3_SHA,
-     SSL3_CK_RSA_DES_192_CBC3_SHA,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_3DES,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     112,
-     168,
-     },
+        1,
+        SSL3_TXT_RSA_DES_192_CBC3_SHA,
+        SSL3_RFC_RSA_DES_192_CBC3_SHA,
+        SSL3_CK_RSA_DES_192_CBC3_SHA,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_3DES,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        112,
+        168,
+    },
     {
-     1,
-     SSL3_TXT_DHE_DSS_DES_192_CBC3_SHA,
-     SSL3_RFC_DHE_DSS_DES_192_CBC3_SHA,
-     SSL3_CK_DHE_DSS_DES_192_CBC3_SHA,
-     SSL_kDHE,
-     SSL_aDSS,
-     SSL_3DES,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     112,
-     168,
-     },
+        1,
+        SSL3_TXT_DHE_DSS_DES_192_CBC3_SHA,
+        SSL3_RFC_DHE_DSS_DES_192_CBC3_SHA,
+        SSL3_CK_DHE_DSS_DES_192_CBC3_SHA,
+        SSL_kDHE,
+        SSL_aDSS,
+        SSL_3DES,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        112,
+        168,
+    },
     {
-     1,
-     SSL3_TXT_DHE_RSA_DES_192_CBC3_SHA,
-     SSL3_RFC_DHE_RSA_DES_192_CBC3_SHA,
-     SSL3_CK_DHE_RSA_DES_192_CBC3_SHA,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_3DES,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     112,
-     168,
-     },
+        1,
+        SSL3_TXT_DHE_RSA_DES_192_CBC3_SHA,
+        SSL3_RFC_DHE_RSA_DES_192_CBC3_SHA,
+        SSL3_CK_DHE_RSA_DES_192_CBC3_SHA,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_3DES,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        112,
+        168,
+    },
     {
-     1,
-     SSL3_TXT_ADH_DES_192_CBC_SHA,
-     SSL3_RFC_ADH_DES_192_CBC_SHA,
-     SSL3_CK_ADH_DES_192_CBC_SHA,
-     SSL_kDHE,
-     SSL_aNULL,
-     SSL_3DES,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     112,
-     168,
-     },
+        1,
+        SSL3_TXT_ADH_DES_192_CBC_SHA,
+        SSL3_RFC_ADH_DES_192_CBC_SHA,
+        SSL3_CK_ADH_DES_192_CBC_SHA,
+        SSL_kDHE,
+        SSL_aNULL,
+        SSL_3DES,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        112,
+        168,
+    },
 #endif
     {
-     1,
-     TLS1_TXT_RSA_WITH_AES_128_SHA,
-     TLS1_RFC_RSA_WITH_AES_128_SHA,
-     TLS1_CK_RSA_WITH_AES_128_SHA,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_AES128,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_AES_128_SHA,
+        TLS1_RFC_RSA_WITH_AES_128_SHA,
+        TLS1_CK_RSA_WITH_AES_128_SHA,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_AES128,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_DSS_WITH_AES_128_SHA,
-     TLS1_RFC_DHE_DSS_WITH_AES_128_SHA,
-     TLS1_CK_DHE_DSS_WITH_AES_128_SHA,
-     SSL_kDHE,
-     SSL_aDSS,
-     SSL_AES128,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_DSS_WITH_AES_128_SHA,
+        TLS1_RFC_DHE_DSS_WITH_AES_128_SHA,
+        TLS1_CK_DHE_DSS_WITH_AES_128_SHA,
+        SSL_kDHE,
+        SSL_aDSS,
+        SSL_AES128,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_AES_128_SHA,
-     TLS1_RFC_DHE_RSA_WITH_AES_128_SHA,
-     TLS1_CK_DHE_RSA_WITH_AES_128_SHA,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_AES128,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_AES_128_SHA,
+        TLS1_RFC_DHE_RSA_WITH_AES_128_SHA,
+        TLS1_CK_DHE_RSA_WITH_AES_128_SHA,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_AES128,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ADH_WITH_AES_128_SHA,
-     TLS1_RFC_ADH_WITH_AES_128_SHA,
-     TLS1_CK_ADH_WITH_AES_128_SHA,
-     SSL_kDHE,
-     SSL_aNULL,
-     SSL_AES128,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ADH_WITH_AES_128_SHA,
+        TLS1_RFC_ADH_WITH_AES_128_SHA,
+        TLS1_CK_ADH_WITH_AES_128_SHA,
+        SSL_kDHE,
+        SSL_aNULL,
+        SSL_AES128,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_RSA_WITH_AES_256_SHA,
-     TLS1_RFC_RSA_WITH_AES_256_SHA,
-     TLS1_CK_RSA_WITH_AES_256_SHA,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_AES256,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_AES_256_SHA,
+        TLS1_RFC_RSA_WITH_AES_256_SHA,
+        TLS1_CK_RSA_WITH_AES_256_SHA,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_AES256,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_DSS_WITH_AES_256_SHA,
-     TLS1_RFC_DHE_DSS_WITH_AES_256_SHA,
-     TLS1_CK_DHE_DSS_WITH_AES_256_SHA,
-     SSL_kDHE,
-     SSL_aDSS,
-     SSL_AES256,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_DSS_WITH_AES_256_SHA,
+        TLS1_RFC_DHE_DSS_WITH_AES_256_SHA,
+        TLS1_CK_DHE_DSS_WITH_AES_256_SHA,
+        SSL_kDHE,
+        SSL_aDSS,
+        SSL_AES256,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_AES_256_SHA,
-     TLS1_RFC_DHE_RSA_WITH_AES_256_SHA,
-     TLS1_CK_DHE_RSA_WITH_AES_256_SHA,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_AES256,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_AES_256_SHA,
+        TLS1_RFC_DHE_RSA_WITH_AES_256_SHA,
+        TLS1_CK_DHE_RSA_WITH_AES_256_SHA,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_AES256,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ADH_WITH_AES_256_SHA,
-     TLS1_RFC_ADH_WITH_AES_256_SHA,
-     TLS1_CK_ADH_WITH_AES_256_SHA,
-     SSL_kDHE,
-     SSL_aNULL,
-     SSL_AES256,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ADH_WITH_AES_256_SHA,
+        TLS1_RFC_ADH_WITH_AES_256_SHA,
+        TLS1_CK_ADH_WITH_AES_256_SHA,
+        SSL_kDHE,
+        SSL_aNULL,
+        SSL_AES256,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
 #ifndef OPENSSL_NO_INTEGRITY_ONLY_CIPHERS
     {
-     1,
-     TLS1_TXT_RSA_WITH_NULL_SHA256,
-     TLS1_RFC_RSA_WITH_NULL_SHA256,
-     TLS1_CK_RSA_WITH_NULL_SHA256,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_eNULL,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     0,
-     0,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_NULL_SHA256,
+        TLS1_RFC_RSA_WITH_NULL_SHA256,
+        TLS1_CK_RSA_WITH_NULL_SHA256,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_eNULL,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        0,
+        0,
+    },
 #endif
     {
-     1,
-     TLS1_TXT_RSA_WITH_AES_128_SHA256,
-     TLS1_RFC_RSA_WITH_AES_128_SHA256,
-     TLS1_CK_RSA_WITH_AES_128_SHA256,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_AES128,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_AES_128_SHA256,
+        TLS1_RFC_RSA_WITH_AES_128_SHA256,
+        TLS1_CK_RSA_WITH_AES_128_SHA256,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_AES128,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_RSA_WITH_AES_256_SHA256,
-     TLS1_RFC_RSA_WITH_AES_256_SHA256,
-     TLS1_CK_RSA_WITH_AES_256_SHA256,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_AES256,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_AES_256_SHA256,
+        TLS1_RFC_RSA_WITH_AES_256_SHA256,
+        TLS1_CK_RSA_WITH_AES_256_SHA256,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_AES256,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_DSS_WITH_AES_128_SHA256,
-     TLS1_RFC_DHE_DSS_WITH_AES_128_SHA256,
-     TLS1_CK_DHE_DSS_WITH_AES_128_SHA256,
-     SSL_kDHE,
-     SSL_aDSS,
-     SSL_AES128,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_DSS_WITH_AES_128_SHA256,
+        TLS1_RFC_DHE_DSS_WITH_AES_128_SHA256,
+        TLS1_CK_DHE_DSS_WITH_AES_128_SHA256,
+        SSL_kDHE,
+        SSL_aDSS,
+        SSL_AES128,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_AES_128_SHA256,
-     TLS1_RFC_DHE_RSA_WITH_AES_128_SHA256,
-     TLS1_CK_DHE_RSA_WITH_AES_128_SHA256,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_AES128,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_AES_128_SHA256,
+        TLS1_RFC_DHE_RSA_WITH_AES_128_SHA256,
+        TLS1_CK_DHE_RSA_WITH_AES_128_SHA256,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_AES128,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_DSS_WITH_AES_256_SHA256,
-     TLS1_RFC_DHE_DSS_WITH_AES_256_SHA256,
-     TLS1_CK_DHE_DSS_WITH_AES_256_SHA256,
-     SSL_kDHE,
-     SSL_aDSS,
-     SSL_AES256,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_DSS_WITH_AES_256_SHA256,
+        TLS1_RFC_DHE_DSS_WITH_AES_256_SHA256,
+        TLS1_CK_DHE_DSS_WITH_AES_256_SHA256,
+        SSL_kDHE,
+        SSL_aDSS,
+        SSL_AES256,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_AES_256_SHA256,
-     TLS1_RFC_DHE_RSA_WITH_AES_256_SHA256,
-     TLS1_CK_DHE_RSA_WITH_AES_256_SHA256,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_AES256,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_AES_256_SHA256,
+        TLS1_RFC_DHE_RSA_WITH_AES_256_SHA256,
+        TLS1_CK_DHE_RSA_WITH_AES_256_SHA256,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_AES256,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ADH_WITH_AES_128_SHA256,
-     TLS1_RFC_ADH_WITH_AES_128_SHA256,
-     TLS1_CK_ADH_WITH_AES_128_SHA256,
-     SSL_kDHE,
-     SSL_aNULL,
-     SSL_AES128,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ADH_WITH_AES_128_SHA256,
+        TLS1_RFC_ADH_WITH_AES_128_SHA256,
+        TLS1_CK_ADH_WITH_AES_128_SHA256,
+        SSL_kDHE,
+        SSL_aNULL,
+        SSL_AES128,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ADH_WITH_AES_256_SHA256,
-     TLS1_RFC_ADH_WITH_AES_256_SHA256,
-     TLS1_CK_ADH_WITH_AES_256_SHA256,
-     SSL_kDHE,
-     SSL_aNULL,
-     SSL_AES256,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ADH_WITH_AES_256_SHA256,
+        TLS1_RFC_ADH_WITH_AES_256_SHA256,
+        TLS1_CK_ADH_WITH_AES_256_SHA256,
+        SSL_kDHE,
+        SSL_aNULL,
+        SSL_AES256,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_RSA_WITH_AES_128_GCM_SHA256,
-     TLS1_RFC_RSA_WITH_AES_128_GCM_SHA256,
-     TLS1_CK_RSA_WITH_AES_128_GCM_SHA256,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_AES128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_AES_128_GCM_SHA256,
+        TLS1_RFC_RSA_WITH_AES_128_GCM_SHA256,
+        TLS1_CK_RSA_WITH_AES_128_GCM_SHA256,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_AES128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_RSA_WITH_AES_256_GCM_SHA384,
-     TLS1_RFC_RSA_WITH_AES_256_GCM_SHA384,
-     TLS1_CK_RSA_WITH_AES_256_GCM_SHA384,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_AES256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_AES_256_GCM_SHA384,
+        TLS1_RFC_RSA_WITH_AES_256_GCM_SHA384,
+        TLS1_CK_RSA_WITH_AES_256_GCM_SHA384,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_AES256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_AES_128_GCM_SHA256,
-     TLS1_RFC_DHE_RSA_WITH_AES_128_GCM_SHA256,
-     TLS1_CK_DHE_RSA_WITH_AES_128_GCM_SHA256,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_AES128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_AES_128_GCM_SHA256,
+        TLS1_RFC_DHE_RSA_WITH_AES_128_GCM_SHA256,
+        TLS1_CK_DHE_RSA_WITH_AES_128_GCM_SHA256,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_AES128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_AES_256_GCM_SHA384,
-     TLS1_RFC_DHE_RSA_WITH_AES_256_GCM_SHA384,
-     TLS1_CK_DHE_RSA_WITH_AES_256_GCM_SHA384,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_AES256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_AES_256_GCM_SHA384,
+        TLS1_RFC_DHE_RSA_WITH_AES_256_GCM_SHA384,
+        TLS1_CK_DHE_RSA_WITH_AES_256_GCM_SHA384,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_AES256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_DSS_WITH_AES_128_GCM_SHA256,
-     TLS1_RFC_DHE_DSS_WITH_AES_128_GCM_SHA256,
-     TLS1_CK_DHE_DSS_WITH_AES_128_GCM_SHA256,
-     SSL_kDHE,
-     SSL_aDSS,
-     SSL_AES128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_DSS_WITH_AES_128_GCM_SHA256,
+        TLS1_RFC_DHE_DSS_WITH_AES_128_GCM_SHA256,
+        TLS1_CK_DHE_DSS_WITH_AES_128_GCM_SHA256,
+        SSL_kDHE,
+        SSL_aDSS,
+        SSL_AES128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_DSS_WITH_AES_256_GCM_SHA384,
-     TLS1_RFC_DHE_DSS_WITH_AES_256_GCM_SHA384,
-     TLS1_CK_DHE_DSS_WITH_AES_256_GCM_SHA384,
-     SSL_kDHE,
-     SSL_aDSS,
-     SSL_AES256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_DSS_WITH_AES_256_GCM_SHA384,
+        TLS1_RFC_DHE_DSS_WITH_AES_256_GCM_SHA384,
+        TLS1_CK_DHE_DSS_WITH_AES_256_GCM_SHA384,
+        SSL_kDHE,
+        SSL_aDSS,
+        SSL_AES256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ADH_WITH_AES_128_GCM_SHA256,
-     TLS1_RFC_ADH_WITH_AES_128_GCM_SHA256,
-     TLS1_CK_ADH_WITH_AES_128_GCM_SHA256,
-     SSL_kDHE,
-     SSL_aNULL,
-     SSL_AES128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ADH_WITH_AES_128_GCM_SHA256,
+        TLS1_RFC_ADH_WITH_AES_128_GCM_SHA256,
+        TLS1_CK_ADH_WITH_AES_128_GCM_SHA256,
+        SSL_kDHE,
+        SSL_aNULL,
+        SSL_AES128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ADH_WITH_AES_256_GCM_SHA384,
-     TLS1_RFC_ADH_WITH_AES_256_GCM_SHA384,
-     TLS1_CK_ADH_WITH_AES_256_GCM_SHA384,
-     SSL_kDHE,
-     SSL_aNULL,
-     SSL_AES256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ADH_WITH_AES_256_GCM_SHA384,
+        TLS1_RFC_ADH_WITH_AES_256_GCM_SHA384,
+        TLS1_CK_ADH_WITH_AES_256_GCM_SHA384,
+        SSL_kDHE,
+        SSL_aNULL,
+        SSL_AES256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_RSA_WITH_AES_128_CCM,
-     TLS1_RFC_RSA_WITH_AES_128_CCM,
-     TLS1_CK_RSA_WITH_AES_128_CCM,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_AES128CCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_AES_128_CCM,
+        TLS1_RFC_RSA_WITH_AES_128_CCM,
+        TLS1_CK_RSA_WITH_AES_128_CCM,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_AES128CCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_RSA_WITH_AES_256_CCM,
-     TLS1_RFC_RSA_WITH_AES_256_CCM,
-     TLS1_CK_RSA_WITH_AES_256_CCM,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_AES256CCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_AES_256_CCM,
+        TLS1_RFC_RSA_WITH_AES_256_CCM,
+        TLS1_CK_RSA_WITH_AES_256_CCM,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_AES256CCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_AES_128_CCM,
-     TLS1_RFC_DHE_RSA_WITH_AES_128_CCM,
-     TLS1_CK_DHE_RSA_WITH_AES_128_CCM,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_AES128CCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_AES_128_CCM,
+        TLS1_RFC_DHE_RSA_WITH_AES_128_CCM,
+        TLS1_CK_DHE_RSA_WITH_AES_128_CCM,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_AES128CCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_AES_256_CCM,
-     TLS1_RFC_DHE_RSA_WITH_AES_256_CCM,
-     TLS1_CK_DHE_RSA_WITH_AES_256_CCM,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_AES256CCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_AES_256_CCM,
+        TLS1_RFC_DHE_RSA_WITH_AES_256_CCM,
+        TLS1_CK_DHE_RSA_WITH_AES_256_CCM,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_AES256CCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_RSA_WITH_AES_128_CCM_8,
-     TLS1_RFC_RSA_WITH_AES_128_CCM_8,
-     TLS1_CK_RSA_WITH_AES_128_CCM_8,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_AES128CCM8,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     64, /* CCM8 uses a short tag, so we have a low security strength */
-     128,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_AES_128_CCM_8,
+        TLS1_RFC_RSA_WITH_AES_128_CCM_8,
+        TLS1_CK_RSA_WITH_AES_128_CCM_8,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_AES128CCM8,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        64, /* CCM8 uses a short tag, so we have a low security strength */
+        128,
+    },
     {
-     1,
-     TLS1_TXT_RSA_WITH_AES_256_CCM_8,
-     TLS1_RFC_RSA_WITH_AES_256_CCM_8,
-     TLS1_CK_RSA_WITH_AES_256_CCM_8,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_AES256CCM8,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     64, /* CCM8 uses a short tag, so we have a low security strength */
-     256,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_AES_256_CCM_8,
+        TLS1_RFC_RSA_WITH_AES_256_CCM_8,
+        TLS1_CK_RSA_WITH_AES_256_CCM_8,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_AES256CCM8,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        64, /* CCM8 uses a short tag, so we have a low security strength */
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_AES_128_CCM_8,
-     TLS1_RFC_DHE_RSA_WITH_AES_128_CCM_8,
-     TLS1_CK_DHE_RSA_WITH_AES_128_CCM_8,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_AES128CCM8,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     64, /* CCM8 uses a short tag, so we have a low security strength */
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_AES_128_CCM_8,
+        TLS1_RFC_DHE_RSA_WITH_AES_128_CCM_8,
+        TLS1_CK_DHE_RSA_WITH_AES_128_CCM_8,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_AES128CCM8,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        64, /* CCM8 uses a short tag, so we have a low security strength */
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_AES_256_CCM_8,
-     TLS1_RFC_DHE_RSA_WITH_AES_256_CCM_8,
-     TLS1_CK_DHE_RSA_WITH_AES_256_CCM_8,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_AES256CCM8,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     64, /* CCM8 uses a short tag, so we have a low security strength */
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_AES_256_CCM_8,
+        TLS1_RFC_DHE_RSA_WITH_AES_256_CCM_8,
+        TLS1_CK_DHE_RSA_WITH_AES_256_CCM_8,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_AES256CCM8,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        64, /* CCM8 uses a short tag, so we have a low security strength */
+        256,
+    },
     {
-     1,
-     TLS1_TXT_PSK_WITH_AES_128_CCM,
-     TLS1_RFC_PSK_WITH_AES_128_CCM,
-     TLS1_CK_PSK_WITH_AES_128_CCM,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_AES128CCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_AES_128_CCM,
+        TLS1_RFC_PSK_WITH_AES_128_CCM,
+        TLS1_CK_PSK_WITH_AES_128_CCM,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_AES128CCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_PSK_WITH_AES_256_CCM,
-     TLS1_RFC_PSK_WITH_AES_256_CCM,
-     TLS1_CK_PSK_WITH_AES_256_CCM,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_AES256CCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_AES_256_CCM,
+        TLS1_RFC_PSK_WITH_AES_256_CCM,
+        TLS1_CK_PSK_WITH_AES_256_CCM,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_AES256CCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_AES_128_CCM,
-     TLS1_RFC_DHE_PSK_WITH_AES_128_CCM,
-     TLS1_CK_DHE_PSK_WITH_AES_128_CCM,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_AES128CCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_AES_128_CCM,
+        TLS1_RFC_DHE_PSK_WITH_AES_128_CCM,
+        TLS1_CK_DHE_PSK_WITH_AES_128_CCM,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_AES128CCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_AES_256_CCM,
-     TLS1_RFC_DHE_PSK_WITH_AES_256_CCM,
-     TLS1_CK_DHE_PSK_WITH_AES_256_CCM,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_AES256CCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_AES_256_CCM,
+        TLS1_RFC_DHE_PSK_WITH_AES_256_CCM,
+        TLS1_CK_DHE_PSK_WITH_AES_256_CCM,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_AES256CCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_PSK_WITH_AES_128_CCM_8,
-     TLS1_RFC_PSK_WITH_AES_128_CCM_8,
-     TLS1_CK_PSK_WITH_AES_128_CCM_8,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_AES128CCM8,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     64, /* CCM8 uses a short tag, so we have a low security strength */
-     128,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_AES_128_CCM_8,
+        TLS1_RFC_PSK_WITH_AES_128_CCM_8,
+        TLS1_CK_PSK_WITH_AES_128_CCM_8,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_AES128CCM8,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        64, /* CCM8 uses a short tag, so we have a low security strength */
+        128,
+    },
     {
-     1,
-     TLS1_TXT_PSK_WITH_AES_256_CCM_8,
-     TLS1_RFC_PSK_WITH_AES_256_CCM_8,
-     TLS1_CK_PSK_WITH_AES_256_CCM_8,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_AES256CCM8,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     64, /* CCM8 uses a short tag, so we have a low security strength */
-     256,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_AES_256_CCM_8,
+        TLS1_RFC_PSK_WITH_AES_256_CCM_8,
+        TLS1_CK_PSK_WITH_AES_256_CCM_8,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_AES256CCM8,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        64, /* CCM8 uses a short tag, so we have a low security strength */
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_AES_128_CCM_8,
-     TLS1_RFC_DHE_PSK_WITH_AES_128_CCM_8,
-     TLS1_CK_DHE_PSK_WITH_AES_128_CCM_8,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_AES128CCM8,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     64, /* CCM8 uses a short tag, so we have a low security strength */
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_AES_128_CCM_8,
+        TLS1_RFC_DHE_PSK_WITH_AES_128_CCM_8,
+        TLS1_CK_DHE_PSK_WITH_AES_128_CCM_8,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_AES128CCM8,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        64, /* CCM8 uses a short tag, so we have a low security strength */
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_AES_256_CCM_8,
-     TLS1_RFC_DHE_PSK_WITH_AES_256_CCM_8,
-     TLS1_CK_DHE_PSK_WITH_AES_256_CCM_8,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_AES256CCM8,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     64, /* CCM8 uses a short tag, so we have a low security strength */
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_AES_256_CCM_8,
+        TLS1_RFC_DHE_PSK_WITH_AES_256_CCM_8,
+        TLS1_CK_DHE_PSK_WITH_AES_256_CCM_8,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_AES256CCM8,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        64, /* CCM8 uses a short tag, so we have a low security strength */
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM,
-     TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM,
-     TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_AES128CCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM,
+        TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM,
+        TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_AES128CCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM,
-     TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM,
-     TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_AES256CCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM,
+        TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM,
+        TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_AES256CCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM_8,
-     TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM_8,
-     TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM_8,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_AES128CCM8,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     64, /* CCM8 uses a short tag, so we have a low security strength */
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CCM_8,
+        TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CCM_8,
+        TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CCM_8,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_AES128CCM8,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        64, /* CCM8 uses a short tag, so we have a low security strength */
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM_8,
-     TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM_8,
-     TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM_8,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_AES256CCM8,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     64, /* CCM8 uses a short tag, so we have a low security strength */
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CCM_8,
+        TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CCM_8,
+        TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CCM_8,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_AES256CCM8,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        64, /* CCM8 uses a short tag, so we have a low security strength */
+        256,
+    },
 #ifndef OPENSSL_NO_INTEGRITY_ONLY_CIPHERS
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_NULL_SHA,
-     TLS1_RFC_ECDHE_ECDSA_WITH_NULL_SHA,
-     TLS1_CK_ECDHE_ECDSA_WITH_NULL_SHA,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_eNULL,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     0,
-     0,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_NULL_SHA,
+        TLS1_RFC_ECDHE_ECDSA_WITH_NULL_SHA,
+        TLS1_CK_ECDHE_ECDSA_WITH_NULL_SHA,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_eNULL,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        0,
+        0,
+    },
 #endif
-# ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
+#ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA,
-     TLS1_RFC_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA,
-     TLS1_CK_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_3DES,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     112,
-     168,
-     },
-# endif
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA,
+        TLS1_RFC_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA,
+        TLS1_CK_ECDHE_ECDSA_WITH_DES_192_CBC3_SHA,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_3DES,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        112,
+        168,
+    },
+#endif
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
-     TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
-     TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_AES128,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
+        TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
+        TLS1_CK_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_AES128,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
-     TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
-     TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_AES256,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
+        TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
+        TLS1_CK_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_AES256,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
 #ifndef OPENSSL_NO_INTEGRITY_ONLY_CIPHERS
     {
-     1,
-     TLS1_TXT_ECDHE_RSA_WITH_NULL_SHA,
-     TLS1_RFC_ECDHE_RSA_WITH_NULL_SHA,
-     TLS1_CK_ECDHE_RSA_WITH_NULL_SHA,
-     SSL_kECDHE,
-     SSL_aRSA,
-     SSL_eNULL,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     0,
-     0,
-     },
+        1,
+        TLS1_TXT_ECDHE_RSA_WITH_NULL_SHA,
+        TLS1_RFC_ECDHE_RSA_WITH_NULL_SHA,
+        TLS1_CK_ECDHE_RSA_WITH_NULL_SHA,
+        SSL_kECDHE,
+        SSL_aRSA,
+        SSL_eNULL,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        0,
+        0,
+    },
 #endif
-# ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
+#ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
     {
-     1,
-     TLS1_TXT_ECDHE_RSA_WITH_DES_192_CBC3_SHA,
-     TLS1_RFC_ECDHE_RSA_WITH_DES_192_CBC3_SHA,
-     TLS1_CK_ECDHE_RSA_WITH_DES_192_CBC3_SHA,
-     SSL_kECDHE,
-     SSL_aRSA,
-     SSL_3DES,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     112,
-     168,
-     },
-# endif
+        1,
+        TLS1_TXT_ECDHE_RSA_WITH_DES_192_CBC3_SHA,
+        TLS1_RFC_ECDHE_RSA_WITH_DES_192_CBC3_SHA,
+        TLS1_CK_ECDHE_RSA_WITH_DES_192_CBC3_SHA,
+        SSL_kECDHE,
+        SSL_aRSA,
+        SSL_3DES,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        112,
+        168,
+    },
+#endif
     {
-     1,
-     TLS1_TXT_ECDHE_RSA_WITH_AES_128_CBC_SHA,
-     TLS1_RFC_ECDHE_RSA_WITH_AES_128_CBC_SHA,
-     TLS1_CK_ECDHE_RSA_WITH_AES_128_CBC_SHA,
-     SSL_kECDHE,
-     SSL_aRSA,
-     SSL_AES128,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_RSA_WITH_AES_128_CBC_SHA,
+        TLS1_RFC_ECDHE_RSA_WITH_AES_128_CBC_SHA,
+        TLS1_CK_ECDHE_RSA_WITH_AES_128_CBC_SHA,
+        SSL_kECDHE,
+        SSL_aRSA,
+        SSL_AES128,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_RSA_WITH_AES_256_CBC_SHA,
-     TLS1_RFC_ECDHE_RSA_WITH_AES_256_CBC_SHA,
-     TLS1_CK_ECDHE_RSA_WITH_AES_256_CBC_SHA,
-     SSL_kECDHE,
-     SSL_aRSA,
-     SSL_AES256,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_RSA_WITH_AES_256_CBC_SHA,
+        TLS1_RFC_ECDHE_RSA_WITH_AES_256_CBC_SHA,
+        TLS1_CK_ECDHE_RSA_WITH_AES_256_CBC_SHA,
+        SSL_kECDHE,
+        SSL_aRSA,
+        SSL_AES256,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
 #ifndef OPENSSL_NO_INTEGRITY_ONLY_CIPHERS
     {
-     1,
-     TLS1_TXT_ECDH_anon_WITH_NULL_SHA,
-     TLS1_RFC_ECDH_anon_WITH_NULL_SHA,
-     TLS1_CK_ECDH_anon_WITH_NULL_SHA,
-     SSL_kECDHE,
-     SSL_aNULL,
-     SSL_eNULL,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     0,
-     0,
-     },
+        1,
+        TLS1_TXT_ECDH_anon_WITH_NULL_SHA,
+        TLS1_RFC_ECDH_anon_WITH_NULL_SHA,
+        TLS1_CK_ECDH_anon_WITH_NULL_SHA,
+        SSL_kECDHE,
+        SSL_aNULL,
+        SSL_eNULL,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        0,
+        0,
+    },
 #endif
-# ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
+#ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
     {
-     1,
-     TLS1_TXT_ECDH_anon_WITH_DES_192_CBC3_SHA,
-     TLS1_RFC_ECDH_anon_WITH_DES_192_CBC3_SHA,
-     TLS1_CK_ECDH_anon_WITH_DES_192_CBC3_SHA,
-     SSL_kECDHE,
-     SSL_aNULL,
-     SSL_3DES,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     112,
-     168,
-     },
-# endif
+        1,
+        TLS1_TXT_ECDH_anon_WITH_DES_192_CBC3_SHA,
+        TLS1_RFC_ECDH_anon_WITH_DES_192_CBC3_SHA,
+        TLS1_CK_ECDH_anon_WITH_DES_192_CBC3_SHA,
+        SSL_kECDHE,
+        SSL_aNULL,
+        SSL_3DES,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        112,
+        168,
+    },
+#endif
     {
-     1,
-     TLS1_TXT_ECDH_anon_WITH_AES_128_CBC_SHA,
-     TLS1_RFC_ECDH_anon_WITH_AES_128_CBC_SHA,
-     TLS1_CK_ECDH_anon_WITH_AES_128_CBC_SHA,
-     SSL_kECDHE,
-     SSL_aNULL,
-     SSL_AES128,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDH_anon_WITH_AES_128_CBC_SHA,
+        TLS1_RFC_ECDH_anon_WITH_AES_128_CBC_SHA,
+        TLS1_CK_ECDH_anon_WITH_AES_128_CBC_SHA,
+        SSL_kECDHE,
+        SSL_aNULL,
+        SSL_AES128,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDH_anon_WITH_AES_256_CBC_SHA,
-     TLS1_RFC_ECDH_anon_WITH_AES_256_CBC_SHA,
-     TLS1_CK_ECDH_anon_WITH_AES_256_CBC_SHA,
-     SSL_kECDHE,
-     SSL_aNULL,
-     SSL_AES256,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDH_anon_WITH_AES_256_CBC_SHA,
+        TLS1_RFC_ECDH_anon_WITH_AES_256_CBC_SHA,
+        TLS1_CK_ECDH_anon_WITH_AES_256_CBC_SHA,
+        SSL_kECDHE,
+        SSL_aNULL,
+        SSL_AES256,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_SHA256,
-     TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_SHA256,
-     TLS1_CK_ECDHE_ECDSA_WITH_AES_128_SHA256,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_AES128,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_SHA256,
+        TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_SHA256,
+        TLS1_CK_ECDHE_ECDSA_WITH_AES_128_SHA256,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_AES128,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_SHA384,
-     TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_SHA384,
-     TLS1_CK_ECDHE_ECDSA_WITH_AES_256_SHA384,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_AES256,
-     SSL_SHA384,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_SHA384,
+        TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_SHA384,
+        TLS1_CK_ECDHE_ECDSA_WITH_AES_256_SHA384,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_AES256,
+        SSL_SHA384,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_RSA_WITH_AES_128_SHA256,
-     TLS1_RFC_ECDHE_RSA_WITH_AES_128_SHA256,
-     TLS1_CK_ECDHE_RSA_WITH_AES_128_SHA256,
-     SSL_kECDHE,
-     SSL_aRSA,
-     SSL_AES128,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_RSA_WITH_AES_128_SHA256,
+        TLS1_RFC_ECDHE_RSA_WITH_AES_128_SHA256,
+        TLS1_CK_ECDHE_RSA_WITH_AES_128_SHA256,
+        SSL_kECDHE,
+        SSL_aRSA,
+        SSL_AES128,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_RSA_WITH_AES_256_SHA384,
-     TLS1_RFC_ECDHE_RSA_WITH_AES_256_SHA384,
-     TLS1_CK_ECDHE_RSA_WITH_AES_256_SHA384,
-     SSL_kECDHE,
-     SSL_aRSA,
-     SSL_AES256,
-     SSL_SHA384,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_RSA_WITH_AES_256_SHA384,
+        TLS1_RFC_ECDHE_RSA_WITH_AES_256_SHA384,
+        TLS1_CK_ECDHE_RSA_WITH_AES_256_SHA384,
+        SSL_kECDHE,
+        SSL_aRSA,
+        SSL_AES256,
+        SSL_SHA384,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-     TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-     TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_AES128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+        TLS1_RFC_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+        TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_AES128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
-     TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
-     TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_AES256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+        TLS1_RFC_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+        TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_AES256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-     TLS1_RFC_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-     TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-     SSL_kECDHE,
-     SSL_aRSA,
-     SSL_AES128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+        TLS1_RFC_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+        TLS1_CK_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+        SSL_kECDHE,
+        SSL_aRSA,
+        SSL_AES128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
-     TLS1_RFC_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
-     TLS1_CK_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
-     SSL_kECDHE,
-     SSL_aRSA,
-     SSL_AES256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+        TLS1_RFC_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+        TLS1_CK_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+        SSL_kECDHE,
+        SSL_aRSA,
+        SSL_AES256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
 #ifndef OPENSSL_NO_INTEGRITY_ONLY_CIPHERS
     {
-     1,
-     TLS1_TXT_PSK_WITH_NULL_SHA,
-     TLS1_RFC_PSK_WITH_NULL_SHA,
-     TLS1_CK_PSK_WITH_NULL_SHA,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_eNULL,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     0,
-     0,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_NULL_SHA,
+        TLS1_RFC_PSK_WITH_NULL_SHA,
+        TLS1_CK_PSK_WITH_NULL_SHA,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_eNULL,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        0,
+        0,
+    },
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_NULL_SHA,
-     TLS1_RFC_DHE_PSK_WITH_NULL_SHA,
-     TLS1_CK_DHE_PSK_WITH_NULL_SHA,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_eNULL,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     0,
-     0,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_NULL_SHA,
+        TLS1_RFC_DHE_PSK_WITH_NULL_SHA,
+        TLS1_CK_DHE_PSK_WITH_NULL_SHA,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_eNULL,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        0,
+        0,
+    },
     {
-     1,
-     TLS1_TXT_RSA_PSK_WITH_NULL_SHA,
-     TLS1_RFC_RSA_PSK_WITH_NULL_SHA,
-     TLS1_CK_RSA_PSK_WITH_NULL_SHA,
-     SSL_kRSAPSK,
-     SSL_aRSA,
-     SSL_eNULL,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     0,
-     0,
-     },
+        1,
+        TLS1_TXT_RSA_PSK_WITH_NULL_SHA,
+        TLS1_RFC_RSA_PSK_WITH_NULL_SHA,
+        TLS1_CK_RSA_PSK_WITH_NULL_SHA,
+        SSL_kRSAPSK,
+        SSL_aRSA,
+        SSL_eNULL,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        0,
+        0,
+    },
 #endif
-# ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
+#ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
     {
-     1,
-     TLS1_TXT_PSK_WITH_3DES_EDE_CBC_SHA,
-     TLS1_RFC_PSK_WITH_3DES_EDE_CBC_SHA,
-     TLS1_CK_PSK_WITH_3DES_EDE_CBC_SHA,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_3DES,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     112,
-     168,
-     },
-# endif
+        1,
+        TLS1_TXT_PSK_WITH_3DES_EDE_CBC_SHA,
+        TLS1_RFC_PSK_WITH_3DES_EDE_CBC_SHA,
+        TLS1_CK_PSK_WITH_3DES_EDE_CBC_SHA,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_3DES,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        112,
+        168,
+    },
+#endif
     {
-     1,
-     TLS1_TXT_PSK_WITH_AES_128_CBC_SHA,
-     TLS1_RFC_PSK_WITH_AES_128_CBC_SHA,
-     TLS1_CK_PSK_WITH_AES_128_CBC_SHA,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_AES128,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_AES_128_CBC_SHA,
+        TLS1_RFC_PSK_WITH_AES_128_CBC_SHA,
+        TLS1_CK_PSK_WITH_AES_128_CBC_SHA,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_AES128,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_PSK_WITH_AES_256_CBC_SHA,
-     TLS1_RFC_PSK_WITH_AES_256_CBC_SHA,
-     TLS1_CK_PSK_WITH_AES_256_CBC_SHA,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_AES256,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
-# ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
+        1,
+        TLS1_TXT_PSK_WITH_AES_256_CBC_SHA,
+        TLS1_RFC_PSK_WITH_AES_256_CBC_SHA,
+        TLS1_CK_PSK_WITH_AES_256_CBC_SHA,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_AES256,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
+#ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_3DES_EDE_CBC_SHA,
-     TLS1_RFC_DHE_PSK_WITH_3DES_EDE_CBC_SHA,
-     TLS1_CK_DHE_PSK_WITH_3DES_EDE_CBC_SHA,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_3DES,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     112,
-     168,
-     },
-# endif
+        1,
+        TLS1_TXT_DHE_PSK_WITH_3DES_EDE_CBC_SHA,
+        TLS1_RFC_DHE_PSK_WITH_3DES_EDE_CBC_SHA,
+        TLS1_CK_DHE_PSK_WITH_3DES_EDE_CBC_SHA,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_3DES,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        112,
+        168,
+    },
+#endif
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA,
-     TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA,
-     TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_AES128,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA,
+        TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA,
+        TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_AES128,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA,
-     TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA,
-     TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_AES256,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
-# ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
+        1,
+        TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA,
+        TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA,
+        TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_AES256,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
+#ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
     {
-     1,
-     TLS1_TXT_RSA_PSK_WITH_3DES_EDE_CBC_SHA,
-     TLS1_RFC_RSA_PSK_WITH_3DES_EDE_CBC_SHA,
-     TLS1_CK_RSA_PSK_WITH_3DES_EDE_CBC_SHA,
-     SSL_kRSAPSK,
-     SSL_aRSA,
-     SSL_3DES,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     112,
-     168,
-     },
-# endif
+        1,
+        TLS1_TXT_RSA_PSK_WITH_3DES_EDE_CBC_SHA,
+        TLS1_RFC_RSA_PSK_WITH_3DES_EDE_CBC_SHA,
+        TLS1_CK_RSA_PSK_WITH_3DES_EDE_CBC_SHA,
+        SSL_kRSAPSK,
+        SSL_aRSA,
+        SSL_3DES,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        112,
+        168,
+    },
+#endif
     {
-     1,
-     TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA,
-     TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA,
-     TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA,
-     SSL_kRSAPSK,
-     SSL_aRSA,
-     SSL_AES128,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA,
+        TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA,
+        TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA,
+        SSL_kRSAPSK,
+        SSL_aRSA,
+        SSL_AES128,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA,
-     TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA,
-     TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA,
-     SSL_kRSAPSK,
-     SSL_aRSA,
-     SSL_AES256,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA,
+        TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA,
+        TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA,
+        SSL_kRSAPSK,
+        SSL_aRSA,
+        SSL_AES256,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_PSK_WITH_AES_128_GCM_SHA256,
-     TLS1_RFC_PSK_WITH_AES_128_GCM_SHA256,
-     TLS1_CK_PSK_WITH_AES_128_GCM_SHA256,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_AES128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_AES_128_GCM_SHA256,
+        TLS1_RFC_PSK_WITH_AES_128_GCM_SHA256,
+        TLS1_CK_PSK_WITH_AES_128_GCM_SHA256,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_AES128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_PSK_WITH_AES_256_GCM_SHA384,
-     TLS1_RFC_PSK_WITH_AES_256_GCM_SHA384,
-     TLS1_CK_PSK_WITH_AES_256_GCM_SHA384,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_AES256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_AES_256_GCM_SHA384,
+        TLS1_RFC_PSK_WITH_AES_256_GCM_SHA384,
+        TLS1_CK_PSK_WITH_AES_256_GCM_SHA384,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_AES256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_AES_128_GCM_SHA256,
-     TLS1_RFC_DHE_PSK_WITH_AES_128_GCM_SHA256,
-     TLS1_CK_DHE_PSK_WITH_AES_128_GCM_SHA256,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_AES128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_AES_128_GCM_SHA256,
+        TLS1_RFC_DHE_PSK_WITH_AES_128_GCM_SHA256,
+        TLS1_CK_DHE_PSK_WITH_AES_128_GCM_SHA256,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_AES128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_AES_256_GCM_SHA384,
-     TLS1_RFC_DHE_PSK_WITH_AES_256_GCM_SHA384,
-     TLS1_CK_DHE_PSK_WITH_AES_256_GCM_SHA384,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_AES256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_AES_256_GCM_SHA384,
+        TLS1_RFC_DHE_PSK_WITH_AES_256_GCM_SHA384,
+        TLS1_CK_DHE_PSK_WITH_AES_256_GCM_SHA384,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_AES256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_RSA_PSK_WITH_AES_128_GCM_SHA256,
-     TLS1_RFC_RSA_PSK_WITH_AES_128_GCM_SHA256,
-     TLS1_CK_RSA_PSK_WITH_AES_128_GCM_SHA256,
-     SSL_kRSAPSK,
-     SSL_aRSA,
-     SSL_AES128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_RSA_PSK_WITH_AES_128_GCM_SHA256,
+        TLS1_RFC_RSA_PSK_WITH_AES_128_GCM_SHA256,
+        TLS1_CK_RSA_PSK_WITH_AES_128_GCM_SHA256,
+        SSL_kRSAPSK,
+        SSL_aRSA,
+        SSL_AES128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_RSA_PSK_WITH_AES_256_GCM_SHA384,
-     TLS1_RFC_RSA_PSK_WITH_AES_256_GCM_SHA384,
-     TLS1_CK_RSA_PSK_WITH_AES_256_GCM_SHA384,
-     SSL_kRSAPSK,
-     SSL_aRSA,
-     SSL_AES256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_RSA_PSK_WITH_AES_256_GCM_SHA384,
+        TLS1_RFC_RSA_PSK_WITH_AES_256_GCM_SHA384,
+        TLS1_CK_RSA_PSK_WITH_AES_256_GCM_SHA384,
+        SSL_kRSAPSK,
+        SSL_aRSA,
+        SSL_AES256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_PSK_WITH_AES_128_CBC_SHA256,
-     TLS1_RFC_PSK_WITH_AES_128_CBC_SHA256,
-     TLS1_CK_PSK_WITH_AES_128_CBC_SHA256,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_AES128,
-     SSL_SHA256,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_AES_128_CBC_SHA256,
+        TLS1_RFC_PSK_WITH_AES_128_CBC_SHA256,
+        TLS1_CK_PSK_WITH_AES_128_CBC_SHA256,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_AES128,
+        SSL_SHA256,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_PSK_WITH_AES_256_CBC_SHA384,
-     TLS1_RFC_PSK_WITH_AES_256_CBC_SHA384,
-     TLS1_CK_PSK_WITH_AES_256_CBC_SHA384,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_AES256,
-     SSL_SHA384,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_AES_256_CBC_SHA384,
+        TLS1_RFC_PSK_WITH_AES_256_CBC_SHA384,
+        TLS1_CK_PSK_WITH_AES_256_CBC_SHA384,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_AES256,
+        SSL_SHA384,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
 #ifndef OPENSSL_NO_INTEGRITY_ONLY_CIPHERS
     {
-     1,
-     TLS1_TXT_PSK_WITH_NULL_SHA256,
-     TLS1_RFC_PSK_WITH_NULL_SHA256,
-     TLS1_CK_PSK_WITH_NULL_SHA256,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_eNULL,
-     SSL_SHA256,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     0,
-     0,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_NULL_SHA256,
+        TLS1_RFC_PSK_WITH_NULL_SHA256,
+        TLS1_CK_PSK_WITH_NULL_SHA256,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_eNULL,
+        SSL_SHA256,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        0,
+        0,
+    },
     {
-     1,
-     TLS1_TXT_PSK_WITH_NULL_SHA384,
-     TLS1_RFC_PSK_WITH_NULL_SHA384,
-     TLS1_CK_PSK_WITH_NULL_SHA384,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_eNULL,
-     SSL_SHA384,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     0,
-     0,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_NULL_SHA384,
+        TLS1_RFC_PSK_WITH_NULL_SHA384,
+        TLS1_CK_PSK_WITH_NULL_SHA384,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_eNULL,
+        SSL_SHA384,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        0,
+        0,
+    },
 #endif
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA256,
-     TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA256,
-     TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA256,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_AES128,
-     SSL_SHA256,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_AES_128_CBC_SHA256,
+        TLS1_RFC_DHE_PSK_WITH_AES_128_CBC_SHA256,
+        TLS1_CK_DHE_PSK_WITH_AES_128_CBC_SHA256,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_AES128,
+        SSL_SHA256,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA384,
-     TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA384,
-     TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA384,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_AES256,
-     SSL_SHA384,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_AES_256_CBC_SHA384,
+        TLS1_RFC_DHE_PSK_WITH_AES_256_CBC_SHA384,
+        TLS1_CK_DHE_PSK_WITH_AES_256_CBC_SHA384,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_AES256,
+        SSL_SHA384,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
 #ifndef OPENSSL_NO_INTEGRITY_ONLY_CIPHERS
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_NULL_SHA256,
-     TLS1_RFC_DHE_PSK_WITH_NULL_SHA256,
-     TLS1_CK_DHE_PSK_WITH_NULL_SHA256,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_eNULL,
-     SSL_SHA256,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     0,
-     0,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_NULL_SHA256,
+        TLS1_RFC_DHE_PSK_WITH_NULL_SHA256,
+        TLS1_CK_DHE_PSK_WITH_NULL_SHA256,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_eNULL,
+        SSL_SHA256,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        0,
+        0,
+    },
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_NULL_SHA384,
-     TLS1_RFC_DHE_PSK_WITH_NULL_SHA384,
-     TLS1_CK_DHE_PSK_WITH_NULL_SHA384,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_eNULL,
-     SSL_SHA384,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     0,
-     0,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_NULL_SHA384,
+        TLS1_RFC_DHE_PSK_WITH_NULL_SHA384,
+        TLS1_CK_DHE_PSK_WITH_NULL_SHA384,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_eNULL,
+        SSL_SHA384,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        0,
+        0,
+    },
 #endif
     {
-     1,
-     TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA256,
-     TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA256,
-     TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA256,
-     SSL_kRSAPSK,
-     SSL_aRSA,
-     SSL_AES128,
-     SSL_SHA256,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_RSA_PSK_WITH_AES_128_CBC_SHA256,
+        TLS1_RFC_RSA_PSK_WITH_AES_128_CBC_SHA256,
+        TLS1_CK_RSA_PSK_WITH_AES_128_CBC_SHA256,
+        SSL_kRSAPSK,
+        SSL_aRSA,
+        SSL_AES128,
+        SSL_SHA256,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA384,
-     TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA384,
-     TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA384,
-     SSL_kRSAPSK,
-     SSL_aRSA,
-     SSL_AES256,
-     SSL_SHA384,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_RSA_PSK_WITH_AES_256_CBC_SHA384,
+        TLS1_RFC_RSA_PSK_WITH_AES_256_CBC_SHA384,
+        TLS1_CK_RSA_PSK_WITH_AES_256_CBC_SHA384,
+        SSL_kRSAPSK,
+        SSL_aRSA,
+        SSL_AES256,
+        SSL_SHA384,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
 #ifndef OPENSSL_NO_INTEGRITY_ONLY_CIPHERS
     {
-     1,
-     TLS1_TXT_RSA_PSK_WITH_NULL_SHA256,
-     TLS1_RFC_RSA_PSK_WITH_NULL_SHA256,
-     TLS1_CK_RSA_PSK_WITH_NULL_SHA256,
-     SSL_kRSAPSK,
-     SSL_aRSA,
-     SSL_eNULL,
-     SSL_SHA256,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     0,
-     0,
-     },
+        1,
+        TLS1_TXT_RSA_PSK_WITH_NULL_SHA256,
+        TLS1_RFC_RSA_PSK_WITH_NULL_SHA256,
+        TLS1_CK_RSA_PSK_WITH_NULL_SHA256,
+        SSL_kRSAPSK,
+        SSL_aRSA,
+        SSL_eNULL,
+        SSL_SHA256,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        0,
+        0,
+    },
     {
-     1,
-     TLS1_TXT_RSA_PSK_WITH_NULL_SHA384,
-     TLS1_RFC_RSA_PSK_WITH_NULL_SHA384,
-     TLS1_CK_RSA_PSK_WITH_NULL_SHA384,
-     SSL_kRSAPSK,
-     SSL_aRSA,
-     SSL_eNULL,
-     SSL_SHA384,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     0,
-     0,
-     },
+        1,
+        TLS1_TXT_RSA_PSK_WITH_NULL_SHA384,
+        TLS1_RFC_RSA_PSK_WITH_NULL_SHA384,
+        TLS1_CK_RSA_PSK_WITH_NULL_SHA384,
+        SSL_kRSAPSK,
+        SSL_aRSA,
+        SSL_eNULL,
+        SSL_SHA384,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        0,
+        0,
+    },
 #endif
-#  ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
+#ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
     {
-     1,
-     TLS1_TXT_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA,
-     TLS1_RFC_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA,
-     TLS1_CK_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA,
-     SSL_kECDHEPSK,
-     SSL_aPSK,
-     SSL_3DES,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     112,
-     168,
-     },
-#  endif
+        1,
+        TLS1_TXT_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA,
+        TLS1_RFC_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA,
+        TLS1_CK_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA,
+        SSL_kECDHEPSK,
+        SSL_aPSK,
+        SSL_3DES,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        112,
+        168,
+    },
+#endif
     {
-     1,
-     TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA,
-     TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA,
-     TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA,
-     SSL_kECDHEPSK,
-     SSL_aPSK,
-     SSL_AES128,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA,
+        TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA,
+        TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA,
+        SSL_kECDHEPSK,
+        SSL_aPSK,
+        SSL_AES128,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA,
-     TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA,
-     TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA,
-     SSL_kECDHEPSK,
-     SSL_aPSK,
-     SSL_AES256,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA,
+        TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA,
+        TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA,
+        SSL_kECDHEPSK,
+        SSL_aPSK,
+        SSL_AES256,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
-     TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
-     TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
-     SSL_kECDHEPSK,
-     SSL_aPSK,
-     SSL_AES128,
-     SSL_SHA256,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
+        TLS1_RFC_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
+        TLS1_CK_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
+        SSL_kECDHEPSK,
+        SSL_aPSK,
+        SSL_AES128,
+        SSL_SHA256,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA384,
-     TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA384,
-     TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA384,
-     SSL_kECDHEPSK,
-     SSL_aPSK,
-     SSL_AES256,
-     SSL_SHA384,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_PSK_WITH_AES_256_CBC_SHA384,
+        TLS1_RFC_ECDHE_PSK_WITH_AES_256_CBC_SHA384,
+        TLS1_CK_ECDHE_PSK_WITH_AES_256_CBC_SHA384,
+        SSL_kECDHEPSK,
+        SSL_aPSK,
+        SSL_AES256,
+        SSL_SHA384,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
 #ifndef OPENSSL_NO_INTEGRITY_ONLY_CIPHERS
     {
-     1,
-     TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA,
-     TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA,
-     TLS1_CK_ECDHE_PSK_WITH_NULL_SHA,
-     SSL_kECDHEPSK,
-     SSL_aPSK,
-     SSL_eNULL,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     0,
-     0,
-     },
+        1,
+        TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA,
+        TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA,
+        TLS1_CK_ECDHE_PSK_WITH_NULL_SHA,
+        SSL_kECDHEPSK,
+        SSL_aPSK,
+        SSL_eNULL,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        0,
+        0,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA256,
-     TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA256,
-     TLS1_CK_ECDHE_PSK_WITH_NULL_SHA256,
-     SSL_kECDHEPSK,
-     SSL_aPSK,
-     SSL_eNULL,
-     SSL_SHA256,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     0,
-     0,
-     },
+        1,
+        TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA256,
+        TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA256,
+        TLS1_CK_ECDHE_PSK_WITH_NULL_SHA256,
+        SSL_kECDHEPSK,
+        SSL_aPSK,
+        SSL_eNULL,
+        SSL_SHA256,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        0,
+        0,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA384,
-     TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA384,
-     TLS1_CK_ECDHE_PSK_WITH_NULL_SHA384,
-     SSL_kECDHEPSK,
-     SSL_aPSK,
-     SSL_eNULL,
-     SSL_SHA384,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_STRONG_NONE | SSL_FIPS,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     0,
-     0,
-     },
+        1,
+        TLS1_TXT_ECDHE_PSK_WITH_NULL_SHA384,
+        TLS1_RFC_ECDHE_PSK_WITH_NULL_SHA384,
+        TLS1_CK_ECDHE_PSK_WITH_NULL_SHA384,
+        SSL_kECDHEPSK,
+        SSL_aPSK,
+        SSL_eNULL,
+        SSL_SHA384,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_STRONG_NONE | SSL_FIPS,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        0,
+        0,
+    },
 #endif
-# ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
+#ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
     {
-     1,
-     TLS1_TXT_SRP_SHA_WITH_3DES_EDE_CBC_SHA,
-     TLS1_RFC_SRP_SHA_WITH_3DES_EDE_CBC_SHA,
-     TLS1_CK_SRP_SHA_WITH_3DES_EDE_CBC_SHA,
-     SSL_kSRP,
-     SSL_aSRP,
-     SSL_3DES,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     112,
-     168,
-     },
+        1,
+        TLS1_TXT_SRP_SHA_WITH_3DES_EDE_CBC_SHA,
+        TLS1_RFC_SRP_SHA_WITH_3DES_EDE_CBC_SHA,
+        TLS1_CK_SRP_SHA_WITH_3DES_EDE_CBC_SHA,
+        SSL_kSRP,
+        SSL_aSRP,
+        SSL_3DES,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        112,
+        168,
+    },
     {
-     1,
-     TLS1_TXT_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA,
-     TLS1_RFC_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA,
-     TLS1_CK_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA,
-     SSL_kSRP,
-     SSL_aRSA,
-     SSL_3DES,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     112,
-     168,
-     },
+        1,
+        TLS1_TXT_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA,
+        TLS1_RFC_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA,
+        TLS1_CK_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA,
+        SSL_kSRP,
+        SSL_aRSA,
+        SSL_3DES,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        112,
+        168,
+    },
     {
-     1,
-     TLS1_TXT_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA,
-     TLS1_RFC_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA,
-     TLS1_CK_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA,
-     SSL_kSRP,
-     SSL_aDSS,
-     SSL_3DES,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     112,
-     168,
-     },
-# endif
+        1,
+        TLS1_TXT_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA,
+        TLS1_RFC_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA,
+        TLS1_CK_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA,
+        SSL_kSRP,
+        SSL_aDSS,
+        SSL_3DES,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        112,
+        168,
+    },
+#endif
     {
-     1,
-     TLS1_TXT_SRP_SHA_WITH_AES_128_CBC_SHA,
-     TLS1_RFC_SRP_SHA_WITH_AES_128_CBC_SHA,
-     TLS1_CK_SRP_SHA_WITH_AES_128_CBC_SHA,
-     SSL_kSRP,
-     SSL_aSRP,
-     SSL_AES128,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_SRP_SHA_WITH_AES_128_CBC_SHA,
+        TLS1_RFC_SRP_SHA_WITH_AES_128_CBC_SHA,
+        TLS1_CK_SRP_SHA_WITH_AES_128_CBC_SHA,
+        SSL_kSRP,
+        SSL_aSRP,
+        SSL_AES128,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_SRP_SHA_RSA_WITH_AES_128_CBC_SHA,
-     TLS1_RFC_SRP_SHA_RSA_WITH_AES_128_CBC_SHA,
-     TLS1_CK_SRP_SHA_RSA_WITH_AES_128_CBC_SHA,
-     SSL_kSRP,
-     SSL_aRSA,
-     SSL_AES128,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_SRP_SHA_RSA_WITH_AES_128_CBC_SHA,
+        TLS1_RFC_SRP_SHA_RSA_WITH_AES_128_CBC_SHA,
+        TLS1_CK_SRP_SHA_RSA_WITH_AES_128_CBC_SHA,
+        SSL_kSRP,
+        SSL_aRSA,
+        SSL_AES128,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_SRP_SHA_DSS_WITH_AES_128_CBC_SHA,
-     TLS1_RFC_SRP_SHA_DSS_WITH_AES_128_CBC_SHA,
-     TLS1_CK_SRP_SHA_DSS_WITH_AES_128_CBC_SHA,
-     SSL_kSRP,
-     SSL_aDSS,
-     SSL_AES128,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_SRP_SHA_DSS_WITH_AES_128_CBC_SHA,
+        TLS1_RFC_SRP_SHA_DSS_WITH_AES_128_CBC_SHA,
+        TLS1_CK_SRP_SHA_DSS_WITH_AES_128_CBC_SHA,
+        SSL_kSRP,
+        SSL_aDSS,
+        SSL_AES128,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_SRP_SHA_WITH_AES_256_CBC_SHA,
-     TLS1_RFC_SRP_SHA_WITH_AES_256_CBC_SHA,
-     TLS1_CK_SRP_SHA_WITH_AES_256_CBC_SHA,
-     SSL_kSRP,
-     SSL_aSRP,
-     SSL_AES256,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_SRP_SHA_WITH_AES_256_CBC_SHA,
+        TLS1_RFC_SRP_SHA_WITH_AES_256_CBC_SHA,
+        TLS1_CK_SRP_SHA_WITH_AES_256_CBC_SHA,
+        SSL_kSRP,
+        SSL_aSRP,
+        SSL_AES256,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_SRP_SHA_RSA_WITH_AES_256_CBC_SHA,
-     TLS1_RFC_SRP_SHA_RSA_WITH_AES_256_CBC_SHA,
-     TLS1_CK_SRP_SHA_RSA_WITH_AES_256_CBC_SHA,
-     SSL_kSRP,
-     SSL_aRSA,
-     SSL_AES256,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_SRP_SHA_RSA_WITH_AES_256_CBC_SHA,
+        TLS1_RFC_SRP_SHA_RSA_WITH_AES_256_CBC_SHA,
+        TLS1_CK_SRP_SHA_RSA_WITH_AES_256_CBC_SHA,
+        SSL_kSRP,
+        SSL_aRSA,
+        SSL_AES256,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_SRP_SHA_DSS_WITH_AES_256_CBC_SHA,
-     TLS1_RFC_SRP_SHA_DSS_WITH_AES_256_CBC_SHA,
-     TLS1_CK_SRP_SHA_DSS_WITH_AES_256_CBC_SHA,
-     SSL_kSRP,
-     SSL_aDSS,
-     SSL_AES256,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_SRP_SHA_DSS_WITH_AES_256_CBC_SHA,
+        TLS1_RFC_SRP_SHA_DSS_WITH_AES_256_CBC_SHA,
+        TLS1_CK_SRP_SHA_DSS_WITH_AES_256_CBC_SHA,
+        SSL_kSRP,
+        SSL_aDSS,
+        SSL_AES256,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
 
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_CHACHA20_POLY1305,
-     TLS1_RFC_DHE_RSA_WITH_CHACHA20_POLY1305,
-     TLS1_CK_DHE_RSA_WITH_CHACHA20_POLY1305,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_CHACHA20POLY1305,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_CHACHA20_POLY1305,
+        TLS1_RFC_DHE_RSA_WITH_CHACHA20_POLY1305,
+        TLS1_CK_DHE_RSA_WITH_CHACHA20_POLY1305,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_CHACHA20POLY1305,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_RSA_WITH_CHACHA20_POLY1305,
-     TLS1_RFC_ECDHE_RSA_WITH_CHACHA20_POLY1305,
-     TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305,
-     SSL_kECDHE,
-     SSL_aRSA,
-     SSL_CHACHA20POLY1305,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_RSA_WITH_CHACHA20_POLY1305,
+        TLS1_RFC_ECDHE_RSA_WITH_CHACHA20_POLY1305,
+        TLS1_CK_ECDHE_RSA_WITH_CHACHA20_POLY1305,
+        SSL_kECDHE,
+        SSL_aRSA,
+        SSL_CHACHA20POLY1305,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
-     TLS1_RFC_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
-     TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_CHACHA20POLY1305,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
+        TLS1_RFC_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
+        TLS1_CK_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_CHACHA20POLY1305,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_PSK_WITH_CHACHA20_POLY1305,
-     TLS1_RFC_PSK_WITH_CHACHA20_POLY1305,
-     TLS1_CK_PSK_WITH_CHACHA20_POLY1305,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_CHACHA20POLY1305,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_CHACHA20_POLY1305,
+        TLS1_RFC_PSK_WITH_CHACHA20_POLY1305,
+        TLS1_CK_PSK_WITH_CHACHA20_POLY1305,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_CHACHA20POLY1305,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_PSK_WITH_CHACHA20_POLY1305,
-     TLS1_RFC_ECDHE_PSK_WITH_CHACHA20_POLY1305,
-     TLS1_CK_ECDHE_PSK_WITH_CHACHA20_POLY1305,
-     SSL_kECDHEPSK,
-     SSL_aPSK,
-     SSL_CHACHA20POLY1305,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_PSK_WITH_CHACHA20_POLY1305,
+        TLS1_RFC_ECDHE_PSK_WITH_CHACHA20_POLY1305,
+        TLS1_CK_ECDHE_PSK_WITH_CHACHA20_POLY1305,
+        SSL_kECDHEPSK,
+        SSL_aPSK,
+        SSL_CHACHA20POLY1305,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_CHACHA20_POLY1305,
-     TLS1_RFC_DHE_PSK_WITH_CHACHA20_POLY1305,
-     TLS1_CK_DHE_PSK_WITH_CHACHA20_POLY1305,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_CHACHA20POLY1305,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_CHACHA20_POLY1305,
+        TLS1_RFC_DHE_PSK_WITH_CHACHA20_POLY1305,
+        TLS1_CK_DHE_PSK_WITH_CHACHA20_POLY1305,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_CHACHA20POLY1305,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_RSA_PSK_WITH_CHACHA20_POLY1305,
-     TLS1_RFC_RSA_PSK_WITH_CHACHA20_POLY1305,
-     TLS1_CK_RSA_PSK_WITH_CHACHA20_POLY1305,
-     SSL_kRSAPSK,
-     SSL_aRSA,
-     SSL_CHACHA20POLY1305,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_RSA_PSK_WITH_CHACHA20_POLY1305,
+        TLS1_RFC_RSA_PSK_WITH_CHACHA20_POLY1305,
+        TLS1_CK_RSA_PSK_WITH_CHACHA20_POLY1305,
+        SSL_kRSAPSK,
+        SSL_aRSA,
+        SSL_CHACHA20POLY1305,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        256,
+        256,
+    },
 
     {
-     1,
-     TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_CAMELLIA128,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA256,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_CAMELLIA128,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256,
-     SSL_kDHE,
-     SSL_aDSS,
-     SSL_CAMELLIA128,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256,
+        SSL_kDHE,
+        SSL_aDSS,
+        SSL_CAMELLIA128,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_CAMELLIA128,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_CAMELLIA128,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA256,
-     SSL_kDHE,
-     SSL_aNULL,
-     SSL_CAMELLIA128,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA256,
+        SSL_kDHE,
+        SSL_aNULL,
+        SSL_CAMELLIA128,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA256,
-     TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA256,
-     TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA256,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_CAMELLIA256,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA256,
+        TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA256,
+        TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA256,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_CAMELLIA256,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256,
-     TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256,
-     TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256,
-     SSL_kDHE,
-     SSL_aDSS,
-     SSL_CAMELLIA256,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256,
+        TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256,
+        TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256,
+        SSL_kDHE,
+        SSL_aDSS,
+        SSL_CAMELLIA256,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256,
-     TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256,
-     TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_CAMELLIA256,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256,
+        TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256,
+        TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_CAMELLIA256,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA256,
-     TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA256,
-     TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA256,
-     SSL_kDHE,
-     SSL_aNULL,
-     SSL_CAMELLIA256,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA256,
+        TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA256,
+        TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA256,
+        SSL_kDHE,
+        SSL_aNULL,
+        SSL_CAMELLIA256,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA,
-     TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA,
-     TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_CAMELLIA256,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_CAMELLIA_256_CBC_SHA,
+        TLS1_RFC_RSA_WITH_CAMELLIA_256_CBC_SHA,
+        TLS1_CK_RSA_WITH_CAMELLIA_256_CBC_SHA,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_CAMELLIA256,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA,
-     TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA,
-     TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA,
-     SSL_kDHE,
-     SSL_aDSS,
-     SSL_CAMELLIA256,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA,
+        TLS1_RFC_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA,
+        TLS1_CK_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA,
+        SSL_kDHE,
+        SSL_aDSS,
+        SSL_CAMELLIA256,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA,
-     TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA,
-     TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_CAMELLIA256,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA,
+        TLS1_RFC_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA,
+        TLS1_CK_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_CAMELLIA256,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA,
-     TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA,
-     TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA,
-     SSL_kDHE,
-     SSL_aNULL,
-     SSL_CAMELLIA256,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ADH_WITH_CAMELLIA_256_CBC_SHA,
+        TLS1_RFC_ADH_WITH_CAMELLIA_256_CBC_SHA,
+        TLS1_CK_ADH_WITH_CAMELLIA_256_CBC_SHA,
+        SSL_kDHE,
+        SSL_aNULL,
+        SSL_CAMELLIA256,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA,
-     TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA,
-     TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_CAMELLIA128,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_CAMELLIA_128_CBC_SHA,
+        TLS1_RFC_RSA_WITH_CAMELLIA_128_CBC_SHA,
+        TLS1_CK_RSA_WITH_CAMELLIA_128_CBC_SHA,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_CAMELLIA128,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA,
-     TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA,
-     TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA,
-     SSL_kDHE,
-     SSL_aDSS,
-     SSL_CAMELLIA128,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA,
+        TLS1_RFC_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA,
+        TLS1_CK_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA,
+        SSL_kDHE,
+        SSL_aDSS,
+        SSL_CAMELLIA128,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA,
-     TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA,
-     TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_CAMELLIA128,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA,
+        TLS1_RFC_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA,
+        TLS1_CK_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_CAMELLIA128,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA,
-     TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA,
-     TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA,
-     SSL_kDHE,
-     SSL_aNULL,
-     SSL_CAMELLIA128,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ADH_WITH_CAMELLIA_128_CBC_SHA,
+        TLS1_RFC_ADH_WITH_CAMELLIA_128_CBC_SHA,
+        TLS1_CK_ADH_WITH_CAMELLIA_128_CBC_SHA,
+        SSL_kDHE,
+        SSL_aNULL,
+        SSL_CAMELLIA128,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_CAMELLIA128,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_CAMELLIA128,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
-     TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
-     TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_CAMELLIA256,
-     SSL_SHA384,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
+        TLS1_RFC_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
+        TLS1_CK_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_CAMELLIA256,
+        SSL_SHA384,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
-     SSL_kECDHE,
-     SSL_aRSA,
-     SSL_CAMELLIA128,
-     SSL_SHA256,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
+        SSL_kECDHE,
+        SSL_aRSA,
+        SSL_CAMELLIA128,
+        SSL_SHA256,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384,
-     TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384,
-     TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384,
-     SSL_kECDHE,
-     SSL_aRSA,
-     SSL_CAMELLIA256,
-     SSL_SHA384,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384,
+        TLS1_RFC_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384,
+        TLS1_CK_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384,
+        SSL_kECDHE,
+        SSL_aRSA,
+        SSL_CAMELLIA256,
+        SSL_SHA384,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_RFC_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_CK_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_CAMELLIA128,
-     SSL_SHA256,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_RFC_PSK_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_CK_PSK_WITH_CAMELLIA_128_CBC_SHA256,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_CAMELLIA128,
+        SSL_SHA256,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-     TLS1_RFC_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-     TLS1_CK_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_CAMELLIA256,
-     SSL_SHA384,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_CAMELLIA_256_CBC_SHA384,
+        TLS1_RFC_PSK_WITH_CAMELLIA_256_CBC_SHA384,
+        TLS1_CK_PSK_WITH_CAMELLIA_256_CBC_SHA384,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_CAMELLIA256,
+        SSL_SHA384,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_RFC_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_CK_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_CAMELLIA128,
-     SSL_SHA256,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_RFC_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_CK_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_CAMELLIA128,
+        SSL_SHA256,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-     TLS1_RFC_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-     TLS1_CK_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_CAMELLIA256,
-     SSL_SHA384,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
+        TLS1_RFC_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
+        TLS1_CK_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_CAMELLIA256,
+        SSL_SHA384,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_RFC_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_CK_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-     SSL_kRSAPSK,
-     SSL_aRSA,
-     SSL_CAMELLIA128,
-     SSL_SHA256,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_RFC_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_CK_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256,
+        SSL_kRSAPSK,
+        SSL_aRSA,
+        SSL_CAMELLIA128,
+        SSL_SHA256,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-     TLS1_RFC_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-     TLS1_CK_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-     SSL_kRSAPSK,
-     SSL_aRSA,
-     SSL_CAMELLIA256,
-     SSL_SHA384,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384,
+        TLS1_RFC_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384,
+        TLS1_CK_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384,
+        SSL_kRSAPSK,
+        SSL_aRSA,
+        SSL_CAMELLIA256,
+        SSL_SHA384,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-     TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
-     SSL_kECDHEPSK,
-     SSL_aPSK,
-     SSL_CAMELLIA128,
-     SSL_SHA256,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
+        TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
+        SSL_kECDHEPSK,
+        SSL_aPSK,
+        SSL_CAMELLIA128,
+        SSL_SHA256,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-     TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-     TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
-     SSL_kECDHEPSK,
-     SSL_aPSK,
-     SSL_CAMELLIA256,
-     SSL_SHA384,
-     TLS1_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
+        TLS1_RFC_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
+        TLS1_CK_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
+        SSL_kECDHEPSK,
+        SSL_aPSK,
+        SSL_CAMELLIA256,
+        SSL_SHA384,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
 
 #ifndef OPENSSL_NO_GOST
     {
-     1,
-     "GOST2001-GOST89-GOST89",
-     "TLS_GOSTR341001_WITH_28147_CNT_IMIT",
-     0x3000081,
-     SSL_kGOST,
-     SSL_aGOST01,
-     SSL_eGOST2814789CNT,
-     SSL_GOST89MAC,
-     TLS1_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_HIGH,
-     SSL_HANDSHAKE_MAC_GOST94 | TLS1_PRF_GOST94 | TLS1_STREAM_MAC,
-     256,
-     256,
-     },
-# ifndef OPENSSL_NO_INTEGRITY_ONLY_CIPHERS
+        1,
+        "GOST2001-GOST89-GOST89",
+        "TLS_GOSTR341001_WITH_28147_CNT_IMIT",
+        0x3000081,
+        SSL_kGOST,
+        SSL_aGOST01,
+        SSL_eGOST2814789CNT,
+        SSL_GOST89MAC,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_HIGH,
+        SSL_HANDSHAKE_MAC_GOST94 | TLS1_PRF_GOST94 | TLS1_STREAM_MAC,
+        256,
+        256,
+    },
+#ifndef OPENSSL_NO_INTEGRITY_ONLY_CIPHERS
     {
-     1,
-     "GOST2001-NULL-GOST94",
-     "TLS_GOSTR341001_WITH_NULL_GOSTR3411",
-     0x3000083,
-     SSL_kGOST,
-     SSL_aGOST01,
-     SSL_eNULL,
-     SSL_GOST94,
-     TLS1_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_STRONG_NONE,
-     SSL_HANDSHAKE_MAC_GOST94 | TLS1_PRF_GOST94,
-     0,
-     0,
-     },
-# endif
+        1,
+        "GOST2001-NULL-GOST94",
+        "TLS_GOSTR341001_WITH_NULL_GOSTR3411",
+        0x3000083,
+        SSL_kGOST,
+        SSL_aGOST01,
+        SSL_eNULL,
+        SSL_GOST94,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_STRONG_NONE,
+        SSL_HANDSHAKE_MAC_GOST94 | TLS1_PRF_GOST94,
+        0,
+        0,
+    },
+#endif
     {
-     1,
-     "IANA-GOST2012-GOST8912-GOST8912",
-     NULL,
-     0x0300c102,
-     SSL_kGOST,
-     SSL_aGOST12 | SSL_aGOST01,
-     SSL_eGOST2814789CNT12,
-     SSL_GOST89MAC12,
-     TLS1_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_HIGH,
-     SSL_HANDSHAKE_MAC_GOST12_256 | TLS1_PRF_GOST12_256 | TLS1_STREAM_MAC,
-     256,
-     256,
-     },
+        1,
+        "IANA-GOST2012-GOST8912-GOST8912",
+        NULL,
+        0x0300c102,
+        SSL_kGOST,
+        SSL_aGOST12 | SSL_aGOST01,
+        SSL_eGOST2814789CNT12,
+        SSL_GOST89MAC12,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_HIGH,
+        SSL_HANDSHAKE_MAC_GOST12_256 | TLS1_PRF_GOST12_256 | TLS1_STREAM_MAC,
+        256,
+        256,
+    },
     {
-     1,
-     "LEGACY-GOST2012-GOST8912-GOST8912",
-     NULL,
-     0x0300ff85,
-     SSL_kGOST,
-     SSL_aGOST12 | SSL_aGOST01,
-     SSL_eGOST2814789CNT12,
-     SSL_GOST89MAC12,
-     TLS1_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_HIGH,
-     SSL_HANDSHAKE_MAC_GOST12_256 | TLS1_PRF_GOST12_256 | TLS1_STREAM_MAC,
-     256,
-     256,
-     },
-# ifndef OPENSSL_NO_INTEGRITY_ONLY_CIPHERS
+        1,
+        "LEGACY-GOST2012-GOST8912-GOST8912",
+        NULL,
+        0x0300ff85,
+        SSL_kGOST,
+        SSL_aGOST12 | SSL_aGOST01,
+        SSL_eGOST2814789CNT12,
+        SSL_GOST89MAC12,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_HIGH,
+        SSL_HANDSHAKE_MAC_GOST12_256 | TLS1_PRF_GOST12_256 | TLS1_STREAM_MAC,
+        256,
+        256,
+    },
+#ifndef OPENSSL_NO_INTEGRITY_ONLY_CIPHERS
     {
-     1,
-     "GOST2012-NULL-GOST12",
-     NULL,
-     0x0300ff87,
-     SSL_kGOST,
-     SSL_aGOST12 | SSL_aGOST01,
-     SSL_eNULL,
-     SSL_GOST12_256,
-     TLS1_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_STRONG_NONE,
-     SSL_HANDSHAKE_MAC_GOST12_256 | TLS1_PRF_GOST12_256 | TLS1_STREAM_MAC,
-     0,
-     0,
-     },
-# endif
+        1,
+        "GOST2012-NULL-GOST12",
+        NULL,
+        0x0300ff87,
+        SSL_kGOST,
+        SSL_aGOST12 | SSL_aGOST01,
+        SSL_eNULL,
+        SSL_GOST12_256,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_STRONG_NONE,
+        SSL_HANDSHAKE_MAC_GOST12_256 | TLS1_PRF_GOST12_256 | TLS1_STREAM_MAC,
+        0,
+        0,
+    },
+#endif
     {
-     1,
-     "GOST2012-KUZNYECHIK-KUZNYECHIKOMAC",
-     NULL,
-     0x0300C100,
-     SSL_kGOST18,
-     SSL_aGOST12,
-     SSL_KUZNYECHIK,
-     SSL_KUZNYECHIKOMAC,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_HIGH,
-     SSL_HANDSHAKE_MAC_GOST12_256 | TLS1_PRF_GOST12_256 | TLS1_TLSTREE,
-     256,
-     256,
-     },
+        1,
+        "GOST2012-KUZNYECHIK-KUZNYECHIKOMAC",
+        NULL,
+        0x0300C100,
+        SSL_kGOST18,
+        SSL_aGOST12,
+        SSL_KUZNYECHIK,
+        SSL_KUZNYECHIKOMAC,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_HIGH,
+        SSL_HANDSHAKE_MAC_GOST12_256 | TLS1_PRF_GOST12_256 | TLS1_TLSTREE,
+        256,
+        256,
+    },
     {
-     1,
-     "GOST2012-MAGMA-MAGMAOMAC",
-     NULL,
-     0x0300C101,
-     SSL_kGOST18,
-     SSL_aGOST12,
-     SSL_MAGMA,
-     SSL_MAGMAOMAC,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_HIGH,
-     SSL_HANDSHAKE_MAC_GOST12_256 | TLS1_PRF_GOST12_256 | TLS1_TLSTREE,
-     256,
-     256,
-     },
-#endif                          /* OPENSSL_NO_GOST */
+        1,
+        "GOST2012-MAGMA-MAGMAOMAC",
+        NULL,
+        0x0300C101,
+        SSL_kGOST18,
+        SSL_aGOST12,
+        SSL_MAGMA,
+        SSL_MAGMAOMAC,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_HIGH,
+        SSL_HANDSHAKE_MAC_GOST12_256 | TLS1_PRF_GOST12_256 | TLS1_TLSTREE,
+        256,
+        256,
+    },
+#endif /* OPENSSL_NO_GOST */
 
     {
-     1,
-     SSL3_TXT_RSA_IDEA_128_SHA,
-     SSL3_RFC_RSA_IDEA_128_SHA,
-     SSL3_CK_RSA_IDEA_128_SHA,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_IDEA,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_1_VERSION,
-     DTLS1_BAD_VER, DTLS1_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        SSL3_TXT_RSA_IDEA_128_SHA,
+        SSL3_RFC_RSA_IDEA_128_SHA,
+        SSL3_CK_RSA_IDEA_128_SHA,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_IDEA,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_1_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
 
     {
-     1,
-     TLS1_TXT_RSA_WITH_SEED_SHA,
-     TLS1_RFC_RSA_WITH_SEED_SHA,
-     TLS1_CK_RSA_WITH_SEED_SHA,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_SEED,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_SEED_SHA,
+        TLS1_RFC_RSA_WITH_SEED_SHA,
+        TLS1_CK_RSA_WITH_SEED_SHA,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_SEED,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_DSS_WITH_SEED_SHA,
-     TLS1_RFC_DHE_DSS_WITH_SEED_SHA,
-     TLS1_CK_DHE_DSS_WITH_SEED_SHA,
-     SSL_kDHE,
-     SSL_aDSS,
-     SSL_SEED,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_DSS_WITH_SEED_SHA,
+        TLS1_RFC_DHE_DSS_WITH_SEED_SHA,
+        TLS1_CK_DHE_DSS_WITH_SEED_SHA,
+        SSL_kDHE,
+        SSL_aDSS,
+        SSL_SEED,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_SEED_SHA,
-     TLS1_RFC_DHE_RSA_WITH_SEED_SHA,
-     TLS1_CK_DHE_RSA_WITH_SEED_SHA,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_SEED,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_SEED_SHA,
+        TLS1_RFC_DHE_RSA_WITH_SEED_SHA,
+        TLS1_CK_DHE_RSA_WITH_SEED_SHA,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_SEED,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ADH_WITH_SEED_SHA,
-     TLS1_RFC_ADH_WITH_SEED_SHA,
-     TLS1_CK_ADH_WITH_SEED_SHA,
-     SSL_kDHE,
-     SSL_aNULL,
-     SSL_SEED,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     DTLS1_BAD_VER, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ADH_WITH_SEED_SHA,
+        TLS1_RFC_ADH_WITH_SEED_SHA,
+        TLS1_CK_ADH_WITH_SEED_SHA,
+        SSL_kDHE,
+        SSL_aNULL,
+        SSL_SEED,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_BAD_VER,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        128,
+        128,
+    },
 
 #ifndef OPENSSL_NO_WEAK_SSL_CIPHERS
     {
-     1,
-     SSL3_TXT_RSA_RC4_128_MD5,
-     SSL3_RFC_RSA_RC4_128_MD5,
-     SSL3_CK_RSA_RC4_128_MD5,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_RC4,
-     SSL_MD5,
-     SSL3_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     80,
-     128,
-     },
+        1,
+        SSL3_TXT_RSA_RC4_128_MD5,
+        SSL3_RFC_RSA_RC4_128_MD5,
+        SSL3_CK_RSA_RC4_128_MD5,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_RC4,
+        SSL_MD5,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        80,
+        128,
+    },
     {
-     1,
-     SSL3_TXT_RSA_RC4_128_SHA,
-     SSL3_RFC_RSA_RC4_128_SHA,
-     SSL3_CK_RSA_RC4_128_SHA,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_RC4,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     80,
-     128,
-     },
+        1,
+        SSL3_TXT_RSA_RC4_128_SHA,
+        SSL3_RFC_RSA_RC4_128_SHA,
+        SSL3_CK_RSA_RC4_128_SHA,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_RC4,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        80,
+        128,
+    },
     {
-     1,
-     SSL3_TXT_ADH_RC4_128_MD5,
-     SSL3_RFC_ADH_RC4_128_MD5,
-     SSL3_CK_ADH_RC4_128_MD5,
-     SSL_kDHE,
-     SSL_aNULL,
-     SSL_RC4,
-     SSL_MD5,
-     SSL3_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     80,
-     128,
-     },
+        1,
+        SSL3_TXT_ADH_RC4_128_MD5,
+        SSL3_RFC_ADH_RC4_128_MD5,
+        SSL3_CK_ADH_RC4_128_MD5,
+        SSL_kDHE,
+        SSL_aNULL,
+        SSL_RC4,
+        SSL_MD5,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        80,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_PSK_WITH_RC4_128_SHA,
-     TLS1_RFC_ECDHE_PSK_WITH_RC4_128_SHA,
-     TLS1_CK_ECDHE_PSK_WITH_RC4_128_SHA,
-     SSL_kECDHEPSK,
-     SSL_aPSK,
-     SSL_RC4,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     80,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_PSK_WITH_RC4_128_SHA,
+        TLS1_RFC_ECDHE_PSK_WITH_RC4_128_SHA,
+        TLS1_CK_ECDHE_PSK_WITH_RC4_128_SHA,
+        SSL_kECDHEPSK,
+        SSL_aPSK,
+        SSL_RC4,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        80,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDH_anon_WITH_RC4_128_SHA,
-     TLS1_RFC_ECDH_anon_WITH_RC4_128_SHA,
-     TLS1_CK_ECDH_anon_WITH_RC4_128_SHA,
-     SSL_kECDHE,
-     SSL_aNULL,
-     SSL_RC4,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     80,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDH_anon_WITH_RC4_128_SHA,
+        TLS1_RFC_ECDH_anon_WITH_RC4_128_SHA,
+        TLS1_CK_ECDH_anon_WITH_RC4_128_SHA,
+        SSL_kECDHE,
+        SSL_aNULL,
+        SSL_RC4,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        80,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_RC4_128_SHA,
-     TLS1_RFC_ECDHE_ECDSA_WITH_RC4_128_SHA,
-     TLS1_CK_ECDHE_ECDSA_WITH_RC4_128_SHA,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_RC4,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     80,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_RC4_128_SHA,
+        TLS1_RFC_ECDHE_ECDSA_WITH_RC4_128_SHA,
+        TLS1_CK_ECDHE_ECDSA_WITH_RC4_128_SHA,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_RC4,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        80,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_RSA_WITH_RC4_128_SHA,
-     TLS1_RFC_ECDHE_RSA_WITH_RC4_128_SHA,
-     TLS1_CK_ECDHE_RSA_WITH_RC4_128_SHA,
-     SSL_kECDHE,
-     SSL_aRSA,
-     SSL_RC4,
-     SSL_SHA1,
-     TLS1_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     80,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_RSA_WITH_RC4_128_SHA,
+        TLS1_RFC_ECDHE_RSA_WITH_RC4_128_SHA,
+        TLS1_CK_ECDHE_RSA_WITH_RC4_128_SHA,
+        SSL_kECDHE,
+        SSL_aRSA,
+        SSL_RC4,
+        SSL_SHA1,
+        TLS1_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        80,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_PSK_WITH_RC4_128_SHA,
-     TLS1_RFC_PSK_WITH_RC4_128_SHA,
-     TLS1_CK_PSK_WITH_RC4_128_SHA,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_RC4,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     80,
-     128,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_RC4_128_SHA,
+        TLS1_RFC_PSK_WITH_RC4_128_SHA,
+        TLS1_CK_PSK_WITH_RC4_128_SHA,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_RC4,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        80,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_RSA_PSK_WITH_RC4_128_SHA,
-     TLS1_RFC_RSA_PSK_WITH_RC4_128_SHA,
-     TLS1_CK_RSA_PSK_WITH_RC4_128_SHA,
-     SSL_kRSAPSK,
-     SSL_aRSA,
-     SSL_RC4,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     80,
-     128,
-     },
+        1,
+        TLS1_TXT_RSA_PSK_WITH_RC4_128_SHA,
+        TLS1_RFC_RSA_PSK_WITH_RC4_128_SHA,
+        TLS1_CK_RSA_PSK_WITH_RC4_128_SHA,
+        SSL_kRSAPSK,
+        SSL_aRSA,
+        SSL_RC4,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        80,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_RC4_128_SHA,
-     TLS1_RFC_DHE_PSK_WITH_RC4_128_SHA,
-     TLS1_CK_DHE_PSK_WITH_RC4_128_SHA,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_RC4,
-     SSL_SHA1,
-     SSL3_VERSION, TLS1_2_VERSION,
-     0, 0,
-     SSL_NOT_DEFAULT | SSL_MEDIUM,
-     SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
-     80,
-     128,
-     },
-#endif                          /* OPENSSL_NO_WEAK_SSL_CIPHERS */
+        1,
+        TLS1_TXT_DHE_PSK_WITH_RC4_128_SHA,
+        TLS1_RFC_DHE_PSK_WITH_RC4_128_SHA,
+        TLS1_CK_DHE_PSK_WITH_RC4_128_SHA,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_RC4,
+        SSL_SHA1,
+        SSL3_VERSION,
+        TLS1_2_VERSION,
+        0,
+        0,
+        SSL_NOT_DEFAULT | SSL_MEDIUM,
+        SSL_HANDSHAKE_MAC_DEFAULT | TLS1_PRF,
+        80,
+        128,
+    },
+#endif /* OPENSSL_NO_WEAK_SSL_CIPHERS */
 
     {
-     1,
-     TLS1_TXT_RSA_WITH_ARIA_128_GCM_SHA256,
-     TLS1_RFC_RSA_WITH_ARIA_128_GCM_SHA256,
-     TLS1_CK_RSA_WITH_ARIA_128_GCM_SHA256,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_ARIA128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_ARIA_128_GCM_SHA256,
+        TLS1_RFC_RSA_WITH_ARIA_128_GCM_SHA256,
+        TLS1_CK_RSA_WITH_ARIA_128_GCM_SHA256,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_ARIA128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_RSA_WITH_ARIA_256_GCM_SHA384,
-     TLS1_RFC_RSA_WITH_ARIA_256_GCM_SHA384,
-     TLS1_CK_RSA_WITH_ARIA_256_GCM_SHA384,
-     SSL_kRSA,
-     SSL_aRSA,
-     SSL_ARIA256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_RSA_WITH_ARIA_256_GCM_SHA384,
+        TLS1_RFC_RSA_WITH_ARIA_256_GCM_SHA384,
+        TLS1_CK_RSA_WITH_ARIA_256_GCM_SHA384,
+        SSL_kRSA,
+        SSL_aRSA,
+        SSL_ARIA256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_ARIA_128_GCM_SHA256,
-     TLS1_RFC_DHE_RSA_WITH_ARIA_128_GCM_SHA256,
-     TLS1_CK_DHE_RSA_WITH_ARIA_128_GCM_SHA256,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_ARIA128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_ARIA_128_GCM_SHA256,
+        TLS1_RFC_DHE_RSA_WITH_ARIA_128_GCM_SHA256,
+        TLS1_CK_DHE_RSA_WITH_ARIA_128_GCM_SHA256,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_ARIA128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_RSA_WITH_ARIA_256_GCM_SHA384,
-     TLS1_RFC_DHE_RSA_WITH_ARIA_256_GCM_SHA384,
-     TLS1_CK_DHE_RSA_WITH_ARIA_256_GCM_SHA384,
-     SSL_kDHE,
-     SSL_aRSA,
-     SSL_ARIA256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_RSA_WITH_ARIA_256_GCM_SHA384,
+        TLS1_RFC_DHE_RSA_WITH_ARIA_256_GCM_SHA384,
+        TLS1_CK_DHE_RSA_WITH_ARIA_256_GCM_SHA384,
+        SSL_kDHE,
+        SSL_aRSA,
+        SSL_ARIA256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_DSS_WITH_ARIA_128_GCM_SHA256,
-     TLS1_RFC_DHE_DSS_WITH_ARIA_128_GCM_SHA256,
-     TLS1_CK_DHE_DSS_WITH_ARIA_128_GCM_SHA256,
-     SSL_kDHE,
-     SSL_aDSS,
-     SSL_ARIA128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_DSS_WITH_ARIA_128_GCM_SHA256,
+        TLS1_RFC_DHE_DSS_WITH_ARIA_128_GCM_SHA256,
+        TLS1_CK_DHE_DSS_WITH_ARIA_128_GCM_SHA256,
+        SSL_kDHE,
+        SSL_aDSS,
+        SSL_ARIA128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_DSS_WITH_ARIA_256_GCM_SHA384,
-     TLS1_RFC_DHE_DSS_WITH_ARIA_256_GCM_SHA384,
-     TLS1_CK_DHE_DSS_WITH_ARIA_256_GCM_SHA384,
-     SSL_kDHE,
-     SSL_aDSS,
-     SSL_ARIA256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_DSS_WITH_ARIA_256_GCM_SHA384,
+        TLS1_RFC_DHE_DSS_WITH_ARIA_256_GCM_SHA384,
+        TLS1_CK_DHE_DSS_WITH_ARIA_256_GCM_SHA384,
+        SSL_kDHE,
+        SSL_aDSS,
+        SSL_ARIA256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256,
-     TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256,
-     TLS1_CK_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_ARIA128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256,
+        TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256,
+        TLS1_CK_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_ARIA128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384,
-     TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384,
-     TLS1_CK_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384,
-     SSL_kECDHE,
-     SSL_aECDSA,
-     SSL_ARIA256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384,
+        TLS1_RFC_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384,
+        TLS1_CK_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384,
+        SSL_kECDHE,
+        SSL_aECDSA,
+        SSL_ARIA256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256,
-     TLS1_RFC_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256,
-     TLS1_CK_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256,
-     SSL_kECDHE,
-     SSL_aRSA,
-     SSL_ARIA128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256,
+        TLS1_RFC_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256,
+        TLS1_CK_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256,
+        SSL_kECDHE,
+        SSL_aRSA,
+        SSL_ARIA128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384,
-     TLS1_RFC_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384,
-     TLS1_CK_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384,
-     SSL_kECDHE,
-     SSL_aRSA,
-     SSL_ARIA256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384,
+        TLS1_RFC_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384,
+        TLS1_CK_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384,
+        SSL_kECDHE,
+        SSL_aRSA,
+        SSL_ARIA256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_PSK_WITH_ARIA_128_GCM_SHA256,
-     TLS1_RFC_PSK_WITH_ARIA_128_GCM_SHA256,
-     TLS1_CK_PSK_WITH_ARIA_128_GCM_SHA256,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_ARIA128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_ARIA_128_GCM_SHA256,
+        TLS1_RFC_PSK_WITH_ARIA_128_GCM_SHA256,
+        TLS1_CK_PSK_WITH_ARIA_128_GCM_SHA256,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_ARIA128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_PSK_WITH_ARIA_256_GCM_SHA384,
-     TLS1_RFC_PSK_WITH_ARIA_256_GCM_SHA384,
-     TLS1_CK_PSK_WITH_ARIA_256_GCM_SHA384,
-     SSL_kPSK,
-     SSL_aPSK,
-     SSL_ARIA256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_PSK_WITH_ARIA_256_GCM_SHA384,
+        TLS1_RFC_PSK_WITH_ARIA_256_GCM_SHA384,
+        TLS1_CK_PSK_WITH_ARIA_256_GCM_SHA384,
+        SSL_kPSK,
+        SSL_aPSK,
+        SSL_ARIA256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_ARIA_128_GCM_SHA256,
-     TLS1_RFC_DHE_PSK_WITH_ARIA_128_GCM_SHA256,
-     TLS1_CK_DHE_PSK_WITH_ARIA_128_GCM_SHA256,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_ARIA128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_ARIA_128_GCM_SHA256,
+        TLS1_RFC_DHE_PSK_WITH_ARIA_128_GCM_SHA256,
+        TLS1_CK_DHE_PSK_WITH_ARIA_128_GCM_SHA256,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_ARIA128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_DHE_PSK_WITH_ARIA_256_GCM_SHA384,
-     TLS1_RFC_DHE_PSK_WITH_ARIA_256_GCM_SHA384,
-     TLS1_CK_DHE_PSK_WITH_ARIA_256_GCM_SHA384,
-     SSL_kDHEPSK,
-     SSL_aPSK,
-     SSL_ARIA256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_DHE_PSK_WITH_ARIA_256_GCM_SHA384,
+        TLS1_RFC_DHE_PSK_WITH_ARIA_256_GCM_SHA384,
+        TLS1_CK_DHE_PSK_WITH_ARIA_256_GCM_SHA384,
+        SSL_kDHEPSK,
+        SSL_aPSK,
+        SSL_ARIA256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
     {
-     1,
-     TLS1_TXT_RSA_PSK_WITH_ARIA_128_GCM_SHA256,
-     TLS1_RFC_RSA_PSK_WITH_ARIA_128_GCM_SHA256,
-     TLS1_CK_RSA_PSK_WITH_ARIA_128_GCM_SHA256,
-     SSL_kRSAPSK,
-     SSL_aRSA,
-     SSL_ARIA128GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
-     128,
-     128,
-     },
+        1,
+        TLS1_TXT_RSA_PSK_WITH_ARIA_128_GCM_SHA256,
+        TLS1_RFC_RSA_PSK_WITH_ARIA_128_GCM_SHA256,
+        TLS1_CK_RSA_PSK_WITH_ARIA_128_GCM_SHA256,
+        SSL_kRSAPSK,
+        SSL_aRSA,
+        SSL_ARIA128GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA256 | TLS1_PRF_SHA256,
+        128,
+        128,
+    },
     {
-     1,
-     TLS1_TXT_RSA_PSK_WITH_ARIA_256_GCM_SHA384,
-     TLS1_RFC_RSA_PSK_WITH_ARIA_256_GCM_SHA384,
-     TLS1_CK_RSA_PSK_WITH_ARIA_256_GCM_SHA384,
-     SSL_kRSAPSK,
-     SSL_aRSA,
-     SSL_ARIA256GCM,
-     SSL_AEAD,
-     TLS1_2_VERSION, TLS1_2_VERSION,
-     DTLS1_2_VERSION, DTLS1_2_VERSION,
-     SSL_NOT_DEFAULT | SSL_HIGH,
-     SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
-     256,
-     256,
-     },
+        1,
+        TLS1_TXT_RSA_PSK_WITH_ARIA_256_GCM_SHA384,
+        TLS1_RFC_RSA_PSK_WITH_ARIA_256_GCM_SHA384,
+        TLS1_CK_RSA_PSK_WITH_ARIA_256_GCM_SHA384,
+        SSL_kRSAPSK,
+        SSL_aRSA,
+        SSL_ARIA256GCM,
+        SSL_AEAD,
+        TLS1_2_VERSION,
+        TLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        DTLS1_2_VERSION,
+        SSL_NOT_DEFAULT | SSL_HIGH,
+        SSL_HANDSHAKE_MAC_SHA384 | TLS1_PRF_SHA384,
+        256,
+        256,
+    },
 };
 
 /*
@@ -3279,18 +3678,40 @@ static SSL_CIPHER ssl3_ciphers[] = {
  */
 static SSL_CIPHER ssl3_scsvs[] = {
     {
-     0,
-     "TLS_EMPTY_RENEGOTIATION_INFO_SCSV",
-     "TLS_EMPTY_RENEGOTIATION_INFO_SCSV",
-     SSL3_CK_SCSV,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0,
+        "TLS_EMPTY_RENEGOTIATION_INFO_SCSV",
+        "TLS_EMPTY_RENEGOTIATION_INFO_SCSV",
+        SSL3_CK_SCSV,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
     },
     {
-     0,
-     "TLS_FALLBACK_SCSV",
-     "TLS_FALLBACK_SCSV",
-     SSL3_CK_FALLBACK_SCSV,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0,
+        "TLS_FALLBACK_SCSV",
+        "TLS_FALLBACK_SCSV",
+        SSL3_CK_FALLBACK_SCSV,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
     },
 };
 
@@ -3307,15 +3728,15 @@ static int cipher_compare(const void *a, const void *b)
 void ssl_sort_cipher_list(void)
 {
     qsort(tls13_ciphers, TLS13_NUM_CIPHERS, sizeof(tls13_ciphers[0]),
-          cipher_compare);
+        cipher_compare);
     qsort(ssl3_ciphers, SSL3_NUM_CIPHERS, sizeof(ssl3_ciphers[0]),
-          cipher_compare);
+        cipher_compare);
     qsort(ssl3_scsvs, SSL3_NUM_SCSVS, sizeof(ssl3_scsvs[0]), cipher_compare);
 }
 
 static int sslcon_undefined_function_1(SSL_CONNECTION *sc, unsigned char *r,
-                                       size_t s, const char *t, size_t u,
-                                       const unsigned char *v, size_t w, int x)
+    size_t s, const char *t, size_t u,
+    const unsigned char *v, size_t w, int x)
 {
     (void)r;
     (void)s;
@@ -3372,7 +3793,7 @@ int ssl3_set_handshake_header(SSL_CONNECTION *s, WPACKET *pkt, int htype)
 
     /* Set the content type and 3 bytes for the message len */
     if (!WPACKET_put_bytes_u8(pkt, htype)
-            || !WPACKET_start_sub_packet_u24(pkt))
+        || !WPACKET_start_sub_packet_u24(pkt))
         return 0;
 
     return 1;
@@ -3555,50 +3976,46 @@ long ssl3_ctrl(SSL *s, int cmd, long larg, void *parg)
         ret = (int)(sc->s3.flags);
         break;
 #if !defined(OPENSSL_NO_DEPRECATED_3_0)
-    case SSL_CTRL_SET_TMP_DH:
-        {
-            EVP_PKEY *pkdh = NULL;
-            if (parg == NULL) {
-                ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
-                return 0;
-            }
-            pkdh = ssl_dh_to_pkey(parg);
-            if (pkdh == NULL) {
-                ERR_raise(ERR_LIB_SSL, ERR_R_DH_LIB);
-                return 0;
-            }
-            if (!SSL_set0_tmp_dh_pkey(s, pkdh)) {
-                EVP_PKEY_free(pkdh);
-                return 0;
-            }
-            return 1;
+    case SSL_CTRL_SET_TMP_DH: {
+        EVP_PKEY *pkdh = NULL;
+        if (parg == NULL) {
+            ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
+            return 0;
         }
-        break;
-    case SSL_CTRL_SET_TMP_DH_CB:
-        {
-            ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
-            return ret;
+        pkdh = ssl_dh_to_pkey(parg);
+        if (pkdh == NULL) {
+            ERR_raise(ERR_LIB_SSL, ERR_R_DH_LIB);
+            return 0;
+        }
+        if (!SSL_set0_tmp_dh_pkey(s, pkdh)) {
+            EVP_PKEY_free(pkdh);
+            return 0;
         }
+        return 1;
+    } break;
+    case SSL_CTRL_SET_TMP_DH_CB: {
+        ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+        return ret;
+    }
 #endif
     case SSL_CTRL_SET_DH_AUTO:
         sc->cert->dh_tmp_auto = larg;
         return 1;
 #if !defined(OPENSSL_NO_DEPRECATED_3_0)
-    case SSL_CTRL_SET_TMP_ECDH:
-        {
-            if (parg == NULL) {
-                ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
-                return 0;
-            }
-            return ssl_set_tmp_ecdh_groups(&sc->ext.supportedgroups,
-                                           &sc->ext.supportedgroups_len,
-                                           &sc->ext.keyshares,
-                                           &sc->ext.keyshares_len,
-                                           &sc->ext.tuples,
-                                           &sc->ext.tuples_len,
-                                           parg);
+    case SSL_CTRL_SET_TMP_ECDH: {
+        if (parg == NULL) {
+            ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
+            return 0;
         }
-#endif                          /* !OPENSSL_NO_DEPRECATED_3_0 */
+        return ssl_set_tmp_ecdh_groups(&sc->ext.supportedgroups,
+            &sc->ext.supportedgroups_len,
+            &sc->ext.keyshares,
+            &sc->ext.keyshares_len,
+            &sc->ext.tuples,
+            &sc->ext.tuples_len,
+            parg);
+    }
+#endif /* !OPENSSL_NO_DEPRECATED_3_0 */
     case SSL_CTRL_SET_TLSEXT_HOSTNAME:
         /*
          * This API is only used for a client to set what SNI it will request
@@ -3668,7 +4085,7 @@ long ssl3_ctrl(SSL *s, int cmd, long larg, void *parg)
     case SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP:
         *(unsigned char **)parg = sc->ext.ocsp.resp;
         if (sc->ext.ocsp.resp_len == 0
-                || sc->ext.ocsp.resp_len > LONG_MAX)
+            || sc->ext.ocsp.resp_len > LONG_MAX)
             return -1;
         return (long)sc->ext.ocsp.resp_len;
 
@@ -3720,70 +4137,67 @@ long ssl3_ctrl(SSL *s, int cmd, long larg, void *parg)
         }
         return ssl_cert_set_current(sc->cert, larg);
 
-    case SSL_CTRL_GET_GROUPS:
-        {
-            uint16_t *clist;
-            size_t clistlen;
+    case SSL_CTRL_GET_GROUPS: {
+        uint16_t *clist;
+        size_t clistlen;
 
-            if (!sc->session)
-                return 0;
-            clist = sc->ext.peer_supportedgroups;
-            clistlen = sc->ext.peer_supportedgroups_len;
-            if (parg) {
-                size_t i;
-                int *cptr = parg;
+        if (!sc->session)
+            return 0;
+        clist = sc->ext.peer_supportedgroups;
+        clistlen = sc->ext.peer_supportedgroups_len;
+        if (parg) {
+            size_t i;
+            int *cptr = parg;
 
-                for (i = 0; i < clistlen; i++) {
-                    const TLS_GROUP_INFO *cinf
-                        = tls1_group_id_lookup(s->ctx, clist[i]);
+            for (i = 0; i < clistlen; i++) {
+                const TLS_GROUP_INFO *cinf
+                    = tls1_group_id_lookup(s->ctx, clist[i]);
 
-                    if (cinf != NULL)
-                        cptr[i] = tls1_group_id2nid(cinf->group_id, 1);
-                    else
-                        cptr[i] = TLSEXT_nid_unknown | clist[i];
-                }
+                if (cinf != NULL)
+                    cptr[i] = tls1_group_id2nid(cinf->group_id, 1);
+                else
+                    cptr[i] = TLSEXT_nid_unknown | clist[i];
             }
-            return (int)clistlen;
         }
+        return (int)clistlen;
+    }
 
     case SSL_CTRL_SET_GROUPS:
         return tls1_set_groups(&sc->ext.supportedgroups,
-                               &sc->ext.supportedgroups_len,
-                               &sc->ext.keyshares,
-                               &sc->ext.keyshares_len,
-                               &sc->ext.tuples,
-                               &sc->ext.tuples_len,
-                               parg, larg);
+            &sc->ext.supportedgroups_len,
+            &sc->ext.keyshares,
+            &sc->ext.keyshares_len,
+            &sc->ext.tuples,
+            &sc->ext.tuples_len,
+            parg, larg);
 
     case SSL_CTRL_SET_GROUPS_LIST:
         return tls1_set_groups_list(s->ctx,
-                                    &sc->ext.supportedgroups,
-                                    &sc->ext.supportedgroups_len,
-                                    &sc->ext.keyshares,
-                                    &sc->ext.keyshares_len,
-                                    &sc->ext.tuples,
-                                    &sc->ext.tuples_len,
-                                    parg);
+            &sc->ext.supportedgroups,
+            &sc->ext.supportedgroups_len,
+            &sc->ext.keyshares,
+            &sc->ext.keyshares_len,
+            &sc->ext.tuples,
+            &sc->ext.tuples_len,
+            parg);
 
-    case SSL_CTRL_GET_SHARED_GROUP:
-        {
-            uint16_t id = tls1_shared_group(sc, larg);
+    case SSL_CTRL_GET_SHARED_GROUP: {
+        uint16_t id = tls1_shared_group(sc, larg);
 
-            if (larg != -1)
-                return tls1_group_id2nid(id, 1);
-            return id;
-        }
-    case SSL_CTRL_GET_NEGOTIATED_GROUP:
-        {
-            unsigned int id;
+        if (larg != -1)
+            return tls1_group_id2nid(id, 1);
+        return id;
+    }
+    case SSL_CTRL_GET_NEGOTIATED_GROUP: {
+        unsigned int id;
 
-            if (SSL_CONNECTION_IS_TLS13(sc) && sc->s3.did_kex)
-                id = sc->s3.group_id;
-            else
-                id = (sc->session != NULL) ? sc->session->kex_group : NID_undef;
-            ret = tls1_group_id2nid(id, 1);
-            break;
-        }
+        if (SSL_CONNECTION_IS_TLS13(sc) && sc->s3.did_kex)
+            id = sc->s3.group_id;
+        else
+            id = (sc->session != NULL) ? sc->session->kex_group : NID_undef;
+        ret = tls1_group_id2nid(id, 1);
+        break;
+    }
     case SSL_CTRL_SET_SIGALGS:
         return tls1_set_sigalgs(sc->cert, parg, larg, 0);
 
@@ -3796,15 +4210,14 @@ long ssl3_ctrl(SSL *s, int cmd, long larg, void *parg)
     case SSL_CTRL_SET_CLIENT_SIGALGS_LIST:
         return tls1_set_sigalgs_list(s->ctx, sc->cert, parg, 1);
 
-    case SSL_CTRL_GET_CLIENT_CERT_TYPES:
-        {
-            const unsigned char **pctype = parg;
-            if (sc->server || !sc->s3.tmp.cert_req)
-                return 0;
-            if (pctype)
-                *pctype = sc->s3.tmp.ctype;
-            return sc->s3.tmp.ctype_len;
-        }
+    case SSL_CTRL_GET_CLIENT_CERT_TYPES: {
+        const unsigned char **pctype = parg;
+        if (sc->server || !sc->s3.tmp.cert_req)
+            return 0;
+        if (pctype)
+            *pctype = sc->s3.tmp.ctype;
+        return sc->s3.tmp.ctype_len;
+    }
 
     case SSL_CTRL_SET_CLIENT_CERT_TYPES:
         if (!sc->server)
@@ -3872,23 +4285,21 @@ long ssl3_ctrl(SSL *s, int cmd, long larg, void *parg)
             return 1;
         }
 
-    case SSL_CTRL_GET_EC_POINT_FORMATS:
-        {
-            const unsigned char **pformat = parg;
+    case SSL_CTRL_GET_EC_POINT_FORMATS: {
+        const unsigned char **pformat = parg;
 
-            if (sc->ext.peer_ecpointformats == NULL)
-                return 0;
-            *pformat = sc->ext.peer_ecpointformats;
-            return (int)sc->ext.peer_ecpointformats_len;
-        }
+        if (sc->ext.peer_ecpointformats == NULL)
+            return 0;
+        *pformat = sc->ext.peer_ecpointformats;
+        return (int)sc->ext.peer_ecpointformats_len;
+    }
 
-    case SSL_CTRL_GET_IANA_GROUPS:
-        {
-            if (parg != NULL) {
-                *(uint16_t **)parg = (uint16_t *)sc->ext.peer_supportedgroups;
-            }
-            return (int)sc->ext.peer_supportedgroups_len;
+    case SSL_CTRL_GET_IANA_GROUPS: {
+        if (parg != NULL) {
+            *(uint16_t **)parg = (uint16_t *)sc->ext.peer_supportedgroups;
         }
+        return (int)sc->ext.peer_supportedgroups_len;
+    }
 
     case SSL_CTRL_SET_MSG_CALLBACK_ARG:
         sc->msg_callback_arg = parg;
@@ -3900,7 +4311,7 @@ long ssl3_ctrl(SSL *s, int cmd, long larg, void *parg)
     return ret;
 }
 
-long ssl3_callback_ctrl(SSL *s, int cmd, void (*fp) (void))
+long ssl3_callback_ctrl(SSL *s, int cmd, void (*fp)(void))
 {
     int ret = 0;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
@@ -3917,7 +4328,7 @@ long ssl3_callback_ctrl(SSL *s, int cmd, void (*fp) (void))
 #endif
     case SSL_CTRL_SET_TLSEXT_DEBUG_CB:
         sc->ext.debug_cb = (void (*)(SSL *, int, int,
-                                     const unsigned char *, int, void *))fp;
+            const unsigned char *, int, void *))fp;
         ret = 1;
         break;
 
@@ -3939,88 +4350,80 @@ long ssl3_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
 {
     switch (cmd) {
 #if !defined(OPENSSL_NO_DEPRECATED_3_0)
-    case SSL_CTRL_SET_TMP_DH:
-        {
-            EVP_PKEY *pkdh = NULL;
-            if (parg == NULL) {
-                ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
-                return 0;
-            }
-            pkdh = ssl_dh_to_pkey(parg);
-            if (pkdh == NULL) {
-                ERR_raise(ERR_LIB_SSL, ERR_R_DH_LIB);
-                return 0;
-            }
-            if (!SSL_CTX_set0_tmp_dh_pkey(ctx, pkdh)) {
-                EVP_PKEY_free(pkdh);
-                return 0;
-            }
-            return 1;
+    case SSL_CTRL_SET_TMP_DH: {
+        EVP_PKEY *pkdh = NULL;
+        if (parg == NULL) {
+            ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
+            return 0;
         }
-    case SSL_CTRL_SET_TMP_DH_CB:
-        {
-            ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+        pkdh = ssl_dh_to_pkey(parg);
+        if (pkdh == NULL) {
+            ERR_raise(ERR_LIB_SSL, ERR_R_DH_LIB);
+            return 0;
+        }
+        if (!SSL_CTX_set0_tmp_dh_pkey(ctx, pkdh)) {
+            EVP_PKEY_free(pkdh);
             return 0;
         }
+        return 1;
+    }
+    case SSL_CTRL_SET_TMP_DH_CB: {
+        ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+        return 0;
+    }
 #endif
     case SSL_CTRL_SET_DH_AUTO:
         ctx->cert->dh_tmp_auto = larg;
         return 1;
 #if !defined(OPENSSL_NO_DEPRECATED_3_0)
-    case SSL_CTRL_SET_TMP_ECDH:
-        {
-            if (parg == NULL) {
-                ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
-                return 0;
-            }
-            return ssl_set_tmp_ecdh_groups(&ctx->ext.supportedgroups,
-                                           &ctx->ext.supportedgroups_len,
-                                           &ctx->ext.keyshares,
-                                           &ctx->ext.keyshares_len,
-                                           &ctx->ext.tuples,
-                                           &ctx->ext.tuples_len,
-                                           parg);
+    case SSL_CTRL_SET_TMP_ECDH: {
+        if (parg == NULL) {
+            ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_NULL_PARAMETER);
+            return 0;
         }
-#endif                          /* !OPENSSL_NO_DEPRECATED_3_0 */
+        return ssl_set_tmp_ecdh_groups(&ctx->ext.supportedgroups,
+            &ctx->ext.supportedgroups_len,
+            &ctx->ext.keyshares,
+            &ctx->ext.keyshares_len,
+            &ctx->ext.tuples,
+            &ctx->ext.tuples_len,
+            parg);
+    }
+#endif /* !OPENSSL_NO_DEPRECATED_3_0 */
     case SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG:
         ctx->ext.servername_arg = parg;
         break;
     case SSL_CTRL_SET_TLSEXT_TICKET_KEYS:
-    case SSL_CTRL_GET_TLSEXT_TICKET_KEYS:
-        {
-            unsigned char *keys = parg;
-            long tick_keylen = (sizeof(ctx->ext.tick_key_name) +
-                                sizeof(ctx->ext.secure->tick_hmac_key) +
-                                sizeof(ctx->ext.secure->tick_aes_key));
-            if (keys == NULL)
-                return tick_keylen;
-            if (larg != tick_keylen) {
-                ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_TICKET_KEYS_LENGTH);
-                return 0;
-            }
-            if (cmd == SSL_CTRL_SET_TLSEXT_TICKET_KEYS) {
-                memcpy(ctx->ext.tick_key_name, keys,
-                       sizeof(ctx->ext.tick_key_name));
-                memcpy(ctx->ext.secure->tick_hmac_key,
-                       keys + sizeof(ctx->ext.tick_key_name),
-                       sizeof(ctx->ext.secure->tick_hmac_key));
-                memcpy(ctx->ext.secure->tick_aes_key,
-                       keys + sizeof(ctx->ext.tick_key_name) +
-                       sizeof(ctx->ext.secure->tick_hmac_key),
-                       sizeof(ctx->ext.secure->tick_aes_key));
-            } else {
-                memcpy(keys, ctx->ext.tick_key_name,
-                       sizeof(ctx->ext.tick_key_name));
-                memcpy(keys + sizeof(ctx->ext.tick_key_name),
-                       ctx->ext.secure->tick_hmac_key,
-                       sizeof(ctx->ext.secure->tick_hmac_key));
-                memcpy(keys + sizeof(ctx->ext.tick_key_name) +
-                       sizeof(ctx->ext.secure->tick_hmac_key),
-                       ctx->ext.secure->tick_aes_key,
-                       sizeof(ctx->ext.secure->tick_aes_key));
-            }
-            return 1;
+    case SSL_CTRL_GET_TLSEXT_TICKET_KEYS: {
+        unsigned char *keys = parg;
+        long tick_keylen = (sizeof(ctx->ext.tick_key_name) + sizeof(ctx->ext.secure->tick_hmac_key) + sizeof(ctx->ext.secure->tick_aes_key));
+        if (keys == NULL)
+            return tick_keylen;
+        if (larg != tick_keylen) {
+            ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_TICKET_KEYS_LENGTH);
+            return 0;
+        }
+        if (cmd == SSL_CTRL_SET_TLSEXT_TICKET_KEYS) {
+            memcpy(ctx->ext.tick_key_name, keys,
+                sizeof(ctx->ext.tick_key_name));
+            memcpy(ctx->ext.secure->tick_hmac_key,
+                keys + sizeof(ctx->ext.tick_key_name),
+                sizeof(ctx->ext.secure->tick_hmac_key));
+            memcpy(ctx->ext.secure->tick_aes_key,
+                keys + sizeof(ctx->ext.tick_key_name) + sizeof(ctx->ext.secure->tick_hmac_key),
+                sizeof(ctx->ext.secure->tick_aes_key));
+        } else {
+            memcpy(keys, ctx->ext.tick_key_name,
+                sizeof(ctx->ext.tick_key_name));
+            memcpy(keys + sizeof(ctx->ext.tick_key_name),
+                ctx->ext.secure->tick_hmac_key,
+                sizeof(ctx->ext.secure->tick_hmac_key));
+            memcpy(keys + sizeof(ctx->ext.tick_key_name) + sizeof(ctx->ext.secure->tick_hmac_key),
+                ctx->ext.secure->tick_aes_key,
+                sizeof(ctx->ext.secure->tick_aes_key));
         }
+        return 1;
+    }
 
     case SSL_CTRL_GET_TLSEXT_STATUS_REQ_TYPE:
         return ctx->ext.status_type;
@@ -4034,11 +4437,11 @@ long ssl3_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
         return 1;
 
     case SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB_ARG:
-        *(void**)parg = ctx->ext.status_arg;
+        *(void **)parg = ctx->ext.status_arg;
         break;
 
     case SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB:
-        *(int (**)(SSL*, void*))parg = ctx->ext.status_cb;
+        *(int (**)(SSL *, void *))parg = ctx->ext.status_cb;
         break;
 
 #ifndef OPENSSL_NO_SRP
@@ -4058,8 +4461,7 @@ long ssl3_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
         }
         break;
     case SSL_CTRL_SET_TLS_EXT_SRP_PASSWORD:
-        ctx->srp_ctx.SRP_give_srp_client_pwd_callback =
-            srp_password_from_info_cb;
+        ctx->srp_ctx.SRP_give_srp_client_pwd_callback = srp_password_from_info_cb;
         if (ctx->srp_ctx.info != NULL)
             OPENSSL_free(ctx->srp_ctx.info);
         if ((ctx->srp_ctx.info = OPENSSL_strdup((char *)parg)) == NULL) {
@@ -4079,28 +4481,28 @@ long ssl3_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
 
     case SSL_CTRL_SET_GROUPS:
         return tls1_set_groups(&ctx->ext.supportedgroups,
-                               &ctx->ext.supportedgroups_len,
-                               &ctx->ext.keyshares,
-                               &ctx->ext.keyshares_len,
-                               &ctx->ext.tuples,
-                               &ctx->ext.tuples_len,
-                               parg, larg);
+            &ctx->ext.supportedgroups_len,
+            &ctx->ext.keyshares,
+            &ctx->ext.keyshares_len,
+            &ctx->ext.tuples,
+            &ctx->ext.tuples_len,
+            parg, larg);
 
     case SSL_CTRL_SET_GROUPS_LIST:
         return tls1_set_groups_list(ctx,
-                                    &ctx->ext.supportedgroups,
-                                    &ctx->ext.supportedgroups_len,
-                                    &ctx->ext.keyshares,
-                                    &ctx->ext.keyshares_len,
-                                    &ctx->ext.tuples,
-                                    &ctx->ext.tuples_len,
-                                    parg);
+            &ctx->ext.supportedgroups,
+            &ctx->ext.supportedgroups_len,
+            &ctx->ext.keyshares,
+            &ctx->ext.keyshares_len,
+            &ctx->ext.tuples,
+            &ctx->ext.tuples_len,
+            parg);
 
     case SSL_CTRL_GET0_IMPLEMENTED_GROUPS:
         return tls1_get0_implemented_groups(ctx->min_proto_version,
-                                            ctx->max_proto_version,
-                                            ctx->group_list,
-                                            ctx->group_list_len, larg, parg);
+            ctx->max_proto_version,
+            ctx->group_list,
+            ctx->group_list_len, larg, parg);
 
     case SSL_CTRL_SET_SIGALGS:
         return tls1_set_sigalgs(ctx->cert, parg, larg, 0);
@@ -4186,15 +4588,13 @@ long ssl3_ctx_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
     return 1;
 }
 
-long ssl3_ctx_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void))
+long ssl3_ctx_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)(void))
 {
     switch (cmd) {
 #if !defined(OPENSSL_NO_DEPRECATED_3_0)
-    case SSL_CTRL_SET_TMP_DH_CB:
-        {
-            ctx->cert->dh_tmp_cb = (DH *(*)(SSL *, int, int))fp;
-        }
-        break;
+    case SSL_CTRL_SET_TMP_DH_CB: {
+        ctx->cert->dh_tmp_cb = (DH *(*)(SSL *, int, int))fp;
+    } break;
 #endif
     case SSL_CTRL_SET_TLSEXT_SERVERNAME_CB:
         ctx->ext.servername_cb = (int (*)(SSL *, int *, void *))fp;
@@ -4204,12 +4604,12 @@ long ssl3_ctx_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void))
         ctx->ext.status_cb = (int (*)(SSL *, void *))fp;
         break;
 
-# ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DEPRECATED_3_0
     case SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB:
         ctx->ext.ticket_key_cb = (int (*)(SSL *, unsigned char *,
-                                          unsigned char *,
-                                          EVP_CIPHER_CTX *,
-                                          HMAC_CTX *, int))fp;
+            unsigned char *,
+            EVP_CIPHER_CTX *,
+            HMAC_CTX *, int))fp;
         break;
 #endif
 
@@ -4220,29 +4620,23 @@ long ssl3_ctx_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void))
         break;
     case SSL_CTRL_SET_TLS_EXT_SRP_USERNAME_CB:
         ctx->srp_ctx.srp_Mask |= SSL_kSRP;
-        ctx->srp_ctx.TLS_ext_srp_username_callback =
-            (int (*)(SSL *, int *, void *))fp;
+        ctx->srp_ctx.TLS_ext_srp_username_callback = (int (*)(SSL *, int *, void *))fp;
         break;
     case SSL_CTRL_SET_SRP_GIVE_CLIENT_PWD_CB:
         ctx->srp_ctx.srp_Mask |= SSL_kSRP;
-        ctx->srp_ctx.SRP_give_srp_client_pwd_callback =
-            (char *(*)(SSL *, void *))fp;
+        ctx->srp_ctx.SRP_give_srp_client_pwd_callback = (char *(*)(SSL *, void *))fp;
         break;
 #endif
-    case SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB:
-        {
-            ctx->not_resumable_session_cb = (int (*)(SSL *, int))fp;
-        }
-        break;
+    case SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB: {
+        ctx->not_resumable_session_cb = (int (*)(SSL *, int))fp;
+    } break;
     default:
         return 0;
     }
     return 1;
 }
 
-int SSL_CTX_set_tlsext_ticket_key_evp_cb
-    (SSL_CTX *ctx, int (*fp)(SSL *, unsigned char *, unsigned char *,
-                             EVP_CIPHER_CTX *, EVP_MAC_CTX *, int))
+int SSL_CTX_set_tlsext_ticket_key_evp_cb(SSL_CTX *ctx, int (*fp)(SSL *, unsigned char *, unsigned char *, EVP_CIPHER_CTX *, EVP_MAC_CTX *, int))
 {
     ctx->ext.ticket_key_evp_cb = fp;
     return 1;
@@ -4266,9 +4660,8 @@ const SSL_CIPHER *ssl3_get_cipher_by_id(uint32_t id)
 const SSL_CIPHER *ssl3_get_cipher_by_std_name(const char *stdname)
 {
     SSL_CIPHER *tbl;
-    SSL_CIPHER *alltabs[] = {tls13_ciphers, ssl3_ciphers, ssl3_scsvs};
-    size_t i, j, tblsize[] = {TLS13_NUM_CIPHERS, SSL3_NUM_CIPHERS,
-                              SSL3_NUM_SCSVS};
+    SSL_CIPHER *alltabs[] = { tls13_ciphers, ssl3_ciphers, ssl3_scsvs };
+    size_t i, j, tblsize[] = { TLS13_NUM_CIPHERS, SSL3_NUM_CIPHERS, SSL3_NUM_SCSVS };
 
     /* this is not efficient, necessary to optimize this? */
     for (j = 0; j < OSSL_NELEM(alltabs); j++) {
@@ -4290,8 +4683,8 @@ const SSL_CIPHER *ssl3_get_cipher_by_std_name(const char *stdname)
 const SSL_CIPHER *ssl3_get_cipher_by_char(const unsigned char *p)
 {
     return ssl3_get_cipher_by_id(SSL3_CK_CIPHERSUITE_FLAG
-                                 | ((uint32_t)p[0] << 8L)
-                                 | (uint32_t)p[1]);
+        | ((uint32_t)p[0] << 8L)
+        | (uint32_t)p[1]);
 }
 
 int ssl3_put_cipher_by_char(const SSL_CIPHER *c, WPACKET *pkt, size_t *len)
@@ -4317,7 +4710,7 @@ int ssl3_put_cipher_by_char(const SSL_CIPHER *c, WPACKET *pkt, size_t *len)
  * Returns the selected cipher or NULL when no common ciphers.
  */
 const SSL_CIPHER *ssl3_choose_cipher(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *clnt,
-                                     STACK_OF(SSL_CIPHER) *srvr)
+    STACK_OF(SSL_CIPHER) *srvr)
 {
     const SSL_CIPHER *c, *ret = NULL;
     STACK_OF(SSL_CIPHER) *prio, *allow;
@@ -4334,20 +4727,22 @@ const SSL_CIPHER *ssl3_choose_cipher(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *cl
      * pay with the price of sk_SSL_CIPHER_dup().
      */
 
-    OSSL_TRACE_BEGIN(TLS_CIPHER) {
+    OSSL_TRACE_BEGIN(TLS_CIPHER)
+    {
         BIO_printf(trc_out, "Server has %d from %p:\n",
-                   sk_SSL_CIPHER_num(srvr), (void *)srvr);
+            sk_SSL_CIPHER_num(srvr), (void *)srvr);
         for (i = 0; i < sk_SSL_CIPHER_num(srvr); ++i) {
             c = sk_SSL_CIPHER_value(srvr, i);
             BIO_printf(trc_out, "%p:%s\n", (void *)c, c->name);
         }
         BIO_printf(trc_out, "Client sent %d from %p:\n",
-                   sk_SSL_CIPHER_num(clnt), (void *)clnt);
+            sk_SSL_CIPHER_num(clnt), (void *)clnt);
         for (i = 0; i < sk_SSL_CIPHER_num(clnt); ++i) {
             c = sk_SSL_CIPHER_value(clnt, i);
             BIO_printf(trc_out, "%p:%s\n", (void *)c, c->name);
         }
-    } OSSL_TRACE_END(TLS_CIPHER);
+    }
+    OSSL_TRACE_END(TLS_CIPHER);
 
     /* SUITE-B takes precedence over server preference and ChaCha priortiy */
     if (tls1_suiteb(s)) {
@@ -4412,7 +4807,8 @@ const SSL_CIPHER *ssl3_choose_cipher(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *cl
          * that.
          */
         if (s->psk_server_callback != NULL) {
-            for (j = 0; j < s->ssl_pkey_num && !ssl_has_cert(s, j); j++);
+            for (j = 0; j < s->ssl_pkey_num && !ssl_has_cert(s, j); j++)
+                ;
             if (j == s->ssl_pkey_num) {
                 /* There are no certificates */
                 prefer_sha256 = 1;
@@ -4457,12 +4853,12 @@ const SSL_CIPHER *ssl3_choose_cipher(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *cl
             /* with PSK there must be server callback set */
             if ((alg_k & SSL_PSK) && s->psk_server_callback == NULL)
                 continue;
-#endif                          /* OPENSSL_NO_PSK */
+#endif /* OPENSSL_NO_PSK */
 
             ok = (alg_k & mask_k) && (alg_a & mask_a);
             OSSL_TRACE7(TLS_CIPHER,
-                        "%d:[%08lX:%08lX:%08lX:%08lX]%p:%s\n",
-                        ok, alg_k, alg_a, mask_k, mask_a, (void *)c, c->name);
+                "%d:[%08lX:%08lX:%08lX:%08lX]%p:%s\n",
+                ok, alg_k, alg_a, mask_k, mask_a, (void *)c, c->name);
 
             /*
              * if we are considering an ECC cipher suite that uses an ephemeral
@@ -4478,7 +4874,7 @@ const SSL_CIPHER *ssl3_choose_cipher(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *cl
         if (ii >= 0) {
             /* Check security callback permits this cipher */
             if (!ssl_security(s, SSL_SECOP_CIPHER_SHARED,
-                              c->strength_bits, 0, (void *)c))
+                    c->strength_bits, 0, (void *)c))
                 continue;
 
             if ((alg_k & SSL_kECDHE) && (alg_a & SSL_aECDSA)
@@ -4491,10 +4887,10 @@ const SSL_CIPHER *ssl3_choose_cipher(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *cl
             if (prefer_sha256) {
                 const SSL_CIPHER *tmp = sk_SSL_CIPHER_value(allow, ii);
                 const EVP_MD *md = ssl_md(SSL_CONNECTION_GET_CTX(s),
-                                          tmp->algorithm2);
+                    tmp->algorithm2);
 
                 if (md != NULL
-                        && EVP_MD_is_a(md, OSSL_DIGEST_NAME_SHA2_256)) {
+                    && EVP_MD_is_a(md, OSSL_DIGEST_NAME_SHA2_256)) {
                     ret = tmp;
                     break;
                 }
@@ -4543,7 +4939,7 @@ int ssl3_get_req_cert_type(SSL_CONNECTION *s, WPACKET *pkt)
         if (!WPACKET_put_bytes_u8(pkt, SSL3_CT_RSA_EPHEMERAL_DH))
             return 0;
         if (!(alg_a & SSL_aDSS)
-                && !WPACKET_put_bytes_u8(pkt, SSL3_CT_DSS_EPHEMERAL_DH))
+            && !WPACKET_put_bytes_u8(pkt, SSL3_CT_DSS_EPHEMERAL_DH))
             return 0;
     }
     if (!(alg_a & SSL_aRSA) && !WPACKET_put_bytes_u8(pkt, SSL3_CT_RSA_SIGN))
@@ -4556,8 +4952,8 @@ int ssl3_get_req_cert_type(SSL_CONNECTION *s, WPACKET *pkt)
      * need to check for SSL_kECDH or SSL_kECDHE
      */
     if (s->version >= TLS1_VERSION
-            && !(alg_a & SSL_aECDSA)
-            && !WPACKET_put_bytes_u8(pkt, TLS_CT_ECDSA_SIGN))
+        && !(alg_a & SSL_aECDSA)
+        && !WPACKET_put_bytes_u8(pkt, TLS_CT_ECDSA_SIGN))
         return 0;
 
     return 1;
@@ -4604,7 +5000,7 @@ int ssl3_shutdown(SSL *s)
          * written, s->s3.alert_dispatch will be > 0
          */
         if (sc->s3.alert_dispatch > 0)
-            return -1;        /* return WANT_WRITE */
+            return -1; /* return WANT_WRITE */
     } else if (sc->s3.alert_dispatch > 0) {
         /* resend it if not sent */
         ret = s->method->ssl_dispatch_alert(s);
@@ -4623,12 +5019,12 @@ int ssl3_shutdown(SSL *s)
          */
         s->method->ssl_read_bytes(s, 0, NULL, NULL, 0, 0, &readbytes);
         if (!(sc->shutdown & SSL_RECEIVED_SHUTDOWN)) {
-            return -1;        /* return WANT_READ */
+            return -1; /* return WANT_READ */
         }
     }
 
     if ((sc->shutdown == (SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN))
-            && sc->s3.alert_dispatch == SSL_ALERT_DISPATCH_NONE)
+        && sc->s3.alert_dispatch == SSL_ALERT_DISPATCH_NONE)
         return 1;
     else
         return 0;
@@ -4646,11 +5042,11 @@ int ssl3_write(SSL *s, const void *buf, size_t len, size_t *written)
         ssl3_renegotiate_check(s, 0);
 
     return s->method->ssl_write_bytes(s, SSL3_RT_APPLICATION_DATA, buf, len,
-                                      written);
+        written);
 }
 
 static int ssl3_read_internal(SSL *s, void *buf, size_t len, int peek,
-                              size_t *readbytes)
+    size_t *readbytes)
 {
     int ret;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
@@ -4662,9 +5058,8 @@ static int ssl3_read_internal(SSL *s, void *buf, size_t len, int peek,
     if (sc->s3.renegotiate)
         ssl3_renegotiate_check(s, 0);
     sc->s3.in_read_app_data = 1;
-    ret =
-        s->method->ssl_read_bytes(s, SSL3_RT_APPLICATION_DATA, NULL, buf, len,
-                                  peek, readbytes);
+    ret = s->method->ssl_read_bytes(s, SSL3_RT_APPLICATION_DATA, NULL, buf, len,
+        peek, readbytes);
     if ((ret == -1) && (sc->s3.in_read_app_data == 2)) {
         /*
          * ssl3_read_bytes decided to call s->handshake_func, which called
@@ -4674,9 +5069,8 @@ static int ssl3_read_internal(SSL *s, void *buf, size_t len, int peek,
          * application data again.
          */
         ossl_statem_set_in_handshake(sc, 1);
-        ret =
-            s->method->ssl_read_bytes(s, SSL3_RT_APPLICATION_DATA, NULL, buf,
-                                      len, peek, readbytes);
+        ret = s->method->ssl_read_bytes(s, SSL3_RT_APPLICATION_DATA, NULL, buf,
+            len, peek, readbytes);
         ossl_statem_set_in_handshake(sc, 0);
     } else
         sc->s3.in_read_app_data = 0;
@@ -4772,8 +5166,8 @@ long ssl_get_algorithm2(SSL_CONNECTION *s)
  * failure, 1 on success.
  */
 int ssl_fill_hello_random(SSL_CONNECTION *s, int server,
-                          unsigned char *result, size_t len,
-                          DOWNGRADE dgrd)
+    unsigned char *result, size_t len,
+    DOWNGRADE dgrd)
 {
     int send_time = 0, ret;
 
@@ -4795,21 +5189,21 @@ int ssl_fill_hello_random(SSL_CONNECTION *s, int server,
 
     if (ret > 0) {
         if (!ossl_assert(sizeof(tls11downgrade) < len)
-                || !ossl_assert(sizeof(tls12downgrade) < len))
-             return 0;
+            || !ossl_assert(sizeof(tls12downgrade) < len))
+            return 0;
         if (dgrd == DOWNGRADE_TO_1_2)
             memcpy(result + len - sizeof(tls12downgrade), tls12downgrade,
-                   sizeof(tls12downgrade));
+                sizeof(tls12downgrade));
         else if (dgrd == DOWNGRADE_TO_1_1)
             memcpy(result + len - sizeof(tls11downgrade), tls11downgrade,
-                   sizeof(tls11downgrade));
+                sizeof(tls11downgrade));
     }
 
     return ret;
 }
 
 int ssl_generate_master_secret(SSL_CONNECTION *s, unsigned char *pms,
-                               size_t pmslen, int free_pms)
+    size_t pmslen, int free_pms)
 {
     unsigned long alg_k = s->s3.tmp.new_cipher->algorithm_mkey;
     int ret = 0;
@@ -4845,8 +5239,8 @@ int ssl_generate_master_secret(SSL_CONNECTION *s, unsigned char *pms,
         s->s3.tmp.psk = NULL;
         s->s3.tmp.psklen = 0;
         if (!ssl->method->ssl3_enc->generate_master_secret(s,
-                    s->session->master_key, pskpms, pskpmslen,
-                    &s->session->master_key_length)) {
+                s->session->master_key, pskpms, pskpmslen,
+                &s->session->master_key_length)) {
             OPENSSL_clear_free(pskpms, pskpmslen);
             /* SSLfatal() already called */
             goto err;
@@ -4866,7 +5260,7 @@ int ssl_generate_master_secret(SSL_CONNECTION *s, unsigned char *pms,
     }
 
     ret = 1;
- err:
+err:
     if (pms) {
         if (free_pms)
             OPENSSL_clear_free(pms, pmslen);
@@ -4899,7 +5293,7 @@ EVP_PKEY *ssl_generate_pkey(SSL_CONNECTION *s, EVP_PKEY *pm)
         pkey = NULL;
     }
 
-    err:
+err:
     EVP_PKEY_CTX_free(pctx);
     return pkey;
 }
@@ -4918,7 +5312,7 @@ EVP_PKEY *ssl_generate_pkey_group(SSL_CONNECTION *s, uint16_t id)
     }
 
     pctx = EVP_PKEY_CTX_new_from_name(sctx->libctx, ginf->algorithm,
-                                      sctx->propq);
+        sctx->propq);
 
     if (pctx == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
@@ -4938,7 +5332,7 @@ EVP_PKEY *ssl_generate_pkey_group(SSL_CONNECTION *s, uint16_t id)
         pkey = NULL;
     }
 
- err:
+err:
     EVP_PKEY_CTX_free(pctx);
     return pkey;
 }
@@ -4957,7 +5351,7 @@ EVP_PKEY *ssl_generate_param_group(SSL_CONNECTION *s, uint16_t id)
         goto err;
 
     pctx = EVP_PKEY_CTX_new_from_name(sctx->libctx, ginf->algorithm,
-                                      sctx->propq);
+        sctx->propq);
 
     if (pctx == NULL)
         goto err;
@@ -4972,7 +5366,7 @@ EVP_PKEY *ssl_generate_param_group(SSL_CONNECTION *s, uint16_t id)
         pkey = NULL;
     }
 
- err:
+err:
     EVP_PKEY_CTX_free(pctx);
     return pkey;
 }
@@ -4990,8 +5384,8 @@ int ssl_gensecret(SSL_CONNECTION *s, unsigned char *pms, size_t pmslen)
          */
         if (!s->hit)
             rv = tls13_generate_secret(s, ssl_handshake_md(s), NULL, NULL,
-                    0,
-                    (unsigned char *)&s->early_secret);
+                0,
+                (unsigned char *)&s->early_secret);
         else
             rv = 1;
 
@@ -5026,7 +5420,7 @@ int ssl_derive(SSL_CONNECTION *s, EVP_PKEY *privkey, EVP_PKEY *pubkey, int gense
         goto err;
     }
 
-    if (SSL_CONNECTION_IS_TLS13(s) &&  EVP_PKEY_is_a(privkey, "DH"))
+    if (SSL_CONNECTION_IS_TLS13(s) && EVP_PKEY_is_a(privkey, "DH"))
         EVP_PKEY_CTX_set_dh_pad(pctx, 1);
 
     pms = OPENSSL_malloc(pmslen);
@@ -5054,7 +5448,7 @@ int ssl_derive(SSL_CONNECTION *s, EVP_PKEY *privkey, EVP_PKEY *pubkey, int gense
         rv = 1;
     }
 
- err:
+err:
     OPENSSL_clear_free(pms, pmslen);
     EVP_PKEY_CTX_free(pctx);
     return rv;
@@ -5062,8 +5456,8 @@ int ssl_derive(SSL_CONNECTION *s, EVP_PKEY *privkey, EVP_PKEY *pubkey, int gense
 
 /* Decapsulate secrets for KEM */
 int ssl_decapsulate(SSL_CONNECTION *s, EVP_PKEY *privkey,
-                    const unsigned char *ct, size_t ctlen,
-                    int gensecret)
+    const unsigned char *ct, size_t ctlen,
+    int gensecret)
 {
     int rv = 0;
     unsigned char *pms = NULL;
@@ -5079,7 +5473,7 @@ int ssl_decapsulate(SSL_CONNECTION *s, EVP_PKEY *privkey,
     pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, privkey, sctx->propq);
 
     if (EVP_PKEY_decapsulate_init(pctx, NULL) <= 0
-            || EVP_PKEY_decapsulate(pctx, NULL, &pmslen, ct, ctlen) <= 0) {
+        || EVP_PKEY_decapsulate(pctx, NULL, &pmslen, ct, ctlen) <= 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
@@ -5106,15 +5500,15 @@ int ssl_decapsulate(SSL_CONNECTION *s, EVP_PKEY *privkey,
         rv = 1;
     }
 
- err:
+err:
     OPENSSL_clear_free(pms, pmslen);
     EVP_PKEY_CTX_free(pctx);
     return rv;
 }
 
 int ssl_encapsulate(SSL_CONNECTION *s, EVP_PKEY *pubkey,
-                    unsigned char **ctp, size_t *ctlenp,
-                    int gensecret)
+    unsigned char **ctp, size_t *ctlenp,
+    int gensecret)
 {
     int rv = 0;
     unsigned char *pms = NULL, *ct = NULL;
@@ -5130,8 +5524,8 @@ int ssl_encapsulate(SSL_CONNECTION *s, EVP_PKEY *pubkey,
     pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, pubkey, sctx->propq);
 
     if (EVP_PKEY_encapsulate_init(pctx, NULL) <= 0
-            || EVP_PKEY_encapsulate(pctx, NULL, &ctlen, NULL, &pmslen) <= 0
-            || pmslen == 0 || ctlen == 0) {
+        || EVP_PKEY_encapsulate(pctx, NULL, &ctlen, NULL, &pmslen) <= 0
+        || pmslen == 0 || ctlen == 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
@@ -5166,7 +5560,7 @@ int ssl_encapsulate(SSL_CONNECTION *s, EVP_PKEY *pubkey,
         ct = NULL;
     }
 
- err:
+err:
     OPENSSL_clear_free(pms, pmslen);
     OPENSSL_free(ct);
     EVP_PKEY_CTX_free(pctx);
@@ -5189,7 +5583,8 @@ const char *SSL_get0_group_name(SSL *s)
     return tls1_group_id2name(s->ctx, id);
 }
 
-const char *SSL_group_to_name(SSL *s, int nid) {
+const char *SSL_group_to_name(SSL *s, int nid)
+{
     int group_id = 0;
     const TLS_GROUP_INFO *cinf = NULL;
 
diff --git a/crypto/openssl/ssl/s3_msg.c b/crypto/openssl/ssl/s3_msg.c
index 6505e0009812..ffe53bfe1818 100644
--- a/crypto/openssl/ssl/s3_msg.c
+++ b/crypto/openssl/ssl/s3_msg.c
@@ -79,7 +79,7 @@ int ssl3_send_alert(SSL_CONNECTION *s, int level, int desc)
 int ssl3_dispatch_alert(SSL *s)
 {
     int i, j;
-    void (*cb) (const SSL *ssl, int type, int val) = NULL;
+    void (*cb)(const SSL *ssl, int type, int val) = NULL;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
     OSSL_RECORD_TEMPLATE templ;
 
@@ -96,9 +96,9 @@ int ssl3_dispatch_alert(SSL *s)
     templ.version = (sc->version == TLS1_3_VERSION) ? TLS1_2_VERSION
                                                     : sc->version;
     if (SSL_get_state(s) == TLS_ST_CW_CLNT_HELLO
-            && !sc->renegotiate
-            && TLS1_get_version(s) > TLS1_VERSION
-            && sc->hello_retry_request == SSL_HRR_NONE) {
+        && !sc->renegotiate
+        && TLS1_get_version(s) > TLS1_VERSION
+        && sc->hello_retry_request == SSL_HRR_NONE) {
         templ.version = TLS1_VERSION;
     }
     templ.buf = &sc->s3.send_alert[0];
@@ -116,7 +116,7 @@ int ssl3_dispatch_alert(SSL *s)
         }
         /* Retry what we've already got pending */
         i = HANDLE_RLAYER_WRITE_RETURN(sc,
-                sc->rlayer.wrlmethod->retry_write_records(sc->rlayer.wrl));
+            sc->rlayer.wrlmethod->retry_write_records(sc->rlayer.wrl));
         if (i <= 0) {
             /* Could be NBIO. Keep alert_dispatch as SSL_ALERT_DISPATCH_RETRY */
             return -1;
@@ -127,7 +127,7 @@ int ssl3_dispatch_alert(SSL *s)
     }
 
     i = HANDLE_RLAYER_WRITE_RETURN(sc,
-            sc->rlayer.wrlmethod->write_records(sc->rlayer.wrl, &templ, 1));
+        sc->rlayer.wrlmethod->write_records(sc->rlayer.wrl, &templ, 1));
 
     if (i <= 0) {
         sc->s3.alert_dispatch = SSL_ALERT_DISPATCH_RETRY;
@@ -144,7 +144,7 @@ int ssl3_dispatch_alert(SSL *s)
 
         if (sc->msg_callback)
             sc->msg_callback(1, sc->version, SSL3_RT_ALERT, sc->s3.send_alert,
-                             2, s, sc->msg_callback_arg);
+                2, s, sc->msg_callback_arg);
 
         if (sc->info_callback != NULL)
             cb = sc->info_callback;
diff --git a/crypto/openssl/ssl/ssl_asn1.c b/crypto/openssl/ssl/ssl_asn1.c
index 9964a8c1eeb3..13ab6490b9a7 100644
--- a/crypto/openssl/ssl/ssl_asn1.c
+++ b/crypto/openssl/ssl/ssl_asn1.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
  * Copyright 2005 Nokia. All rights reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
@@ -88,7 +88,7 @@ IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(SSL_SESSION_ASN1)
 /* Initialise OCTET STRING from buffer and length */
 
 static void ssl_session_oinit(ASN1_OCTET_STRING **dest, ASN1_OCTET_STRING *os,
-                              const unsigned char *data, size_t len)
+    const unsigned char *data, size_t len)
 {
     os->data = (unsigned char *)data; /* justified cast: data is not modified */
     os->length = (int)len;
@@ -98,7 +98,7 @@ static void ssl_session_oinit(ASN1_OCTET_STRING **dest, ASN1_OCTET_STRING *os,
 
 /* Initialise OCTET STRING from string */
 static void ssl_session_sinit(ASN1_OCTET_STRING **dest, ASN1_OCTET_STRING *os,
-                              const char *data)
+    const char *data)
 {
     if (data != NULL)
         ssl_session_oinit(dest, os, (const unsigned char *)data, strlen(data));
@@ -160,13 +160,13 @@ int i2d_SSL_SESSION(const SSL_SESSION *in, unsigned char **pp)
 #endif
 
     ssl_session_oinit(&as.master_key, &master_key,
-                      in->master_key, in->master_key_length);
+        in->master_key, in->master_key_length);
 
     ssl_session_oinit(&as.session_id, &session_id,
-                      in->session_id, in->session_id_length);
+        in->session_id, in->session_id_length);
 
     ssl_session_oinit(&as.session_id_context, &sid_ctx,
-                      in->sid_ctx, in->sid_ctx_length);
+        in->sid_ctx, in->sid_ctx_length);
 
     as.time = (int64_t)ossl_time_to_time_t(in->time);
     as.timeout = (int64_t)ossl_time2seconds(in->timeout);
@@ -183,22 +183,22 @@ int i2d_SSL_SESSION(const SSL_SESSION *in, unsigned char **pp)
     }
 
     ssl_session_sinit(&as.tlsext_hostname, &tlsext_hostname,
-                      in->ext.hostname);
+        in->ext.hostname);
     if (in->ext.tick) {
         ssl_session_oinit(&as.tlsext_tick, &tlsext_tick,
-                          in->ext.tick, in->ext.ticklen);
+            in->ext.tick, in->ext.ticklen);
     }
     if (in->ext.tick_lifetime_hint > 0)
         as.tlsext_tick_lifetime_hint = in->ext.tick_lifetime_hint;
     as.tlsext_tick_age_add = in->ext.tick_age_add;
 #ifndef OPENSSL_NO_PSK
     ssl_session_sinit(&as.psk_identity_hint, &psk_identity_hint,
-                      in->psk_identity_hint);
+        in->psk_identity_hint);
     ssl_session_sinit(&as.psk_identity, &psk_identity, in->psk_identity);
-#endif                          /* OPENSSL_NO_PSK */
+#endif /* OPENSSL_NO_PSK */
 #ifndef OPENSSL_NO_SRP
     ssl_session_sinit(&as.srp_username, &srp_username, in->srp_username);
-#endif                          /* OPENSSL_NO_SRP */
+#endif /* OPENSSL_NO_SRP */
 
     as.flags = in->flags;
     as.max_early_data = in->ext.max_early_data;
@@ -207,7 +207,7 @@ int i2d_SSL_SESSION(const SSL_SESSION *in, unsigned char **pp)
         as.alpn_selected = NULL;
     else
         ssl_session_oinit(&as.alpn_selected, &alpn_selected,
-                          in->ext.alpn_selected, in->ext.alpn_selected_len);
+            in->ext.alpn_selected, in->ext.alpn_selected_len);
 
     as.tlsext_max_fragment_len_mode = in->ext.max_fragment_len_mode;
 
@@ -215,7 +215,7 @@ int i2d_SSL_SESSION(const SSL_SESSION *in, unsigned char **pp)
         as.ticket_appdata = NULL;
     else
         ssl_session_oinit(&as.ticket_appdata, &ticket_appdata,
-                          in->ticket_appdata, in->ticket_appdata_len);
+            in->ticket_appdata, in->ticket_appdata_len);
 
     ret = i2d_SSL_SESSION_ASN1(&as, pp);
     OPENSSL_free(peer_rpk.data);
@@ -241,7 +241,7 @@ static int ssl_session_strndup(char **pdst, ASN1_OCTET_STRING *src)
 /* Copy an OCTET STRING, return error if it exceeds maximum length */
 
 static int ssl_session_memcpy(unsigned char *dst, size_t *pdstlen,
-                              ASN1_OCTET_STRING *src, size_t maxlen)
+    ASN1_OCTET_STRING *src, size_t maxlen)
 {
     if (src == NULL || src->length == 0) {
         *pdstlen = 0;
@@ -255,13 +255,13 @@ static int ssl_session_memcpy(unsigned char *dst, size_t *pdstlen,
 }
 
 SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a, const unsigned char **pp,
-                             long length)
+    long length)
 {
     return d2i_SSL_SESSION_ex(a, pp, length, NULL, NULL);
 }
 SSL_SESSION *d2i_SSL_SESSION_ex(SSL_SESSION **a, const unsigned char **pp,
-                                long length, OSSL_LIB_CTX *libctx,
-                                const char *propq)
+    long length, OSSL_LIB_CTX *libctx,
+    const char *propq)
 {
     long id;
     size_t tmpl;
@@ -304,7 +304,7 @@ SSL_SESSION *d2i_SSL_SESSION_ex(SSL_SESSION **a, const unsigned char **pp,
     }
 
     id = 0x03000000L | ((unsigned long)as->cipher->data[0] << 8L)
-                     | (unsigned long)as->cipher->data[1];
+        | (unsigned long)as->cipher->data[1];
 
     ret->cipher_id = id;
     ret->cipher = ssl3_get_cipher_by_id(id);
@@ -312,11 +312,11 @@ SSL_SESSION *d2i_SSL_SESSION_ex(SSL_SESSION **a, const unsigned char **pp,
         goto err;
 
     if (!ssl_session_memcpy(ret->session_id, &ret->session_id_length,
-                            as->session_id, SSL3_MAX_SSL_SESSION_ID_LENGTH))
+            as->session_id, SSL3_MAX_SSL_SESSION_ID_LENGTH))
         goto err;
 
     if (!ssl_session_memcpy(ret->master_key, &tmpl,
-                            as->master_key, TLS13_MAX_RESUMPTION_PSK_LENGTH))
+            as->master_key, TLS13_MAX_RESUMPTION_PSK_LENGTH))
         goto err;
 
     ret->master_key_length = tmpl;
@@ -350,7 +350,7 @@ SSL_SESSION *d2i_SSL_SESSION_ex(SSL_SESSION **a, const unsigned char **pp,
     }
 
     if (!ssl_session_memcpy(ret->sid_ctx, &ret->sid_ctx_length,
-                            as->session_id_context, SSL_MAX_SID_CTX_LENGTH))
+            as->session_id_context, SSL_MAX_SID_CTX_LENGTH))
         goto err;
 
     /* NB: this defaults to zero which is X509_V_OK */
@@ -391,7 +391,7 @@ SSL_SESSION *d2i_SSL_SESSION_ex(SSL_SESSION **a, const unsigned char **pp,
 #ifndef OPENSSL_NO_SRP
     if (!ssl_session_strndup(&ret->srp_username, as->srp_username))
         goto err;
-#endif                          /* OPENSSL_NO_SRP */
+#endif /* OPENSSL_NO_SRP */
     /* Flags defaults to zero which is fine */
     ret->flags = (int32_t)as->flags;
     ret->ext.max_early_data = as->max_early_data;
@@ -425,7 +425,7 @@ SSL_SESSION *d2i_SSL_SESSION_ex(SSL_SESSION **a, const unsigned char **pp,
     *pp = p;
     return ret;
 
- err:
+err:
     M_ASN1_free_of(as, SSL_SESSION_ASN1);
     if ((a == NULL) || (*a != ret))
         SSL_SESSION_free(ret);
diff --git a/crypto/openssl/ssl/ssl_cert.c b/crypto/openssl/ssl/ssl_cert.c
index 1be6cd7dbc99..adc5bb3d35c3 100644
--- a/crypto/openssl/ssl/ssl_cert.c
+++ b/crypto/openssl/ssl/ssl_cert.c
@@ -28,19 +28,18 @@
 #include "internal/thread_once.h"
 #include "internal/ssl_unwrap.h"
 #ifndef OPENSSL_NO_POSIX_IO
-# include <sys/stat.h>
-# ifdef _WIN32
-#  define stat _stat
-# endif
-# ifndef S_ISDIR
-#  define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
-# endif
+#include <sys/stat.h>
+#ifdef _WIN32
+#define stat _stat
+#endif
+#ifndef S_ISDIR
+#define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
+#endif
 #endif
-
 
 static int ssl_security_default_callback(const SSL *s, const SSL_CTX *ctx,
-                                         int op, int bits, int nid, void *other,
-                                         void *ex);
+    int op, int bits, int nid, void *other,
+    void *ex);
 
 static CRYPTO_ONCE ssl_x509_store_ctx_once = CRYPTO_ONCE_STATIC_INIT;
 static volatile int ssl_x509_store_ctx_idx = -1;
@@ -48,8 +47,8 @@ static volatile int ssl_x509_store_ctx_idx = -1;
 DEFINE_RUN_ONCE_STATIC(ssl_x509_store_ctx_init)
 {
     ssl_x509_store_ctx_idx = X509_STORE_CTX_get_ex_new_index(0,
-                                                             "SSL for verify callback",
-                                                             NULL, NULL, NULL);
+        "SSL for verify callback",
+        NULL, NULL, NULL);
     return ssl_x509_store_ctx_idx >= 0;
 }
 
@@ -171,22 +170,22 @@ CERT *ssl_cert_dup(CERT *cert)
     /* Configured sigalgs copied across */
     if (cert->conf_sigalgs) {
         ret->conf_sigalgs = OPENSSL_malloc(cert->conf_sigalgslen
-                                           * sizeof(*cert->conf_sigalgs));
+            * sizeof(*cert->conf_sigalgs));
         if (ret->conf_sigalgs == NULL)
             goto err;
         memcpy(ret->conf_sigalgs, cert->conf_sigalgs,
-               cert->conf_sigalgslen * sizeof(*cert->conf_sigalgs));
+            cert->conf_sigalgslen * sizeof(*cert->conf_sigalgs));
         ret->conf_sigalgslen = cert->conf_sigalgslen;
     } else
         ret->conf_sigalgs = NULL;
 
     if (cert->client_sigalgs) {
         ret->client_sigalgs = OPENSSL_malloc(cert->client_sigalgslen
-                                             * sizeof(*cert->client_sigalgs));
+            * sizeof(*cert->client_sigalgs));
         if (ret->client_sigalgs == NULL)
             goto err;
         memcpy(ret->client_sigalgs, cert->client_sigalgs,
-               cert->client_sigalgslen * sizeof(*cert->client_sigalgs));
+            cert->client_sigalgslen * sizeof(*cert->client_sigalgs));
         ret->client_sigalgslen = cert->client_sigalgslen;
     } else
         ret->client_sigalgs = NULL;
@@ -230,7 +229,7 @@ CERT *ssl_cert_dup(CERT *cert)
 #endif
     return ret;
 
- err:
+err:
     ssl_cert_free(ret);
 
     return NULL;
@@ -412,7 +411,7 @@ int ssl_cert_set_current(CERT *c, long op)
     return 0;
 }
 
-void ssl_cert_set_cert_cb(CERT *c, int (*cb) (SSL *ssl, void *arg), void *arg)
+void ssl_cert_set_cert_cb(CERT *c, int (*cb)(SSL *ssl, void *arg), void *arg)
 {
     c->cert_cb = cb;
     c->cert_cb_arg = arg;
@@ -525,7 +524,7 @@ static int ssl_verify_internal(SSL_CONNECTION *s, STACK_OF(X509) *sk, EVP_PKEY *
     /* Move peername from the store context params to the SSL handle's */
     X509_VERIFY_PARAM_move_peername(s->param, param);
 
- end:
+end:
     X509_STORE_CTX_free(ctx);
     return i;
 }
@@ -555,7 +554,7 @@ int ssl_verify_cert_chain(SSL_CONNECTION *s, STACK_OF(X509) *sk)
 }
 
 static void set0_CA_list(STACK_OF(X509_NAME) **ca_list,
-                        STACK_OF(X509_NAME) *name_list)
+    STACK_OF(X509_NAME) *name_list)
 {
     sk_X509_NAME_pop_free(*ca_list, X509_NAME_free);
     *ca_list = name_list;
@@ -580,7 +579,7 @@ STACK_OF(X509_NAME) *SSL_dup_CA_list(const STACK_OF(X509_NAME) *sk)
             sk_X509_NAME_pop_free(ret, X509_NAME_free);
             return NULL;
         }
-        sk_X509_NAME_push(ret, name);   /* Cannot fail after reserve call */
+        sk_X509_NAME_push(ret, name); /* Cannot fail after reserve call */
     }
     return ret;
 }
@@ -747,8 +746,8 @@ static unsigned long xname_hash(const X509_NAME *a)
 }
 
 STACK_OF(X509_NAME) *SSL_load_client_CA_file_ex(const char *file,
-                                                OSSL_LIB_CTX *libctx,
-                                                const char *propq)
+    OSSL_LIB_CTX *libctx,
+    const char *propq)
 {
     BIO *in = BIO_new(BIO_s_file());
     X509 *x = NULL;
@@ -808,11 +807,11 @@ STACK_OF(X509_NAME) *SSL_load_client_CA_file_ex(const char *file,
     }
     goto done;
 
- err:
+err:
     X509_NAME_free(xn);
     sk_X509_NAME_pop_free(ret, X509_NAME_free);
     ret = NULL;
- done:
+done:
     /* restore the old libctx */
     OSSL_LIB_CTX_set0_default(prev_libctx);
     BIO_free(in);
@@ -829,8 +828,8 @@ STACK_OF(X509_NAME) *SSL_load_client_CA_file(const char *file)
 }
 
 static int add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
-                                           const char *file,
-                                           LHASH_OF(X509_NAME) *name_hash)
+    const char *file,
+    LHASH_OF(X509_NAME) *name_hash)
 {
     BIO *in;
     X509 *x = NULL;
@@ -870,16 +869,16 @@ static int add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
     ERR_clear_error();
     goto done;
 
- err:
+err:
     ret = 0;
- done:
+done:
     BIO_free(in);
     X509_free(x);
     return ret;
 }
 
 int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
-                                        const char *file)
+    const char *file)
 {
     X509_NAME *xn = NULL;
     int ret = 1;
@@ -912,15 +911,15 @@ int SSL_add_file_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
     ret = add_file_cert_subjects_to_stack(stack, file, name_hash);
     goto done;
 
- err:
+err:
     ret = 0;
- done:
+done:
     lh_X509_NAME_free(name_hash);
     return ret;
 }
 
 int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
-                                       const char *dir)
+    const char *dir)
 {
     OPENSSL_DIR_CTX *d = NULL;
     const char *filename;
@@ -980,14 +979,14 @@ int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
 
     if (errno) {
         ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                       "calling OPENSSL_dir_read(%s)", dir);
+            "calling OPENSSL_dir_read(%s)", dir);
         ERR_raise(ERR_LIB_SSL, ERR_R_SYS_LIB);
         goto err;
     }
 
     ret = 1;
 
- err:
+err:
     if (d)
         OPENSSL_DIR_end(&d);
     lh_X509_NAME_free(name_hash);
@@ -996,7 +995,7 @@ int SSL_add_dir_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
 }
 
 static int add_uris_recursive(STACK_OF(X509_NAME) *stack,
-                              const char *uri, int depth)
+    const char *uri, int depth)
 {
     int ok = 1;
     OSSL_STORE_CTX *ctx = NULL;
@@ -1021,7 +1020,7 @@ static int add_uris_recursive(STACK_OF(X509_NAME) *stack,
              */
             if (depth > 0)
                 ok = add_uris_recursive(stack, OSSL_STORE_INFO_get0_NAME(info),
-                                        depth - 1);
+                    depth - 1);
         } else if (infotype == OSSL_STORE_INFO_CERT) {
             if ((x = OSSL_STORE_INFO_get0_CERT(info)) == NULL
                 || (xn = X509_get_subject_name(x)) == NULL
@@ -1043,19 +1042,19 @@ static int add_uris_recursive(STACK_OF(X509_NAME) *stack,
     ERR_clear_error();
     goto done;
 
- err:
+err:
     ok = 0;
     OSSL_STORE_INFO_free(info);
- done:
+done:
     OSSL_STORE_close(ctx);
 
     return ok;
 }
 
 int SSL_add_store_cert_subjects_to_stack(STACK_OF(X509_NAME) *stack,
-                                         const char *store)
+    const char *store)
 {
-    int (*oldcmp) (const X509_NAME *const *a, const X509_NAME *const *b)
+    int (*oldcmp)(const X509_NAME *const *a, const X509_NAME *const *b)
         = sk_X509_NAME_set_cmp_func(stack, xname_sk_cmp);
     int ret = add_uris_recursive(stack, store, 1);
 
@@ -1113,7 +1112,7 @@ int ssl_build_cert_chain(SSL_CONNECTION *s, SSL_CTX *ctx, int flags)
     }
     /* Set suite B flags if needed */
     X509_STORE_CTX_set_flags(xs_ctx,
-                             c->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS);
+        c->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS);
 
     i = X509_verify_cert(xs_ctx);
     if (i <= 0 && flags & SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR) {
@@ -1127,7 +1126,7 @@ int ssl_build_cert_chain(SSL_CONNECTION *s, SSL_CTX *ctx, int flags)
     if (i <= 0) {
         i = X509_STORE_CTX_get_error(xs_ctx);
         ERR_raise_data(ERR_LIB_SSL, SSL_R_CERTIFICATE_VERIFY_FAILED,
-                       "Verify error:%s", X509_verify_cert_error_string(i));
+            "Verify error:%s", X509_verify_cert_error_string(i));
 
         goto err;
     }
@@ -1162,7 +1161,7 @@ int ssl_build_cert_chain(SSL_CONNECTION *s, SSL_CTX *ctx, int flags)
     cpk->chain = chain;
     if (rv == 0)
         rv = 1;
- err:
+err:
     if (flags & SSL_BUILD_CHAIN_FLAG_CHECK)
         X509_STORE_free(chain_store);
     X509_STORE_CTX_free(xs_ctx);
@@ -1220,8 +1219,8 @@ int ssl_get_security_level_bits(const SSL *s, const SSL_CTX *ctx, int *levelp)
 }
 
 static int ssl_security_default_callback(const SSL *s, const SSL_CTX *ctx,
-                                         int op, int bits, int nid, void *other,
-                                         void *ex)
+    int op, int bits, int nid, void *other,
+    void *ex)
 {
     int level, minbits, pfs_mask;
     const SSL_CONNECTION *sc;
@@ -1240,28 +1239,26 @@ static int ssl_security_default_callback(const SSL *s, const SSL_CTX *ctx,
     switch (op) {
     case SSL_SECOP_CIPHER_SUPPORTED:
     case SSL_SECOP_CIPHER_SHARED:
-    case SSL_SECOP_CIPHER_CHECK:
-        {
-            const SSL_CIPHER *c = other;
-            /* No ciphers below security level */
-            if (bits < minbits)
-                return 0;
-            /* No unauthenticated ciphersuites */
-            if (c->algorithm_auth & SSL_aNULL)
-                return 0;
-            /* No MD5 mac ciphersuites */
-            if (c->algorithm_mac & SSL_MD5)
-                return 0;
-            /* SHA1 HMAC is 160 bits of security */
-            if (minbits > 160 && c->algorithm_mac & SSL_SHA1)
-                return 0;
-            /* Level 3: forward secure ciphersuites only */
-            pfs_mask = SSL_kDHE | SSL_kECDHE | SSL_kDHEPSK | SSL_kECDHEPSK;
-            if (level >= 3 && c->min_tls != TLS1_3_VERSION &&
-                               !(c->algorithm_mkey & pfs_mask))
-                return 0;
-            break;
-        }
+    case SSL_SECOP_CIPHER_CHECK: {
+        const SSL_CIPHER *c = other;
+        /* No ciphers below security level */
+        if (bits < minbits)
+            return 0;
+        /* No unauthenticated ciphersuites */
+        if (c->algorithm_auth & SSL_aNULL)
+            return 0;
+        /* No MD5 mac ciphersuites */
+        if (c->algorithm_mac & SSL_MD5)
+            return 0;
+        /* SHA1 HMAC is 160 bits of security */
+        if (minbits > 160 && c->algorithm_mac & SSL_SHA1)
+            return 0;
+        /* Level 3: forward secure ciphersuites only */
+        pfs_mask = SSL_kDHE | SSL_kECDHE | SSL_kDHEPSK | SSL_kECDHEPSK;
+        if (level >= 3 && c->min_tls != TLS1_3_VERSION && !(c->algorithm_mkey & pfs_mask))
+            return 0;
+        break;
+    }
     case SSL_SECOP_VERSION:
         if ((sc = SSL_CONNECTION_FROM_CONST_SSL(s)) == NULL)
             return 0;
@@ -1294,13 +1291,13 @@ static int ssl_security_default_callback(const SSL *s, const SSL_CTX *ctx,
 int ssl_security(const SSL_CONNECTION *s, int op, int bits, int nid, void *other)
 {
     return s->cert->sec_cb(SSL_CONNECTION_GET_USER_SSL(s), NULL, op, bits, nid,
-                           other, s->cert->sec_ex);
+        other, s->cert->sec_ex);
 }
 
 int ssl_ctx_security(const SSL_CTX *ctx, int op, int bits, int nid, void *other)
 {
     return ctx->cert->sec_cb(NULL, ctx, op, bits, nid, other,
-                             ctx->cert->sec_ex);
+        ctx->cert->sec_ex);
 }
 
 int ssl_cert_lookup_by_nid(int nid, size_t *pidx, SSL_CTX *ctx)
@@ -1308,13 +1305,13 @@ int ssl_cert_lookup_by_nid(int nid, size_t *pidx, SSL_CTX *ctx)
     size_t i;
 
     for (i = 0; i < OSSL_NELEM(ssl_cert_info); i++) {
-        if (ssl_cert_info[i].nid == nid) {
+        if (ssl_cert_info[i].pkey_nid == nid) {
             *pidx = i;
             return 1;
         }
     }
     for (i = 0; i < ctx->sigalg_list_len; i++) {
-        if (ctx->ssl_cert_info[i].nid == nid) {
+        if (ctx->ssl_cert_info[i].pkey_nid == nid) {
             *pidx = SSL_PKEY_NUM + i;
             return 1;
         }
@@ -1330,8 +1327,8 @@ const SSL_CERT_LOOKUP *ssl_cert_lookup_by_pkey(const EVP_PKEY *pk, size_t *pidx,
     for (i = 0; i < OSSL_NELEM(ssl_cert_info); i++) {
         const SSL_CERT_LOOKUP *tmp_lu = &ssl_cert_info[i];
 
-        if (EVP_PKEY_is_a(pk, OBJ_nid2sn(tmp_lu->nid))
-            || EVP_PKEY_is_a(pk, OBJ_nid2ln(tmp_lu->nid))) {
+        if (EVP_PKEY_is_a(pk, OBJ_nid2sn(tmp_lu->pkey_nid))
+            || EVP_PKEY_is_a(pk, OBJ_nid2ln(tmp_lu->pkey_nid))) {
             if (pidx != NULL)
                 *pidx = i;
             return tmp_lu;
@@ -1341,8 +1338,8 @@ const SSL_CERT_LOOKUP *ssl_cert_lookup_by_pkey(const EVP_PKEY *pk, size_t *pidx,
     for (i = 0; i < ctx->sigalg_list_len; i++) {
         SSL_CERT_LOOKUP *tmp_lu = &(ctx->ssl_cert_info[i]);
 
-        if (EVP_PKEY_is_a(pk, OBJ_nid2sn(tmp_lu->nid))
-            || EVP_PKEY_is_a(pk, OBJ_nid2ln(tmp_lu->nid))) {
+        if (EVP_PKEY_is_a(pk, OBJ_nid2sn(tmp_lu->pkey_nid))
+            || EVP_PKEY_is_a(pk, OBJ_nid2ln(tmp_lu->pkey_nid))) {
             if (pidx != NULL)
                 *pidx = SSL_PKEY_NUM + i;
             return &ctx->ssl_cert_info[i];
diff --git a/crypto/openssl/ssl/ssl_cert_comp.c b/crypto/openssl/ssl/ssl_cert_comp.c
index 018fcc14a569..a59b79811b8c 100644
--- a/crypto/openssl/ssl/ssl_cert_comp.c
+++ b/crypto/openssl/ssl/ssl_cert_comp.c
@@ -63,9 +63,9 @@ static OSSL_COMP_CERT *OSSL_COMP_CERT_new(unsigned char *data, size_t len, size_
     OSSL_COMP_CERT *ret = NULL;
 
     if (!ossl_comp_has_alg(alg)
-            || data == NULL
-            || (ret = OPENSSL_zalloc(sizeof(*ret))) == NULL
-            || !CRYPTO_NEW_REF(&ret->references, 1))
+        || data == NULL
+        || (ret = OPENSSL_zalloc(sizeof(*ret))) == NULL
+        || !CRYPTO_NEW_REF(&ret->references, 1))
         goto err;
 
     ret->data = data;
@@ -73,7 +73,7 @@ static OSSL_COMP_CERT *OSSL_COMP_CERT_new(unsigned char *data, size_t len, size_
     ret->orig_len = orig_len;
     ret->alg = alg;
     return ret;
- err:
+err:
     ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
     OPENSSL_free(data);
     OPENSSL_free(ret);
@@ -81,13 +81,13 @@ static OSSL_COMP_CERT *OSSL_COMP_CERT_new(unsigned char *data, size_t len, size_
 }
 
 __owur static OSSL_COMP_CERT *OSSL_COMP_CERT_from_compressed_data(unsigned char *data, size_t len,
-                                                                  size_t orig_len, int alg)
+    size_t orig_len, int alg)
 {
     return OSSL_COMP_CERT_new(OPENSSL_memdup(data, len), len, orig_len, alg);
 }
 
 __owur static OSSL_COMP_CERT *OSSL_COMP_CERT_from_uncompressed_data(unsigned char *data, size_t len,
-                                                                    int alg)
+    int alg)
 {
     OSSL_COMP_CERT *ret = NULL;
     size_t max_length;
@@ -111,9 +111,9 @@ __owur static OSSL_COMP_CERT *OSSL_COMP_CERT_from_uncompressed_data(unsigned cha
     }
 
     if ((max_length = ossl_calculate_comp_expansion(alg, len)) == 0
-          || method == NULL
-          || (comp_ctx = COMP_CTX_new(method)) == NULL
-          || (comp_data = OPENSSL_zalloc(max_length)) == NULL)
+        || method == NULL
+        || (comp_ctx = COMP_CTX_new(method)) == NULL
+        || (comp_data = OPENSSL_zalloc(max_length)) == NULL)
         goto err;
 
     comp_length = COMP_compress_block(comp_ctx, comp_data, max_length, data, len);
@@ -123,7 +123,7 @@ __owur static OSSL_COMP_CERT *OSSL_COMP_CERT_from_uncompressed_data(unsigned cha
     ret = OSSL_COMP_CERT_new(comp_data, comp_length, len, alg);
     comp_data = NULL;
 
- err:
+err:
     OPENSSL_free(comp_data);
     COMP_CTX_free(comp_ctx);
     return ret;
@@ -200,9 +200,9 @@ static size_t ssl_get_cert_to_compress(SSL *ssl, CERT_PKEY *cpk, unsigned char *
     size_t ret = 0;
 
     if (sc == NULL
-            || cpk == NULL
-            || !sc->server
-            || !SSL_in_before(ssl))
+        || cpk == NULL
+        || !sc->server
+        || !SSL_in_before(ssl))
         return 0;
 
     /* Use the |tmppkt| for the to-be-compressed data */
@@ -221,7 +221,7 @@ static size_t ssl_get_cert_to_compress(SSL *ssl, CERT_PKEY *cpk, unsigned char *
         goto out;
     WPACKET_get_total_written(&tmppkt, &ret);
 
- out:
+out:
     WPACKET_cleanup(&tmppkt);
     if (ret != 0 && data != NULL)
         *data = (unsigned char *)buf.data;
@@ -237,8 +237,8 @@ static int ssl_compress_one_cert(SSL *ssl, CERT_PKEY *cpk, int alg)
     size_t length;
 
     if (cpk == NULL
-            || alg == TLSEXT_comp_cert_none
-            || !ossl_comp_has_alg(alg))
+        || alg == TLSEXT_comp_cert_none
+        || !ossl_comp_has_alg(alg))
         return 0;
 
     if ((length = ssl_get_cert_to_compress(ssl, cpk, &cert_data)) == 0)
@@ -263,8 +263,8 @@ static int ssl_compress_certs(SSL *ssl, CERT_PKEY *cpks, int alg_in)
     int count = 0;
 
     if (sc == NULL
-            || cpks == NULL
-            || !ossl_comp_has_alg(alg_in))
+        || cpks == NULL
+        || !ossl_comp_has_alg(alg_in))
         return 0;
 
     /* Look through the preferences to see what we have */
@@ -275,7 +275,7 @@ static int ssl_compress_certs(SSL *ssl, CERT_PKEY *cpks, int alg_in)
          */
         alg = sc->cert_comp_prefs[i];
         if ((alg_in == 0 && alg != TLSEXT_comp_cert_none)
-                || (alg_in != 0 && alg == alg_in)) {
+            || (alg_in != 0 && alg == alg_in)) {
 
             for (j = 0; j < SSL_PKEY_NUM; j++) {
                 /* No cert, move on */
@@ -299,7 +299,7 @@ static int ssl_compress_certs(SSL *ssl, CERT_PKEY *cpks, int alg_in)
 }
 
 static size_t ssl_get_compressed_cert(SSL *ssl, CERT_PKEY *cpk, int alg, unsigned char **data,
-                                      size_t *orig_len)
+    size_t *orig_len)
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
     size_t cert_len = 0;
@@ -308,12 +308,12 @@ static size_t ssl_get_compressed_cert(SSL *ssl, CERT_PKEY *cpk, int alg, unsigne
     OSSL_COMP_CERT *comp_cert = NULL;
 
     if (sc == NULL
-            || cpk == NULL
-            || data == NULL
-            || orig_len == NULL
-            || !sc->server
-            || !SSL_in_before(ssl)
-            || !ossl_comp_has_alg(alg))
+        || cpk == NULL
+        || data == NULL
+        || orig_len == NULL
+        || !sc->server
+        || !SSL_in_before(ssl)
+        || !ossl_comp_has_alg(alg))
         return 0;
 
     if ((cert_len = ssl_get_cert_to_compress(ssl, cpk, &cert_data)) == 0)
@@ -328,14 +328,14 @@ static size_t ssl_get_compressed_cert(SSL *ssl, CERT_PKEY *cpk, int alg, unsigne
     *orig_len = comp_cert->orig_len;
     *data = comp_cert->data;
     comp_cert->data = NULL;
- err:
+err:
     OSSL_COMP_CERT_free(comp_cert);
     return comp_len;
 }
 
 static int ossl_set1_compressed_cert(CERT *cert, int algorithm,
-                                     unsigned char *comp_data, size_t comp_length,
-                                     size_t orig_length)
+    unsigned char *comp_data, size_t comp_length,
+    size_t orig_length)
 {
     OSSL_COMP_CERT *comp_cert;
 
@@ -344,7 +344,7 @@ static int ossl_set1_compressed_cert(CERT *cert, int algorithm,
         return 0;
 
     comp_cert = OSSL_COMP_CERT_from_compressed_data(comp_data, comp_length,
-                                                    orig_length, algorithm);
+        orig_length, algorithm);
     if (comp_cert == NULL)
         return 0;
 
@@ -438,12 +438,12 @@ size_t SSL_CTX_get1_compressed_cert(SSL_CTX *ctx, int alg, unsigned char **data,
     SSL_free(new);
     return ret;
 #else
-        return 0;
+    return 0;
 #endif
 }
 
 int SSL_CTX_set1_compressed_cert(SSL_CTX *ctx, int algorithm, unsigned char *comp_data,
-                                 size_t comp_length, size_t orig_length)
+    size_t comp_length, size_t orig_length)
 {
 #ifndef OPENSSL_NO_COMP_ALG
     return ossl_set1_compressed_cert(ctx->cert, algorithm, comp_data, comp_length, orig_length);
@@ -453,7 +453,7 @@ int SSL_CTX_set1_compressed_cert(SSL_CTX *ctx, int algorithm, unsigned char *com
 }
 
 int SSL_set1_compressed_cert(SSL *ssl, int algorithm, unsigned char *comp_data,
-                             size_t comp_length, size_t orig_length)
+    size_t comp_length, size_t orig_length)
 {
 #ifndef OPENSSL_NO_COMP_ALG
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
diff --git a/crypto/openssl/ssl/ssl_cert_table.h b/crypto/openssl/ssl/ssl_cert_table.h
index e4dc8063b1fc..f7fc9844c97e 100644
--- a/crypto/openssl/ssl/ssl_cert_table.h
+++ b/crypto/openssl/ssl/ssl_cert_table.h
@@ -10,14 +10,14 @@
 /*
  * Certificate table information. NB: table entries must match SSL_PKEY indices
  */
-static const SSL_CERT_LOOKUP ssl_cert_info [] = {
-    {EVP_PKEY_RSA, SSL_aRSA}, /* SSL_PKEY_RSA */
-    {EVP_PKEY_RSA_PSS, SSL_aRSA}, /* SSL_PKEY_RSA_PSS_SIGN */
-    {EVP_PKEY_DSA, SSL_aDSS}, /* SSL_PKEY_DSA_SIGN */
-    {EVP_PKEY_EC, SSL_aECDSA}, /* SSL_PKEY_ECC */
-    {NID_id_GostR3410_2001, SSL_aGOST01}, /* SSL_PKEY_GOST01 */
-    {NID_id_GostR3410_2012_256, SSL_aGOST12}, /* SSL_PKEY_GOST12_256 */
-    {NID_id_GostR3410_2012_512, SSL_aGOST12}, /* SSL_PKEY_GOST12_512 */
-    {EVP_PKEY_ED25519, SSL_aECDSA}, /* SSL_PKEY_ED25519 */
-    {EVP_PKEY_ED448, SSL_aECDSA} /* SSL_PKEY_ED448 */
+static const SSL_CERT_LOOKUP ssl_cert_info[] = {
+    { EVP_PKEY_RSA, SSL_aRSA }, /* SSL_PKEY_RSA */
+    { EVP_PKEY_RSA_PSS, SSL_aRSA }, /* SSL_PKEY_RSA_PSS_SIGN */
+    { EVP_PKEY_DSA, SSL_aDSS }, /* SSL_PKEY_DSA_SIGN */
+    { EVP_PKEY_EC, SSL_aECDSA }, /* SSL_PKEY_ECC */
+    { NID_id_GostR3410_2001, SSL_aGOST01 }, /* SSL_PKEY_GOST01 */
+    { NID_id_GostR3410_2012_256, SSL_aGOST12 }, /* SSL_PKEY_GOST12_256 */
+    { NID_id_GostR3410_2012_512, SSL_aGOST12 }, /* SSL_PKEY_GOST12_512 */
+    { EVP_PKEY_ED25519, SSL_aECDSA }, /* SSL_PKEY_ED25519 */
+    { EVP_PKEY_ED448, SSL_aECDSA } /* SSL_PKEY_ED448 */
 };
diff --git a/crypto/openssl/ssl/ssl_ciph.c b/crypto/openssl/ssl/ssl_ciph.c
index 6127cb7a4b48..7dccec626065 100644
--- a/crypto/openssl/ssl/ssl_ciph.c
+++ b/crypto/openssl/ssl/ssl_ciph.c
@@ -33,81 +33,81 @@ typedef struct {
 
 /* Table of NIDs for each cipher */
 static const ssl_cipher_table ssl_cipher_table_cipher[SSL_ENC_NUM_IDX] = {
-    {SSL_DES, NID_des_cbc},     /* SSL_ENC_DES_IDX 0 */
-    {SSL_3DES, NID_des_ede3_cbc}, /* SSL_ENC_3DES_IDX 1 */
-    {SSL_RC4, NID_rc4},         /* SSL_ENC_RC4_IDX 2 */
-    {SSL_RC2, NID_rc2_cbc},     /* SSL_ENC_RC2_IDX 3 */
-    {SSL_IDEA, NID_idea_cbc},   /* SSL_ENC_IDEA_IDX 4 */
-    {SSL_eNULL, NID_undef},     /* SSL_ENC_NULL_IDX 5 */
-    {SSL_AES128, NID_aes_128_cbc}, /* SSL_ENC_AES128_IDX 6 */
-    {SSL_AES256, NID_aes_256_cbc}, /* SSL_ENC_AES256_IDX 7 */
-    {SSL_CAMELLIA128, NID_camellia_128_cbc}, /* SSL_ENC_CAMELLIA128_IDX 8 */
-    {SSL_CAMELLIA256, NID_camellia_256_cbc}, /* SSL_ENC_CAMELLIA256_IDX 9 */
-    {SSL_eGOST2814789CNT, NID_gost89_cnt}, /* SSL_ENC_GOST89_IDX 10 */
-    {SSL_SEED, NID_seed_cbc},   /* SSL_ENC_SEED_IDX 11 */
-    {SSL_AES128GCM, NID_aes_128_gcm}, /* SSL_ENC_AES128GCM_IDX 12 */
-    {SSL_AES256GCM, NID_aes_256_gcm}, /* SSL_ENC_AES256GCM_IDX 13 */
-    {SSL_AES128CCM, NID_aes_128_ccm}, /* SSL_ENC_AES128CCM_IDX 14 */
-    {SSL_AES256CCM, NID_aes_256_ccm}, /* SSL_ENC_AES256CCM_IDX 15 */
-    {SSL_AES128CCM8, NID_aes_128_ccm}, /* SSL_ENC_AES128CCM8_IDX 16 */
-    {SSL_AES256CCM8, NID_aes_256_ccm}, /* SSL_ENC_AES256CCM8_IDX 17 */
-    {SSL_eGOST2814789CNT12, NID_gost89_cnt_12}, /* SSL_ENC_GOST8912_IDX 18 */
-    {SSL_CHACHA20POLY1305, NID_chacha20_poly1305}, /* SSL_ENC_CHACHA_IDX 19 */
-    {SSL_ARIA128GCM, NID_aria_128_gcm}, /* SSL_ENC_ARIA128GCM_IDX 20 */
-    {SSL_ARIA256GCM, NID_aria_256_gcm}, /* SSL_ENC_ARIA256GCM_IDX 21 */
-    {SSL_MAGMA, NID_magma_ctr_acpkm}, /* SSL_ENC_MAGMA_IDX */
-    {SSL_KUZNYECHIK, NID_kuznyechik_ctr_acpkm}, /* SSL_ENC_KUZNYECHIK_IDX */
+    { SSL_DES, NID_des_cbc }, /* SSL_ENC_DES_IDX 0 */
+    { SSL_3DES, NID_des_ede3_cbc }, /* SSL_ENC_3DES_IDX 1 */
+    { SSL_RC4, NID_rc4 }, /* SSL_ENC_RC4_IDX 2 */
+    { SSL_RC2, NID_rc2_cbc }, /* SSL_ENC_RC2_IDX 3 */
+    { SSL_IDEA, NID_idea_cbc }, /* SSL_ENC_IDEA_IDX 4 */
+    { SSL_eNULL, NID_undef }, /* SSL_ENC_NULL_IDX 5 */
+    { SSL_AES128, NID_aes_128_cbc }, /* SSL_ENC_AES128_IDX 6 */
+    { SSL_AES256, NID_aes_256_cbc }, /* SSL_ENC_AES256_IDX 7 */
+    { SSL_CAMELLIA128, NID_camellia_128_cbc }, /* SSL_ENC_CAMELLIA128_IDX 8 */
+    { SSL_CAMELLIA256, NID_camellia_256_cbc }, /* SSL_ENC_CAMELLIA256_IDX 9 */
+    { SSL_eGOST2814789CNT, NID_gost89_cnt }, /* SSL_ENC_GOST89_IDX 10 */
+    { SSL_SEED, NID_seed_cbc }, /* SSL_ENC_SEED_IDX 11 */
+    { SSL_AES128GCM, NID_aes_128_gcm }, /* SSL_ENC_AES128GCM_IDX 12 */
+    { SSL_AES256GCM, NID_aes_256_gcm }, /* SSL_ENC_AES256GCM_IDX 13 */
+    { SSL_AES128CCM, NID_aes_128_ccm }, /* SSL_ENC_AES128CCM_IDX 14 */
+    { SSL_AES256CCM, NID_aes_256_ccm }, /* SSL_ENC_AES256CCM_IDX 15 */
+    { SSL_AES128CCM8, NID_aes_128_ccm }, /* SSL_ENC_AES128CCM8_IDX 16 */
+    { SSL_AES256CCM8, NID_aes_256_ccm }, /* SSL_ENC_AES256CCM8_IDX 17 */
+    { SSL_eGOST2814789CNT12, NID_gost89_cnt_12 }, /* SSL_ENC_GOST8912_IDX 18 */
+    { SSL_CHACHA20POLY1305, NID_chacha20_poly1305 }, /* SSL_ENC_CHACHA_IDX 19 */
+    { SSL_ARIA128GCM, NID_aria_128_gcm }, /* SSL_ENC_ARIA128GCM_IDX 20 */
+    { SSL_ARIA256GCM, NID_aria_256_gcm }, /* SSL_ENC_ARIA256GCM_IDX 21 */
+    { SSL_MAGMA, NID_magma_ctr_acpkm }, /* SSL_ENC_MAGMA_IDX */
+    { SSL_KUZNYECHIK, NID_kuznyechik_ctr_acpkm }, /* SSL_ENC_KUZNYECHIK_IDX */
 };
 
 /* NB: make sure indices in this table matches values above */
 static const ssl_cipher_table ssl_cipher_table_mac[SSL_MD_NUM_IDX] = {
-    {SSL_MD5, NID_md5},         /* SSL_MD_MD5_IDX 0 */
-    {SSL_SHA1, NID_sha1},       /* SSL_MD_SHA1_IDX 1 */
-    {SSL_GOST94, NID_id_GostR3411_94}, /* SSL_MD_GOST94_IDX 2 */
-    {SSL_GOST89MAC, NID_id_Gost28147_89_MAC}, /* SSL_MD_GOST89MAC_IDX 3 */
-    {SSL_SHA256, NID_sha256},   /* SSL_MD_SHA256_IDX 4 */
-    {SSL_SHA384, NID_sha384},   /* SSL_MD_SHA384_IDX 5 */
-    {SSL_GOST12_256, NID_id_GostR3411_2012_256}, /* SSL_MD_GOST12_256_IDX 6 */
-    {SSL_GOST89MAC12, NID_gost_mac_12}, /* SSL_MD_GOST89MAC12_IDX 7 */
-    {SSL_GOST12_512, NID_id_GostR3411_2012_512}, /* SSL_MD_GOST12_512_IDX 8 */
-    {0, NID_md5_sha1},          /* SSL_MD_MD5_SHA1_IDX 9 */
-    {0, NID_sha224},            /* SSL_MD_SHA224_IDX 10 */
-    {0, NID_sha512},            /* SSL_MD_SHA512_IDX 11 */
-    {SSL_MAGMAOMAC, NID_magma_mac}, /* sSL_MD_MAGMAOMAC_IDX */
-    {SSL_KUZNYECHIKOMAC, NID_kuznyechik_mac} /* SSL_MD_KUZNYECHIKOMAC_IDX */
+    { SSL_MD5, NID_md5 }, /* SSL_MD_MD5_IDX 0 */
+    { SSL_SHA1, NID_sha1 }, /* SSL_MD_SHA1_IDX 1 */
+    { SSL_GOST94, NID_id_GostR3411_94 }, /* SSL_MD_GOST94_IDX 2 */
+    { SSL_GOST89MAC, NID_id_Gost28147_89_MAC }, /* SSL_MD_GOST89MAC_IDX 3 */
+    { SSL_SHA256, NID_sha256 }, /* SSL_MD_SHA256_IDX 4 */
+    { SSL_SHA384, NID_sha384 }, /* SSL_MD_SHA384_IDX 5 */
+    { SSL_GOST12_256, NID_id_GostR3411_2012_256 }, /* SSL_MD_GOST12_256_IDX 6 */
+    { SSL_GOST89MAC12, NID_gost_mac_12 }, /* SSL_MD_GOST89MAC12_IDX 7 */
+    { SSL_GOST12_512, NID_id_GostR3411_2012_512 }, /* SSL_MD_GOST12_512_IDX 8 */
+    { 0, NID_md5_sha1 }, /* SSL_MD_MD5_SHA1_IDX 9 */
+    { 0, NID_sha224 }, /* SSL_MD_SHA224_IDX 10 */
+    { 0, NID_sha512 }, /* SSL_MD_SHA512_IDX 11 */
+    { SSL_MAGMAOMAC, NID_magma_mac }, /* sSL_MD_MAGMAOMAC_IDX */
+    { SSL_KUZNYECHIKOMAC, NID_kuznyechik_mac } /* SSL_MD_KUZNYECHIKOMAC_IDX */
 };
 
 /* *INDENT-OFF* */
 static const ssl_cipher_table ssl_cipher_table_kx[] = {
-    {SSL_kRSA,      NID_kx_rsa},
-    {SSL_kECDHE,    NID_kx_ecdhe},
-    {SSL_kDHE,      NID_kx_dhe},
-    {SSL_kECDHEPSK, NID_kx_ecdhe_psk},
-    {SSL_kDHEPSK,   NID_kx_dhe_psk},
-    {SSL_kRSAPSK,   NID_kx_rsa_psk},
-    {SSL_kPSK,      NID_kx_psk},
-    {SSL_kSRP,      NID_kx_srp},
-    {SSL_kGOST,     NID_kx_gost},
-    {SSL_kGOST18,   NID_kx_gost18},
-    {SSL_kANY,      NID_kx_any}
+    { SSL_kRSA, NID_kx_rsa },
+    { SSL_kECDHE, NID_kx_ecdhe },
+    { SSL_kDHE, NID_kx_dhe },
+    { SSL_kECDHEPSK, NID_kx_ecdhe_psk },
+    { SSL_kDHEPSK, NID_kx_dhe_psk },
+    { SSL_kRSAPSK, NID_kx_rsa_psk },
+    { SSL_kPSK, NID_kx_psk },
+    { SSL_kSRP, NID_kx_srp },
+    { SSL_kGOST, NID_kx_gost },
+    { SSL_kGOST18, NID_kx_gost18 },
+    { SSL_kANY, NID_kx_any }
 };
 
 static const ssl_cipher_table ssl_cipher_table_auth[] = {
-    {SSL_aRSA,    NID_auth_rsa},
-    {SSL_aECDSA,  NID_auth_ecdsa},
-    {SSL_aPSK,    NID_auth_psk},
-    {SSL_aDSS,    NID_auth_dss},
-    {SSL_aGOST01, NID_auth_gost01},
-    {SSL_aGOST12, NID_auth_gost12},
-    {SSL_aSRP,    NID_auth_srp},
-    {SSL_aNULL,   NID_auth_null},
-    {SSL_aANY,    NID_auth_any}
+    { SSL_aRSA, NID_auth_rsa },
+    { SSL_aECDSA, NID_auth_ecdsa },
+    { SSL_aPSK, NID_auth_psk },
+    { SSL_aDSS, NID_auth_dss },
+    { SSL_aGOST01, NID_auth_gost01 },
+    { SSL_aGOST12, NID_auth_gost12 },
+    { SSL_aSRP, NID_auth_srp },
+    { SSL_aNULL, NID_auth_null },
+    { SSL_aANY, NID_auth_any }
 };
 /* *INDENT-ON* */
 
 /* Utility function for table lookup */
 static int ssl_cipher_info_find(const ssl_cipher_table *table,
-                                size_t table_cnt, uint32_t mask)
+    size_t table_cnt, uint32_t mask)
 {
     size_t i;
     for (i = 0; i < table_cnt; i++, table++) {
@@ -136,16 +136,16 @@ static const int default_mac_pkey_id[SSL_MD_NUM_IDX] = {
     NID_undef, NID_undef, NID_undef, NID_undef, NID_undef
 };
 
-#define CIPHER_ADD      1
-#define CIPHER_KILL     2
-#define CIPHER_DEL      3
-#define CIPHER_ORD      4
-#define CIPHER_SPECIAL  5
+#define CIPHER_ADD 1
+#define CIPHER_KILL 2
+#define CIPHER_DEL 3
+#define CIPHER_ORD 4
+#define CIPHER_SPECIAL 5
 /*
  * Bump the ciphers to the top of the list.
  * This rule isn't currently supported by the public cipherstring API.
  */
-#define CIPHER_BUMP     6
+#define CIPHER_BUMP 6
 
 typedef struct cipher_order_st {
     const SSL_CIPHER *cipher;
@@ -156,122 +156,122 @@ typedef struct cipher_order_st {
 
 static const SSL_CIPHER cipher_aliases[] = {
     /* "ALL" doesn't include eNULL (must be specifically enabled) */
-    {0, SSL_TXT_ALL, NULL, 0, 0, 0, ~SSL_eNULL},
+    { 0, SSL_TXT_ALL, NULL, 0, 0, 0, ~SSL_eNULL },
     /* "COMPLEMENTOFALL" */
-    {0, SSL_TXT_CMPALL, NULL, 0, 0, 0, SSL_eNULL},
+    { 0, SSL_TXT_CMPALL, NULL, 0, 0, 0, SSL_eNULL },
 
     /*
      * "COMPLEMENTOFDEFAULT" (does *not* include ciphersuites not found in
      * ALL!)
      */
-    {0, SSL_TXT_CMPDEF, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_NOT_DEFAULT},
+    { 0, SSL_TXT_CMPDEF, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_NOT_DEFAULT },
 
     /*
      * key exchange aliases (some of those using only a single bit here
      * combine multiple key exchange algs according to the RFCs, e.g. kDHE
      * combines DHE_DSS and DHE_RSA)
      */
-    {0, SSL_TXT_kRSA, NULL, 0, SSL_kRSA},
+    { 0, SSL_TXT_kRSA, NULL, 0, SSL_kRSA },
 
-    {0, SSL_TXT_kEDH, NULL, 0, SSL_kDHE},
-    {0, SSL_TXT_kDHE, NULL, 0, SSL_kDHE},
-    {0, SSL_TXT_DH, NULL, 0, SSL_kDHE},
+    { 0, SSL_TXT_kEDH, NULL, 0, SSL_kDHE },
+    { 0, SSL_TXT_kDHE, NULL, 0, SSL_kDHE },
+    { 0, SSL_TXT_DH, NULL, 0, SSL_kDHE },
 
-    {0, SSL_TXT_kEECDH, NULL, 0, SSL_kECDHE},
-    {0, SSL_TXT_kECDHE, NULL, 0, SSL_kECDHE},
-    {0, SSL_TXT_ECDH, NULL, 0, SSL_kECDHE},
+    { 0, SSL_TXT_kEECDH, NULL, 0, SSL_kECDHE },
+    { 0, SSL_TXT_kECDHE, NULL, 0, SSL_kECDHE },
+    { 0, SSL_TXT_ECDH, NULL, 0, SSL_kECDHE },
 
-    {0, SSL_TXT_kPSK, NULL, 0, SSL_kPSK},
-    {0, SSL_TXT_kRSAPSK, NULL, 0, SSL_kRSAPSK},
-    {0, SSL_TXT_kECDHEPSK, NULL, 0, SSL_kECDHEPSK},
-    {0, SSL_TXT_kDHEPSK, NULL, 0, SSL_kDHEPSK},
-    {0, SSL_TXT_kSRP, NULL, 0, SSL_kSRP},
-    {0, SSL_TXT_kGOST, NULL, 0, SSL_kGOST},
-    {0, SSL_TXT_kGOST18, NULL, 0, SSL_kGOST18},
+    { 0, SSL_TXT_kPSK, NULL, 0, SSL_kPSK },
+    { 0, SSL_TXT_kRSAPSK, NULL, 0, SSL_kRSAPSK },
+    { 0, SSL_TXT_kECDHEPSK, NULL, 0, SSL_kECDHEPSK },
+    { 0, SSL_TXT_kDHEPSK, NULL, 0, SSL_kDHEPSK },
+    { 0, SSL_TXT_kSRP, NULL, 0, SSL_kSRP },
+    { 0, SSL_TXT_kGOST, NULL, 0, SSL_kGOST },
+    { 0, SSL_TXT_kGOST18, NULL, 0, SSL_kGOST18 },
 
     /* server authentication aliases */
-    {0, SSL_TXT_aRSA, NULL, 0, 0, SSL_aRSA},
-    {0, SSL_TXT_aDSS, NULL, 0, 0, SSL_aDSS},
-    {0, SSL_TXT_DSS, NULL, 0, 0, SSL_aDSS},
-    {0, SSL_TXT_aNULL, NULL, 0, 0, SSL_aNULL},
-    {0, SSL_TXT_aECDSA, NULL, 0, 0, SSL_aECDSA},
-    {0, SSL_TXT_ECDSA, NULL, 0, 0, SSL_aECDSA},
-    {0, SSL_TXT_aPSK, NULL, 0, 0, SSL_aPSK},
-    {0, SSL_TXT_aGOST01, NULL, 0, 0, SSL_aGOST01},
-    {0, SSL_TXT_aGOST12, NULL, 0, 0, SSL_aGOST12},
-    {0, SSL_TXT_aGOST, NULL, 0, 0, SSL_aGOST01 | SSL_aGOST12},
-    {0, SSL_TXT_aSRP, NULL, 0, 0, SSL_aSRP},
+    { 0, SSL_TXT_aRSA, NULL, 0, 0, SSL_aRSA },
+    { 0, SSL_TXT_aDSS, NULL, 0, 0, SSL_aDSS },
+    { 0, SSL_TXT_DSS, NULL, 0, 0, SSL_aDSS },
+    { 0, SSL_TXT_aNULL, NULL, 0, 0, SSL_aNULL },
+    { 0, SSL_TXT_aECDSA, NULL, 0, 0, SSL_aECDSA },
+    { 0, SSL_TXT_ECDSA, NULL, 0, 0, SSL_aECDSA },
+    { 0, SSL_TXT_aPSK, NULL, 0, 0, SSL_aPSK },
+    { 0, SSL_TXT_aGOST01, NULL, 0, 0, SSL_aGOST01 },
+    { 0, SSL_TXT_aGOST12, NULL, 0, 0, SSL_aGOST12 },
+    { 0, SSL_TXT_aGOST, NULL, 0, 0, SSL_aGOST01 | SSL_aGOST12 },
+    { 0, SSL_TXT_aSRP, NULL, 0, 0, SSL_aSRP },
 
     /* aliases combining key exchange and server authentication */
-    {0, SSL_TXT_EDH, NULL, 0, SSL_kDHE, ~SSL_aNULL},
-    {0, SSL_TXT_DHE, NULL, 0, SSL_kDHE, ~SSL_aNULL},
-    {0, SSL_TXT_EECDH, NULL, 0, SSL_kECDHE, ~SSL_aNULL},
-    {0, SSL_TXT_ECDHE, NULL, 0, SSL_kECDHE, ~SSL_aNULL},
-    {0, SSL_TXT_NULL, NULL, 0, 0, 0, SSL_eNULL},
-    {0, SSL_TXT_RSA, NULL, 0, SSL_kRSA, SSL_aRSA},
-    {0, SSL_TXT_ADH, NULL, 0, SSL_kDHE, SSL_aNULL},
-    {0, SSL_TXT_AECDH, NULL, 0, SSL_kECDHE, SSL_aNULL},
-    {0, SSL_TXT_PSK, NULL, 0, SSL_PSK},
-    {0, SSL_TXT_SRP, NULL, 0, SSL_kSRP},
+    { 0, SSL_TXT_EDH, NULL, 0, SSL_kDHE, ~SSL_aNULL },
+    { 0, SSL_TXT_DHE, NULL, 0, SSL_kDHE, ~SSL_aNULL },
+    { 0, SSL_TXT_EECDH, NULL, 0, SSL_kECDHE, ~SSL_aNULL },
+    { 0, SSL_TXT_ECDHE, NULL, 0, SSL_kECDHE, ~SSL_aNULL },
+    { 0, SSL_TXT_NULL, NULL, 0, 0, 0, SSL_eNULL },
+    { 0, SSL_TXT_RSA, NULL, 0, SSL_kRSA, SSL_aRSA },
+    { 0, SSL_TXT_ADH, NULL, 0, SSL_kDHE, SSL_aNULL },
+    { 0, SSL_TXT_AECDH, NULL, 0, SSL_kECDHE, SSL_aNULL },
+    { 0, SSL_TXT_PSK, NULL, 0, SSL_PSK },
+    { 0, SSL_TXT_SRP, NULL, 0, SSL_kSRP },
 
     /* symmetric encryption aliases */
-    {0, SSL_TXT_3DES, NULL, 0, 0, 0, SSL_3DES},
-    {0, SSL_TXT_RC4, NULL, 0, 0, 0, SSL_RC4},
-    {0, SSL_TXT_RC2, NULL, 0, 0, 0, SSL_RC2},
-    {0, SSL_TXT_IDEA, NULL, 0, 0, 0, SSL_IDEA},
-    {0, SSL_TXT_SEED, NULL, 0, 0, 0, SSL_SEED},
-    {0, SSL_TXT_eNULL, NULL, 0, 0, 0, SSL_eNULL},
-    {0, SSL_TXT_GOST, NULL, 0, 0, 0,
-     SSL_eGOST2814789CNT | SSL_eGOST2814789CNT12 | SSL_MAGMA | SSL_KUZNYECHIK},
-    {0, SSL_TXT_AES128, NULL, 0, 0, 0,
-     SSL_AES128 | SSL_AES128GCM | SSL_AES128CCM | SSL_AES128CCM8},
-    {0, SSL_TXT_AES256, NULL, 0, 0, 0,
-     SSL_AES256 | SSL_AES256GCM | SSL_AES256CCM | SSL_AES256CCM8},
-    {0, SSL_TXT_AES, NULL, 0, 0, 0, SSL_AES},
-    {0, SSL_TXT_AES_GCM, NULL, 0, 0, 0, SSL_AES128GCM | SSL_AES256GCM},
-    {0, SSL_TXT_AES_CCM, NULL, 0, 0, 0,
-     SSL_AES128CCM | SSL_AES256CCM | SSL_AES128CCM8 | SSL_AES256CCM8},
-    {0, SSL_TXT_AES_CCM_8, NULL, 0, 0, 0, SSL_AES128CCM8 | SSL_AES256CCM8},
-    {0, SSL_TXT_CAMELLIA128, NULL, 0, 0, 0, SSL_CAMELLIA128},
-    {0, SSL_TXT_CAMELLIA256, NULL, 0, 0, 0, SSL_CAMELLIA256},
-    {0, SSL_TXT_CAMELLIA, NULL, 0, 0, 0, SSL_CAMELLIA},
-    {0, SSL_TXT_CHACHA20, NULL, 0, 0, 0, SSL_CHACHA20},
-    {0, SSL_TXT_GOST2012_GOST8912_GOST8912, NULL, 0, 0, 0, SSL_eGOST2814789CNT12},
+    { 0, SSL_TXT_3DES, NULL, 0, 0, 0, SSL_3DES },
+    { 0, SSL_TXT_RC4, NULL, 0, 0, 0, SSL_RC4 },
+    { 0, SSL_TXT_RC2, NULL, 0, 0, 0, SSL_RC2 },
+    { 0, SSL_TXT_IDEA, NULL, 0, 0, 0, SSL_IDEA },
+    { 0, SSL_TXT_SEED, NULL, 0, 0, 0, SSL_SEED },
+    { 0, SSL_TXT_eNULL, NULL, 0, 0, 0, SSL_eNULL },
+    { 0, SSL_TXT_GOST, NULL, 0, 0, 0,
+        SSL_eGOST2814789CNT | SSL_eGOST2814789CNT12 | SSL_MAGMA | SSL_KUZNYECHIK },
+    { 0, SSL_TXT_AES128, NULL, 0, 0, 0,
+        SSL_AES128 | SSL_AES128GCM | SSL_AES128CCM | SSL_AES128CCM8 },
+    { 0, SSL_TXT_AES256, NULL, 0, 0, 0,
+        SSL_AES256 | SSL_AES256GCM | SSL_AES256CCM | SSL_AES256CCM8 },
+    { 0, SSL_TXT_AES, NULL, 0, 0, 0, SSL_AES },
+    { 0, SSL_TXT_AES_GCM, NULL, 0, 0, 0, SSL_AES128GCM | SSL_AES256GCM },
+    { 0, SSL_TXT_AES_CCM, NULL, 0, 0, 0,
+        SSL_AES128CCM | SSL_AES256CCM | SSL_AES128CCM8 | SSL_AES256CCM8 },
+    { 0, SSL_TXT_AES_CCM_8, NULL, 0, 0, 0, SSL_AES128CCM8 | SSL_AES256CCM8 },
+    { 0, SSL_TXT_CAMELLIA128, NULL, 0, 0, 0, SSL_CAMELLIA128 },
+    { 0, SSL_TXT_CAMELLIA256, NULL, 0, 0, 0, SSL_CAMELLIA256 },
+    { 0, SSL_TXT_CAMELLIA, NULL, 0, 0, 0, SSL_CAMELLIA },
+    { 0, SSL_TXT_CHACHA20, NULL, 0, 0, 0, SSL_CHACHA20 },
+    { 0, SSL_TXT_GOST2012_GOST8912_GOST8912, NULL, 0, 0, 0, SSL_eGOST2814789CNT12 },
 
-    {0, SSL_TXT_ARIA, NULL, 0, 0, 0, SSL_ARIA},
-    {0, SSL_TXT_ARIA_GCM, NULL, 0, 0, 0, SSL_ARIA128GCM | SSL_ARIA256GCM},
-    {0, SSL_TXT_ARIA128, NULL, 0, 0, 0, SSL_ARIA128GCM},
-    {0, SSL_TXT_ARIA256, NULL, 0, 0, 0, SSL_ARIA256GCM},
-    {0, SSL_TXT_CBC, NULL, 0, 0, 0, SSL_CBC},
+    { 0, SSL_TXT_ARIA, NULL, 0, 0, 0, SSL_ARIA },
+    { 0, SSL_TXT_ARIA_GCM, NULL, 0, 0, 0, SSL_ARIA128GCM | SSL_ARIA256GCM },
+    { 0, SSL_TXT_ARIA128, NULL, 0, 0, 0, SSL_ARIA128GCM },
+    { 0, SSL_TXT_ARIA256, NULL, 0, 0, 0, SSL_ARIA256GCM },
+    { 0, SSL_TXT_CBC, NULL, 0, 0, 0, SSL_CBC },
 
     /* MAC aliases */
-    {0, SSL_TXT_MD5, NULL, 0, 0, 0, 0, SSL_MD5},
-    {0, SSL_TXT_SHA1, NULL, 0, 0, 0, 0, SSL_SHA1},
-    {0, SSL_TXT_SHA, NULL, 0, 0, 0, 0, SSL_SHA1},
-    {0, SSL_TXT_GOST94, NULL, 0, 0, 0, 0, SSL_GOST94},
-    {0, SSL_TXT_GOST89MAC, NULL, 0, 0, 0, 0, SSL_GOST89MAC | SSL_GOST89MAC12},
-    {0, SSL_TXT_SHA256, NULL, 0, 0, 0, 0, SSL_SHA256},
-    {0, SSL_TXT_SHA384, NULL, 0, 0, 0, 0, SSL_SHA384},
-    {0, SSL_TXT_GOST12, NULL, 0, 0, 0, 0, SSL_GOST12_256},
+    { 0, SSL_TXT_MD5, NULL, 0, 0, 0, 0, SSL_MD5 },
+    { 0, SSL_TXT_SHA1, NULL, 0, 0, 0, 0, SSL_SHA1 },
+    { 0, SSL_TXT_SHA, NULL, 0, 0, 0, 0, SSL_SHA1 },
+    { 0, SSL_TXT_GOST94, NULL, 0, 0, 0, 0, SSL_GOST94 },
+    { 0, SSL_TXT_GOST89MAC, NULL, 0, 0, 0, 0, SSL_GOST89MAC | SSL_GOST89MAC12 },
+    { 0, SSL_TXT_SHA256, NULL, 0, 0, 0, 0, SSL_SHA256 },
+    { 0, SSL_TXT_SHA384, NULL, 0, 0, 0, 0, SSL_SHA384 },
+    { 0, SSL_TXT_GOST12, NULL, 0, 0, 0, 0, SSL_GOST12_256 },
 
     /* protocol version aliases */
-    {0, SSL_TXT_SSLV3, NULL, 0, 0, 0, 0, 0, SSL3_VERSION},
-    {0, SSL_TXT_TLSV1, NULL, 0, 0, 0, 0, 0, TLS1_VERSION},
-    {0, "TLSv1.0", NULL, 0, 0, 0, 0, 0, TLS1_VERSION},
-    {0, SSL_TXT_TLSV1_2, NULL, 0, 0, 0, 0, 0, TLS1_2_VERSION},
+    { 0, SSL_TXT_SSLV3, NULL, 0, 0, 0, 0, 0, SSL3_VERSION },
+    { 0, SSL_TXT_TLSV1, NULL, 0, 0, 0, 0, 0, TLS1_VERSION },
+    { 0, "TLSv1.0", NULL, 0, 0, 0, 0, 0, TLS1_VERSION },
+    { 0, SSL_TXT_TLSV1_2, NULL, 0, 0, 0, 0, 0, TLS1_2_VERSION },
 
     /* strength classes */
-    {0, SSL_TXT_LOW, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_LOW},
-    {0, SSL_TXT_MEDIUM, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_MEDIUM},
-    {0, SSL_TXT_HIGH, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_HIGH},
+    { 0, SSL_TXT_LOW, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_LOW },
+    { 0, SSL_TXT_MEDIUM, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_MEDIUM },
+    { 0, SSL_TXT_HIGH, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, SSL_HIGH },
     /* FIPS 140-2 approved ciphersuite */
-    {0, SSL_TXT_FIPS, NULL, 0, 0, 0, ~SSL_eNULL, 0, 0, 0, 0, 0, SSL_FIPS},
+    { 0, SSL_TXT_FIPS, NULL, 0, 0, 0, ~SSL_eNULL, 0, 0, 0, 0, 0, SSL_FIPS },
 
     /* "EDH-" aliases to "DHE-" labels (for backward compatibility) */
-    {0, SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA, NULL, 0,
-     SSL_kDHE, SSL_aDSS, SSL_3DES, SSL_SHA1, 0, 0, 0, 0, SSL_HIGH | SSL_FIPS},
-    {0, SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA, NULL, 0,
-     SSL_kDHE, SSL_aRSA, SSL_3DES, SSL_SHA1, 0, 0, 0, 0, SSL_HIGH | SSL_FIPS},
+    { 0, SSL3_TXT_EDH_DSS_DES_192_CBC3_SHA, NULL, 0,
+        SSL_kDHE, SSL_aDSS, SSL_3DES, SSL_SHA1, 0, 0, 0, 0, SSL_HIGH | SSL_FIPS },
+    { 0, SSL3_TXT_EDH_RSA_DES_192_CBC3_SHA, NULL, 0,
+        SSL_kDHE, SSL_aRSA, SSL_3DES, SSL_SHA1, 0, 0, 0, 0, SSL_HIGH | SSL_FIPS },
 
 };
 
@@ -286,8 +286,7 @@ static int get_optional_pkey_id(const char *pkey_name)
     const EVP_PKEY_ASN1_METHOD *ameth;
     int pkey_id = 0;
     ameth = EVP_PKEY_asn1_find_str(NULL, pkey_name, -1);
-    if (ameth && EVP_PKEY_asn1_get0_info(&pkey_id, NULL, NULL, NULL, NULL,
-                                         ameth) > 0)
+    if (ameth && EVP_PKEY_asn1_get0_info(&pkey_id, NULL, NULL, NULL, NULL, ameth) > 0)
         return pkey_id;
     return 0;
 }
@@ -302,7 +301,8 @@ static int get_optional_pkey_id(const char *pkey_name)
     ameth = EVP_PKEY_asn1_find_str(&tmpeng, pkey_name, -1);
     if (ameth) {
         if (EVP_PKEY_asn1_get0_info(&pkey_id, NULL, NULL, NULL, NULL,
-                                    ameth) <= 0)
+                ameth)
+            <= 0)
             pkey_id = 0;
     }
     tls_engine_finish(tmpeng);
@@ -389,31 +389,27 @@ int ssl_load_ciphers(SSL_CTX *ctx)
      * present, disable appropriate auth and key exchange
      */
     memcpy(ctx->ssl_mac_pkey_id, default_mac_pkey_id,
-           sizeof(ctx->ssl_mac_pkey_id));
+        sizeof(ctx->ssl_mac_pkey_id));
 
-    ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC_IDX] =
-        get_optional_pkey_id(SN_id_Gost28147_89_MAC);
+    ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC_IDX] = get_optional_pkey_id(SN_id_Gost28147_89_MAC);
     if (ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC_IDX])
         ctx->ssl_mac_secret_size[SSL_MD_GOST89MAC_IDX] = 32;
     else
         ctx->disabled_mac_mask |= SSL_GOST89MAC;
 
-    ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC12_IDX] =
-        get_optional_pkey_id(SN_gost_mac_12);
+    ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC12_IDX] = get_optional_pkey_id(SN_gost_mac_12);
     if (ctx->ssl_mac_pkey_id[SSL_MD_GOST89MAC12_IDX])
         ctx->ssl_mac_secret_size[SSL_MD_GOST89MAC12_IDX] = 32;
     else
         ctx->disabled_mac_mask |= SSL_GOST89MAC12;
 
-    ctx->ssl_mac_pkey_id[SSL_MD_MAGMAOMAC_IDX] =
-        get_optional_pkey_id(SN_magma_mac);
+    ctx->ssl_mac_pkey_id[SSL_MD_MAGMAOMAC_IDX] = get_optional_pkey_id(SN_magma_mac);
     if (ctx->ssl_mac_pkey_id[SSL_MD_MAGMAOMAC_IDX])
         ctx->ssl_mac_secret_size[SSL_MD_MAGMAOMAC_IDX] = 32;
     else
         ctx->disabled_mac_mask |= SSL_MAGMAOMAC;
 
-    ctx->ssl_mac_pkey_id[SSL_MD_KUZNYECHIKOMAC_IDX] =
-        get_optional_pkey_id(SN_kuznyechik_mac);
+    ctx->ssl_mac_pkey_id[SSL_MD_KUZNYECHIKOMAC_IDX] = get_optional_pkey_id(SN_kuznyechik_mac);
     if (ctx->ssl_mac_pkey_id[SSL_MD_KUZNYECHIKOMAC_IDX])
         ctx->ssl_mac_secret_size[SSL_MD_KUZNYECHIKOMAC_IDX] = 32;
     else
@@ -428,21 +424,20 @@ int ssl_load_ciphers(SSL_CTX *ctx)
     /*
      * Disable GOST key exchange if no GOST signature algs are available *
      */
-    if ((ctx->disabled_auth_mask & (SSL_aGOST01 | SSL_aGOST12)) ==
-        (SSL_aGOST01 | SSL_aGOST12))
+    if ((ctx->disabled_auth_mask & (SSL_aGOST01 | SSL_aGOST12)) == (SSL_aGOST01 | SSL_aGOST12))
         ctx->disabled_mkey_mask |= SSL_kGOST;
 
-    if ((ctx->disabled_auth_mask & SSL_aGOST12) ==  SSL_aGOST12)
+    if ((ctx->disabled_auth_mask & SSL_aGOST12) == SSL_aGOST12)
         ctx->disabled_mkey_mask |= SSL_kGOST18;
 
     return 1;
 }
 
 int ssl_cipher_get_evp_cipher(SSL_CTX *ctx, const SSL_CIPHER *sslc,
-                              const EVP_CIPHER **enc)
+    const EVP_CIPHER **enc)
 {
     int i = ssl_cipher_info_lookup(ssl_cipher_table_cipher,
-                                   sslc->algorithm_enc);
+        sslc->algorithm_enc);
 
     if (i == -1) {
         *enc = NULL;
@@ -460,7 +455,7 @@ int ssl_cipher_get_evp_cipher(SSL_CTX *ctx, const SSL_CIPHER *sslc,
             const EVP_CIPHER *cipher = ctx->ssl_cipher_methods[i];
 
             if (cipher == NULL
-                    || !ssl_evp_cipher_up_ref(cipher))
+                || !ssl_evp_cipher_up_ref(cipher))
                 return 0;
             *enc = ctx->ssl_cipher_methods[i];
         }
@@ -469,8 +464,8 @@ int ssl_cipher_get_evp_cipher(SSL_CTX *ctx, const SSL_CIPHER *sslc,
 }
 
 int ssl_cipher_get_evp_md_mac(SSL_CTX *ctx, const SSL_CIPHER *sslc,
-                              const EVP_MD **md,
-                              int *mac_pkey_type, size_t *mac_secret_size)
+    const EVP_MD **md,
+    int *mac_pkey_type, size_t *mac_secret_size)
 {
     int i = ssl_cipher_info_lookup(ssl_cipher_table_mac, sslc->algorithm_mac);
 
@@ -483,7 +478,7 @@ int ssl_cipher_get_evp_md_mac(SSL_CTX *ctx, const SSL_CIPHER *sslc,
     } else {
         const EVP_MD *digest = ctx->ssl_digest_methods[i];
 
-        if (digest == NULL || !ssl_evp_md_up_ref(digest)) 
+        if (digest == NULL || !ssl_evp_md_up_ref(digest))
             return 0;
 
         *md = digest;
@@ -496,9 +491,9 @@ int ssl_cipher_get_evp_md_mac(SSL_CTX *ctx, const SSL_CIPHER *sslc,
 }
 
 int ssl_cipher_get_evp(SSL_CTX *ctx, const SSL_SESSION *s,
-                       const EVP_CIPHER **enc, const EVP_MD **md,
-                       int *mac_pkey_type, size_t *mac_secret_size,
-                       SSL_COMP **comp, int use_etm)
+    const EVP_CIPHER **enc, const EVP_MD **md,
+    int *mac_pkey_type, size_t *mac_secret_size,
+    SSL_COMP **comp, int use_etm)
 {
     int i;
     const SSL_CIPHER *c;
@@ -530,7 +525,7 @@ int ssl_cipher_get_evp(SSL_CTX *ctx, const SSL_SESSION *s,
         return 0;
 
     if (!ssl_cipher_get_evp_md_mac(ctx, c, md, mac_pkey_type,
-                                   mac_secret_size)) {
+            mac_secret_size)) {
         ssl_evp_cipher_free(*enc);
         return 0;
     }
@@ -543,34 +538,34 @@ int ssl_cipher_get_evp(SSL_CTX *ctx, const SSL_SESSION *s,
         const EVP_CIPHER *evp = NULL;
 
         if (use_etm
-                || s->ssl_version >> 8 != TLS1_VERSION_MAJOR
-                || s->ssl_version < TLS1_VERSION)
+            || s->ssl_version >> 8 != TLS1_VERSION_MAJOR
+            || s->ssl_version < TLS1_VERSION)
             return 1;
 
         if (c->algorithm_enc == SSL_RC4
-                && c->algorithm_mac == SSL_MD5)
+            && c->algorithm_mac == SSL_MD5)
             evp = ssl_evp_cipher_fetch(ctx->libctx, NID_rc4_hmac_md5,
-                                       ctx->propq);
+                ctx->propq);
         else if (c->algorithm_enc == SSL_AES128
-                    && c->algorithm_mac == SSL_SHA1)
+            && c->algorithm_mac == SSL_SHA1)
             evp = ssl_evp_cipher_fetch(ctx->libctx,
-                                       NID_aes_128_cbc_hmac_sha1,
-                                       ctx->propq);
+                NID_aes_128_cbc_hmac_sha1,
+                ctx->propq);
         else if (c->algorithm_enc == SSL_AES256
-                    && c->algorithm_mac == SSL_SHA1)
-             evp = ssl_evp_cipher_fetch(ctx->libctx,
-                                        NID_aes_256_cbc_hmac_sha1,
-                                        ctx->propq);
+            && c->algorithm_mac == SSL_SHA1)
+            evp = ssl_evp_cipher_fetch(ctx->libctx,
+                NID_aes_256_cbc_hmac_sha1,
+                ctx->propq);
         else if (c->algorithm_enc == SSL_AES128
-                    && c->algorithm_mac == SSL_SHA256)
+            && c->algorithm_mac == SSL_SHA256)
             evp = ssl_evp_cipher_fetch(ctx->libctx,
-                                       NID_aes_128_cbc_hmac_sha256,
-                                       ctx->propq);
+                NID_aes_128_cbc_hmac_sha256,
+                ctx->propq);
         else if (c->algorithm_enc == SSL_AES256
-                    && c->algorithm_mac == SSL_SHA256)
+            && c->algorithm_mac == SSL_SHA256)
             evp = ssl_evp_cipher_fetch(ctx->libctx,
-                                       NID_aes_256_cbc_hmac_sha256,
-                                       ctx->propq);
+                NID_aes_256_cbc_hmac_sha256,
+                ctx->propq);
 
         if (evp != NULL) {
             ssl_evp_cipher_free(*enc);
@@ -600,15 +595,14 @@ const EVP_MD *ssl_handshake_md(SSL_CONNECTION *s)
 const EVP_MD *ssl_prf_md(SSL_CONNECTION *s)
 {
     return ssl_md(SSL_CONNECTION_GET_CTX(s),
-                  ssl_get_algorithm2(s) >> TLS1_PRF_DGST_SHIFT);
+        ssl_get_algorithm2(s) >> TLS1_PRF_DGST_SHIFT);
 }
 
-
 #define ITEM_SEP(a) \
-        (((a) == ':') || ((a) == ' ') || ((a) == ';') || ((a) == ','))
+    (((a) == ':') || ((a) == ' ') || ((a) == ';') || ((a) == ','))
 
 static void ll_append_tail(CIPHER_ORDER **head, CIPHER_ORDER *curr,
-                           CIPHER_ORDER **tail)
+    CIPHER_ORDER **tail)
 {
     if (curr == *tail)
         return;
@@ -625,7 +619,7 @@ static void ll_append_tail(CIPHER_ORDER **head, CIPHER_ORDER *curr,
 }
 
 static void ll_append_head(CIPHER_ORDER **head, CIPHER_ORDER *curr,
-                           CIPHER_ORDER **tail)
+    CIPHER_ORDER **tail)
 {
     if (curr == *head)
         return;
@@ -642,14 +636,14 @@ static void ll_append_head(CIPHER_ORDER **head, CIPHER_ORDER *curr,
 }
 
 static void ssl_cipher_collect_ciphers(const SSL_METHOD *ssl_method,
-                                       int num_of_ciphers,
-                                       uint32_t disabled_mkey,
-                                       uint32_t disabled_auth,
-                                       uint32_t disabled_enc,
-                                       uint32_t disabled_mac,
-                                       CIPHER_ORDER *co_list,
-                                       CIPHER_ORDER **head_p,
-                                       CIPHER_ORDER **tail_p)
+    int num_of_ciphers,
+    uint32_t disabled_mkey,
+    uint32_t disabled_auth,
+    uint32_t disabled_enc,
+    uint32_t disabled_mac,
+    CIPHER_ORDER *co_list,
+    CIPHER_ORDER **head_p,
+    CIPHER_ORDER **tail_p)
 {
     int i, co_list_num;
     const SSL_CIPHER *c;
@@ -662,22 +656,17 @@ static void ssl_cipher_collect_ciphers(const SSL_METHOD *ssl_method,
      */
 
     /* Get the initial list of ciphers */
-    co_list_num = 0;            /* actual count of ciphers */
+    co_list_num = 0; /* actual count of ciphers */
     for (i = 0; i < num_of_ciphers; i++) {
         c = ssl_method->get_cipher(i);
         /* drop those that use any of that is not available */
         if (c == NULL || !c->valid)
             continue;
-        if ((c->algorithm_mkey & disabled_mkey) ||
-            (c->algorithm_auth & disabled_auth) ||
-            (c->algorithm_enc & disabled_enc) ||
-            (c->algorithm_mac & disabled_mac))
+        if ((c->algorithm_mkey & disabled_mkey) || (c->algorithm_auth & disabled_auth) || (c->algorithm_enc & disabled_enc) || (c->algorithm_mac & disabled_mac))
             continue;
-        if (((ssl_method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS) == 0) &&
-            c->min_tls == 0)
+        if (((ssl_method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS) == 0) && c->min_tls == 0)
             continue;
-        if (((ssl_method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS) != 0) &&
-            c->min_dtls == 0)
+        if (((ssl_method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS) != 0) && c->min_dtls == 0)
             continue;
 
         co_list[co_list_num].cipher = c;
@@ -712,12 +701,12 @@ static void ssl_cipher_collect_ciphers(const SSL_METHOD *ssl_method,
 }
 
 static void ssl_cipher_collect_aliases(const SSL_CIPHER **ca_list,
-                                       int num_of_group_aliases,
-                                       uint32_t disabled_mkey,
-                                       uint32_t disabled_auth,
-                                       uint32_t disabled_enc,
-                                       uint32_t disabled_mac,
-                                       CIPHER_ORDER *head)
+    int num_of_group_aliases,
+    uint32_t disabled_mkey,
+    uint32_t disabled_auth,
+    uint32_t disabled_enc,
+    uint32_t disabled_mac,
+    CIPHER_ORDER *head)
 {
     CIPHER_ORDER *ciph_curr;
     const SSL_CIPHER **ca_curr;
@@ -770,31 +759,32 @@ static void ssl_cipher_collect_aliases(const SSL_CIPHER **ca_list,
         ca_curr++;
     }
 
-    *ca_curr = NULL;            /* end of list */
+    *ca_curr = NULL; /* end of list */
 }
 
 static void ssl_cipher_apply_rule(uint32_t cipher_id, uint32_t alg_mkey,
-                                  uint32_t alg_auth, uint32_t alg_enc,
-                                  uint32_t alg_mac, int min_tls,
-                                  uint32_t algo_strength, int rule,
-                                  int32_t strength_bits, CIPHER_ORDER **head_p,
-                                  CIPHER_ORDER **tail_p)
+    uint32_t alg_auth, uint32_t alg_enc,
+    uint32_t alg_mac, int min_tls,
+    uint32_t algo_strength, int rule,
+    int32_t strength_bits, CIPHER_ORDER **head_p,
+    CIPHER_ORDER **tail_p)
 {
     CIPHER_ORDER *head, *tail, *curr, *next, *last;
     const SSL_CIPHER *cp;
     int reverse = 0;
 
-    OSSL_TRACE_BEGIN(TLS_CIPHER) {
+    OSSL_TRACE_BEGIN(TLS_CIPHER)
+    {
         BIO_printf(trc_out,
-                   "Applying rule %d with %08x/%08x/%08x/%08x/%08x %08x (%d)\n",
-                   rule, (unsigned int)alg_mkey, (unsigned int)alg_auth,
-                   (unsigned int)alg_enc, (unsigned int)alg_mac, min_tls,
-                   (unsigned int)algo_strength, (int)strength_bits);
+            "Applying rule %d with %08x/%08x/%08x/%08x/%08x %08x (%d)\n",
+            rule, (unsigned int)alg_mkey, (unsigned int)alg_auth,
+            (unsigned int)alg_enc, (unsigned int)alg_mac, min_tls,
+            (unsigned int)algo_strength, (int)strength_bits);
     }
 
     if (rule == CIPHER_DEL || rule == CIPHER_BUMP)
-        reverse = 1;            /* needed to maintain sorting between currently
-                                 * deleted ciphers */
+        reverse = 1; /* needed to maintain sorting between currently
+                      * deleted ciphers */
 
     head = *head_p;
     tail = *tail_p;
@@ -831,15 +821,15 @@ static void ssl_cipher_apply_rule(uint32_t cipher_id, uint32_t alg_mkey,
         } else {
             if (trc_out != NULL) {
                 BIO_printf(trc_out,
-                           "\nName: %s:"
-                           "\nAlgo = %08x/%08x/%08x/%08x/%08x Algo_strength = %08x\n",
-                           cp->name,
-                           (unsigned int)cp->algorithm_mkey,
-                           (unsigned int)cp->algorithm_auth,
-                           (unsigned int)cp->algorithm_enc,
-                           (unsigned int)cp->algorithm_mac,
-                           cp->min_tls,
-                           (unsigned int)cp->algo_strength);
+                    "\nName: %s:"
+                    "\nAlgo = %08x/%08x/%08x/%08x/%08x Algo_strength = %08x\n",
+                    cp->name,
+                    (unsigned int)cp->algorithm_mkey,
+                    (unsigned int)cp->algorithm_auth,
+                    (unsigned int)cp->algorithm_enc,
+                    (unsigned int)cp->algorithm_mac,
+                    cp->min_tls,
+                    (unsigned int)cp->algo_strength);
             }
             if (cipher_id != 0 && (cipher_id != cp->id))
                 continue;
@@ -917,7 +907,7 @@ static void ssl_cipher_apply_rule(uint32_t cipher_id, uint32_t alg_mkey,
 }
 
 static int ssl_cipher_strength_sort(CIPHER_ORDER **head_p,
-                                    CIPHER_ORDER **tail_p)
+    CIPHER_ORDER **tail_p)
 {
     int32_t max_strength_bits;
     int i, *number_uses;
@@ -956,16 +946,16 @@ static int ssl_cipher_strength_sort(CIPHER_ORDER **head_p,
     for (i = max_strength_bits; i >= 0; i--)
         if (number_uses[i] > 0)
             ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_ORD, i, head_p,
-                                  tail_p);
+                tail_p);
 
     OPENSSL_free(number_uses);
     return 1;
 }
 
 static int ssl_cipher_process_rulestr(const char *rule_str,
-                                      CIPHER_ORDER **head_p,
-                                      CIPHER_ORDER **tail_p,
-                                      const SSL_CIPHER **ca_list, CERT *c)
+    CIPHER_ORDER **head_p,
+    CIPHER_ORDER **tail_p,
+    const SSL_CIPHER **ca_list, CERT *c)
 {
     uint32_t alg_mkey, alg_auth, alg_enc, alg_mac, algo_strength;
     int min_tls;
@@ -980,7 +970,7 @@ static int ssl_cipher_process_rulestr(const char *rule_str,
         ch = *l;
 
         if (ch == '\0')
-            break;              /* done */
+            break; /* done */
         if (ch == '-') {
             rule = CIPHER_DEL;
             l++;
@@ -1014,13 +1004,10 @@ static int ssl_cipher_process_rulestr(const char *rule_str,
             buf = l;
             buflen = 0;
 #ifndef CHARSET_EBCDIC
-            while (((ch >= 'A') && (ch <= 'Z')) ||
-                   ((ch >= '0') && (ch <= '9')) ||
-                   ((ch >= 'a') && (ch <= 'z')) ||
-                   (ch == '-') || (ch == '_') || (ch == '.') || (ch == '='))
+            while (((ch >= 'A') && (ch <= 'Z')) || ((ch >= '0') && (ch <= '9')) || ((ch >= 'a') && (ch <= 'z')) || (ch == '-') || (ch == '_') || (ch == '.') || (ch == '='))
 #else
             while (isalnum((unsigned char)ch) || (ch == '-') || (ch == '_') || (ch == '.')
-                   || (ch == '='))
+                || (ch == '='))
 #endif
             {
                 ch = *(++l);
@@ -1038,8 +1025,8 @@ static int ssl_cipher_process_rulestr(const char *rule_str,
             }
 
             if (rule == CIPHER_SPECIAL) {
-                found = 0;      /* unused -- avoid compiler warning */
-                break;          /* special treatment */
+                found = 0; /* unused -- avoid compiler warning */
+                break; /* special treatment */
             }
 
             /* check for multi-part specification */
@@ -1069,8 +1056,8 @@ static int ssl_cipher_process_rulestr(const char *rule_str,
                     found = 1;
                     break;
                 } else if (ca_list[j]->stdname != NULL
-                           && strncmp(buf, ca_list[j]->stdname, buflen) == 0
-                           && ca_list[j]->stdname[buflen] == '\0') {
+                    && strncmp(buf, ca_list[j]->stdname, buflen) == 0
+                    && ca_list[j]->stdname[buflen] == '\0') {
                     found = 1;
                     break;
                 } else
@@ -1078,7 +1065,7 @@ static int ssl_cipher_process_rulestr(const char *rule_str,
             }
 
             if (!found)
-                break;          /* ignore this entry */
+                break; /* ignore this entry */
 
             if (ca_list[j]->algorithm_mkey) {
                 if (alg_mkey) {
@@ -1130,9 +1117,7 @@ static int ssl_cipher_process_rulestr(const char *rule_str,
 
             if (ca_list[j]->algo_strength & SSL_STRONG_MASK) {
                 if (algo_strength & SSL_STRONG_MASK) {
-                    algo_strength &=
-                        (ca_list[j]->algo_strength & SSL_STRONG_MASK) |
-                        ~SSL_STRONG_MASK;
+                    algo_strength &= (ca_list[j]->algo_strength & SSL_STRONG_MASK) | ~SSL_STRONG_MASK;
                     if (!(algo_strength & SSL_STRONG_MASK)) {
                         found = 0;
                         break;
@@ -1144,16 +1129,13 @@ static int ssl_cipher_process_rulestr(const char *rule_str,
 
             if (ca_list[j]->algo_strength & SSL_DEFAULT_MASK) {
                 if (algo_strength & SSL_DEFAULT_MASK) {
-                    algo_strength &=
-                        (ca_list[j]->algo_strength & SSL_DEFAULT_MASK) |
-                        ~SSL_DEFAULT_MASK;
+                    algo_strength &= (ca_list[j]->algo_strength & SSL_DEFAULT_MASK) | ~SSL_DEFAULT_MASK;
                     if (!(algo_strength & SSL_DEFAULT_MASK)) {
                         found = 0;
                         break;
                     }
                 } else {
-                    algo_strength |=
-                        ca_list[j]->algo_strength & SSL_DEFAULT_MASK;
+                    algo_strength |= ca_list[j]->algo_strength & SSL_DEFAULT_MASK;
                 }
             }
 
@@ -1214,22 +1196,22 @@ static int ssl_cipher_process_rulestr(const char *rule_str,
                 l++;
         } else if (found) {
             ssl_cipher_apply_rule(cipher_id,
-                                  alg_mkey, alg_auth, alg_enc, alg_mac,
-                                  min_tls, algo_strength, rule, -1, head_p,
-                                  tail_p);
+                alg_mkey, alg_auth, alg_enc, alg_mac,
+                min_tls, algo_strength, rule, -1, head_p,
+                tail_p);
         } else {
             while ((*l != '\0') && !ITEM_SEP(*l))
                 l++;
         }
         if (*l == '\0')
-            break;              /* done */
+            break; /* done */
     }
 
     return retval;
 }
 
 static int check_suiteb_cipher_list(const SSL_METHOD *meth, CERT *c,
-                                    const char **prule_str)
+    const char **prule_str)
 {
     unsigned int suiteb_flags = 0, suiteb_comb2 = 0;
     if (HAS_PREFIX(*prule_str, "SUITEB128ONLY")) {
@@ -1264,8 +1246,7 @@ static int check_suiteb_cipher_list(const SSL_METHOD *meth, CERT *c,
         if (suiteb_comb2)
             *prule_str = "ECDHE-ECDSA-AES256-GCM-SHA384";
         else
-            *prule_str =
-                "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384";
+            *prule_str = "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384";
         break;
     case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY:
         *prule_str = "ECDHE-ECDSA-AES128-GCM-SHA256";
@@ -1313,8 +1294,8 @@ static __owur int set_ciphersuites(STACK_OF(SSL_CIPHER) **currciphers, const cha
 
     /* Parse the list. We explicitly allow an empty list */
     if (*str != '\0'
-            && (CONF_parse_list(str, ':', 1, ciphersuite_cb, newciphers) <= 0
-                || sk_SSL_CIPHER_num(newciphers) == 0)) {
+        && (CONF_parse_list(str, ':', 1, ciphersuite_cb, newciphers) <= 0
+            || sk_SSL_CIPHER_num(newciphers) == 0)) {
         ERR_raise(ERR_LIB_SSL, SSL_R_NO_CIPHER_MATCH);
         sk_SSL_CIPHER_free(newciphers);
         return 0;
@@ -1326,7 +1307,7 @@ static __owur int set_ciphersuites(STACK_OF(SSL_CIPHER) **currciphers, const cha
 }
 
 static int update_cipher_list_by_id(STACK_OF(SSL_CIPHER) **cipher_list_by_id,
-                                    STACK_OF(SSL_CIPHER) *cipherstack)
+    STACK_OF(SSL_CIPHER) *cipherstack)
 {
     STACK_OF(SSL_CIPHER) *tmp_cipher_list = sk_SSL_CIPHER_dup(cipherstack);
 
@@ -1344,9 +1325,9 @@ static int update_cipher_list_by_id(STACK_OF(SSL_CIPHER) **cipher_list_by_id,
 }
 
 static int update_cipher_list(SSL_CTX *ctx,
-                              STACK_OF(SSL_CIPHER) **cipher_list,
-                              STACK_OF(SSL_CIPHER) **cipher_list_by_id,
-                              STACK_OF(SSL_CIPHER) *tls13_ciphersuites)
+    STACK_OF(SSL_CIPHER) **cipher_list,
+    STACK_OF(SSL_CIPHER) **cipher_list_by_id,
+    STACK_OF(SSL_CIPHER) *tls13_ciphersuites)
 {
     int i;
     STACK_OF(SSL_CIPHER) *tmp_cipher_list = sk_SSL_CIPHER_dup(*cipher_list);
@@ -1359,8 +1340,8 @@ static int update_cipher_list(SSL_CTX *ctx,
      * list.
      */
     while (sk_SSL_CIPHER_num(tmp_cipher_list) > 0
-           && sk_SSL_CIPHER_value(tmp_cipher_list, 0)->min_tls
-              == TLS1_3_VERSION)
+        && sk_SSL_CIPHER_value(tmp_cipher_list, 0)->min_tls
+            == TLS1_3_VERSION)
         (void)sk_SSL_CIPHER_delete(tmp_cipher_list, 0);
 
     /* Insert the new TLSv1.3 ciphersuites */
@@ -1369,9 +1350,11 @@ static int update_cipher_list(SSL_CTX *ctx,
 
         /* Don't include any TLSv1.3 ciphersuites that are disabled */
         if ((sslc->algorithm_enc & ctx->disabled_enc_mask) == 0
-                && (ssl_cipher_table_mac[sslc->algorithm2
-                                         & SSL_HANDSHAKE_MAC_MASK].mask
-                    & ctx->disabled_mac_mask) == 0) {
+            && (ssl_cipher_table_mac[sslc->algorithm2
+                    & SSL_HANDSHAKE_MAC_MASK]
+                       .mask
+                   & ctx->disabled_mac_mask)
+                == 0) {
             sk_SSL_CIPHER_unshift(tmp_cipher_list, sslc);
         }
     }
@@ -1393,7 +1376,7 @@ int SSL_CTX_set_ciphersuites(SSL_CTX *ctx, const char *str)
 
     if (ret && ctx->cipher_list != NULL)
         return update_cipher_list(ctx, &ctx->cipher_list, &ctx->cipher_list_by_id,
-                                  ctx->tls13_ciphersuites);
+            ctx->tls13_ciphersuites);
 
     return ret;
 }
@@ -1415,18 +1398,18 @@ int SSL_set_ciphersuites(SSL *s, const char *str)
     }
     if (ret && sc->cipher_list != NULL)
         return update_cipher_list(s->ctx, &sc->cipher_list,
-                                  &sc->cipher_list_by_id,
-                                  sc->tls13_ciphersuites);
+            &sc->cipher_list_by_id,
+            sc->tls13_ciphersuites);
 
     return ret;
 }
 
 STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx,
-                                             STACK_OF(SSL_CIPHER) *tls13_ciphersuites,
-                                             STACK_OF(SSL_CIPHER) **cipher_list,
-                                             STACK_OF(SSL_CIPHER) **cipher_list_by_id,
-                                             const char *rule_str,
-                                             CERT *c)
+    STACK_OF(SSL_CIPHER) *tls13_ciphersuites,
+    STACK_OF(SSL_CIPHER) **cipher_list,
+    STACK_OF(SSL_CIPHER) **cipher_list_by_id,
+    const char *rule_str,
+    CERT *c)
 {
     int ok, num_of_ciphers, num_of_alias_max, num_of_group_aliases, i;
     uint32_t disabled_mkey, disabled_auth, disabled_enc, disabled_mac;
@@ -1465,12 +1448,12 @@ STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx,
     if (num_of_ciphers > 0) {
         co_list = OPENSSL_malloc(sizeof(*co_list) * num_of_ciphers);
         if (co_list == NULL)
-            return NULL;          /* Failure */
+            return NULL; /* Failure */
     }
 
     ssl_cipher_collect_ciphers(ssl_method, num_of_ciphers,
-                               disabled_mkey, disabled_auth, disabled_enc,
-                               disabled_mac, co_list, &head, &tail);
+        disabled_mkey, disabled_auth, disabled_enc,
+        disabled_mac, co_list, &head, &tail);
 
     /* Now arrange all ciphers by preference. */
 
@@ -1482,17 +1465,17 @@ STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx,
      * preference).
      */
     ssl_cipher_apply_rule(0, SSL_kECDHE, SSL_aECDSA, 0, 0, 0, 0, CIPHER_ADD,
-                          -1, &head, &tail);
+        -1, &head, &tail);
     ssl_cipher_apply_rule(0, SSL_kECDHE, 0, 0, 0, 0, 0, CIPHER_ADD, -1, &head,
-                          &tail);
+        &tail);
     ssl_cipher_apply_rule(0, SSL_kECDHE, 0, 0, 0, 0, 0, CIPHER_DEL, -1, &head,
-                          &tail);
+        &tail);
 
     /* Within each strength group, we prefer GCM over CHACHA... */
     ssl_cipher_apply_rule(0, 0, 0, SSL_AESGCM, 0, 0, 0, CIPHER_ADD, -1,
-                          &head, &tail);
+        &head, &tail);
     ssl_cipher_apply_rule(0, 0, 0, SSL_CHACHA20, 0, 0, 0, CIPHER_ADD, -1,
-                          &head, &tail);
+        &head, &tail);
 
     /*
      * ...and generally, our preferred cipher is AES.
@@ -1500,14 +1483,14 @@ STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx,
      * strength.
      */
     ssl_cipher_apply_rule(0, 0, 0, SSL_AES ^ SSL_AESGCM, 0, 0, 0, CIPHER_ADD,
-                          -1, &head, &tail);
+        -1, &head, &tail);
 
     /* Temporarily enable everything else for sorting */
     ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_ADD, -1, &head, &tail);
 
     /* Low priority for MD5 */
     ssl_cipher_apply_rule(0, 0, 0, 0, SSL_MD5, 0, 0, CIPHER_ORD, -1, &head,
-                          &tail);
+        &tail);
 
     /*
      * Move anonymous ciphers to the end.  Usually, these will remain
@@ -1515,16 +1498,16 @@ STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx,
      * we prefer authenticated ciphers.)
      */
     ssl_cipher_apply_rule(0, 0, SSL_aNULL, 0, 0, 0, 0, CIPHER_ORD, -1, &head,
-                          &tail);
+        &tail);
 
     ssl_cipher_apply_rule(0, SSL_kRSA, 0, 0, 0, 0, 0, CIPHER_ORD, -1, &head,
-                          &tail);
+        &tail);
     ssl_cipher_apply_rule(0, SSL_kPSK, 0, 0, 0, 0, 0, CIPHER_ORD, -1, &head,
-                          &tail);
+        &tail);
 
     /* RC4 is sort-of broken -- move to the end */
     ssl_cipher_apply_rule(0, 0, 0, SSL_RC4, 0, 0, 0, CIPHER_ORD, -1, &head,
-                          &tail);
+        &tail);
 
     /*
      * Now sort by symmetric encryption strength.  The above ordering remains
@@ -1539,7 +1522,7 @@ STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx,
      * Partially overrule strength sort to prefer TLS 1.2 ciphers/PRFs.
      */
     ssl_cipher_apply_rule(0, 0, 0, 0, 0, TLS1_2_VERSION, 0, CIPHER_BUMP, -1,
-                          &head, &tail);
+        &head, &tail);
 
     /*
      * Irrespective of strength, enforce the following order:
@@ -1555,11 +1538,11 @@ STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx,
      * reverse order of preference.
      */
     ssl_cipher_apply_rule(0, 0, 0, 0, SSL_AEAD, 0, 0, CIPHER_BUMP, -1,
-                          &head, &tail);
+        &head, &tail);
     ssl_cipher_apply_rule(0, SSL_kDHE | SSL_kECDHE, 0, 0, 0, 0, 0,
-                          CIPHER_BUMP, -1, &head, &tail);
+        CIPHER_BUMP, -1, &head, &tail);
     ssl_cipher_apply_rule(0, SSL_kDHE | SSL_kECDHE, 0, 0, SSL_AEAD, 0, 0,
-                          CIPHER_BUMP, -1, &head, &tail);
+        CIPHER_BUMP, -1, &head, &tail);
 
     /* Now disable everything (maintaining the ordering!) */
     ssl_cipher_apply_rule(0, 0, 0, 0, 0, 0, 0, CIPHER_DEL, -1, &head, &tail);
@@ -1577,11 +1560,11 @@ STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx,
     ca_list = OPENSSL_malloc(sizeof(*ca_list) * num_of_alias_max);
     if (ca_list == NULL) {
         OPENSSL_free(co_list);
-        return NULL;          /* Failure */
+        return NULL; /* Failure */
     }
     ssl_cipher_collect_aliases(ca_list, num_of_group_aliases,
-                               disabled_mkey, disabled_auth, disabled_enc,
-                               disabled_mac, head);
+        disabled_mkey, disabled_auth, disabled_enc,
+        disabled_mac, head);
 
     /*
      * If the rule_string begins with DEFAULT, apply the default rule
@@ -1591,7 +1574,7 @@ STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx,
     rule_p = rule_str;
     if (HAS_PREFIX(rule_str, "DEFAULT")) {
         ok = ssl_cipher_process_rulestr(OSSL_default_cipher_list(),
-                                        &head, &tail, ca_list, c);
+            &head, &tail, ca_list, c);
         rule_p += 7;
         if (*rule_p == ':')
             rule_p++;
@@ -1600,9 +1583,9 @@ STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx,
     if (ok && (rule_p[0] != '\0'))
         ok = ssl_cipher_process_rulestr(rule_p, &head, &tail, ca_list, c);
 
-    OPENSSL_free(ca_list);      /* Not needed anymore */
+    OPENSSL_free(ca_list); /* Not needed anymore */
 
-    if (!ok) {                  /* Rule processing failure */
+    if (!ok) { /* Rule processing failure */
         OPENSSL_free(co_list);
         return NULL;
     }
@@ -1622,9 +1605,11 @@ STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx,
 
         /* Don't include any TLSv1.3 ciphers that are disabled */
         if ((sslc->algorithm_enc & disabled_enc) != 0
-                || (ssl_cipher_table_mac[sslc->algorithm2
-                                         & SSL_HANDSHAKE_MAC_MASK].mask
-                    & ctx->disabled_mac_mask) != 0) {
+            || (ssl_cipher_table_mac[sslc->algorithm2
+                    & SSL_HANDSHAKE_MAC_MASK]
+                       .mask
+                   & ctx->disabled_mac_mask)
+                != 0) {
             sk_SSL_CIPHER_delete(tls13_ciphersuites, i);
             i--;
             continue;
@@ -1637,7 +1622,8 @@ STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx,
         }
     }
 
-    OSSL_TRACE_BEGIN(TLS_CIPHER) {
+    OSSL_TRACE_BEGIN(TLS_CIPHER)
+    {
         BIO_printf(trc_out, "cipher selection:\n");
     }
     /*
@@ -1656,7 +1642,7 @@ STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx,
                 BIO_printf(trc_out, "<%s>\n", curr->cipher->name);
         }
     }
-    OPENSSL_free(co_list);      /* Not needed any longer */
+    OPENSSL_free(co_list); /* Not needed any longer */
     OSSL_TRACE_END(TLS_CIPHER);
 
     if (!update_cipher_list_by_id(cipher_list_by_id, cipherstack)) {
@@ -1965,7 +1951,7 @@ STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void)
 }
 
 STACK_OF(SSL_COMP) *SSL_COMP_set0_compression_methods(STACK_OF(SSL_COMP)
-                                                      *meths)
+        *meths)
 {
     return meths;
 }
@@ -1981,7 +1967,7 @@ STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void)
     STACK_OF(SSL_COMP) **rv;
 
     rv = (STACK_OF(SSL_COMP) **)OSSL_LIB_CTX_get_data(NULL,
-                                     OSSL_LIB_CTX_COMP_METHODS);
+        OSSL_LIB_CTX_COMP_METHODS);
     if (rv != NULL)
         return *rv;
     else
@@ -1989,13 +1975,13 @@ STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void)
 }
 
 STACK_OF(SSL_COMP) *SSL_COMP_set0_compression_methods(STACK_OF(SSL_COMP)
-                                                      *meths)
+        *meths)
 {
     STACK_OF(SSL_COMP) **comp_methods;
     STACK_OF(SSL_COMP) *old_meths;
 
     comp_methods = (STACK_OF(SSL_COMP) **)OSSL_LIB_CTX_get_data(NULL,
-                                              OSSL_LIB_CTX_COMP_METHODS);
+        OSSL_LIB_CTX_COMP_METHODS);
     if (comp_methods == NULL) {
         old_meths = meths;
     } else {
@@ -2080,8 +2066,8 @@ int SSL_COMP_get_id(const SSL_COMP *comp)
 }
 
 const SSL_CIPHER *ssl_get_cipher_by_char(SSL_CONNECTION *s,
-                                         const unsigned char *ptr,
-                                         int all)
+    const unsigned char *ptr,
+    int all)
 {
     const SSL_CIPHER *c = SSL_CONNECTION_GET_SSL(s)->method->get_cipher_by_char(ptr);
 
@@ -2133,10 +2119,11 @@ int SSL_CIPHER_get_auth_nid(const SSL_CIPHER *c)
     return ssl_cipher_table_auth[i].nid;
 }
 
-int ssl_get_md_idx(int md_nid) {
+int ssl_get_md_idx(int md_nid)
+{
     int i;
 
-    for(i = 0; i < SSL_MD_NUM_IDX; i++) {
+    for (i = 0; i < SSL_MD_NUM_IDX; i++) {
         if (md_nid == ssl_cipher_table_mac[i].nid)
             return i;
     }
@@ -2158,8 +2145,8 @@ int SSL_CIPHER_is_aead(const SSL_CIPHER *c)
 }
 
 int ssl_cipher_get_overhead(const SSL_CIPHER *c, size_t *mac_overhead,
-                            size_t *int_overhead, size_t *blocksize,
-                            size_t *ext_overhead)
+    size_t *int_overhead, size_t *blocksize,
+    size_t *ext_overhead)
 {
     int mac = 0, in = 0, blk = 0, out = 0;
 
@@ -2193,8 +2180,7 @@ int ssl_cipher_get_overhead(const SSL_CIPHER *c, size_t *mac_overhead,
 
             /* If it wasn't AEAD or SSL_eNULL, we expect it to be a
                known CBC cipher. */
-            if (e_ciph == NULL ||
-                EVP_CIPHER_get_mode(e_ciph) != EVP_CIPH_CBC_MODE)
+            if (e_ciph == NULL || EVP_CIPHER_get_mode(e_ciph) != EVP_CIPH_CBC_MODE)
                 return 0;
 
             in = 1; /* padding length byte */
diff --git a/crypto/openssl/ssl/ssl_conf.c b/crypto/openssl/ssl/ssl_conf.c
index 946d20be527c..0d9359388095 100644
--- a/crypto/openssl/ssl/ssl_conf.c
+++ b/crypto/openssl/ssl/ssl_conf.c
@@ -37,38 +37,38 @@ typedef struct {
 } ssl_switch_tbl;
 
 /* Sense of name is inverted e.g. "TLSv1" will clear SSL_OP_NO_TLSv1 */
-#define SSL_TFLAG_INV   0x1
+#define SSL_TFLAG_INV 0x1
 /* Mask for type of flag referred to */
 #define SSL_TFLAG_TYPE_MASK 0xf00
 /* Flag is for options */
-#define SSL_TFLAG_OPTION    0x000
+#define SSL_TFLAG_OPTION 0x000
 /* Flag is for cert_flags */
-#define SSL_TFLAG_CERT      0x100
+#define SSL_TFLAG_CERT 0x100
 /* Flag is for verify mode */
-#define SSL_TFLAG_VFY       0x200
+#define SSL_TFLAG_VFY 0x200
 /* Option can only be used for clients */
 #define SSL_TFLAG_CLIENT SSL_CONF_FLAG_CLIENT
 /* Option can only be used for servers */
 #define SSL_TFLAG_SERVER SSL_CONF_FLAG_SERVER
-#define SSL_TFLAG_BOTH (SSL_TFLAG_CLIENT|SSL_TFLAG_SERVER)
+#define SSL_TFLAG_BOTH (SSL_TFLAG_CLIENT | SSL_TFLAG_SERVER)
 
 #define SSL_FLAG_TBL(str, flag) \
-        {str, (int)(sizeof(str) - 1), SSL_TFLAG_BOTH, flag}
+    { str, (int)(sizeof(str) - 1), SSL_TFLAG_BOTH, flag }
 #define SSL_FLAG_TBL_SRV(str, flag) \
-        {str, (int)(sizeof(str) - 1), SSL_TFLAG_SERVER, flag}
+    { str, (int)(sizeof(str) - 1), SSL_TFLAG_SERVER, flag }
 #define SSL_FLAG_TBL_CLI(str, flag) \
-        {str, (int)(sizeof(str) - 1), SSL_TFLAG_CLIENT, flag}
+    { str, (int)(sizeof(str) - 1), SSL_TFLAG_CLIENT, flag }
 #define SSL_FLAG_TBL_INV(str, flag) \
-        {str, (int)(sizeof(str) - 1), SSL_TFLAG_INV|SSL_TFLAG_BOTH, flag}
+    { str, (int)(sizeof(str) - 1), SSL_TFLAG_INV | SSL_TFLAG_BOTH, flag }
 #define SSL_FLAG_TBL_SRV_INV(str, flag) \
-        {str, (int)(sizeof(str) - 1), SSL_TFLAG_INV|SSL_TFLAG_SERVER, flag}
+    { str, (int)(sizeof(str) - 1), SSL_TFLAG_INV | SSL_TFLAG_SERVER, flag }
 #define SSL_FLAG_TBL_CERT(str, flag) \
-        {str, (int)(sizeof(str) - 1), SSL_TFLAG_CERT|SSL_TFLAG_BOTH, flag}
+    { str, (int)(sizeof(str) - 1), SSL_TFLAG_CERT | SSL_TFLAG_BOTH, flag }
 
 #define SSL_FLAG_VFY_CLI(str, flag) \
-        {str, (int)(sizeof(str) - 1), SSL_TFLAG_VFY | SSL_TFLAG_CLIENT, flag}
+    { str, (int)(sizeof(str) - 1), SSL_TFLAG_VFY | SSL_TFLAG_CLIENT, flag }
 #define SSL_FLAG_VFY_SRV(str, flag) \
-        {str, (int)(sizeof(str) - 1), SSL_TFLAG_VFY | SSL_TFLAG_SERVER, flag}
+    { str, (int)(sizeof(str) - 1), SSL_TFLAG_VFY | SSL_TFLAG_SERVER, flag }
 
 /*
  * Opaque structure containing SSL configuration context.
@@ -109,7 +109,7 @@ struct ssl_conf_ctx_st {
 };
 
 static void ssl_set_option(SSL_CONF_CTX *cctx, unsigned int name_flags,
-                           uint64_t option_value, int onoff)
+    uint64_t option_value, int onoff)
 {
     uint32_t *pflags;
 
@@ -136,7 +136,6 @@ static void ssl_set_option(SSL_CONF_CTX *cctx, unsigned int name_flags,
 
     default:
         return;
-
     }
     if (onoff)
         *pflags |= option_value;
@@ -145,7 +144,7 @@ static void ssl_set_option(SSL_CONF_CTX *cctx, unsigned int name_flags,
 }
 
 static int ssl_match_option(SSL_CONF_CTX *cctx, const ssl_flag_tbl *tbl,
-                            const char *name, int namelen, int onoff)
+    const char *name, int namelen, int onoff)
 {
     /* If name not relevant for context skip */
     if (!(cctx->flags & tbl->name_flags & SSL_TFLAG_BOTH))
@@ -154,7 +153,7 @@ static int ssl_match_option(SSL_CONF_CTX *cctx, const ssl_flag_tbl *tbl,
         if (strcmp(tbl->name, name))
             return 0;
     } else if (tbl->namelen != namelen
-               || OPENSSL_strncasecmp(tbl->name, name, namelen))
+        || OPENSSL_strncasecmp(tbl->name, name, namelen))
         return 0;
     ssl_set_option(cctx, tbl->name_flags, tbl->option_value, onoff);
     return 1;
@@ -238,11 +237,10 @@ static int cmd_ECDHParameters(SSL_CONF_CTX *cctx, const char *value)
 
     /* Ignore values supported by 1.0.2 for the automatic selection */
     if ((cctx->flags & SSL_CONF_FLAG_FILE)
-            && (OPENSSL_strcasecmp(value, "+automatic") == 0
-                || OPENSSL_strcasecmp(value, "automatic") == 0))
+        && (OPENSSL_strcasecmp(value, "+automatic") == 0
+            || OPENSSL_strcasecmp(value, "automatic") == 0))
         return 1;
-    if ((cctx->flags & SSL_CONF_FLAG_CMDLINE) &&
-        strcmp(value, "auto") == 0)
+    if ((cctx->flags & SSL_CONF_FLAG_CMDLINE) && strcmp(value, "auto") == 0)
         return 1;
 
     /* ECDHParameters accepts a single group name */
@@ -316,14 +314,14 @@ static int protocol_from_string(const char *value)
      * shrink.
      */
     static const struct protocol_versions versions[] = {
-        {"None", 0},
-        {"SSLv3", SSL3_VERSION},
-        {"TLSv1", TLS1_VERSION},
-        {"TLSv1.1", TLS1_1_VERSION},
-        {"TLSv1.2", TLS1_2_VERSION},
-        {"TLSv1.3", TLS1_3_VERSION},
-        {"DTLSv1", DTLS1_VERSION},
-        {"DTLSv1.2", DTLS1_2_VERSION}
+        { "None", 0 },
+        { "SSLv3", SSL3_VERSION },
+        { "TLSv1", TLS1_VERSION },
+        { "TLSv1.1", TLS1_1_VERSION },
+        { "TLSv1.2", TLS1_2_VERSION },
+        { "TLSv1.3", TLS1_3_VERSION },
+        { "DTLSv1", DTLS1_VERSION },
+        { "DTLSv1.2", DTLS1_2_VERSION }
     };
     size_t i;
     size_t n = OSSL_NELEM(versions);
@@ -379,20 +377,20 @@ static int cmd_Options(SSL_CONF_CTX *cctx, const char *value)
     static const ssl_flag_tbl ssl_option_list[] = {
         SSL_FLAG_TBL_INV("SessionTicket", SSL_OP_NO_TICKET),
         SSL_FLAG_TBL_INV("EmptyFragments",
-                         SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS),
+            SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS),
         SSL_FLAG_TBL("Bugs", SSL_OP_ALL),
         SSL_FLAG_TBL_INV("Compression", SSL_OP_NO_COMPRESSION),
         SSL_FLAG_TBL_SRV("ServerPreference", SSL_OP_CIPHER_SERVER_PREFERENCE),
         SSL_FLAG_TBL_SRV("NoResumptionOnRenegotiation",
-                         SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION),
+            SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION),
         SSL_FLAG_TBL_SRV("DHSingle", SSL_OP_SINGLE_DH_USE),
         SSL_FLAG_TBL_SRV("ECDHSingle", SSL_OP_SINGLE_ECDH_USE),
         SSL_FLAG_TBL("UnsafeLegacyRenegotiation",
-                     SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION),
+            SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION),
         SSL_FLAG_TBL("UnsafeLegacyServerConnect",
-                     SSL_OP_LEGACY_SERVER_CONNECT),
+            SSL_OP_LEGACY_SERVER_CONNECT),
         SSL_FLAG_TBL("ClientRenegotiation",
-                     SSL_OP_ALLOW_CLIENT_RENEGOTIATION),
+            SSL_OP_ALLOW_CLIENT_RENEGOTIATION),
         SSL_FLAG_TBL_INV("EncryptThenMac", SSL_OP_NO_ENCRYPT_THEN_MAC),
         SSL_FLAG_TBL("NoRenegotiation", SSL_OP_NO_RENEGOTIATION),
         SSL_FLAG_TBL("AllowNoDHEKEX", SSL_OP_ALLOW_NO_DHE_KEX),
@@ -422,13 +420,12 @@ static int cmd_VerifyMode(SSL_CONF_CTX *cctx, const char *value)
         SSL_FLAG_VFY_CLI("Peer", SSL_VERIFY_PEER),
         SSL_FLAG_VFY_SRV("Request", SSL_VERIFY_PEER),
         SSL_FLAG_VFY_SRV("Require",
-                         SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
+            SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
         SSL_FLAG_VFY_SRV("Once", SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE),
         SSL_FLAG_VFY_SRV("RequestPostHandshake",
-                         SSL_VERIFY_PEER | SSL_VERIFY_POST_HANDSHAKE),
+            SSL_VERIFY_PEER | SSL_VERIFY_POST_HANDSHAKE),
         SSL_FLAG_VFY_SRV("RequirePostHandshake",
-                         SSL_VERIFY_PEER | SSL_VERIFY_POST_HANDSHAKE |
-                         SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
+            SSL_VERIFY_PEER | SSL_VERIFY_POST_HANDSHAKE | SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
     };
     if (value == NULL)
         return -3;
@@ -494,8 +491,8 @@ static int cmd_ServerInfoFile(SSL_CONF_CTX *cctx, const char *value)
 }
 
 static int do_store(SSL_CONF_CTX *cctx,
-                    const char *CAfile, const char *CApath, const char *CAstore,
-                    int verify_store)
+    const char *CAfile, const char *CApath, const char *CAstore,
+    int verify_store)
 {
     CERT *cert;
     X509_STORE **st;
@@ -532,8 +529,7 @@ static int do_store(SSL_CONF_CTX *cctx,
         return 0;
     if (CApath != NULL && !X509_STORE_load_path(*st, CApath))
         return 0;
-    if (CAstore != NULL && !X509_STORE_load_store_ex(*st, CAstore, libctx,
-                                                     propq))
+    if (CAstore != NULL && !X509_STORE_load_store_ex(*st, CAstore, libctx, propq))
         return 0;
     return 1;
 }
@@ -627,14 +623,15 @@ static int cmd_DHParameters(SSL_CONF_CTX *cctx, const char *value)
 
         decoderctx
             = OSSL_DECODER_CTX_new_for_pkey(&dhpkey, "PEM", NULL, "DH",
-                                            OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
-                                            sslctx->libctx, sslctx->propq);
+                OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS,
+                sslctx->libctx, sslctx->propq);
         if (decoderctx == NULL)
             goto end;
         ERR_set_mark();
         while (!OSSL_DECODER_from_bio(decoderctx, in)
-               && dhpkey == NULL
-               && !BIO_eof(in));
+            && dhpkey == NULL
+            && !BIO_eof(in))
+            ;
         OSSL_DECODER_CTX_free(decoderctx);
 
         if (dhpkey == NULL) {
@@ -654,7 +651,7 @@ static int cmd_DHParameters(SSL_CONF_CTX *cctx, const char *value)
         if ((rv = SSL_set0_tmp_dh_pkey(cctx->ssl, dhpkey)) > 0)
             dhpkey = NULL;
     }
- end:
+end:
     EVP_PKEY_free(dhpkey);
     BIO_free(in);
     return rv > 0;
@@ -693,18 +690,35 @@ static int cmd_RecordPadding(SSL_CONF_CTX *cctx, const char *value)
      * All we care about are non-negative values,
      * the setters check the range
      */
-    if (cctx->ctx)
-        rv = SSL_CTX_set_block_padding_ex(cctx->ctx, (size_t)block_padding,
-                                          (size_t)hs_padding);
-    if (cctx->ssl)
-        rv = SSL_set_block_padding_ex(cctx->ssl, (size_t)block_padding,
-                                      (size_t)hs_padding);
+    if (cctx->ctx) {
+        /*
+         * QUIC always pads TLS data at the packet level, and as such, attempting
+         * to set block padding at the record level fails in calls to SSL_CTX_set_block_padding_ex.
+         * However, when configuring record padding via config file, we have no idea if we are
+         * going to create TCP or QUIC based SSL's, so silently ignore this configuration option
+         * for QUIC.
+         */
+        if (SSL_CTX_is_quic(cctx->ctx))
+            rv = 1;
+        else
+            rv = SSL_CTX_set_block_padding_ex(cctx->ctx, (size_t)block_padding,
+                (size_t)hs_padding);
+    }
+    if (cctx->ssl) {
+        /*
+         * As above, ignore this config option for QUIC
+         */
+        if (SSL_is_quic(cctx->ssl))
+            rv = 1;
+        else
+            rv = SSL_set_block_padding_ex(cctx->ssl, (size_t)block_padding,
+                (size_t)hs_padding);
+    }
 out:
     OPENSSL_free(copy);
     return rv;
 }
 
-
 static int cmd_NumTickets(SSL_CONF_CTX *cctx, const char *value)
 {
     int rv = 0;
@@ -720,7 +734,7 @@ static int cmd_NumTickets(SSL_CONF_CTX *cctx, const char *value)
 }
 
 typedef struct {
-    int (*cmd) (SSL_CONF_CTX *cctx, const char *value);
+    int (*cmd)(SSL_CONF_CTX *cctx, const char *value);
     const char *str_file;
     const char *str_cmdline;
     unsigned short flags;
@@ -730,13 +744,13 @@ typedef struct {
 /* Table of supported parameters */
 
 #define SSL_CONF_CMD(name, cmdopt, flags, type) \
-        {cmd_##name, #name, cmdopt, flags, type}
+    { cmd_##name, #name, cmdopt, flags, type }
 
 #define SSL_CONF_CMD_STRING(name, cmdopt, flags) \
-        SSL_CONF_CMD(name, cmdopt, flags, SSL_CONF_TYPE_STRING)
+    SSL_CONF_CMD(name, cmdopt, flags, SSL_CONF_TYPE_STRING)
 
 #define SSL_CONF_CMD_SWITCH(name, flags) \
-        {0, NULL, name, flags, SSL_CONF_TYPE_NONE}
+    { 0, NULL, name, flags, SSL_CONF_TYPE_NONE }
 
 /* See apps/include/opt.h if you change this table. */
 /* The SSL_CONF_CMD_SWITCH should be the same order as ssl_cmd_switches */
@@ -784,92 +798,92 @@ static const ssl_conf_cmd_tbl ssl_conf_cmds[] = {
     SSL_CONF_CMD_STRING(Options, NULL, 0),
     SSL_CONF_CMD_STRING(VerifyMode, NULL, 0),
     SSL_CONF_CMD(Certificate, "cert", SSL_CONF_FLAG_CERTIFICATE,
-                 SSL_CONF_TYPE_FILE),
+        SSL_CONF_TYPE_FILE),
     SSL_CONF_CMD(PrivateKey, "key", SSL_CONF_FLAG_CERTIFICATE,
-                 SSL_CONF_TYPE_FILE),
+        SSL_CONF_TYPE_FILE),
     SSL_CONF_CMD(ServerInfoFile, NULL,
-                 SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
-                 SSL_CONF_TYPE_FILE),
+        SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
+        SSL_CONF_TYPE_FILE),
     SSL_CONF_CMD(ChainCAPath, "chainCApath", SSL_CONF_FLAG_CERTIFICATE,
-                 SSL_CONF_TYPE_DIR),
+        SSL_CONF_TYPE_DIR),
     SSL_CONF_CMD(ChainCAFile, "chainCAfile", SSL_CONF_FLAG_CERTIFICATE,
-                 SSL_CONF_TYPE_FILE),
+        SSL_CONF_TYPE_FILE),
     SSL_CONF_CMD(ChainCAStore, "chainCAstore", SSL_CONF_FLAG_CERTIFICATE,
-                 SSL_CONF_TYPE_STORE),
+        SSL_CONF_TYPE_STORE),
     SSL_CONF_CMD(VerifyCAPath, "verifyCApath", SSL_CONF_FLAG_CERTIFICATE,
-                 SSL_CONF_TYPE_DIR),
+        SSL_CONF_TYPE_DIR),
     SSL_CONF_CMD(VerifyCAFile, "verifyCAfile", SSL_CONF_FLAG_CERTIFICATE,
-                 SSL_CONF_TYPE_FILE),
+        SSL_CONF_TYPE_FILE),
     SSL_CONF_CMD(VerifyCAStore, "verifyCAstore", SSL_CONF_FLAG_CERTIFICATE,
-                 SSL_CONF_TYPE_STORE),
+        SSL_CONF_TYPE_STORE),
     SSL_CONF_CMD(RequestCAFile, "requestCAFile", SSL_CONF_FLAG_CERTIFICATE,
-                 SSL_CONF_TYPE_FILE),
+        SSL_CONF_TYPE_FILE),
     SSL_CONF_CMD(ClientCAFile, NULL,
-                 SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
-                 SSL_CONF_TYPE_FILE),
+        SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
+        SSL_CONF_TYPE_FILE),
     SSL_CONF_CMD(RequestCAPath, NULL, SSL_CONF_FLAG_CERTIFICATE,
-                 SSL_CONF_TYPE_DIR),
+        SSL_CONF_TYPE_DIR),
     SSL_CONF_CMD(ClientCAPath, NULL,
-                 SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
-                 SSL_CONF_TYPE_DIR),
+        SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
+        SSL_CONF_TYPE_DIR),
     SSL_CONF_CMD(RequestCAStore, "requestCAStore", SSL_CONF_FLAG_CERTIFICATE,
-                 SSL_CONF_TYPE_STORE),
+        SSL_CONF_TYPE_STORE),
     SSL_CONF_CMD(ClientCAStore, NULL,
-                 SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
-                 SSL_CONF_TYPE_STORE),
+        SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
+        SSL_CONF_TYPE_STORE),
     SSL_CONF_CMD(DHParameters, "dhparam",
-                 SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
-                 SSL_CONF_TYPE_FILE),
+        SSL_CONF_FLAG_SERVER | SSL_CONF_FLAG_CERTIFICATE,
+        SSL_CONF_TYPE_FILE),
     SSL_CONF_CMD_STRING(RecordPadding, "record_padding", 0),
     SSL_CONF_CMD_STRING(NumTickets, "num_tickets", SSL_CONF_FLAG_SERVER),
 };
 
 /* Supported switches: must match order of switches in ssl_conf_cmds */
 static const ssl_switch_tbl ssl_cmd_switches[] = {
-    {SSL_OP_NO_SSLv3, 0},       /* no_ssl3 */
-    {SSL_OP_NO_TLSv1, 0},       /* no_tls1 */
-    {SSL_OP_NO_TLSv1_1, 0},     /* no_tls1_1 */
-    {SSL_OP_NO_TLSv1_2, 0},     /* no_tls1_2 */
-    {SSL_OP_NO_TLSv1_3, 0},     /* no_tls1_3 */
-    {SSL_OP_ALL, 0},            /* bugs */
-    {SSL_OP_NO_COMPRESSION, 0}, /* no_comp */
-    {SSL_OP_NO_COMPRESSION, SSL_TFLAG_INV}, /* comp */
-    {SSL_OP_NO_TX_CERTIFICATE_COMPRESSION, 0}, /* no_tx_cert_comp */
-    {SSL_OP_NO_TX_CERTIFICATE_COMPRESSION, SSL_TFLAG_INV}, /* tx_cert_comp */
-    {SSL_OP_NO_RX_CERTIFICATE_COMPRESSION, 0}, /* no_rx_cert_comp */
-    {SSL_OP_NO_RX_CERTIFICATE_COMPRESSION, SSL_TFLAG_INV}, /* rx_cert_comp */
-    {SSL_OP_SINGLE_ECDH_USE, 0}, /* ecdh_single */
-    {SSL_OP_NO_TICKET, 0},      /* no_ticket */
-    {SSL_OP_CIPHER_SERVER_PREFERENCE, 0}, /* serverpref */
+    { SSL_OP_NO_SSLv3, 0 }, /* no_ssl3 */
+    { SSL_OP_NO_TLSv1, 0 }, /* no_tls1 */
+    { SSL_OP_NO_TLSv1_1, 0 }, /* no_tls1_1 */
+    { SSL_OP_NO_TLSv1_2, 0 }, /* no_tls1_2 */
+    { SSL_OP_NO_TLSv1_3, 0 }, /* no_tls1_3 */
+    { SSL_OP_ALL, 0 }, /* bugs */
+    { SSL_OP_NO_COMPRESSION, 0 }, /* no_comp */
+    { SSL_OP_NO_COMPRESSION, SSL_TFLAG_INV }, /* comp */
+    { SSL_OP_NO_TX_CERTIFICATE_COMPRESSION, 0 }, /* no_tx_cert_comp */
+    { SSL_OP_NO_TX_CERTIFICATE_COMPRESSION, SSL_TFLAG_INV }, /* tx_cert_comp */
+    { SSL_OP_NO_RX_CERTIFICATE_COMPRESSION, 0 }, /* no_rx_cert_comp */
+    { SSL_OP_NO_RX_CERTIFICATE_COMPRESSION, SSL_TFLAG_INV }, /* rx_cert_comp */
+    { SSL_OP_SINGLE_ECDH_USE, 0 }, /* ecdh_single */
+    { SSL_OP_NO_TICKET, 0 }, /* no_ticket */
+    { SSL_OP_CIPHER_SERVER_PREFERENCE, 0 }, /* serverpref */
     /* legacy_renegotiation */
-    {SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION, 0},
+    { SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION, 0 },
     /* Allow client renegotiation */
-    {SSL_OP_ALLOW_CLIENT_RENEGOTIATION, 0},
+    { SSL_OP_ALLOW_CLIENT_RENEGOTIATION, 0 },
     /* legacy_server_connect */
-    {SSL_OP_LEGACY_SERVER_CONNECT, 0},
+    { SSL_OP_LEGACY_SERVER_CONNECT, 0 },
     /* no_renegotiation */
-    {SSL_OP_NO_RENEGOTIATION, 0},
+    { SSL_OP_NO_RENEGOTIATION, 0 },
     /* no_resumption_on_reneg */
-    {SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION, 0},
+    { SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION, 0 },
     /* no_legacy_server_connect */
-    {SSL_OP_LEGACY_SERVER_CONNECT, SSL_TFLAG_INV},
+    { SSL_OP_LEGACY_SERVER_CONNECT, SSL_TFLAG_INV },
     /* allow_no_dhe_kex */
-    {SSL_OP_ALLOW_NO_DHE_KEX, 0},
+    { SSL_OP_ALLOW_NO_DHE_KEX, 0 },
     /* prefer_no_dhe_kex */
-    {SSL_OP_PREFER_NO_DHE_KEX, 0},
+    { SSL_OP_PREFER_NO_DHE_KEX, 0 },
     /* chacha reprioritization */
-    {SSL_OP_PRIORITIZE_CHACHA, 0},
-    {SSL_CERT_FLAG_TLS_STRICT, SSL_TFLAG_CERT}, /* strict */
+    { SSL_OP_PRIORITIZE_CHACHA, 0 },
+    { SSL_CERT_FLAG_TLS_STRICT, SSL_TFLAG_CERT }, /* strict */
     /* no_middlebox */
-    {SSL_OP_ENABLE_MIDDLEBOX_COMPAT, SSL_TFLAG_INV},
+    { SSL_OP_ENABLE_MIDDLEBOX_COMPAT, SSL_TFLAG_INV },
     /* anti_replay */
-    {SSL_OP_NO_ANTI_REPLAY, SSL_TFLAG_INV},
+    { SSL_OP_NO_ANTI_REPLAY, SSL_TFLAG_INV },
     /* no_anti_replay */
-    {SSL_OP_NO_ANTI_REPLAY, 0},
+    { SSL_OP_NO_ANTI_REPLAY, 0 },
     /* no Encrypt-then-Mac */
-    {SSL_OP_NO_ENCRYPT_THEN_MAC, 0},
+    { SSL_OP_NO_ENCRYPT_THEN_MAC, 0 },
     /* no Extended master secret */
-    {SSL_OP_NO_EXTENDED_MASTER_SECRET, 0},
+    { SSL_OP_NO_EXTENDED_MASTER_SECRET, 0 },
 };
 
 static int ssl_conf_cmd_skip_prefix(SSL_CONF_CTX *cctx, const char **pcmd)
@@ -880,11 +894,9 @@ static int ssl_conf_cmd_skip_prefix(SSL_CONF_CTX *cctx, const char **pcmd)
     if (cctx->prefix) {
         if (strlen(*pcmd) <= cctx->prefixlen)
             return 0;
-        if (cctx->flags & SSL_CONF_FLAG_CMDLINE &&
-            strncmp(*pcmd, cctx->prefix, cctx->prefixlen))
+        if (cctx->flags & SSL_CONF_FLAG_CMDLINE && strncmp(*pcmd, cctx->prefix, cctx->prefixlen))
             return 0;
-        if (cctx->flags & SSL_CONF_FLAG_FILE &&
-            OPENSSL_strncasecmp(*pcmd, cctx->prefix, cctx->prefixlen))
+        if (cctx->flags & SSL_CONF_FLAG_FILE && OPENSSL_strncasecmp(*pcmd, cctx->prefix, cctx->prefixlen))
             return 0;
         *pcmd += cctx->prefixlen;
     } else if (cctx->flags & SSL_CONF_FLAG_CMDLINE) {
@@ -911,7 +923,7 @@ static int ssl_conf_cmd_allowed(SSL_CONF_CTX *cctx, const ssl_conf_cmd_tbl *t)
 }
 
 static const ssl_conf_cmd_tbl *ssl_conf_cmd_lookup(SSL_CONF_CTX *cctx,
-                                                   const char *cmd)
+    const char *cmd)
 {
     const ssl_conf_cmd_tbl *t;
     size_t i;
@@ -978,15 +990,15 @@ int SSL_CONF_cmd(SSL_CONF_CTX *cctx, const char *cmd, const char *value)
         if (rv != -2)
             rv = 0;
 
- bad_value:
+    bad_value:
         if (cctx->flags & SSL_CONF_FLAG_SHOW_ERRORS)
             ERR_raise_data(ERR_LIB_SSL, SSL_R_BAD_VALUE,
-                           "cmd=%s, value=%s", cmd,
-                           value != NULL ? value : "<EMPTY>");
+                "cmd=%s, value=%s", cmd,
+                value != NULL ? value : "<EMPTY>");
         return rv;
     }
 
- unknown_cmd:
+unknown_cmd:
     if (cctx->flags & SSL_CONF_FLAG_SHOW_ERRORS)
         ERR_raise_data(ERR_LIB_SSL, SSL_R_UNKNOWN_CMD_NAME, "cmd=%s", cmd);
 
@@ -1150,7 +1162,7 @@ void SSL_CONF_CTX_set_ssl(SSL_CONF_CTX *cctx, SSL *ssl)
         cctx->pcert_flags = &sc->cert->cert_flags;
         cctx->pvfy_flags = &sc->verify_mode;
         cctx->cert_filename = OPENSSL_zalloc(sc->ssl_pkey_num
-                                             * sizeof(*cctx->cert_filename));
+            * sizeof(*cctx->cert_filename));
         if (cctx->cert_filename != NULL)
             cctx->num_cert_filename = sc->ssl_pkey_num;
     } else {
@@ -1174,7 +1186,7 @@ void SSL_CONF_CTX_set_ssl_ctx(SSL_CONF_CTX *cctx, SSL_CTX *ctx)
         cctx->pcert_flags = &ctx->cert->cert_flags;
         cctx->pvfy_flags = &ctx->verify_mode;
         cctx->cert_filename = OPENSSL_zalloc((SSL_PKEY_NUM + ctx->sigalg_list_len)
-                                             * sizeof(*cctx->cert_filename));
+            * sizeof(*cctx->cert_filename));
         if (cctx->cert_filename != NULL)
             cctx->num_cert_filename = SSL_PKEY_NUM + ctx->sigalg_list_len;
     } else {
diff --git a/crypto/openssl/ssl/ssl_init.c b/crypto/openssl/ssl/ssl_init.c
index 2a879bdc7851..1e92658b7a41 100644
--- a/crypto/openssl/ssl/ssl_init.c
+++ b/crypto/openssl/ssl/ssl_init.c
@@ -15,7 +15,7 @@
 #include <openssl/trace.h>
 #include "ssl_local.h"
 #include "internal/thread_once.h"
-#include "internal/rio_notifier.h"    /* for ossl_wsa_cleanup() */
+#include "internal/rio_notifier.h" /* for ossl_wsa_cleanup() */
 
 static int stopped;
 
@@ -25,7 +25,7 @@ DEFINE_RUN_ONCE_STATIC(ossl_init_ssl_base)
 {
 #ifndef OPENSSL_NO_COMP
     OSSL_TRACE(INIT, "ossl_init_ssl_base: "
-               "SSL_COMP_get_compression_methods()\n");
+                     "SSL_COMP_get_compression_methods()\n");
     /*
      * This will initialise the built-in compression algorithms. The value
      * returned is a STACK_OF(SSL_COMP), but that can be discarded safely
@@ -61,7 +61,7 @@ int OPENSSL_init_ssl(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings)
     }
 
     opts |= OPENSSL_INIT_ADD_ALL_CIPHERS
-         |  OPENSSL_INIT_ADD_ALL_DIGESTS;
+        | OPENSSL_INIT_ADD_ALL_DIGESTS;
 #ifndef OPENSSL_NO_AUTOLOAD_CONFIG
     if ((opts & OPENSSL_INIT_NO_LOAD_CONFIG) == 0)
         opts |= OPENSSL_INIT_LOAD_CONFIG;
diff --git a/crypto/openssl/ssl/ssl_lib.c b/crypto/openssl/ssl/ssl_lib.c
index 9696a4c55fab..05b0209a76b3 100644
--- a/crypto/openssl/ssl/ssl_lib.c
+++ b/crypto/openssl/ssl/ssl_lib.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 1995-2025 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
  * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
  * Copyright 2005 Nokia. All rights reserved.
  *
@@ -34,12 +34,12 @@
 #include "quic/quic_local.h"
 
 #ifndef OPENSSL_NO_SSLKEYLOG
-# include <sys/stat.h>
-# include <fcntl.h>
+#include <sys/stat.h>
+#include <fcntl.h>
 #endif
 
 static int ssl_undefined_function_3(SSL_CONNECTION *sc, unsigned char *r,
-                                    unsigned char *s, size_t t, size_t *u)
+    unsigned char *s, size_t t, size_t *u)
 {
     return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
 }
@@ -50,7 +50,7 @@ static int ssl_undefined_function_4(SSL_CONNECTION *sc, int r)
 }
 
 static size_t ssl_undefined_function_5(SSL_CONNECTION *sc, const char *r,
-                                       size_t s, unsigned char *t)
+    size_t s, unsigned char *t)
 {
     return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
 }
@@ -61,8 +61,8 @@ static int ssl_undefined_function_6(int r)
 }
 
 static int ssl_undefined_function_7(SSL_CONNECTION *sc, unsigned char *r,
-                                    size_t s, const char *t, size_t u,
-                                    const unsigned char *v, size_t w, int x)
+    size_t s, const char *t, size_t u,
+    const unsigned char *v, size_t w, int x)
 {
     return ssl_undefined_function(SSL_CONNECTION_GET_SSL(sc));
 }
@@ -77,10 +77,10 @@ const SSL3_ENC_METHOD ssl3_undef_enc_method = {
     ssl_undefined_function_3,
     ssl_undefined_function_4,
     ssl_undefined_function_5,
-    NULL,                       /* client_finished_label */
-    0,                          /* client_finished_label_len */
-    NULL,                       /* server_finished_label */
-    0,                          /* server_finished_label_len */
+    NULL, /* client_finished_label */
+    0, /* client_finished_label_len */
+    NULL, /* server_finished_label */
+    0, /* server_finished_label_len */
     ssl_undefined_function_6,
     ssl_undefined_function_7,
 };
@@ -89,11 +89,13 @@ struct ssl_async_args {
     SSL *s;
     void *buf;
     size_t num;
-    enum { READFUNC, WRITEFUNC, OTHERFUNC } type;
+    enum { READFUNC,
+        WRITEFUNC,
+        OTHERFUNC } type;
     union {
-        int (*func_read) (SSL *, void *, size_t, size_t *);
-        int (*func_write) (SSL *, const void *, size_t, size_t *);
-        int (*func_other) (SSL *);
+        int (*func_read)(SSL *, void *, size_t, size_t *);
+        int (*func_write)(SSL *, const void *, size_t, size_t *);
+        int (*func_other)(SSL *);
     } f;
 };
 
@@ -102,15 +104,9 @@ static const struct {
     uint8_t ord;
     int nid;
 } dane_mds[] = {
-    {
-        DANETLS_MATCHING_FULL, 0, NID_undef
-    },
-    {
-        DANETLS_MATCHING_2256, 1, NID_sha256
-    },
-    {
-        DANETLS_MATCHING_2512, 2, NID_sha512
-    },
+    { DANETLS_MATCHING_FULL, 0, NID_undef },
+    { DANETLS_MATCHING_2256, 1, NID_sha256 },
+    { DANETLS_MATCHING_2512, 2, NID_sha512 },
 };
 
 static int dane_ctx_enable(struct dane_ctx_st *dctx)
@@ -118,7 +114,7 @@ static int dane_ctx_enable(struct dane_ctx_st *dctx)
     const EVP_MD **mdevp;
     uint8_t *mdord;
     uint8_t mdmax = DANETLS_MATCHING_LAST;
-    int n = ((int)mdmax) + 1;   /* int to handle PrivMatch(255) */
+    int n = ((int)mdmax) + 1; /* int to handle PrivMatch(255) */
     size_t i;
 
     if (dctx->mdevp != NULL)
@@ -137,8 +133,7 @@ static int dane_ctx_enable(struct dane_ctx_st *dctx)
     for (i = 0; i < OSSL_NELEM(dane_mds); ++i) {
         const EVP_MD *md;
 
-        if (dane_mds[i].nid == NID_undef ||
-            (md = EVP_get_digestbynid(dane_mds[i].nid)) == NULL)
+        if (dane_mds[i].nid == NID_undef || (md = EVP_get_digestbynid(dane_mds[i].nid)) == NULL)
             continue;
         mdevp[dane_mds[i].mtype] = md;
         mdord[dane_mds[i].mtype] = dane_mds[i].ord;
@@ -211,14 +206,15 @@ static int ssl_dane_dup(SSL_CONNECTION *to, SSL_CONNECTION *from)
         danetls_record *t = sk_danetls_record_value(from->dane.trecs, i);
 
         if (SSL_dane_tlsa_add(SSL_CONNECTION_GET_SSL(to), t->usage,
-                              t->selector, t->mtype, t->data, t->dlen) <= 0)
+                t->selector, t->mtype, t->data, t->dlen)
+            <= 0)
             return 0;
     }
     return 1;
 }
 
 static int dane_mtype_set(struct dane_ctx_st *dctx,
-                          const EVP_MD *md, uint8_t mtype, uint8_t ord)
+    const EVP_MD *md, uint8_t mtype, uint8_t ord)
 {
     int i;
 
@@ -266,9 +262,9 @@ static const EVP_MD *tlsa_md_get(SSL_DANE *dane, uint8_t mtype)
 }
 
 static int dane_tlsa_add(SSL_DANE *dane,
-                         uint8_t usage,
-                         uint8_t selector,
-                         uint8_t mtype, const unsigned char *data, size_t dlen)
+    uint8_t usage,
+    uint8_t selector,
+    uint8_t mtype, const unsigned char *data, size_t dlen)
 {
     danetls_record *t;
     const EVP_MD *md = NULL;
@@ -339,8 +335,7 @@ static int dane_tlsa_add(SSL_DANE *dane,
 
         switch (selector) {
         case DANETLS_SELECTOR_CERT:
-            if (!d2i_X509(&cert, &p, ilen) || p < data ||
-                dlen != (size_t)(p - data)) {
+            if (!d2i_X509(&cert, &p, ilen) || p < data || dlen != (size_t)(p - data)) {
                 X509_free(cert);
                 tlsa_free(t);
                 ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_CERTIFICATE);
@@ -377,9 +372,7 @@ static int dane_tlsa_add(SSL_DANE *dane,
              * the chain with untrusted Full(0) certificates from DNS, in case
              * they are missing from the chain.
              */
-            if ((dane->certs == NULL &&
-                 (dane->certs = sk_X509_new_null()) == NULL) ||
-                !sk_X509_push(dane->certs, cert)) {
+            if ((dane->certs == NULL && (dane->certs = sk_X509_new_null()) == NULL) || !sk_X509_push(dane->certs, cert)) {
                 ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
                 X509_free(cert);
                 tlsa_free(t);
@@ -388,8 +381,7 @@ static int dane_tlsa_add(SSL_DANE *dane,
             break;
 
         case DANETLS_SELECTOR_SPKI:
-            if (!d2i_PUBKEY(&pkey, &p, ilen) || p < data ||
-                dlen != (size_t)(p - data)) {
+            if (!d2i_PUBKEY(&pkey, &p, ilen) || p < data || dlen != (size_t)(p - data)) {
                 EVP_PKEY_free(pkey);
                 tlsa_free(t);
                 ERR_raise(ERR_LIB_SSL, SSL_R_DANE_TLSA_BAD_PUBLIC_KEY);
@@ -497,7 +489,7 @@ static int ssl_check_allowed_versions(int min_version, int max_version)
             || (DTLS_VERSION_GE(min_version, DTLS1_2_VERSION)
                 && DTLS_VERSION_GE(DTLS1_2_VERSION, max_version))
 #endif
-            )
+        )
             return 0;
     } else {
         /* Regular TLS version checks. */
@@ -554,7 +546,7 @@ static int ssl_check_allowed_versions(int min_version, int max_version)
 #ifdef OPENSSL_NO_TLS1_3
             || (min_version <= TLS1_3_VERSION && TLS1_3_VERSION <= max_version)
 #endif
-            )
+        )
             return 0;
     }
     return 1;
@@ -566,10 +558,10 @@ static int ssl_check_allowed_versions(int min_version, int max_version)
  * This is used by platform version identification tools.
  * Do not inline this procedure or make it static.
  */
-# define OPENSSL_VPROC_STRING_(x)    x##_SSL
-# define OPENSSL_VPROC_STRING(x)     OPENSSL_VPROC_STRING_(x)
-# define OPENSSL_VPROC_FUNC          OPENSSL_VPROC_STRING(OPENSSL_VPROC)
-void OPENSSL_VPROC_FUNC(void) {}
+#define OPENSSL_VPROC_STRING_(x) x##_SSL
+#define OPENSSL_VPROC_STRING(x) OPENSSL_VPROC_STRING_(x)
+#define OPENSSL_VPROC_FUNC OPENSSL_VPROC_STRING(OPENSSL_VPROC)
+void OPENSSL_VPROC_FUNC(void) { }
 #endif
 
 int SSL_clear(SSL *s)
@@ -622,7 +614,7 @@ int ossl_ssl_connection_reset(SSL *s)
 
     sc->key_update = SSL_KEY_UPDATE_NONE;
     memset(sc->ext.compress_certificate_from_peer, 0,
-           sizeof(sc->ext.compress_certificate_from_peer));
+        sizeof(sc->ext.compress_certificate_from_peer));
     sc->ext.compress_certificate_sent = 0;
 
     EVP_MD_CTX_free(sc->pha_dgst);
@@ -683,10 +675,10 @@ int SSL_CTX_set_ssl_version(SSL_CTX *ctx, const SSL_METHOD *meth)
         return 0;
     }
     sk = ssl_create_cipher_list(ctx,
-                                ctx->tls13_ciphersuites,
-                                &(ctx->cipher_list),
-                                &(ctx->cipher_list_by_id),
-                                OSSL_default_cipher_list(), ctx->cert);
+        ctx->tls13_ciphersuites,
+        &(ctx->cipher_list),
+        &(ctx->cipher_list_by_id),
+        OSSL_default_cipher_list(), ctx->cert);
     if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= 0)) {
         ERR_raise(ERR_LIB_SSL, SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
         return 0;
@@ -737,7 +729,7 @@ err:
 }
 
 SSL *ossl_ssl_connection_new_int(SSL_CTX *ctx, SSL *user_ssl,
-                                 const SSL_METHOD *method)
+    const SSL_METHOD *method)
 {
     SSL_CONNECTION *s;
     SSL *ssl;
@@ -837,15 +829,13 @@ SSL *ossl_ssl_connection_new_int(SSL_CTX *ctx, SSL *user_ssl,
 
     s->session_ctx = ctx;
     if (ctx->ext.ecpointformats != NULL) {
-        s->ext.ecpointformats =
-            OPENSSL_memdup(ctx->ext.ecpointformats,
-                           ctx->ext.ecpointformats_len);
+        s->ext.ecpointformats = OPENSSL_memdup(ctx->ext.ecpointformats,
+            ctx->ext.ecpointformats_len);
         if (s->ext.ecpointformats == NULL) {
             s->ext.ecpointformats_len = 0;
             goto err;
         }
-        s->ext.ecpointformats_len =
-            ctx->ext.ecpointformats_len;
+        s->ext.ecpointformats_len = ctx->ext.ecpointformats_len;
     }
     if (ctx->ext.supportedgroups != NULL) {
         size_t add = 0;
@@ -853,10 +843,9 @@ SSL *ossl_ssl_connection_new_int(SSL_CTX *ctx, SSL *user_ssl,
         if (ctx->ext.supportedgroups_len == 0)
             /* Add 1 so allocation won't fail */
             add = 1;
-        s->ext.supportedgroups =
-            OPENSSL_memdup(ctx->ext.supportedgroups,
-                           (ctx->ext.supportedgroups_len + add)
-                           * sizeof(*ctx->ext.supportedgroups));
+        s->ext.supportedgroups = OPENSSL_memdup(ctx->ext.supportedgroups,
+            (ctx->ext.supportedgroups_len + add)
+                * sizeof(*ctx->ext.supportedgroups));
         if (s->ext.supportedgroups == NULL) {
             s->ext.supportedgroups_len = 0;
             goto err;
@@ -869,10 +858,9 @@ SSL *ossl_ssl_connection_new_int(SSL_CTX *ctx, SSL *user_ssl,
         if (ctx->ext.keyshares_len == 0)
             /* Add 1 so allocation won't fail */
             add = 1;
-        s->ext.keyshares =
-            OPENSSL_memdup(ctx->ext.keyshares,
-                           (ctx->ext.keyshares_len + add)
-                           * sizeof(*ctx->ext.keyshares));
+        s->ext.keyshares = OPENSSL_memdup(ctx->ext.keyshares,
+            (ctx->ext.keyshares_len + add)
+                * sizeof(*ctx->ext.keyshares));
         if (s->ext.keyshares == NULL) {
             s->ext.keyshares_len = 0;
             goto err;
@@ -885,10 +873,9 @@ SSL *ossl_ssl_connection_new_int(SSL_CTX *ctx, SSL *user_ssl,
         if (ctx->ext.tuples_len == 0)
             /* Add 1 so allocation won't fail */
             add = 1;
-        s->ext.tuples =
-            OPENSSL_memdup(ctx->ext.tuples,
-                           (ctx->ext.tuples_len + add)
-                           * sizeof(*ctx->ext.tuples));
+        s->ext.tuples = OPENSSL_memdup(ctx->ext.tuples,
+            (ctx->ext.tuples_len + add)
+                * sizeof(*ctx->ext.tuples));
         if (s->ext.tuples == NULL) {
             s->ext.tuples_len = 0;
             goto err;
@@ -948,14 +935,14 @@ SSL *ossl_ssl_connection_new_int(SSL_CTX *ctx, SSL *user_ssl,
 #endif
     if (ctx->client_cert_type != NULL) {
         s->client_cert_type = OPENSSL_memdup(ctx->client_cert_type,
-                                             ctx->client_cert_type_len);
+            ctx->client_cert_type_len);
         if (s->client_cert_type == NULL)
             goto sslerr;
         s->client_cert_type_len = ctx->client_cert_type_len;
     }
     if (ctx->server_cert_type != NULL) {
         s->server_cert_type = OPENSSL_memdup(ctx->server_cert_type,
-                                             ctx->server_cert_type_len);
+            ctx->server_cert_type_len);
         if (s->server_cert_type == NULL)
             goto sslerr;
         s->server_cert_type_len = ctx->server_cert_type_len;
@@ -963,21 +950,21 @@ SSL *ossl_ssl_connection_new_int(SSL_CTX *ctx, SSL *user_ssl,
 
 #ifndef OPENSSL_NO_CT
     if (!SSL_set_ct_validation_callback(ssl, ctx->ct_validation_callback,
-                                        ctx->ct_validation_callback_arg))
+            ctx->ct_validation_callback_arg))
         goto sslerr;
 #endif
 
     s->ssl_pkey_num = SSL_PKEY_NUM + ctx->sigalg_list_len;
     return ssl;
- cerr:
+cerr:
     ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
     goto err;
- asn1err:
+asn1err:
     ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB);
     goto err;
- sslerr:
+sslerr:
     ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB);
- err:
+err:
     SSL_free(ssl);
     return NULL;
 }
@@ -1022,6 +1009,11 @@ int SSL_is_quic(const SSL *s)
     return IS_QUIC(s);
 }
 
+int SSL_CTX_is_quic(const SSL_CTX *c)
+{
+    return IS_QUIC_CTX(c);
+}
+
 int SSL_up_ref(SSL *s)
 {
     int i;
@@ -1035,7 +1027,7 @@ int SSL_up_ref(SSL *s)
 }
 
 int SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx,
-                                   unsigned int sid_ctx_len)
+    unsigned int sid_ctx_len)
 {
     if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) {
         ERR_raise(ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
@@ -1048,7 +1040,7 @@ int SSL_CTX_set_session_id_context(SSL_CTX *ctx, const unsigned char *sid_ctx,
 }
 
 int SSL_set_session_id_context(SSL *ssl, const unsigned char *sid_ctx,
-                               unsigned int sid_ctx_len)
+    unsigned int sid_ctx_len)
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
 
@@ -1086,7 +1078,7 @@ int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)
 }
 
 int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
-                                unsigned int id_len)
+    unsigned int id_len)
 {
     /*
      * A quick examination of SSL_SESSION_hash and SSL_SESSION_cmp shows how
@@ -1182,7 +1174,7 @@ int SSL_add1_host(SSL *s, const char *host)
                 OPENSSL_free(old_ip);
                 /* There can be only one IP address */
                 ERR_raise_data(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT,
-                               "IP address was already set");
+                    "IP address was already set");
                 return 0;
             }
 
@@ -1332,7 +1324,7 @@ int SSL_get0_dane_authority(SSL *s, X509 **mcert, EVP_PKEY **mspki)
 }
 
 int SSL_get0_dane_tlsa(SSL *s, uint8_t *usage, uint8_t *selector,
-                       uint8_t *mtype, const unsigned char **data, size_t *dlen)
+    uint8_t *mtype, const unsigned char **data, size_t *dlen)
 {
     SSL_DANE *dane;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
@@ -1370,7 +1362,7 @@ SSL_DANE *SSL_get0_dane(SSL *s)
 }
 
 int SSL_dane_tlsa_add(SSL *s, uint8_t usage, uint8_t selector,
-                      uint8_t mtype, const unsigned char *data, size_t dlen)
+    uint8_t mtype, const unsigned char *data, size_t dlen)
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 
@@ -1381,7 +1373,7 @@ int SSL_dane_tlsa_add(SSL *s, uint8_t usage, uint8_t selector,
 }
 
 int SSL_CTX_dane_mtype_set(SSL_CTX *ctx, const EVP_MD *md, uint8_t mtype,
-                           uint8_t ord)
+    uint8_t ord)
 {
     return dane_mtype_set(&ctx->dane, md, mtype, ord);
 }
@@ -1733,17 +1725,8 @@ int SSL_set_fd(SSL *s, int fd)
     }
     BIO_set_fd(bio, fd, BIO_NOCLOSE);
     SSL_set_bio(s, bio, bio);
-#ifndef OPENSSL_NO_KTLS
-    /*
-     * The new socket is created successfully regardless of ktls_enable.
-     * ktls_enable doesn't change any functionality of the socket, except
-     * changing the setsockopt to enable the processing of ktls_start.
-     * Thus, it is not a problem to call it for non-TLS sockets.
-     */
-    ktls_enable(fd);
-#endif /* OPENSSL_NO_KTLS */
     ret = 1;
- err:
+err:
     return ret;
 }
 
@@ -1767,15 +1750,6 @@ int SSL_set_wfd(SSL *s, int fd)
         }
         BIO_set_fd(bio, fd, BIO_NOCLOSE);
         SSL_set0_wbio(s, bio);
-#ifndef OPENSSL_NO_KTLS
-        /*
-         * The new socket is created successfully regardless of ktls_enable.
-         * ktls_enable doesn't change any functionality of the socket, except
-         * changing the setsockopt to enable the processing of ktls_start.
-         * Thus, it is not a problem to call it for non-TLS sockets.
-         */
-        ktls_enable(fd);
-#endif /* OPENSSL_NO_KTLS */
     } else {
         if (!BIO_up_ref(rbio))
             return 0;
@@ -1866,7 +1840,8 @@ int SSL_get_verify_depth(const SSL *s)
     return X509_VERIFY_PARAM_get_depth(sc->param);
 }
 
-int (*SSL_get_verify_callback(const SSL *s)) (int, X509_STORE_CTX *) {
+int (*SSL_get_verify_callback(const SSL *s))(int, X509_STORE_CTX *)
+{
     const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
 
     if (sc == NULL)
@@ -1885,12 +1860,13 @@ int SSL_CTX_get_verify_depth(const SSL_CTX *ctx)
     return X509_VERIFY_PARAM_get_depth(ctx->param);
 }
 
-int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx)) (int, X509_STORE_CTX *) {
+int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx))(int, X509_STORE_CTX *)
+{
     return ctx->default_verify_callback;
 }
 
 void SSL_set_verify(SSL *s, int mode,
-                    int (*callback) (int ok, X509_STORE_CTX *ctx))
+    int (*callback)(int ok, X509_STORE_CTX *ctx))
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 
@@ -1923,7 +1899,7 @@ void SSL_set_read_ahead(SSL *s, int yes)
     RECORD_LAYER_set_read_ahead(&sc->rlayer, yes);
 
     *opts++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD,
-                                       &sc->rlayer.read_ahead);
+        &sc->rlayer.read_ahead);
     *opts = OSSL_PARAM_construct_end();
 
     /* Ignore return value */
@@ -2089,8 +2065,7 @@ int SSL_CTX_check_private_key(const SSL_CTX *ctx)
         ERR_raise(ERR_LIB_SSL, SSL_R_NO_PRIVATE_KEY_ASSIGNED);
         return 0;
     }
-    return X509_check_private_key
-            (ctx->cert->key->x509, ctx->cert->key->privatekey);
+    return X509_check_private_key(ctx->cert->key->x509, ctx->cert->key->privatekey);
 }
 
 /* Fix this function so that it takes an optional type parameter */
@@ -2111,7 +2086,7 @@ int SSL_check_private_key(const SSL *ssl)
         return 0;
     }
     return X509_check_private_key(sc->cert->key->x509,
-                                   sc->cert->key->privatekey);
+        sc->cert->key->privatekey);
 }
 
 int SSL_waiting_for_async(SSL *s)
@@ -2141,7 +2116,7 @@ int SSL_get_all_async_fds(SSL *s, OSSL_ASYNC_FD *fds, size_t *numfds)
 }
 
 int SSL_get_changed_async_fds(SSL *s, OSSL_ASYNC_FD *addfd, size_t *numaddfds,
-                              OSSL_ASYNC_FD *delfd, size_t *numdelfds)
+    OSSL_ASYNC_FD *delfd, size_t *numdelfds)
 {
     ASYNC_WAIT_CTX *ctx;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
@@ -2152,7 +2127,7 @@ int SSL_get_changed_async_fds(SSL *s, OSSL_ASYNC_FD *addfd, size_t *numaddfds,
     if ((ctx = sc->waitctx) == NULL)
         return 0;
     return ASYNC_WAIT_CTX_get_changed_fds(ctx, addfd, numaddfds, delfd,
-                                          numdelfds);
+        numdelfds);
 }
 
 int SSL_CTX_set_async_callback(SSL_CTX *ctx, SSL_async_callback_fn callback)
@@ -2260,7 +2235,7 @@ static int ssl_async_wait_ctx_cb(void *arg)
 }
 
 static int ssl_start_async_job(SSL *s, struct ssl_async_args *args,
-                               int (*func) (void *))
+    int (*func)(void *))
 {
     int ret;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
@@ -2273,14 +2248,13 @@ static int ssl_start_async_job(SSL *s, struct ssl_async_args *args,
         if (sc->waitctx == NULL)
             return -1;
         if (sc->async_cb != NULL
-            && !ASYNC_WAIT_CTX_set_callback
-                 (sc->waitctx, ssl_async_wait_ctx_cb, s))
+            && !ASYNC_WAIT_CTX_set_callback(sc->waitctx, ssl_async_wait_ctx_cb, s))
             return -1;
     }
 
     sc->rwstate = SSL_NOTHING;
     switch (ASYNC_start_job(&sc->job, sc->waitctx, &ret, func, args,
-                            sizeof(struct ssl_async_args))) {
+        sizeof(struct ssl_async_args))) {
     case ASYNC_ERR:
         sc->rwstate = SSL_NOTHING;
         ERR_raise(ERR_LIB_SSL, SSL_R_FAILED_TO_INIT_ASYNC);
@@ -2351,7 +2325,7 @@ int ssl_read_internal(SSL *s, void *buf, size_t num, size_t *readbytes)
     }
 
     if (sc->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY
-                || sc->early_data_state == SSL_EARLY_DATA_ACCEPT_RETRY) {
+        || sc->early_data_state == SSL_EARLY_DATA_ACCEPT_RETRY) {
         ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
         return 0;
     }
@@ -2449,8 +2423,7 @@ int SSL_read_early_data(SSL *s, void *buf, size_t num, size_t *readbytes)
              * SSL_EARLY_DATA_FINISHED_READING if we get an EndOfEarlyData
              * message
              */
-            if (ret > 0 || (ret <= 0 && sc->early_data_state
-                                        != SSL_EARLY_DATA_FINISHED_READING)) {
+            if (ret > 0 || (ret <= 0 && sc->early_data_state != SSL_EARLY_DATA_FINISHED_READING)) {
                 sc->early_data_state = SSL_EARLY_DATA_READ_RETRY;
                 return ret > 0 ? SSL_READ_EARLY_DATA_SUCCESS
                                : SSL_READ_EARLY_DATA_ERROR;
@@ -2538,7 +2511,6 @@ int SSL_peek(SSL *s, void *buf, int num)
     return ret;
 }
 
-
 int SSL_peek_ex(SSL *s, void *buf, size_t num, size_t *readbytes)
 {
     int ret = ssl_peek_internal(s, buf, num, readbytes);
@@ -2549,7 +2521,7 @@ int SSL_peek_ex(SSL *s, void *buf, size_t num, size_t *readbytes)
 }
 
 int ssl_write_internal(SSL *s, const void *buf, size_t num,
-                       uint64_t flags, size_t *written)
+    uint64_t flags, size_t *written)
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 
@@ -2578,8 +2550,8 @@ int ssl_write_internal(SSL *s, const void *buf, size_t num,
     }
 
     if (sc->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY
-                || sc->early_data_state == SSL_EARLY_DATA_ACCEPT_RETRY
-                || sc->early_data_state == SSL_EARLY_DATA_READ_RETRY) {
+        || sc->early_data_state == SSL_EARLY_DATA_ACCEPT_RETRY
+        || sc->early_data_state == SSL_EARLY_DATA_READ_RETRY) {
         ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
         return 0;
     }
@@ -2653,20 +2625,18 @@ ossl_ssize_t SSL_sendfile(SSL *s, int fd, off_t offset, size_t size, int flags)
 
 #ifdef OPENSSL_NO_KTLS
     ERR_raise_data(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR,
-                   "can't call ktls_sendfile(), ktls disabled");
+        "can't call ktls_sendfile(), ktls disabled");
     return -1;
 #else
     ret = ktls_sendfile(SSL_get_wfd(s), fd, offset, size, flags);
     if (ret < 0) {
 #if defined(EAGAIN) && defined(EINTR) && defined(EBUSY)
-        if ((get_last_sys_error() == EAGAIN) ||
-            (get_last_sys_error() == EINTR) ||
-            (get_last_sys_error() == EBUSY))
+        if ((get_last_sys_error() == EAGAIN) || (get_last_sys_error() == EINTR) || (get_last_sys_error() == EBUSY))
             BIO_set_retry_write(sc->wbio);
         else
 #endif
             ERR_raise_data(ERR_LIB_SYS, get_last_sys_error(),
-                           "ktls_sendfile failure");
+                "ktls_sendfile failure");
         return ret;
     }
     sc->rwstate = SSL_NOTHING;
@@ -2702,7 +2672,7 @@ int SSL_write_ex(SSL *s, const void *buf, size_t num, size_t *written)
 }
 
 int SSL_write_ex2(SSL *s, const void *buf, size_t num, uint64_t flags,
-                  size_t *written)
+    size_t *written)
 {
     int ret = ssl_write_internal(s, buf, num, flags, written);
 
@@ -2725,9 +2695,9 @@ int SSL_write_early_data(SSL *s, const void *buf, size_t num, size_t *written)
     switch (sc->early_data_state) {
     case SSL_EARLY_DATA_NONE:
         if (sc->server
-                || !SSL_in_before(s)
-                || ((sc->session == NULL || sc->session->ext.max_early_data == 0)
-                     && (sc->psk_use_session_cb == NULL))) {
+            || !SSL_in_before(s)
+            || ((sc->session == NULL || sc->session->ext.max_early_data == 0)
+                && (sc->psk_use_session_cb == NULL))) {
             ERR_raise(ERR_LIB_SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
             return 0;
         }
@@ -2847,7 +2817,7 @@ int SSL_key_update(SSL *s, int updatetype)
     }
 
     if (updatetype != SSL_KEY_UPDATE_NOT_REQUESTED
-            && updatetype != SSL_KEY_UPDATE_REQUESTED) {
+        && updatetype != SSL_KEY_UPDATE_REQUESTED) {
         ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_KEY_UPDATE_TYPE);
         return 0;
     }
@@ -2954,8 +2924,8 @@ int SSL_new_session_ticket(SSL *s)
 
     /* If we are in init because we're sending tickets, okay to send more. */
     if ((SSL_in_init(s) && sc->ext.extra_tickets_expected == 0)
-            || SSL_IS_FIRST_HANDSHAKE(sc) || !sc->server
-            || !SSL_CONNECTION_IS_TLS13(sc))
+        || SSL_IS_FIRST_HANDSHAKE(sc) || !sc->server
+        || !SSL_CONNECTION_IS_TLS13(sc))
         return 0;
     sc->ext.extra_tickets_expected++;
     if (!RECORD_LAYER_write_pending(&sc->rlayer) && !SSL_in_init(s))
@@ -3002,14 +2972,13 @@ long ossl_ctrl_internal(SSL *s, int cmd, long larg, void *parg, int no_quic)
         RECORD_LAYER_set_read_ahead(&sc->rlayer, larg);
         return l;
 
-    case SSL_CTRL_MODE:
-    {
+    case SSL_CTRL_MODE: {
         OSSL_PARAM options[2], *opts = options;
 
         sc->mode |= larg;
 
         *opts++ = OSSL_PARAM_construct_uint32(OSSL_LIBSSL_RECORD_LAYER_PARAM_MODE,
-                                              &sc->mode);
+            &sc->mode);
         *opts = OSSL_PARAM_construct_end();
 
         /* Ignore return value */
@@ -3079,14 +3048,14 @@ long ossl_ctrl_internal(SSL *s, int cmd, long larg, void *parg, int no_quic)
             return 0;
     case SSL_CTRL_SET_MIN_PROTO_VERSION:
         return ssl_check_allowed_versions(larg, sc->max_proto_version)
-               && ssl_set_version_bound(s->defltmeth->version, (int)larg,
-                                        &sc->min_proto_version);
+            && ssl_set_version_bound(s->defltmeth->version, (int)larg,
+                &sc->min_proto_version);
     case SSL_CTRL_GET_MIN_PROTO_VERSION:
         return sc->min_proto_version;
     case SSL_CTRL_SET_MAX_PROTO_VERSION:
         return ssl_check_allowed_versions(sc->min_proto_version, larg)
-               && ssl_set_version_bound(s->defltmeth->version, (int)larg,
-                                        &sc->max_proto_version);
+            && ssl_set_version_bound(s->defltmeth->version, (int)larg,
+                &sc->max_proto_version);
     case SSL_CTRL_GET_MAX_PROTO_VERSION:
         return sc->max_proto_version;
     default:
@@ -3097,7 +3066,7 @@ long ossl_ctrl_internal(SSL *s, int cmd, long larg, void *parg, int no_quic)
     }
 }
 
-long SSL_callback_ctrl(SSL *s, int cmd, void (*fp) (void))
+long SSL_callback_ctrl(SSL *s, int cmd, void (*fp)(void))
 {
     return s->method->ssl_callback_ctrl(s, cmd, fp);
 }
@@ -3222,14 +3191,14 @@ long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
         return (ctx->cert->cert_flags &= ~larg);
     case SSL_CTRL_SET_MIN_PROTO_VERSION:
         return ssl_check_allowed_versions(larg, ctx->max_proto_version)
-               && ssl_set_version_bound(ctx->method->version, (int)larg,
-                                        &ctx->min_proto_version);
+            && ssl_set_version_bound(ctx->method->version, (int)larg,
+                &ctx->min_proto_version);
     case SSL_CTRL_GET_MIN_PROTO_VERSION:
         return ctx->min_proto_version;
     case SSL_CTRL_SET_MAX_PROTO_VERSION:
         return ssl_check_allowed_versions(ctx->min_proto_version, larg)
-               && ssl_set_version_bound(ctx->method->version, (int)larg,
-                                        &ctx->max_proto_version);
+            && ssl_set_version_bound(ctx->method->version, (int)larg,
+                &ctx->max_proto_version);
     case SSL_CTRL_GET_MAX_PROTO_VERSION:
         return ctx->max_proto_version;
     default:
@@ -3237,14 +3206,13 @@ long SSL_CTX_ctrl(SSL_CTX *ctx, int cmd, long larg, void *parg)
     }
 }
 
-long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp) (void))
+long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)(void))
 {
     switch (cmd) {
     case SSL_CTRL_SET_MSG_CALLBACK:
-        ctx->msg_callback = (void (*)
-                             (int write_p, int version, int content_type,
-                              const void *buf, size_t len, SSL *ssl,
-                              void *arg))(fp);
+        ctx->msg_callback = (void (*)(int write_p, int version, int content_type,
+            const void *buf, size_t len, SSL *ssl,
+            void *arg))(fp);
         return 1;
 
     default:
@@ -3262,7 +3230,7 @@ int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b)
 }
 
 int ssl_cipher_ptr_id_cmp(const SSL_CIPHER *const *ap,
-                          const SSL_CIPHER *const *bp)
+    const SSL_CIPHER *const *bp)
 {
     if ((*ap)->id > (*bp)->id)
         return 1;
@@ -3336,7 +3304,7 @@ STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL_CONNECTION *s)
         if (s->cipher_list_by_id != NULL)
             return s->cipher_list_by_id;
         else if (s->ssl.ctx != NULL
-                 && s->ssl.ctx->cipher_list_by_id != NULL)
+            && s->ssl.ctx->cipher_list_by_id != NULL)
             return s->ssl.ctx->cipher_list_by_id;
     }
     return NULL;
@@ -3394,8 +3362,8 @@ int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
     STACK_OF(SSL_CIPHER) *sk;
 
     sk = ssl_create_cipher_list(ctx, ctx->tls13_ciphersuites,
-                                &ctx->cipher_list, &ctx->cipher_list_by_id, str,
-                                ctx->cert);
+        &ctx->cipher_list, &ctx->cipher_list_by_id, str,
+        ctx->cert);
     /*
      * ssl_create_cipher_list may return an empty stack if it was unable to
      * find a cipher matching the given rule string (for example if the rule
@@ -3424,8 +3392,8 @@ int SSL_set_cipher_list(SSL *s, const char *str)
 
     ctx = s->ctx;
     sk = ssl_create_cipher_list(ctx, sc->tls13_ciphersuites,
-                                &sc->cipher_list, &sc->cipher_list_by_id, str,
-                                sc->cert);
+        &sc->cipher_list, &sc->cipher_list_by_id, str,
+        sc->cert);
     /* see comment in SSL_CTX_set_cipher_list */
     if (sk == NULL)
         return 0;
@@ -3444,22 +3412,21 @@ char *SSL_get_shared_ciphers(const SSL *s, char *buf, int size)
     int i;
     const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
 
-    if (sc == NULL)
+    if (size < 2 || buf == NULL)
         return NULL;
 
-    if (!sc->server
-            || sc->peer_ciphers == NULL
-            || size < 2)
+    buf[0] = '\0';
+
+    if (sc == NULL || !sc->server)
         return NULL;
 
     p = buf;
     clntsk = sc->peer_ciphers;
     srvrsk = SSL_get_ciphers(s);
-    if (clntsk == NULL || srvrsk == NULL)
-        return NULL;
 
-    if (sk_SSL_CIPHER_num(clntsk) == 0 || sk_SSL_CIPHER_num(srvrsk) == 0)
-        return NULL;
+    if (clntsk == NULL || sk_SSL_CIPHER_num(clntsk) == 0
+        || srvrsk == NULL || sk_SSL_CIPHER_num(srvrsk) == 0)
+        return buf;
 
     for (i = 0; i < sk_SSL_CIPHER_num(clntsk); i++) {
         int n;
@@ -3468,19 +3435,20 @@ char *SSL_get_shared_ciphers(const SSL *s, char *buf, int size)
         if (sk_SSL_CIPHER_find(srvrsk, c) < 0)
             continue;
 
-        n = OPENSSL_strnlen(c->name, size);
-        if (n >= size) {
-            if (p != buf)
-                --p;
-            *p = '\0';
-            return buf;
-        }
+        n = (int)OPENSSL_strnlen(c->name, size);
+        if (n >= size)
+            break;
+
         memcpy(p, c->name, n);
         p += n;
         *(p++) = ':';
         size -= n + 1;
     }
-    p[-1] = '\0';
+
+    /* No overlap */
+    if (p != buf)
+        p[-1] = '\0';
+
     return buf;
 }
 
@@ -3528,7 +3496,7 @@ const char *SSL_get_servername(const SSL *s, const int type)
          * - The function will return the servername requested by the client in
          *   this handshake or NULL if none was requested.
          */
-         if (sc->hit && !SSL_CONNECTION_IS_TLS13(sc))
+        if (sc->hit && !SSL_CONNECTION_IS_TLS13(sc))
             return sc->session->ext.hostname;
     } else {
         /**
@@ -3555,8 +3523,8 @@ const char *SSL_get_servername(const SSL *s, const int type)
          */
         if (SSL_in_before(s)) {
             if (sc->ext.hostname == NULL
-                    && sc->session != NULL
-                    && sc->session->ssl_version != TLS1_3_VERSION)
+                && sc->session != NULL
+                && sc->session->ssl_version != TLS1_3_VERSION)
                 return sc->session->ext.hostname;
         } else {
             if (!SSL_CONNECTION_IS_TLS13(sc) && sc->hit
@@ -3596,15 +3564,15 @@ int SSL_get_servername_type(const SSL *s)
  * found, or OPENSSL_NPN_NO_OVERLAP if the fallback case was reached.
  */
 int SSL_select_next_proto(unsigned char **out, unsigned char *outlen,
-                          const unsigned char *server,
-                          unsigned int server_len,
-                          const unsigned char *client, unsigned int client_len)
+    const unsigned char *server,
+    unsigned int server_len,
+    const unsigned char *client, unsigned int client_len)
 {
     PACKET cpkt, csubpkt, spkt, ssubpkt;
 
     if (!PACKET_buf_init(&cpkt, client, client_len)
-            || !PACKET_get_length_prefixed_1(&cpkt, &csubpkt)
-            || PACKET_remaining(&csubpkt) == 0) {
+        || !PACKET_get_length_prefixed_1(&cpkt, &csubpkt)
+        || PACKET_remaining(&csubpkt) == 0) {
         *out = NULL;
         *outlen = 0;
         return OPENSSL_NPN_NO_OVERLAP;
@@ -3627,7 +3595,7 @@ int SSL_select_next_proto(unsigned char **out, unsigned char *outlen,
             if (PACKET_buf_init(&cpkt, client, client_len)) {
                 while (PACKET_get_length_prefixed_1(&cpkt, &csubpkt)) {
                     if (PACKET_equal(&csubpkt, PACKET_data(&ssubpkt),
-                                     PACKET_remaining(&ssubpkt))) {
+                            PACKET_remaining(&ssubpkt))) {
                         /* We found a match */
                         *out = (unsigned char *)PACKET_data(&ssubpkt);
                         *outlen = (unsigned char)PACKET_remaining(&ssubpkt);
@@ -3660,7 +3628,7 @@ int SSL_select_next_proto(unsigned char **out, unsigned char *outlen,
  * provided by the callback.
  */
 void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data,
-                                    unsigned *len)
+    unsigned *len)
 {
     const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
 
@@ -3690,8 +3658,8 @@ void SSL_get0_next_proto_negotiated(const SSL *s, const unsigned char **data,
  * ServerHello.
  */
 void SSL_CTX_set_npn_advertised_cb(SSL_CTX *ctx,
-                                   SSL_CTX_npn_advertised_cb_func cb,
-                                   void *arg)
+    SSL_CTX_npn_advertised_cb_func cb,
+    void *arg)
 {
     if (IS_QUIC_CTX(ctx))
         /* NPN not allowed for QUIC */
@@ -3712,8 +3680,8 @@ void SSL_CTX_set_npn_advertised_cb(SSL_CTX *ctx,
  * a value other than SSL_TLSEXT_ERR_OK.
  */
 void SSL_CTX_set_npn_select_cb(SSL_CTX *ctx,
-                               SSL_CTX_npn_select_cb_func cb,
-                               void *arg)
+    SSL_CTX_npn_select_cb_func cb,
+    void *arg)
 {
     if (IS_QUIC_CTX(ctx))
         /* NPN not allowed for QUIC */
@@ -3743,7 +3711,7 @@ static int alpn_value_ok(const unsigned char *protos, unsigned int protos_len)
  * length-prefixed strings). Returns 0 on success.
  */
 int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos,
-                            unsigned int protos_len)
+    unsigned int protos_len)
 {
     unsigned char *alpn;
 
@@ -3773,7 +3741,7 @@ int SSL_CTX_set_alpn_protos(SSL_CTX *ctx, const unsigned char *protos,
  * length-prefixed strings). Returns 0 on success.
  */
 int SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos,
-                        unsigned int protos_len)
+    unsigned int protos_len)
 {
     unsigned char *alpn;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
@@ -3807,8 +3775,8 @@ int SSL_set_alpn_protos(SSL *ssl, const unsigned char *protos,
  * from the client's list of offered protocols.
  */
 void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx,
-                                SSL_CTX_alpn_select_cb_func cb,
-                                void *arg)
+    SSL_CTX_alpn_select_cb_func cb,
+    void *arg)
 {
     ctx->ext.alpn_select_cb = cb;
     ctx->ext.alpn_select_cb_arg = arg;
@@ -3821,7 +3789,7 @@ void SSL_CTX_set_alpn_select_cb(SSL_CTX *ctx,
  * respond with a negotiated protocol then |*len| will be zero.
  */
 void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,
-                            unsigned int *len)
+    unsigned int *len)
 {
     const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
 
@@ -3840,9 +3808,9 @@ void SSL_get0_alpn_selected(const SSL *ssl, const unsigned char **data,
 }
 
 int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
-                               const char *label, size_t llen,
-                               const unsigned char *context, size_t contextlen,
-                               int use_context)
+    const char *label, size_t llen,
+    const unsigned char *context, size_t contextlen,
+    int use_context)
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 
@@ -3854,15 +3822,15 @@ int SSL_export_keying_material(SSL *s, unsigned char *out, size_t olen,
         return -1;
 
     return sc->ssl.method->ssl3_enc->export_keying_material(sc, out, olen, label,
-                                                            llen, context,
-                                                            contextlen,
-                                                            use_context);
+        llen, context,
+        contextlen,
+        use_context);
 }
 
 int SSL_export_keying_material_early(SSL *s, unsigned char *out, size_t olen,
-                                     const char *label, size_t llen,
-                                     const unsigned char *context,
-                                     size_t contextlen)
+    const char *label, size_t llen,
+    const unsigned char *context,
+    size_t contextlen)
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 
@@ -3873,7 +3841,7 @@ int SSL_export_keying_material_early(SSL *s, unsigned char *out, size_t olen,
         return 0;
 
     return tls13_export_keying_material_early(sc, out, olen, label, llen,
-                                              context, contextlen);
+        context, contextlen);
 }
 
 static unsigned long ssl_session_hash(const SSL_SESSION *a)
@@ -3888,11 +3856,7 @@ static unsigned long ssl_session_hash(const SSL_SESSION *a)
         session_id = tmp_storage;
     }
 
-    l = (unsigned long)
-        ((unsigned long)session_id[0]) |
-        ((unsigned long)session_id[1] << 8L) |
-        ((unsigned long)session_id[2] << 16L) |
-        ((unsigned long)session_id[3] << 24L);
+    l = (unsigned long)((unsigned long)session_id[0]) | ((unsigned long)session_id[1] << 8L) | ((unsigned long)session_id[2] << 16L) | ((unsigned long)session_id[3] << 24L);
     return l;
 }
 
@@ -3948,15 +3912,15 @@ DEFINE_RUN_ONCE_STATIC(ssl_keylog_init)
  * @returns 1 always
  */
 static long check_keylog_bio_free(BIO *b, int oper, const char *argp,
-                                  size_t len, int argi, long argl, int ret,
-                                  size_t *processed)
+    size_t len, int argi, long argl, int ret,
+    size_t *processed)
 {
 
     /*
      * Note we _dont_ take the keylog_lock here
      * This is intentional, because we only free the keylog lock
-     * During SSL_CTX_free, in which we already posess the lock, so
-     * Theres no need to grab it again here
+     * During SSL_CTX_free, in which we already possess the lock, so
+     * There's no need to grab it again here
      */
     if (oper == BIO_CB_FREE)
         keylog_bio = NULL;
@@ -3991,12 +3955,12 @@ static void do_sslkeylogfile(const SSL *ssl, const char *line)
 #ifndef OPENSSL_NO_SSLKEYLOG
 static BIO *get_sslkeylog_bio(const char *keylogfile)
 {
-# ifdef _POSIX_C_SOURCE
+#ifdef _POSIX_C_SOURCE
     BIO *b;
     int fdno = -1;
     FILE *fp = NULL;
 
-    fdno = open(keylogfile, O_WRONLY | O_CREAT | O_APPEND,  0600);
+    fdno = open(keylogfile, O_WRONLY | O_CREAT | O_APPEND, 0600);
     if (fdno < 0)
         return NULL;
 
@@ -4009,14 +3973,14 @@ static BIO *get_sslkeylog_bio(const char *keylogfile)
     if ((b = BIO_new_fp(fp, BIO_CLOSE)) == NULL)
         fclose(fp);
     return b;
-# else
+#else
     return BIO_new_file(keylogfile, "a");
-# endif
+#endif
 }
 #endif
 
 SSL_CTX *SSL_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq,
-                        const SSL_METHOD *meth)
+    const SSL_METHOD *meth)
 {
     SSL_CTX *ret = NULL;
 #ifndef OPENSSL_NO_SSLKEYLOG
@@ -4134,9 +4098,9 @@ SSL_CTX *SSL_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq,
     }
 
     if (!ssl_create_cipher_list(ret,
-                                ret->tls13_ciphersuites,
-                                &ret->cipher_list, &ret->cipher_list_by_id,
-                                OSSL_default_cipher_list(), ret->cert)
+            ret->tls13_ciphersuites,
+            &ret->cipher_list, &ret->cipher_list_by_id,
+            OSSL_default_cipher_list(), ret->cert)
         || sk_SSL_CIPHER_num(ret->cipher_list) <= 0) {
         ERR_raise(ERR_LIB_SSL, SSL_R_LIBRARY_HAS_NO_CIPHERS);
         goto err;
@@ -4182,15 +4146,19 @@ SSL_CTX *SSL_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq,
 
     /* Setup RFC5077 ticket keys */
     if ((RAND_bytes_ex(libctx, ret->ext.tick_key_name,
-                       sizeof(ret->ext.tick_key_name), 0) <= 0)
+             sizeof(ret->ext.tick_key_name), 0)
+            <= 0)
         || (RAND_priv_bytes_ex(libctx, ret->ext.secure->tick_hmac_key,
-                               sizeof(ret->ext.secure->tick_hmac_key), 0) <= 0)
+                sizeof(ret->ext.secure->tick_hmac_key), 0)
+            <= 0)
         || (RAND_priv_bytes_ex(libctx, ret->ext.secure->tick_aes_key,
-                               sizeof(ret->ext.secure->tick_aes_key), 0) <= 0))
+                sizeof(ret->ext.secure->tick_aes_key), 0)
+            <= 0))
         ret->options |= SSL_OP_NO_TICKET;
 
     if (RAND_priv_bytes_ex(libctx, ret->ext.cookie_hmac_key,
-                           sizeof(ret->ext.cookie_hmac_key), 0) <= 0) {
+            sizeof(ret->ext.cookie_hmac_key), 0)
+        <= 0) {
         ERR_raise(ERR_LIB_SSL, ERR_R_RAND_LIB);
         goto err;
     }
@@ -4202,9 +4170,9 @@ SSL_CTX *SSL_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq,
     }
 #endif
 #ifndef OPENSSL_NO_ENGINE
-# ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO
-#  define eng_strx(x)     #x
-#  define eng_str(x)      eng_strx(x)
+#ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO
+#define eng_strx(x) #x
+#define eng_str(x) eng_strx(x)
     /* Use specific client engine automatically... ignore errors */
     {
         ENGINE *eng;
@@ -4217,7 +4185,7 @@ SSL_CTX *SSL_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq,
         if (!eng || !SSL_CTX_set_client_cert_engine(ret, eng))
             ERR_clear_error();
     }
-# endif
+#endif
 #endif
 
 #ifndef OPENSSL_NO_COMP_ALG
@@ -4277,14 +4245,14 @@ SSL_CTX *SSL_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq,
     /* By default we send two session tickets automatically in TLSv1.3 */
     ret->num_tickets = 2;
 
-# ifndef OPENSSL_NO_QUIC
+#ifndef OPENSSL_NO_QUIC
     /* only create a cache for client CTX-es */
     if (meth == OSSL_QUIC_client_method())
         if ((ret->tokencache = ossl_quic_new_token_store()) == NULL)
             goto err;
     ret->domain_flags = 0;
     if (IS_QUIC_METHOD(meth)) {
-#  if defined(OPENSSL_THREADS)
+#if defined(OPENSSL_THREADS)
         if (meth == OSSL_QUIC_client_thread_method())
             ret->domain_flags
                 = SSL_DOMAIN_FLAG_MULTI_THREAD
@@ -4294,13 +4262,13 @@ SSL_CTX *SSL_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq,
             ret->domain_flags
                 = SSL_DOMAIN_FLAG_MULTI_THREAD
                 | SSL_DOMAIN_FLAG_LEGACY_BLOCKING;
-#  else
+#else
         ret->domain_flags
             = SSL_DOMAIN_FLAG_SINGLE_THREAD
             | SSL_DOMAIN_FLAG_LEGACY_BLOCKING;
-#  endif
+#endif
     }
-# endif
+#endif
 
     if (!ssl_ctx_system_config(ret)) {
         ERR_raise(ERR_LIB_SSL, SSL_R_ERROR_IN_SYSTEM_DEFAULT_CONFIG);
@@ -4312,7 +4280,7 @@ SSL_CTX *SSL_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq,
         /* Make sure we have a global lock allocated */
         if (!RUN_ONCE(&ssl_keylog_once, ssl_keylog_init)) {
             /* use a trace message as a warning */
-            OSSL_TRACE(TLS, "Unable to initalize keylog data\n");
+            OSSL_TRACE(TLS, "Unable to initialize keylog data\n");
             goto out;
         }
 
@@ -4347,7 +4315,7 @@ SSL_CTX *SSL_CTX_new_ex(OSSL_LIB_CTX *libctx, const char *propq,
 out:
 #endif
     return ret;
- err:
+err:
     SSL_CTX_free(ret);
 #ifndef OPENSSL_NO_SSLKEYLOG
     BIO_free(keylog_bio);
@@ -4553,15 +4521,15 @@ void *SSL_get_default_passwd_cb_userdata(SSL *s)
 }
 
 void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,
-                                      int (*cb) (X509_STORE_CTX *, void *),
-                                      void *arg)
+    int (*cb)(X509_STORE_CTX *, void *),
+    void *arg)
 {
     ctx->app_verify_callback = cb;
     ctx->app_verify_arg = arg;
 }
 
 void SSL_CTX_set_verify(SSL_CTX *ctx, int mode,
-                        int (*cb) (int, X509_STORE_CTX *))
+    int (*cb)(int, X509_STORE_CTX *))
 {
     ctx->verify_mode = mode;
     ctx->default_verify_callback = cb;
@@ -4572,12 +4540,12 @@ void SSL_CTX_set_verify_depth(SSL_CTX *ctx, int depth)
     X509_VERIFY_PARAM_set_depth(ctx->param, depth);
 }
 
-void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb) (SSL *ssl, void *arg), void *arg)
+void SSL_CTX_set_cert_cb(SSL_CTX *c, int (*cb)(SSL *ssl, void *arg), void *arg)
 {
     ssl_cert_set_cert_cb(c->cert, cb, arg);
 }
 
-void SSL_set_cert_cb(SSL *s, int (*cb) (SSL *ssl, void *arg), void *arg)
+void SSL_set_cert_cb(SSL *s, int (*cb)(SSL *ssl, void *arg), void *arg)
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 
@@ -4599,8 +4567,8 @@ void ssl_set_masks(SSL_CONNECTION *s)
         return;
 
     dh_tmp = (c->dh_tmp != NULL
-              || c->dh_tmp_cb != NULL
-              || c->dh_tmp_auto);
+        || c->dh_tmp_cb != NULL
+        || c->dh_tmp_auto);
 
     rsa_enc = pvalid[SSL_PKEY_RSA] & CERT_PKEY_VALID;
     rsa_sign = pvalid[SSL_PKEY_RSA] & CERT_PKEY_VALID;
@@ -4610,7 +4578,7 @@ void ssl_set_masks(SSL_CONNECTION *s)
     mask_a = 0;
 
     OSSL_TRACE4(TLS_CIPHER, "dh_tmp=%d rsa_enc=%d rsa_sign=%d dsa_sign=%d\n",
-               dh_tmp, rsa_enc, rsa_sign, dsa_sign);
+        dh_tmp, rsa_enc, rsa_sign, dsa_sign);
 
 #ifndef OPENSSL_NO_GOST
     if (ssl_has_cert(s, SSL_PKEY_GOST12_512)) {
@@ -4638,9 +4606,7 @@ void ssl_set_masks(SSL_CONNECTION *s)
      * if TLS 1.2 and peer supports it.
      */
 
-    if (rsa_enc || rsa_sign || (ssl_has_cert(s, SSL_PKEY_RSA_PSS_SIGN)
-                && pvalid[SSL_PKEY_RSA_PSS_SIGN] & CERT_PKEY_EXPLICIT_SIGN
-                && TLS1_get_version(&s->ssl) == TLS1_2_VERSION))
+    if (rsa_enc || rsa_sign || (ssl_has_cert(s, SSL_PKEY_RSA_PSS_SIGN) && pvalid[SSL_PKEY_RSA_PSS_SIGN] & CERT_PKEY_EXPLICIT_SIGN && TLS1_get_version(&s->ssl) == TLS1_2_VERSION))
         mask_a |= SSL_aRSA;
 
     if (dsa_sign) {
@@ -4663,7 +4629,7 @@ void ssl_set_masks(SSL_CONNECTION *s)
         if (pvalid[SSL_PKEY_RSA_PSS_SIGN] & CERT_PKEY_RPK)
             mask_a |= SSL_aRSA;
         if (pvalid[SSL_PKEY_ED25519] & CERT_PKEY_RPK
-                || pvalid[SSL_PKEY_ED448] & CERT_PKEY_RPK)
+            || pvalid[SSL_PKEY_ED448] & CERT_PKEY_RPK)
             mask_a |= SSL_aECDSA;
     }
 
@@ -4682,15 +4648,15 @@ void ssl_set_masks(SSL_CONNECTION *s)
     }
     /* Allow Ed25519 for TLS 1.2 if peer supports it */
     if (!(mask_a & SSL_aECDSA) && ssl_has_cert(s, SSL_PKEY_ED25519)
-            && pvalid[SSL_PKEY_ED25519] & CERT_PKEY_EXPLICIT_SIGN
-            && TLS1_get_version(&s->ssl) == TLS1_2_VERSION)
-            mask_a |= SSL_aECDSA;
+        && pvalid[SSL_PKEY_ED25519] & CERT_PKEY_EXPLICIT_SIGN
+        && TLS1_get_version(&s->ssl) == TLS1_2_VERSION)
+        mask_a |= SSL_aECDSA;
 
     /* Allow Ed448 for TLS 1.2 if peer supports it */
     if (!(mask_a & SSL_aECDSA) && ssl_has_cert(s, SSL_PKEY_ED448)
-            && pvalid[SSL_PKEY_ED448] & CERT_PKEY_EXPLICIT_SIGN
-            && TLS1_get_version(&s->ssl) == TLS1_2_VERSION)
-            mask_a |= SSL_aECDSA;
+        && pvalid[SSL_PKEY_ED448] & CERT_PKEY_EXPLICIT_SIGN
+        && TLS1_get_version(&s->ssl) == TLS1_2_VERSION)
+        mask_a |= SSL_aECDSA;
 
     mask_k |= SSL_kECDHE;
 
@@ -4718,12 +4684,12 @@ int ssl_check_srvr_ecc_cert_and_alg(X509 *x, SSL_CONNECTION *s)
             return 0;
         }
     }
-    return 1;                   /* all checks are ok */
+    return 1; /* all checks are ok */
 }
 
 int ssl_get_server_cert_serverinfo(SSL_CONNECTION *s,
-                                   const unsigned char **serverinfo,
-                                   size_t *serverinfo_length)
+    const unsigned char **serverinfo,
+    size_t *serverinfo_length)
 {
     CERT_PKEY *cpk = s->s3.tmp.cert;
     *serverinfo_length = 0;
@@ -4758,7 +4724,7 @@ void ssl_update_cache(SSL_CONNECTION *s, int mode)
      * (clients can set SSL_VERIFY_PEER without needing a sid_ctx set).
      */
     if (s->server && s->session->sid_ctx_length == 0
-            && (s->verify_mode & SSL_VERIFY_PEER) != 0)
+        && (s->verify_mode & SSL_VERIFY_PEER) != 0)
         return;
 
     i = s->session_ctx->session_cache_mode;
@@ -4776,12 +4742,12 @@ void ssl_update_cache(SSL_CONNECTION *s, int mode)
          * - SSL_OP_NO_TICKET is set in which case it is a stateful ticket
          */
         if ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE) == 0
-                && (!SSL_CONNECTION_IS_TLS13(s)
-                    || !s->server
-                    || (s->max_early_data > 0
-                        && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0)
-                    || s->session_ctx->remove_session_cb != NULL
-                    || (s->options & SSL_OP_NO_TICKET) != 0))
+            && (!SSL_CONNECTION_IS_TLS13(s)
+                || !s->server
+                || (s->max_early_data > 0
+                    && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0)
+                || s->session_ctx->remove_session_cb != NULL
+                || (s->options & SSL_OP_NO_TICKET) != 0))
             SSL_CTX_add_session(s->session_ctx, s->session);
 
         /*
@@ -4791,7 +4757,7 @@ void ssl_update_cache(SSL_CONNECTION *s, int mode)
          */
         if (s->session_ctx->new_session_cb != NULL && SSL_SESSION_up_ref(s->session)) {
             if (!s->session_ctx->new_session_cb(SSL_CONNECTION_GET_USER_SSL(s),
-                                                s->session))
+                    s->session))
                 SSL_SESSION_free(s->session);
         }
     }
@@ -4832,7 +4798,7 @@ int SSL_set_ssl_method(SSL *s, const SSL_METHOD *meth)
 
     if (s->method != meth) {
         const SSL_METHOD *sm = s->method;
-        int (*hf) (SSL *) = sc->handshake_func;
+        int (*hf)(SSL *) = sc->handshake_func;
 
         if (sm->version == meth->version)
             s->method = meth;
@@ -4953,8 +4919,7 @@ int ossl_ssl_get_error(const SSL *s, int i, int check_err)
     if (SSL_want_client_hello_cb(s))
         return SSL_ERROR_WANT_CLIENT_HELLO_CB;
 
-    if ((sc->shutdown & SSL_RECEIVED_SHUTDOWN) &&
-        (sc->s3.warn_alert == SSL_AD_CLOSE_NOTIFY))
+    if ((sc->shutdown & SSL_RECEIVED_SHUTDOWN) && (sc->s3.warn_alert == SSL_AD_CLOSE_NOTIFY))
         return SSL_ERROR_ZERO_RETURN;
 
     return SSL_ERROR_SYSCALL;
@@ -5206,7 +5171,7 @@ SSL *SSL_dup(SSL *s)
         }
 
         if (!SSL_set_session_id_context(ret, sc->sid_ctx,
-                                        (int)sc->sid_ctx_length))
+                (int)sc->sid_ctx_length))
             goto err;
     }
 
@@ -5258,12 +5223,12 @@ SSL *SSL_dup(SSL *s)
 
     /* Dup the client_CA list */
     if (!dup_ca_names(&retsc->ca_names, sc->ca_names)
-            || !dup_ca_names(&retsc->client_ca_names, sc->client_ca_names))
+        || !dup_ca_names(&retsc->client_ca_names, sc->client_ca_names))
         goto err;
 
     return ret;
 
- err:
+err:
     SSL_free(ret);
     return NULL;
 }
@@ -5528,16 +5493,14 @@ SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX *ctx)
      * not match (i.e., it was set per-ssl with SSL_set_session_id_context),
      * leave it unchanged.
      */
-    if ((ssl->ctx != NULL) &&
-        (sc->sid_ctx_length == ssl->ctx->sid_ctx_length) &&
-        (memcmp(sc->sid_ctx, ssl->ctx->sid_ctx, sc->sid_ctx_length) == 0)) {
+    if ((ssl->ctx != NULL) && (sc->sid_ctx_length == ssl->ctx->sid_ctx_length) && (memcmp(sc->sid_ctx, ssl->ctx->sid_ctx, sc->sid_ctx_length) == 0)) {
         sc->sid_ctx_length = ctx->sid_ctx_length;
         memcpy(&sc->sid_ctx, &ctx->sid_ctx, sizeof(sc->sid_ctx));
     }
 
     ssl_cert_free(sc->cert);
     sc->cert = new_cert;
-    SSL_CTX_free(ssl->ctx);     /* decrement reference count */
+    SSL_CTX_free(ssl->ctx); /* decrement reference count */
     ssl->ctx = ctx;
 
     return ssl->ctx;
@@ -5550,7 +5513,7 @@ err:
 int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
 {
     return X509_STORE_set_default_paths_ex(ctx->cert_store, ctx->libctx,
-                                           ctx->propq);
+        ctx->propq);
 }
 
 int SSL_CTX_set_default_verify_dir(SSL_CTX *ctx)
@@ -5583,7 +5546,7 @@ int SSL_CTX_set_default_verify_file(SSL_CTX *ctx)
     ERR_set_mark();
 
     X509_LOOKUP_load_file_ex(lookup, NULL, X509_FILETYPE_DEFAULT, ctx->libctx,
-                             ctx->propq);
+        ctx->propq);
 
     ERR_pop_to_mark();
 
@@ -5611,7 +5574,7 @@ int SSL_CTX_set_default_verify_store(SSL_CTX *ctx)
 int SSL_CTX_load_verify_file(SSL_CTX *ctx, const char *CAfile)
 {
     return X509_STORE_load_file_ex(ctx->cert_store, CAfile, ctx->libctx,
-                                   ctx->propq);
+        ctx->propq);
 }
 
 int SSL_CTX_load_verify_dir(SSL_CTX *ctx, const char *CApath)
@@ -5622,11 +5585,11 @@ int SSL_CTX_load_verify_dir(SSL_CTX *ctx, const char *CApath)
 int SSL_CTX_load_verify_store(SSL_CTX *ctx, const char *CAstore)
 {
     return X509_STORE_load_store_ex(ctx->cert_store, CAstore, ctx->libctx,
-                                    ctx->propq);
+        ctx->propq);
 }
 
 int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
-                                  const char *CApath)
+    const char *CApath)
 {
     if (CAfile == NULL && CApath == NULL)
         return 0;
@@ -5638,7 +5601,7 @@ int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
 }
 
 void SSL_set_info_callback(SSL *ssl,
-                           void (*cb) (const SSL *ssl, int type, int val))
+    void (*cb)(const SSL *ssl, int type, int val))
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
 
@@ -5652,9 +5615,10 @@ void SSL_set_info_callback(SSL *ssl,
  * One compiler (Diab DCC) doesn't like argument names in returned function
  * pointer.
  */
-void (*SSL_get_info_callback(const SSL *ssl)) (const SSL * /* ssl */ ,
-                                               int /* type */ ,
-                                               int /* val */ ) {
+void (*SSL_get_info_callback(const SSL *ssl))(const SSL * /* ssl */,
+    int /* type */,
+    int /* val */)
+{
     const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(ssl);
 
     if (sc == NULL)
@@ -5714,7 +5678,7 @@ size_t SSL_get_server_random(const SSL *ssl, unsigned char *out, size_t outlen)
 }
 
 size_t SSL_SESSION_get_master_key(const SSL_SESSION *session,
-                                  unsigned char *out, size_t outlen)
+    unsigned char *out, size_t outlen)
 {
     if (outlen == 0)
         return session->master_key_length;
@@ -5725,7 +5689,7 @@ size_t SSL_SESSION_get_master_key(const SSL_SESSION *session,
 }
 
 int SSL_SESSION_set1_master_key(SSL_SESSION *sess, const unsigned char *in,
-                                size_t len)
+    size_t len)
 {
     if (len > sizeof(sess->master_key))
         return 0;
@@ -5735,7 +5699,6 @@ int SSL_SESSION_set1_master_key(SSL_SESSION *sess, const unsigned char *in,
     return 1;
 }
 
-
 int SSL_set_ex_data(SSL *s, int idx, void *arg)
 {
     return CRYPTO_set_ex_data(&s->ex_data, idx, arg);
@@ -5890,7 +5853,7 @@ void SSL_set_psk_find_session_callback(SSL *s, SSL_psk_find_session_cb_func cb)
 }
 
 void SSL_CTX_set_psk_find_session_callback(SSL_CTX *ctx,
-                                           SSL_psk_find_session_cb_func cb)
+    SSL_psk_find_session_cb_func cb)
 {
     ctx->psk_find_session_cb = cb;
 }
@@ -5906,47 +5869,47 @@ void SSL_set_psk_use_session_callback(SSL *s, SSL_psk_use_session_cb_func cb)
 }
 
 void SSL_CTX_set_psk_use_session_callback(SSL_CTX *ctx,
-                                           SSL_psk_use_session_cb_func cb)
+    SSL_psk_use_session_cb_func cb)
 {
     ctx->psk_use_session_cb = cb;
 }
 
 void SSL_CTX_set_msg_callback(SSL_CTX *ctx,
-                              void (*cb) (int write_p, int version,
-                                          int content_type, const void *buf,
-                                          size_t len, SSL *ssl, void *arg))
+    void (*cb)(int write_p, int version,
+        int content_type, const void *buf,
+        size_t len, SSL *ssl, void *arg))
 {
     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
 }
 
 void SSL_set_msg_callback(SSL *ssl,
-                          void (*cb) (int write_p, int version,
-                                      int content_type, const void *buf,
-                                      size_t len, SSL *ssl, void *arg))
+    void (*cb)(int write_p, int version,
+        int content_type, const void *buf,
+        size_t len, SSL *ssl, void *arg))
 {
     SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
 }
 
 void SSL_CTX_set_not_resumable_session_callback(SSL_CTX *ctx,
-                                                int (*cb) (SSL *ssl,
-                                                           int
-                                                           is_forward_secure))
+    int (*cb)(SSL *ssl,
+        int
+            is_forward_secure))
 {
     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
-                          (void (*)(void))cb);
+        (void (*)(void))cb);
 }
 
 void SSL_set_not_resumable_session_callback(SSL *ssl,
-                                            int (*cb) (SSL *ssl,
-                                                       int is_forward_secure))
+    int (*cb)(SSL *ssl,
+        int is_forward_secure))
 {
     SSL_callback_ctrl(ssl, SSL_CTRL_SET_NOT_RESUMABLE_SESS_CB,
-                      (void (*)(void))cb);
+        (void (*)(void))cb);
 }
 
 void SSL_CTX_set_record_padding_callback(SSL_CTX *ctx,
-                                         size_t (*cb) (SSL *ssl, int type,
-                                                       size_t len, void *arg))
+    size_t (*cb)(SSL *ssl, int type,
+        size_t len, void *arg))
 {
     ctx->record_padding_cb = cb;
 }
@@ -5962,7 +5925,7 @@ void *SSL_CTX_get_record_padding_callback_arg(const SSL_CTX *ctx)
 }
 
 int SSL_CTX_set_block_padding_ex(SSL_CTX *ctx, size_t app_block_size,
-                                 size_t hs_block_size)
+    size_t hs_block_size)
 {
     if (IS_QUIC_CTX(ctx) && (app_block_size > 1 || hs_block_size > 1))
         return 0;
@@ -5991,8 +5954,8 @@ int SSL_CTX_set_block_padding(SSL_CTX *ctx, size_t block_size)
 }
 
 int SSL_set_record_padding_callback(SSL *ssl,
-                                     size_t (*cb) (SSL *ssl, int type,
-                                                   size_t len, void *arg))
+    size_t (*cb)(SSL *ssl, int type,
+        size_t len, void *arg))
 {
     BIO *b;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
@@ -6029,7 +5992,7 @@ void *SSL_get_record_padding_callback_arg(const SSL *ssl)
 }
 
 int SSL_set_block_padding_ex(SSL *ssl, size_t app_block_size,
-                             size_t hs_block_size)
+    size_t hs_block_size)
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
 
@@ -6097,8 +6060,8 @@ size_t SSL_CTX_get_num_tickets(const SSL_CTX *ctx)
 
 /* Retrieve handshake hashes */
 int ssl_handshake_hash(SSL_CONNECTION *s,
-                       unsigned char *out, size_t outlen,
-                       size_t *hashlen)
+    unsigned char *out, size_t outlen,
+    size_t *hashlen)
 {
     EVP_MD_CTX *ctx = NULL;
     EVP_MD_CTX *hdgst = s->s3.handshake_dgst;
@@ -6125,7 +6088,7 @@ int ssl_handshake_hash(SSL_CONNECTION *s,
     *hashlen = hashleni;
 
     ret = 1;
- err:
+err:
     EVP_MD_CTX_free(ctx);
     return ret;
 }
@@ -6180,9 +6143,9 @@ int SSL_get_security_level(const SSL *s)
 }
 
 void SSL_set_security_callback(SSL *s,
-                               int (*cb) (const SSL *s, const SSL_CTX *ctx,
-                                          int op, int bits, int nid,
-                                          void *other, void *ex))
+    int (*cb)(const SSL *s, const SSL_CTX *ctx,
+        int op, int bits, int nid,
+        void *other, void *ex))
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 
@@ -6192,10 +6155,11 @@ void SSL_set_security_callback(SSL *s,
     sc->cert->sec_cb = cb;
 }
 
-int (*SSL_get_security_callback(const SSL *s)) (const SSL *s,
-                                                const SSL_CTX *ctx, int op,
-                                                int bits, int nid, void *other,
-                                                void *ex) {
+int (*SSL_get_security_callback(const SSL *s))(const SSL *s,
+    const SSL_CTX *ctx, int op,
+    int bits, int nid, void *other,
+    void *ex)
+{
     const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
 
     if (sc == NULL)
@@ -6235,19 +6199,20 @@ int SSL_CTX_get_security_level(const SSL_CTX *ctx)
 }
 
 void SSL_CTX_set_security_callback(SSL_CTX *ctx,
-                                   int (*cb) (const SSL *s, const SSL_CTX *ctx,
-                                              int op, int bits, int nid,
-                                              void *other, void *ex))
+    int (*cb)(const SSL *s, const SSL_CTX *ctx,
+        int op, int bits, int nid,
+        void *other, void *ex))
 {
     ctx->cert->sec_cb = cb;
 }
 
-int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx)) (const SSL *s,
-                                                          const SSL_CTX *ctx,
-                                                          int op, int bits,
-                                                          int nid,
-                                                          void *other,
-                                                          void *ex) {
+int (*SSL_CTX_get_security_callback(const SSL_CTX *ctx))(const SSL *s,
+    const SSL_CTX *ctx,
+    int op, int bits,
+    int nid,
+    void *other,
+    void *ex)
+{
     return ctx->cert->sec_cb;
 }
 
@@ -6303,7 +6268,7 @@ uint64_t SSL_set_options(SSL *s, uint64_t op)
     sc->options |= op;
 
     *opts++ = OSSL_PARAM_construct_uint64(OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS,
-                                          &sc->options);
+        &sc->options);
     *opts = OSSL_PARAM_construct_end();
 
     /* Ignore return value */
@@ -6334,7 +6299,7 @@ uint64_t SSL_clear_options(SSL *s, uint64_t op)
     sc->options &= ~op;
 
     *opts++ = OSSL_PARAM_construct_uint64(OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS,
-                                          &sc->options);
+        &sc->options);
     *opts = OSSL_PARAM_construct_end();
 
     /* Ignore return value */
@@ -6368,7 +6333,7 @@ IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id);
  * of error, likewise the |src| stack may be left in an intermediate state.
  */
 static int ct_move_scts(STACK_OF(SCT) **dst, STACK_OF(SCT) *src,
-                        sct_source_t origin)
+    sct_source_t origin)
 {
     int scts_moved = 0;
     SCT *sct = NULL;
@@ -6391,7 +6356,7 @@ static int ct_move_scts(STACK_OF(SCT) **dst, STACK_OF(SCT) *src,
     }
 
     return scts_moved;
- err:
+err:
     SCT_free(sct);
     return -1;
 }
@@ -6426,7 +6391,7 @@ static int ct_extract_tls_extension_scts(SSL_CONNECTION *s)
  */
 static int ct_extract_ocsp_response_scts(SSL_CONNECTION *s)
 {
-# ifndef OPENSSL_NO_OCSP
+#ifndef OPENSSL_NO_OCSP
     int scts_extracted = 0;
     const unsigned char *p;
     OCSP_BASICRESP *br = NULL;
@@ -6452,22 +6417,20 @@ static int ct_extract_ocsp_response_scts(SSL_CONNECTION *s)
         if (single == NULL)
             continue;
 
-        scts =
-            OCSP_SINGLERESP_get1_ext_d2i(single, NID_ct_cert_scts, NULL, NULL);
-        scts_extracted =
-            ct_move_scts(&s->scts, scts, SCT_SOURCE_OCSP_STAPLED_RESPONSE);
+        scts = OCSP_SINGLERESP_get1_ext_d2i(single, NID_ct_cert_scts, NULL, NULL);
+        scts_extracted = ct_move_scts(&s->scts, scts, SCT_SOURCE_OCSP_STAPLED_RESPONSE);
         if (scts_extracted < 0)
             goto err;
     }
- err:
+err:
     SCT_LIST_free(scts);
     OCSP_BASICRESP_free(br);
     OCSP_RESPONSE_free(rsp);
     return scts_extracted;
-# else
+#else
     /* Behave as if no OCSP response exists */
     return 0;
-# endif
+#endif
 }
 
 /*
@@ -6481,11 +6444,9 @@ static int ct_extract_x509v3_extension_scts(SSL_CONNECTION *s)
     X509 *cert = s->session != NULL ? s->session->peer : NULL;
 
     if (cert != NULL) {
-        STACK_OF(SCT) *scts =
-            X509_get_ext_d2i(cert, NID_ct_precert_scts, NULL, NULL);
+        STACK_OF(SCT) *scts = X509_get_ext_d2i(cert, NID_ct_precert_scts, NULL, NULL);
 
-        scts_extracted =
-            ct_move_scts(&s->scts, scts, SCT_SOURCE_X509V3_EXTENSION);
+        scts_extracted = ct_move_scts(&s->scts, scts, SCT_SOURCE_X509V3_EXTENSION);
 
         SCT_LIST_free(scts);
     }
@@ -6506,26 +6467,24 @@ const STACK_OF(SCT) *SSL_get0_peer_scts(SSL *s)
         return NULL;
 
     if (!sc->scts_parsed) {
-        if (ct_extract_tls_extension_scts(sc) < 0 ||
-            ct_extract_ocsp_response_scts(sc) < 0 ||
-            ct_extract_x509v3_extension_scts(sc) < 0)
+        if (ct_extract_tls_extension_scts(sc) < 0 || ct_extract_ocsp_response_scts(sc) < 0 || ct_extract_x509v3_extension_scts(sc) < 0)
             goto err;
 
         sc->scts_parsed = 1;
     }
     return sc->scts;
- err:
+err:
     return NULL;
 }
 
 static int ct_permissive(const CT_POLICY_EVAL_CTX *ctx,
-                         const STACK_OF(SCT) *scts, void *unused_arg)
+    const STACK_OF(SCT) *scts, void *unused_arg)
 {
     return 1;
 }
 
 static int ct_strict(const CT_POLICY_EVAL_CTX *ctx,
-                     const STACK_OF(SCT) *scts, void *unused_arg)
+    const STACK_OF(SCT) *scts, void *unused_arg)
 {
     int count = scts != NULL ? sk_SCT_num(scts) : 0;
     int i;
@@ -6542,7 +6501,7 @@ static int ct_strict(const CT_POLICY_EVAL_CTX *ctx,
 }
 
 int SSL_set_ct_validation_callback(SSL *s, ssl_ct_validation_cb callback,
-                                   void *arg)
+    void *arg)
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 
@@ -6553,9 +6512,7 @@ int SSL_set_ct_validation_callback(SSL *s, ssl_ct_validation_cb callback,
      * Since code exists that uses the custom extension handler for CT, look
      * for this and throw an error if they have already registered to use CT.
      */
-    if (callback != NULL && SSL_CTX_has_client_custom_ext(s->ctx,
-                                                          TLSEXT_TYPE_signed_certificate_timestamp))
-    {
+    if (callback != NULL && SSL_CTX_has_client_custom_ext(s->ctx, TLSEXT_TYPE_signed_certificate_timestamp)) {
         ERR_raise(ERR_LIB_SSL, SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED);
         return 0;
     }
@@ -6575,15 +6532,13 @@ int SSL_set_ct_validation_callback(SSL *s, ssl_ct_validation_cb callback,
 }
 
 int SSL_CTX_set_ct_validation_callback(SSL_CTX *ctx,
-                                       ssl_ct_validation_cb callback, void *arg)
+    ssl_ct_validation_cb callback, void *arg)
 {
     /*
      * Since code exists that uses the custom extension handler for CT, look for
      * this and throw an error if they have already registered to use CT.
      */
-    if (callback != NULL && SSL_CTX_has_client_custom_ext(ctx,
-                                                          TLSEXT_TYPE_signed_certificate_timestamp))
-    {
+    if (callback != NULL && SSL_CTX_has_client_custom_ext(ctx, TLSEXT_TYPE_signed_certificate_timestamp)) {
         ERR_raise(ERR_LIB_SSL, SSL_R_CUSTOM_EXT_HANDLER_ALREADY_INSTALLED);
         return 0;
     }
@@ -6628,9 +6583,7 @@ int ssl_validate_ct(SSL_CONNECTION *s)
      * applications that perform certificate verification and therefore will
      * process SCTs when enabled.
      */
-    if (s->ct_validation_callback == NULL || cert == NULL ||
-        s->verify_result != X509_V_OK ||
-        s->verified_chain == NULL || sk_X509_num(s->verified_chain) <= 1)
+    if (s->ct_validation_callback == NULL || cert == NULL || s->verify_result != X509_V_OK || s->verified_chain == NULL || sk_X509_num(s->verified_chain) <= 1)
         return 1;
 
     /*
@@ -6646,7 +6599,7 @@ int ssl_validate_ct(SSL_CONNECTION *s)
     }
 
     ctx = CT_POLICY_EVAL_CTX_new_ex(SSL_CONNECTION_GET_CTX(s)->libctx,
-                                    SSL_CONNECTION_GET_CTX(s)->propq);
+        SSL_CONNECTION_GET_CTX(s)->propq);
     if (ctx == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CT_LIB);
         goto end;
@@ -6656,9 +6609,9 @@ int ssl_validate_ct(SSL_CONNECTION *s)
     CT_POLICY_EVAL_CTX_set1_cert(ctx, cert);
     CT_POLICY_EVAL_CTX_set1_issuer(ctx, issuer);
     CT_POLICY_EVAL_CTX_set_shared_CTLOG_STORE(ctx,
-            SSL_CONNECTION_GET_CTX(s)->ctlog_store);
+        SSL_CONNECTION_GET_CTX(s)->ctlog_store);
     CT_POLICY_EVAL_CTX_set_time(
-            ctx, (uint64_t)SSL_SESSION_get_time_ex(s->session) * 1000);
+        ctx, (uint64_t)SSL_SESSION_get_time_ex(s->session) * 1000);
 
     scts = SSL_get0_peer_scts(SSL_CONNECTION_GET_SSL(s));
 
@@ -6683,11 +6636,11 @@ int ssl_validate_ct(SSL_CONNECTION *s)
 
     ret = s->ct_validation_callback(ctx, scts, s->ct_validation_callback_arg);
     if (ret < 0)
-        ret = 0;                /* This function returns 0 on failure */
+        ret = 0; /* This function returns 0 on failure */
     if (!ret)
         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_CALLBACK_FAILED);
 
- end:
+end:
     CT_POLICY_EVAL_CTX_free(ctx);
     /*
      * With SSL_VERIFY_NONE the session may be cached and reused despite a
@@ -6756,17 +6709,17 @@ const CTLOG_STORE *SSL_CTX_get0_ctlog_store(const SSL_CTX *ctx)
     return ctx->ctlog_store;
 }
 
-#endif  /* OPENSSL_NO_CT */
+#endif /* OPENSSL_NO_CT */
 
 void SSL_CTX_set_client_hello_cb(SSL_CTX *c, SSL_client_hello_cb_fn cb,
-                                 void *arg)
+    void *arg)
 {
     c->client_hello_cb = cb;
     c->client_hello_cb_arg = arg;
 }
 
 void SSL_CTX_set_new_pending_conn_cb(SSL_CTX *c, SSL_new_pending_conn_cb_fn cb,
-                                     void *arg)
+    void *arg)
 {
     c->new_pending_conn_cb = cb;
     c->new_pending_conn_arg = arg;
@@ -6887,7 +6840,7 @@ int SSL_client_hello_get1_extensions_present(SSL *s, int **out, size_t *outlen)
     *out = present;
     *outlen = num;
     return 1;
- err:
+err:
     OPENSSL_free(present);
     return 0;
 }
@@ -6931,7 +6884,7 @@ int SSL_client_hello_get_extension_order(SSL *s, uint16_t *exts, size_t *num_ext
 }
 
 int SSL_client_hello_get0_ext(SSL *s, unsigned int type, const unsigned char **out,
-                       size_t *outlen)
+    size_t *outlen)
 {
     size_t i;
     RAW_EXTENSION *r;
@@ -6966,7 +6919,7 @@ int SSL_free_buffers(SSL *ssl)
     rl = &sc->rlayer;
 
     return rl->rrlmethod->free_buffers(rl->rrl)
-           && rl->wrlmethod->free_buffers(rl->wrl);
+        && rl->wrlmethod->free_buffers(rl->wrl);
 }
 
 int SSL_alloc_buffers(SSL *ssl)
@@ -6984,7 +6937,7 @@ int SSL_alloc_buffers(SSL *ssl)
     rl = &sc->rlayer;
 
     return rl->rrlmethod->alloc_buffers(rl->rrl)
-           && rl->wrlmethod->alloc_buffers(rl->wrl);
+        && rl->wrlmethod->alloc_buffers(rl->wrl);
 }
 
 void SSL_CTX_set_keylog_callback(SSL_CTX *ctx, SSL_CTX_keylog_cb_func cb)
@@ -6998,11 +6951,11 @@ SSL_CTX_keylog_cb_func SSL_CTX_get_keylog_callback(const SSL_CTX *ctx)
 }
 
 static int nss_keylog_int(const char *prefix,
-                          SSL_CONNECTION *sc,
-                          const uint8_t *parameter_1,
-                          size_t parameter_1_len,
-                          const uint8_t *parameter_2,
-                          size_t parameter_2_len)
+    SSL_CONNECTION *sc,
+    const uint8_t *parameter_1,
+    size_t parameter_1_len,
+    const uint8_t *parameter_2,
+    size_t parameter_2_len)
 {
     char *out = NULL;
     char *cursor = NULL;
@@ -7053,10 +7006,10 @@ static int nss_keylog_int(const char *prefix,
 }
 
 int ssl_log_rsa_client_key_exchange(SSL_CONNECTION *sc,
-                                    const uint8_t *encrypted_premaster,
-                                    size_t encrypted_premaster_len,
-                                    const uint8_t *premaster,
-                                    size_t premaster_len)
+    const uint8_t *encrypted_premaster,
+    size_t encrypted_premaster_len,
+    const uint8_t *premaster,
+    size_t premaster_len)
 {
     if (encrypted_premaster_len < 8) {
         SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
@@ -7065,27 +7018,27 @@ int ssl_log_rsa_client_key_exchange(SSL_CONNECTION *sc,
 
     /* We only want the first 8 bytes of the encrypted premaster as a tag. */
     return nss_keylog_int("RSA",
-                          sc,
-                          encrypted_premaster,
-                          8,
-                          premaster,
-                          premaster_len);
+        sc,
+        encrypted_premaster,
+        8,
+        premaster,
+        premaster_len);
 }
 
 int ssl_log_secret(SSL_CONNECTION *sc,
-                   const char *label,
-                   const uint8_t *secret,
-                   size_t secret_len)
+    const char *label,
+    const uint8_t *secret,
+    size_t secret_len)
 {
     return nss_keylog_int(label,
-                          sc,
-                          sc->s3.client_random,
-                          SSL3_RANDOM_SIZE,
-                          secret,
-                          secret_len);
+        sc,
+        sc->s3.client_random,
+        SSL3_RANDOM_SIZE,
+        secret,
+        secret_len);
 }
 
-#define SSLV2_CIPHER_LEN    3
+#define SSLV2_CIPHER_LEN 3
 
 int ssl_cache_cipherlist(SSL_CONNECTION *s, PACKET *cipher_suites, int sslv2format)
 {
@@ -7127,14 +7080,14 @@ int ssl_cache_cipherlist(SSL_CONNECTION *s, PACKET *cipher_suites, int sslv2form
             return 0;
         }
         for (s->s3.tmp.ciphers_rawlen = 0;
-             PACKET_remaining(&sslv2ciphers) > 0;
-             raw += TLS_CIPHER_LEN) {
+            PACKET_remaining(&sslv2ciphers) > 0;
+            raw += TLS_CIPHER_LEN) {
             if (!PACKET_get_1(&sslv2ciphers, &leadbyte)
-                    || (leadbyte == 0
-                        && !PACKET_copy_bytes(&sslv2ciphers, raw,
-                                              TLS_CIPHER_LEN))
-                    || (leadbyte != 0
-                        && !PACKET_forward(&sslv2ciphers, TLS_CIPHER_LEN))) {
+                || (leadbyte == 0
+                    && !PACKET_copy_bytes(&sslv2ciphers, raw,
+                        TLS_CIPHER_LEN))
+                || (leadbyte != 0
+                    && !PACKET_forward(&sslv2ciphers, TLS_CIPHER_LEN))) {
                 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_PACKET);
                 OPENSSL_free(s->s3.tmp.ciphers_raw);
                 s->s3.tmp.ciphers_raw = NULL;
@@ -7145,7 +7098,7 @@ int ssl_cache_cipherlist(SSL_CONNECTION *s, PACKET *cipher_suites, int sslv2form
                 s->s3.tmp.ciphers_rawlen += TLS_CIPHER_LEN;
         }
     } else if (!PACKET_memdup(cipher_suites, &s->s3.tmp.ciphers_raw,
-                           &s->s3.tmp.ciphers_rawlen)) {
+                   &s->s3.tmp.ciphers_rawlen)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
@@ -7153,8 +7106,8 @@ int ssl_cache_cipherlist(SSL_CONNECTION *s, PACKET *cipher_suites, int sslv2form
 }
 
 int SSL_bytes_to_cipher_list(SSL *s, const unsigned char *bytes, size_t len,
-                             int isv2format, STACK_OF(SSL_CIPHER) **sk,
-                             STACK_OF(SSL_CIPHER) **scsvs)
+    int isv2format, STACK_OF(SSL_CIPHER) **sk,
+    STACK_OF(SSL_CIPHER) **scsvs)
 {
     PACKET pkt;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
@@ -7168,9 +7121,9 @@ int SSL_bytes_to_cipher_list(SSL *s, const unsigned char *bytes, size_t len,
 }
 
 int ossl_bytes_to_cipher_list(SSL_CONNECTION *s, PACKET *cipher_suites,
-                              STACK_OF(SSL_CIPHER) **skp,
-                              STACK_OF(SSL_CIPHER) **scsvs_out,
-                              int sslv2format, int fatal)
+    STACK_OF(SSL_CIPHER) **skp,
+    STACK_OF(SSL_CIPHER) **scsvs_out,
+    int sslv2format, int fatal)
 {
     const SSL_CIPHER *c;
     STACK_OF(SSL_CIPHER) *sk = NULL;
@@ -7192,7 +7145,7 @@ int ossl_bytes_to_cipher_list(SSL_CONNECTION *s, PACKET *cipher_suites,
     if (PACKET_remaining(cipher_suites) % n != 0) {
         if (fatal)
             SSLfatal(s, SSL_AD_DECODE_ERROR,
-                     SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST);
+                SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST);
         else
             ERR_raise(ERR_LIB_SSL, SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST);
         return 0;
@@ -7220,8 +7173,7 @@ int ossl_bytes_to_cipher_list(SSL_CONNECTION *s, PACKET *cipher_suites,
         /* For SSLv2-compat, ignore leading 0-byte. */
         c = ssl_get_cipher_by_char(s, sslv2format ? &cipher[1] : cipher, 1);
         if (c != NULL) {
-            if ((c->valid && !sk_SSL_CIPHER_push(sk, c)) ||
-                (!c->valid && !sk_SSL_CIPHER_push(scsvs, c))) {
+            if ((c->valid && !sk_SSL_CIPHER_push(sk, c)) || (!c->valid && !sk_SSL_CIPHER_push(scsvs, c))) {
                 if (fatal)
                     SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
                 else
@@ -7247,7 +7199,7 @@ int ossl_bytes_to_cipher_list(SSL_CONNECTION *s, PACKET *cipher_suites,
     else
         sk_SSL_CIPHER_free(scsvs);
     return 1;
- err:
+err:
     sk_SSL_CIPHER_free(sk);
     sk_SSL_CIPHER_free(scsvs);
     return 0;
@@ -7448,9 +7400,9 @@ int SSL_verify_client_post_handshake(SSL *ssl)
 }
 
 int SSL_CTX_set_session_ticket_cb(SSL_CTX *ctx,
-                                  SSL_CTX_generate_session_ticket_fn gen_cb,
-                                  SSL_CTX_decrypt_session_ticket_fn dec_cb,
-                                  void *arg)
+    SSL_CTX_generate_session_ticket_fn gen_cb,
+    SSL_CTX_decrypt_session_ticket_fn dec_cb,
+    void *arg)
 {
     ctx->generate_ticket_cb = gen_cb;
     ctx->decrypt_ticket_cb = dec_cb;
@@ -7459,16 +7411,16 @@ int SSL_CTX_set_session_ticket_cb(SSL_CTX *ctx,
 }
 
 void SSL_CTX_set_allow_early_data_cb(SSL_CTX *ctx,
-                                     SSL_allow_early_data_cb_fn cb,
-                                     void *arg)
+    SSL_allow_early_data_cb_fn cb,
+    void *arg)
 {
     ctx->allow_early_data_cb = cb;
     ctx->allow_early_data_cb_data = arg;
 }
 
 void SSL_set_allow_early_data_cb(SSL *s,
-                                 SSL_allow_early_data_cb_fn cb,
-                                 void *arg)
+    SSL_allow_early_data_cb_fn cb,
+    void *arg)
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL_ONLY(s);
 
@@ -7480,8 +7432,8 @@ void SSL_set_allow_early_data_cb(SSL *s,
 }
 
 const EVP_CIPHER *ssl_evp_cipher_fetch(OSSL_LIB_CTX *libctx,
-                                       int nid,
-                                       const char *properties)
+    int nid,
+    const char *properties)
 {
     const EVP_CIPHER *ciph;
 
@@ -7500,7 +7452,7 @@ const EVP_CIPHER *ssl_evp_cipher_fetch(OSSL_LIB_CTX *libctx,
         int decrypt_only = 0;
 
         params[0] = OSSL_PARAM_construct_int(OSSL_CIPHER_PARAM_DECRYPT_ONLY,
-                                             &decrypt_only);
+            &decrypt_only);
         params[1] = OSSL_PARAM_construct_end();
         if (EVP_CIPHER_get_params((EVP_CIPHER *)ciph, params)
             && decrypt_only) {
@@ -7513,7 +7465,6 @@ const EVP_CIPHER *ssl_evp_cipher_fetch(OSSL_LIB_CTX *libctx,
     return ciph;
 }
 
-
 int ssl_evp_cipher_up_ref(const EVP_CIPHER *cipher)
 {
     /* Don't up-ref an implicit EVP_CIPHER */
@@ -7542,8 +7493,8 @@ void ssl_evp_cipher_free(const EVP_CIPHER *cipher)
 }
 
 const EVP_MD *ssl_evp_md_fetch(OSSL_LIB_CTX *libctx,
-                               int nid,
-                               const char *properties)
+    int nid,
+    const char *properties)
 {
     const EVP_MD *md;
 
@@ -7593,7 +7544,7 @@ int SSL_set0_tmp_dh_pkey(SSL *s, EVP_PKEY *dhpkey)
         return 0;
 
     if (!ssl_security(sc, SSL_SECOP_TMP_DH,
-                      EVP_PKEY_get_security_bits(dhpkey), 0, dhpkey)) {
+            EVP_PKEY_get_security_bits(dhpkey), 0, dhpkey)) {
         ERR_raise(ERR_LIB_SSL, SSL_R_DH_KEY_TOO_SMALL);
         return 0;
     }
@@ -7605,7 +7556,7 @@ int SSL_set0_tmp_dh_pkey(SSL *s, EVP_PKEY *dhpkey)
 int SSL_CTX_set0_tmp_dh_pkey(SSL_CTX *ctx, EVP_PKEY *dhpkey)
 {
     if (!ssl_ctx_security(ctx, SSL_SECOP_TMP_DH,
-                          EVP_PKEY_get_security_bits(dhpkey), 0, dhpkey)) {
+            EVP_PKEY_get_security_bits(dhpkey), 0, dhpkey)) {
         ERR_raise(ERR_LIB_SSL, SSL_R_DH_KEY_TOO_SMALL);
         return 0;
     }
@@ -7655,7 +7606,7 @@ int SSL_get_event_timeout(SSL *s, struct timeval *tv, int *is_infinite)
         return 1;
     }
 
-    tv->tv_sec  = 1000000;
+    tv->tv_sec = 1000000;
     tv->tv_usec = 0;
     *is_infinite = 1;
     return 1;
@@ -7752,8 +7703,8 @@ int SSL_set1_initial_peer_addr(SSL *s, const BIO_ADDR *peer_addr)
 }
 
 int SSL_shutdown_ex(SSL *ssl, uint64_t flags,
-                    const SSL_SHUTDOWN_EX_ARGS *args,
-                    size_t args_len)
+    const SSL_SHUTDOWN_EX_ARGS *args,
+    size_t args_len)
 {
 #ifndef OPENSSL_NO_QUIC
     if (!IS_QUIC(ssl))
@@ -7925,8 +7876,8 @@ size_t SSL_get_accept_stream_queue_len(SSL *s)
 }
 
 int SSL_stream_reset(SSL *s,
-                     const SSL_STREAM_RESET_ARGS *args,
-                     size_t args_len)
+    const SSL_STREAM_RESET_ARGS *args,
+    size_t args_len)
 {
 #ifndef OPENSSL_NO_QUIC
     if (!IS_QUIC(s))
@@ -7987,7 +7938,7 @@ int SSL_get_stream_write_error_code(SSL *s, uint64_t *app_error_code)
 }
 
 int SSL_get_conn_close_info(SSL *s, SSL_CONN_CLOSE_INFO *info,
-                            size_t info_len)
+    size_t info_len)
 {
 #ifndef OPENSSL_NO_QUIC
     if (!IS_QUIC(s))
@@ -8000,7 +7951,7 @@ int SSL_get_conn_close_info(SSL *s, SSL_CONN_CLOSE_INFO *info,
 }
 
 int SSL_get_value_uint(SSL *s, uint32_t class_, uint32_t id,
-                       uint64_t *value)
+    uint64_t *value)
 {
 #ifndef OPENSSL_NO_QUIC
     if (IS_QUIC(s))
@@ -8012,7 +7963,7 @@ int SSL_get_value_uint(SSL *s, uint32_t class_, uint32_t id,
 }
 
 int SSL_set_value_uint(SSL *s, uint32_t class_, uint32_t id,
-                       uint64_t value)
+    uint64_t value)
 {
 #ifndef OPENSSL_NO_QUIC
     if (IS_QUIC(s))
@@ -8111,21 +8062,20 @@ int ossl_adjust_domain_flags(uint64_t domain_flags, uint64_t *p_domain_flags)
 {
     if ((domain_flags & ~OSSL_QUIC_SUPPORTED_DOMAIN_FLAGS) != 0) {
         ERR_raise_data(ERR_LIB_SSL, ERR_R_UNSUPPORTED,
-                       "unsupported domain flag requested");
+            "unsupported domain flag requested");
         return 0;
     }
 
     if ((domain_flags & SSL_DOMAIN_FLAG_THREAD_ASSISTED) != 0)
         domain_flags |= SSL_DOMAIN_FLAG_MULTI_THREAD;
 
-    if ((domain_flags & (SSL_DOMAIN_FLAG_MULTI_THREAD
-                         | SSL_DOMAIN_FLAG_SINGLE_THREAD)) == 0)
+    if ((domain_flags & (SSL_DOMAIN_FLAG_MULTI_THREAD | SSL_DOMAIN_FLAG_SINGLE_THREAD)) == 0)
         domain_flags |= SSL_DOMAIN_FLAG_MULTI_THREAD;
 
     if ((domain_flags & SSL_DOMAIN_FLAG_SINGLE_THREAD) != 0
         && (domain_flags & SSL_DOMAIN_FLAG_MULTI_THREAD) != 0) {
         ERR_raise_data(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT,
-                       "mutually exclusive domain flags specified");
+            "mutually exclusive domain flags specified");
         return 0;
     }
 
@@ -8133,13 +8083,13 @@ int ossl_adjust_domain_flags(uint64_t domain_flags, uint64_t *p_domain_flags)
      * Note: We treat MULTI_THREAD as a no-op in non-threaded builds, but
      * not THREAD_ASSISTED.
      */
-# ifndef OPENSSL_THREADS
+#ifndef OPENSSL_THREADS
     if ((domain_flags & SSL_DOMAIN_FLAG_THREAD_ASSISTED) != 0) {
         ERR_raise_data(ERR_LIB_SSL, ERR_R_UNSUPPORTED,
-                       "thread assisted mode not available in this build");
+            "thread assisted mode not available in this build");
         return 0;
     }
-# endif
+#endif
 
     *p_domain_flags = domain_flags;
     return 1;
@@ -8158,7 +8108,7 @@ int SSL_CTX_set_domain_flags(SSL_CTX *ctx, uint64_t domain_flags)
 #endif
 
     ERR_raise_data(ERR_LIB_SSL, ERR_R_UNSUPPORTED,
-                   "domain flags unsupported on this kind of SSL_CTX");
+        "domain flags unsupported on this kind of SSL_CTX");
     return 0;
 }
 
@@ -8174,7 +8124,7 @@ int SSL_CTX_get_domain_flags(const SSL_CTX *ctx, uint64_t *domain_flags)
 #endif
 
     ERR_raise_data(ERR_LIB_SSL, ERR_R_UNSUPPORTED,
-                   "domain flags unsupported on this kind of SSL_CTX");
+        "domain flags unsupported on this kind of SSL_CTX");
     return 0;
 }
 
@@ -8200,9 +8150,10 @@ int SSL_add_expected_rpk(SSL *s, EVP_PKEY *rpk)
         return 0;
 
     ret = SSL_dane_tlsa_add(s, DANETLS_USAGE_DANE_EE,
-                            DANETLS_SELECTOR_SPKI,
-                            DANETLS_MATCHING_FULL,
-                            data, (size_t)ret) > 0;
+              DANETLS_SELECTOR_SPKI,
+              DANETLS_MATCHING_FULL,
+              data, (size_t)ret)
+        > 0;
     OPENSSL_free(data);
     return ret;
 }
@@ -8270,9 +8221,9 @@ static int validate_cert_type(const unsigned char *val, size_t len)
 }
 
 static int set_cert_type(unsigned char **cert_type,
-                         size_t *cert_type_len,
-                         const unsigned char *val,
-                         size_t len)
+    size_t *cert_type_len,
+    const unsigned char *val,
+    size_t len)
 {
     unsigned char *tmp = NULL;
 
@@ -8296,7 +8247,7 @@ int SSL_set1_client_cert_type(SSL *s, const unsigned char *val, size_t len)
         return 0;
 
     return set_cert_type(&sc->client_cert_type, &sc->client_cert_type_len,
-                         val, len);
+        val, len);
 }
 
 int SSL_set1_server_cert_type(SSL *s, const unsigned char *val, size_t len)
@@ -8307,19 +8258,19 @@ int SSL_set1_server_cert_type(SSL *s, const unsigned char *val, size_t len)
         return 0;
 
     return set_cert_type(&sc->server_cert_type, &sc->server_cert_type_len,
-                         val, len);
+        val, len);
 }
 
 int SSL_CTX_set1_client_cert_type(SSL_CTX *ctx, const unsigned char *val, size_t len)
 {
     return set_cert_type(&ctx->client_cert_type, &ctx->client_cert_type_len,
-                         val, len);
+        val, len);
 }
 
 int SSL_CTX_set1_server_cert_type(SSL_CTX *ctx, const unsigned char *val, size_t len)
 {
     return set_cert_type(&ctx->server_cert_type, &ctx->server_cert_type_len,
-                         val, len);
+        val, len);
 }
 
 int SSL_get0_client_cert_type(const SSL *s, unsigned char **t, size_t *len)
diff --git a/crypto/openssl/ssl/ssl_local.h b/crypto/openssl/ssl/ssl_local.h
index c53ebc36ae9d..8fc8b6440615 100644
--- a/crypto/openssl/ssl/ssl_local.h
+++ b/crypto/openssl/ssl/ssl_local.h
@@ -10,57 +10,57 @@
  */
 
 #ifndef OSSL_SSL_LOCAL_H
-# define OSSL_SSL_LOCAL_H
+#define OSSL_SSL_LOCAL_H
 
-# include <stdlib.h>
-# include <time.h>
-# include <errno.h>
-# include "internal/common.h" /* for HAS_PREFIX */
+#include <stdlib.h>
+#include <time.h>
+#include <errno.h>
+#include "internal/common.h" /* for HAS_PREFIX */
 
-# include <openssl/buffer.h>
-# include <openssl/bio.h>
-# include <openssl/comp.h>
-# include <openssl/dsa.h>
-# include <openssl/err.h>
-# include <openssl/ssl.h>
-# include <openssl/async.h>
-# include <openssl/symhacks.h>
-# include <openssl/ct.h>
-# include "internal/recordmethod.h"
-# include "internal/statem.h"
-# include "internal/packet.h"
-# include "internal/dane.h"
-# include "internal/refcount.h"
-# include "internal/tsan_assist.h"
-# include "internal/bio.h"
-# include "internal/ktls.h"
-# include "internal/time.h"
-# include "internal/ssl.h"
-# include "internal/cryptlib.h"
-# include "internal/quic_predef.h"
-# include "record/record.h"
-# include "internal/quic_predef.h"
-# include "internal/quic_tls.h"
+#include <openssl/buffer.h>
+#include <openssl/bio.h>
+#include <openssl/comp.h>
+#include <openssl/dsa.h>
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+#include <openssl/async.h>
+#include <openssl/symhacks.h>
+#include <openssl/ct.h>
+#include "internal/recordmethod.h"
+#include "internal/statem.h"
+#include "internal/packet.h"
+#include "internal/dane.h"
+#include "internal/refcount.h"
+#include "internal/tsan_assist.h"
+#include "internal/bio.h"
+#include "internal/ktls.h"
+#include "internal/time.h"
+#include "internal/ssl.h"
+#include "internal/cryptlib.h"
+#include "internal/quic_predef.h"
+#include "record/record.h"
+#include "internal/quic_predef.h"
+#include "internal/quic_tls.h"
 
-# ifdef OPENSSL_BUILD_SHLIBSSL
-#  undef OPENSSL_EXTERN
-#  define OPENSSL_EXTERN OPENSSL_EXPORT
-# endif
+#ifdef OPENSSL_BUILD_SHLIBSSL
+#undef OPENSSL_EXTERN
+#define OPENSSL_EXTERN OPENSSL_EXPORT
+#endif
 
-# define TLS_MAX_VERSION_INTERNAL TLS1_3_VERSION
-# define DTLS_MAX_VERSION_INTERNAL DTLS1_2_VERSION
+#define TLS_MAX_VERSION_INTERNAL TLS1_3_VERSION
+#define DTLS_MAX_VERSION_INTERNAL DTLS1_2_VERSION
 
 /*
  * DTLS version numbers are strange because they're inverted. Except for
  * DTLS1_BAD_VER, which should be considered "lower" than the rest.
  */
-# define dtls_ver_ordinal(v1) (((v1) == DTLS1_BAD_VER) ? 0xff00 : (v1))
-# define DTLS_VERSION_GT(v1, v2) (dtls_ver_ordinal(v1) < dtls_ver_ordinal(v2))
-# define DTLS_VERSION_GE(v1, v2) (dtls_ver_ordinal(v1) <= dtls_ver_ordinal(v2))
-# define DTLS_VERSION_LT(v1, v2) (dtls_ver_ordinal(v1) > dtls_ver_ordinal(v2))
-# define DTLS_VERSION_LE(v1, v2) (dtls_ver_ordinal(v1) >= dtls_ver_ordinal(v2))
+#define dtls_ver_ordinal(v1) (((v1) == DTLS1_BAD_VER) ? 0xff00 : (v1))
+#define DTLS_VERSION_GT(v1, v2) (dtls_ver_ordinal(v1) < dtls_ver_ordinal(v2))
+#define DTLS_VERSION_GE(v1, v2) (dtls_ver_ordinal(v1) <= dtls_ver_ordinal(v2))
+#define DTLS_VERSION_LT(v1, v2) (dtls_ver_ordinal(v1) > dtls_ver_ordinal(v2))
+#define DTLS_VERSION_LE(v1, v2) (dtls_ver_ordinal(v1) >= dtls_ver_ordinal(v2))
 
-# define SSL_AD_NO_ALERT    -1
+#define SSL_AD_NO_ALERT -1
 
 /*
  * Define the Bitmasks for SSL_CIPHER.algorithms.
@@ -78,281 +78,280 @@
 
 /* Bits for algorithm_mkey (key exchange algorithm) */
 /* RSA key exchange */
-# define SSL_kRSA                0x00000001U
+#define SSL_kRSA 0x00000001U
 /* tmp DH key no DH cert */
-# define SSL_kDHE                0x00000002U
+#define SSL_kDHE 0x00000002U
 /* ephemeral ECDH */
-# define SSL_kECDHE              0x00000004U
+#define SSL_kECDHE 0x00000004U
 /* PSK */
-# define SSL_kPSK                0x00000008U
+#define SSL_kPSK 0x00000008U
 /* GOST key exchange */
-# define SSL_kGOST               0x00000010U
+#define SSL_kGOST 0x00000010U
 /* SRP */
-# define SSL_kSRP                0x00000020U
+#define SSL_kSRP 0x00000020U
 
-# define SSL_kRSAPSK             0x00000040U
-# define SSL_kECDHEPSK           0x00000080U
-# define SSL_kDHEPSK             0x00000100U
+#define SSL_kRSAPSK 0x00000040U
+#define SSL_kECDHEPSK 0x00000080U
+#define SSL_kDHEPSK 0x00000100U
 /* GOST KDF key exchange, draft-smyshlyaev-tls12-gost-suites */
-# define SSL_kGOST18             0x00000200U
+#define SSL_kGOST18 0x00000200U
 
 /* all PSK */
 
-# define SSL_PSK     (SSL_kPSK | SSL_kRSAPSK | SSL_kECDHEPSK | SSL_kDHEPSK)
+#define SSL_PSK (SSL_kPSK | SSL_kRSAPSK | SSL_kECDHEPSK | SSL_kDHEPSK)
 
 /* Any appropriate key exchange algorithm (for TLS 1.3 ciphersuites) */
-# define SSL_kANY                0x00000000U
+#define SSL_kANY 0x00000000U
 
 /* Bits for algorithm_auth (server authentication) */
 /* RSA auth */
-# define SSL_aRSA                0x00000001U
+#define SSL_aRSA 0x00000001U
 /* DSS auth */
-# define SSL_aDSS                0x00000002U
+#define SSL_aDSS 0x00000002U
 /* no auth (i.e. use ADH or AECDH) */
-# define SSL_aNULL               0x00000004U
+#define SSL_aNULL 0x00000004U
 /* ECDSA auth*/
-# define SSL_aECDSA              0x00000008U
+#define SSL_aECDSA 0x00000008U
 /* PSK auth */
-# define SSL_aPSK                0x00000010U
+#define SSL_aPSK 0x00000010U
 /* GOST R 34.10-2001 signature auth */
-# define SSL_aGOST01             0x00000020U
+#define SSL_aGOST01 0x00000020U
 /* SRP auth */
-# define SSL_aSRP                0x00000040U
+#define SSL_aSRP 0x00000040U
 /* GOST R 34.10-2012 signature auth */
-# define SSL_aGOST12             0x00000080U
+#define SSL_aGOST12 0x00000080U
 /* Any appropriate signature auth (for TLS 1.3 ciphersuites) */
-# define SSL_aANY                0x00000000U
+#define SSL_aANY 0x00000000U
 /* All bits requiring a certificate */
 #define SSL_aCERT \
     (SSL_aRSA | SSL_aDSS | SSL_aECDSA | SSL_aGOST01 | SSL_aGOST12)
 
 /* Bits for algorithm_enc (symmetric encryption) */
-# define SSL_DES                 0x00000001U
-# define SSL_3DES                0x00000002U
-# define SSL_RC4                 0x00000004U
-# define SSL_RC2                 0x00000008U
-# define SSL_IDEA                0x00000010U
-# define SSL_eNULL               0x00000020U
-# define SSL_AES128              0x00000040U
-# define SSL_AES256              0x00000080U
-# define SSL_CAMELLIA128         0x00000100U
-# define SSL_CAMELLIA256         0x00000200U
-# define SSL_eGOST2814789CNT     0x00000400U
-# define SSL_SEED                0x00000800U
-# define SSL_AES128GCM           0x00001000U
-# define SSL_AES256GCM           0x00002000U
-# define SSL_AES128CCM           0x00004000U
-# define SSL_AES256CCM           0x00008000U
-# define SSL_AES128CCM8          0x00010000U
-# define SSL_AES256CCM8          0x00020000U
-# define SSL_eGOST2814789CNT12   0x00040000U
-# define SSL_CHACHA20POLY1305    0x00080000U
-# define SSL_ARIA128GCM          0x00100000U
-# define SSL_ARIA256GCM          0x00200000U
-# define SSL_MAGMA               0x00400000U
-# define SSL_KUZNYECHIK          0x00800000U
+#define SSL_DES 0x00000001U
+#define SSL_3DES 0x00000002U
+#define SSL_RC4 0x00000004U
+#define SSL_RC2 0x00000008U
+#define SSL_IDEA 0x00000010U
+#define SSL_eNULL 0x00000020U
+#define SSL_AES128 0x00000040U
+#define SSL_AES256 0x00000080U
+#define SSL_CAMELLIA128 0x00000100U
+#define SSL_CAMELLIA256 0x00000200U
+#define SSL_eGOST2814789CNT 0x00000400U
+#define SSL_SEED 0x00000800U
+#define SSL_AES128GCM 0x00001000U
+#define SSL_AES256GCM 0x00002000U
+#define SSL_AES128CCM 0x00004000U
+#define SSL_AES256CCM 0x00008000U
+#define SSL_AES128CCM8 0x00010000U
+#define SSL_AES256CCM8 0x00020000U
+#define SSL_eGOST2814789CNT12 0x00040000U
+#define SSL_CHACHA20POLY1305 0x00080000U
+#define SSL_ARIA128GCM 0x00100000U
+#define SSL_ARIA256GCM 0x00200000U
+#define SSL_MAGMA 0x00400000U
+#define SSL_KUZNYECHIK 0x00800000U
 
-# define SSL_AESGCM              (SSL_AES128GCM | SSL_AES256GCM)
-# define SSL_AESCCM              (SSL_AES128CCM | SSL_AES256CCM | SSL_AES128CCM8 | SSL_AES256CCM8)
-# define SSL_AES                 (SSL_AES128|SSL_AES256|SSL_AESGCM|SSL_AESCCM)
-# define SSL_CAMELLIA            (SSL_CAMELLIA128|SSL_CAMELLIA256)
-# define SSL_CHACHA20            (SSL_CHACHA20POLY1305)
-# define SSL_ARIAGCM             (SSL_ARIA128GCM | SSL_ARIA256GCM)
-# define SSL_ARIA                (SSL_ARIAGCM)
-# define SSL_CBC                 (SSL_DES | SSL_3DES | SSL_RC2 | SSL_IDEA \
-                                  | SSL_AES128 | SSL_AES256 | SSL_CAMELLIA128 \
-                                  | SSL_CAMELLIA256 | SSL_SEED)
+#define SSL_AESGCM (SSL_AES128GCM | SSL_AES256GCM)
+#define SSL_AESCCM (SSL_AES128CCM | SSL_AES256CCM | SSL_AES128CCM8 | SSL_AES256CCM8)
+#define SSL_AES (SSL_AES128 | SSL_AES256 | SSL_AESGCM | SSL_AESCCM)
+#define SSL_CAMELLIA (SSL_CAMELLIA128 | SSL_CAMELLIA256)
+#define SSL_CHACHA20 (SSL_CHACHA20POLY1305)
+#define SSL_ARIAGCM (SSL_ARIA128GCM | SSL_ARIA256GCM)
+#define SSL_ARIA (SSL_ARIAGCM)
+#define SSL_CBC (SSL_DES | SSL_3DES | SSL_RC2 | SSL_IDEA \
+    | SSL_AES128 | SSL_AES256 | SSL_CAMELLIA128          \
+    | SSL_CAMELLIA256 | SSL_SEED)
 
 /* Bits for algorithm_mac (symmetric authentication) */
 
-# define SSL_MD5                 0x00000001U
-# define SSL_SHA1                0x00000002U
-# define SSL_GOST94      0x00000004U
-# define SSL_GOST89MAC   0x00000008U
-# define SSL_SHA256              0x00000010U
-# define SSL_SHA384              0x00000020U
+#define SSL_MD5 0x00000001U
+#define SSL_SHA1 0x00000002U
+#define SSL_GOST94 0x00000004U
+#define SSL_GOST89MAC 0x00000008U
+#define SSL_SHA256 0x00000010U
+#define SSL_SHA384 0x00000020U
 /* Not a real MAC, just an indication it is part of cipher */
-# define SSL_AEAD                0x00000040U
-# define SSL_GOST12_256          0x00000080U
-# define SSL_GOST89MAC12         0x00000100U
-# define SSL_GOST12_512          0x00000200U
-# define SSL_MAGMAOMAC           0x00000400U
-# define SSL_KUZNYECHIKOMAC      0x00000800U
+#define SSL_AEAD 0x00000040U
+#define SSL_GOST12_256 0x00000080U
+#define SSL_GOST89MAC12 0x00000100U
+#define SSL_GOST12_512 0x00000200U
+#define SSL_MAGMAOMAC 0x00000400U
+#define SSL_KUZNYECHIKOMAC 0x00000800U
 
 /*
  * When adding new digest in the ssl_ciph.c and increment SSL_MD_NUM_IDX make
  * sure to update this constant too
  */
 
-# define SSL_MD_MD5_IDX  0
-# define SSL_MD_SHA1_IDX 1
-# define SSL_MD_GOST94_IDX 2
-# define SSL_MD_GOST89MAC_IDX 3
-# define SSL_MD_SHA256_IDX 4
-# define SSL_MD_SHA384_IDX 5
-# define SSL_MD_GOST12_256_IDX  6
-# define SSL_MD_GOST89MAC12_IDX 7
-# define SSL_MD_GOST12_512_IDX  8
-# define SSL_MD_MD5_SHA1_IDX 9
-# define SSL_MD_SHA224_IDX 10
-# define SSL_MD_SHA512_IDX 11
-# define SSL_MD_MAGMAOMAC_IDX 12
-# define SSL_MD_KUZNYECHIKOMAC_IDX 13
-# define SSL_MAX_DIGEST 14
+#define SSL_MD_MD5_IDX 0
+#define SSL_MD_SHA1_IDX 1
+#define SSL_MD_GOST94_IDX 2
+#define SSL_MD_GOST89MAC_IDX 3
+#define SSL_MD_SHA256_IDX 4
+#define SSL_MD_SHA384_IDX 5
+#define SSL_MD_GOST12_256_IDX 6
+#define SSL_MD_GOST89MAC12_IDX 7
+#define SSL_MD_GOST12_512_IDX 8
+#define SSL_MD_MD5_SHA1_IDX 9
+#define SSL_MD_SHA224_IDX 10
+#define SSL_MD_SHA512_IDX 11
+#define SSL_MD_MAGMAOMAC_IDX 12
+#define SSL_MD_KUZNYECHIKOMAC_IDX 13
+#define SSL_MAX_DIGEST 14
 
-#define SSL_MD_NUM_IDX  SSL_MAX_DIGEST
+#define SSL_MD_NUM_IDX SSL_MAX_DIGEST
 
 /* Bits for algorithm2 (handshake digests and other extra flags) */
 
 /* Bits 0-7 are handshake MAC */
-# define SSL_HANDSHAKE_MAC_MASK  0xFF
-# define SSL_HANDSHAKE_MAC_MD5_SHA1 SSL_MD_MD5_SHA1_IDX
-# define SSL_HANDSHAKE_MAC_SHA256   SSL_MD_SHA256_IDX
-# define SSL_HANDSHAKE_MAC_SHA384   SSL_MD_SHA384_IDX
-# define SSL_HANDSHAKE_MAC_GOST94 SSL_MD_GOST94_IDX
-# define SSL_HANDSHAKE_MAC_GOST12_256 SSL_MD_GOST12_256_IDX
-# define SSL_HANDSHAKE_MAC_GOST12_512 SSL_MD_GOST12_512_IDX
-# define SSL_HANDSHAKE_MAC_DEFAULT  SSL_HANDSHAKE_MAC_MD5_SHA1
+#define SSL_HANDSHAKE_MAC_MASK 0xFF
+#define SSL_HANDSHAKE_MAC_MD5_SHA1 SSL_MD_MD5_SHA1_IDX
+#define SSL_HANDSHAKE_MAC_SHA256 SSL_MD_SHA256_IDX
+#define SSL_HANDSHAKE_MAC_SHA384 SSL_MD_SHA384_IDX
+#define SSL_HANDSHAKE_MAC_GOST94 SSL_MD_GOST94_IDX
+#define SSL_HANDSHAKE_MAC_GOST12_256 SSL_MD_GOST12_256_IDX
+#define SSL_HANDSHAKE_MAC_GOST12_512 SSL_MD_GOST12_512_IDX
+#define SSL_HANDSHAKE_MAC_DEFAULT SSL_HANDSHAKE_MAC_MD5_SHA1
 
 /* Bits 8-15 bits are PRF */
-# define TLS1_PRF_DGST_SHIFT 8
-# define TLS1_PRF_SHA1_MD5 (SSL_MD_MD5_SHA1_IDX << TLS1_PRF_DGST_SHIFT)
-# define TLS1_PRF_SHA256 (SSL_MD_SHA256_IDX << TLS1_PRF_DGST_SHIFT)
-# define TLS1_PRF_SHA384 (SSL_MD_SHA384_IDX << TLS1_PRF_DGST_SHIFT)
-# define TLS1_PRF_GOST94 (SSL_MD_GOST94_IDX << TLS1_PRF_DGST_SHIFT)
-# define TLS1_PRF_GOST12_256 (SSL_MD_GOST12_256_IDX << TLS1_PRF_DGST_SHIFT)
-# define TLS1_PRF_GOST12_512 (SSL_MD_GOST12_512_IDX << TLS1_PRF_DGST_SHIFT)
-# define TLS1_PRF            (SSL_MD_MD5_SHA1_IDX << TLS1_PRF_DGST_SHIFT)
+#define TLS1_PRF_DGST_SHIFT 8
+#define TLS1_PRF_SHA1_MD5 (SSL_MD_MD5_SHA1_IDX << TLS1_PRF_DGST_SHIFT)
+#define TLS1_PRF_SHA256 (SSL_MD_SHA256_IDX << TLS1_PRF_DGST_SHIFT)
+#define TLS1_PRF_SHA384 (SSL_MD_SHA384_IDX << TLS1_PRF_DGST_SHIFT)
+#define TLS1_PRF_GOST94 (SSL_MD_GOST94_IDX << TLS1_PRF_DGST_SHIFT)
+#define TLS1_PRF_GOST12_256 (SSL_MD_GOST12_256_IDX << TLS1_PRF_DGST_SHIFT)
+#define TLS1_PRF_GOST12_512 (SSL_MD_GOST12_512_IDX << TLS1_PRF_DGST_SHIFT)
+#define TLS1_PRF (SSL_MD_MD5_SHA1_IDX << TLS1_PRF_DGST_SHIFT)
 
 /*
  * Stream MAC for GOST ciphersuites from cryptopro draft (currently this also
  * goes into algorithm2)
  */
-# define TLS1_STREAM_MAC 0x10000
+#define TLS1_STREAM_MAC 0x10000
 /*
  * TLSTREE cipher/mac key derivation from draft-smyshlyaev-tls12-gost-suites
  * (currently this also  goes into algorithm2)
  */
-# define TLS1_TLSTREE 0x20000
+#define TLS1_TLSTREE 0x20000
 
 /* Ciphersuite supported in QUIC */
-# define SSL_QUIC                0x00040000U
+#define SSL_QUIC 0x00040000U
 
-# define SSL_STRONG_MASK         0x0000001FU
-# define SSL_DEFAULT_MASK        0X00000020U
+#define SSL_STRONG_MASK 0x0000001FU
+#define SSL_DEFAULT_MASK 0X00000020U
 
-# define SSL_STRONG_NONE         0x00000001U
-# define SSL_LOW                 0x00000002U
-# define SSL_MEDIUM              0x00000004U
-# define SSL_HIGH                0x00000008U
-# define SSL_FIPS                0x00000010U
-# define SSL_NOT_DEFAULT         0x00000020U
+#define SSL_STRONG_NONE 0x00000001U
+#define SSL_LOW 0x00000002U
+#define SSL_MEDIUM 0x00000004U
+#define SSL_HIGH 0x00000008U
+#define SSL_FIPS 0x00000010U
+#define SSL_NOT_DEFAULT 0x00000020U
 
 /* we have used 0000003f - 26 bits left to go */
 
 /* Flag used on OpenSSL ciphersuite ids to indicate they are for SSLv3+ */
-# define SSL3_CK_CIPHERSUITE_FLAG                0x03000000
+#define SSL3_CK_CIPHERSUITE_FLAG 0x03000000
 
 /* Check if an SSL structure is using DTLS */
-# define SSL_CONNECTION_IS_DTLS(s) \
+#define SSL_CONNECTION_IS_DTLS(s) \
     (SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS)
 
 /* Check if an SSL_CTX structure is using DTLS */
-# define SSL_CTX_IS_DTLS(ctx) \
+#define SSL_CTX_IS_DTLS(ctx) \
     (ctx->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_DTLS)
 
 /* Check if we are using TLSv1.3 */
-# define SSL_CONNECTION_IS_TLS13(s) (!SSL_CONNECTION_IS_DTLS(s) \
+#define SSL_CONNECTION_IS_TLS13(s) (!SSL_CONNECTION_IS_DTLS(s)      \
     && SSL_CONNECTION_GET_SSL(s)->method->version >= TLS1_3_VERSION \
     && SSL_CONNECTION_GET_SSL(s)->method->version != TLS_ANY_VERSION)
 
-# define SSL_CONNECTION_TREAT_AS_TLS13(s) \
-    (SSL_CONNECTION_IS_TLS13(s) \
-     || (s)->early_data_state == SSL_EARLY_DATA_CONNECTING \
-     || (s)->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY \
-     || (s)->early_data_state == SSL_EARLY_DATA_WRITING \
-     || (s)->early_data_state == SSL_EARLY_DATA_WRITE_RETRY \
-     || (s)->hello_retry_request == SSL_HRR_PENDING)
+#define SSL_CONNECTION_TREAT_AS_TLS13(s)                         \
+    (SSL_CONNECTION_IS_TLS13(s)                                  \
+        || (s)->early_data_state == SSL_EARLY_DATA_CONNECTING    \
+        || (s)->early_data_state == SSL_EARLY_DATA_CONNECT_RETRY \
+        || (s)->early_data_state == SSL_EARLY_DATA_WRITING       \
+        || (s)->early_data_state == SSL_EARLY_DATA_WRITE_RETRY   \
+        || (s)->hello_retry_request == SSL_HRR_PENDING)
 
-# define SSL_IS_FIRST_HANDSHAKE(s) ((s)->s3.tmp.finish_md_len == 0 \
-                                    || (s)->s3.tmp.peer_finish_md_len == 0)
+#define SSL_IS_FIRST_HANDSHAKE(s) ((s)->s3.tmp.finish_md_len == 0 \
+    || (s)->s3.tmp.peer_finish_md_len == 0)
 
 /*
  * See if we use signature algorithms extension and signature algorithm
  * before signatures.
  */
-# define SSL_USE_SIGALGS(s)      \
+#define SSL_USE_SIGALGS(s) \
     (SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_SIGALGS)
 /*
  * Allow TLS 1.2 ciphersuites: applies to DTLS 1.2 as well as TLS 1.2: may
  * apply to others in future.
  */
-# define SSL_USE_TLS1_2_CIPHERS(s)       \
+#define SSL_USE_TLS1_2_CIPHERS(s) \
     (SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->enc_flags & SSL_ENC_FLAG_TLS1_2_CIPHERS)
 
-# define IS_MAX_FRAGMENT_LENGTH_EXT_VALID(value) \
-    (((value) >= TLSEXT_max_fragment_length_512) && \
-     ((value) <= TLSEXT_max_fragment_length_4096))
-# define USE_MAX_FRAGMENT_LENGTH_EXT(session) \
+#define IS_MAX_FRAGMENT_LENGTH_EXT_VALID(value) \
+    (((value) >= TLSEXT_max_fragment_length_512) && ((value) <= TLSEXT_max_fragment_length_4096))
+#define USE_MAX_FRAGMENT_LENGTH_EXT(session) \
     IS_MAX_FRAGMENT_LENGTH_EXT_VALID(session->ext.max_fragment_len_mode)
-# define GET_MAX_FRAGMENT_LENGTH(session) \
+#define GET_MAX_FRAGMENT_LENGTH(session) \
     (512U << (session->ext.max_fragment_len_mode - 1))
 
-# define SSL_READ_ETM(s) (s->s3.flags & TLS1_FLAGS_ENCRYPT_THEN_MAC_READ)
-# define SSL_WRITE_ETM(s) (s->s3.flags & TLS1_FLAGS_ENCRYPT_THEN_MAC_WRITE)
+#define SSL_READ_ETM(s) (s->s3.flags & TLS1_FLAGS_ENCRYPT_THEN_MAC_READ)
+#define SSL_WRITE_ETM(s) (s->s3.flags & TLS1_FLAGS_ENCRYPT_THEN_MAC_WRITE)
 
-# define SSL_IS_QUIC_HANDSHAKE(s) (((s)->s3.flags & TLS1_FLAGS_QUIC) != 0)
-# define SSL_IS_QUIC_INT_HANDSHAKE(s) (((s)->s3.flags & TLS1_FLAGS_QUIC_INTERNAL) != 0)
+#define SSL_IS_QUIC_HANDSHAKE(s) (((s)->s3.flags & TLS1_FLAGS_QUIC) != 0)
+#define SSL_IS_QUIC_INT_HANDSHAKE(s) (((s)->s3.flags & TLS1_FLAGS_QUIC_INTERNAL) != 0)
 
 /* no end of early data */
-# define SSL_NO_EOED(s) SSL_IS_QUIC_HANDSHAKE(s)
+#define SSL_NO_EOED(s) SSL_IS_QUIC_HANDSHAKE(s)
 
 /* alert_dispatch values */
 
 /* No alert pending */
-# define SSL_ALERT_DISPATCH_NONE    0
+#define SSL_ALERT_DISPATCH_NONE 0
 /* Alert pending */
-# define SSL_ALERT_DISPATCH_PENDING 1
+#define SSL_ALERT_DISPATCH_PENDING 1
 /* Pending alert write needs to be retried */
-# define SSL_ALERT_DISPATCH_RETRY   2
+#define SSL_ALERT_DISPATCH_RETRY 2
 
 /* Mostly for SSLv3 */
-# define SSL_PKEY_RSA            0
-# define SSL_PKEY_RSA_PSS_SIGN   1
-# define SSL_PKEY_DSA_SIGN       2
-# define SSL_PKEY_ECC            3
-# define SSL_PKEY_GOST01         4
-# define SSL_PKEY_GOST12_256     5
-# define SSL_PKEY_GOST12_512     6
-# define SSL_PKEY_ED25519        7
-# define SSL_PKEY_ED448          8
-# define SSL_PKEY_NUM            9
+#define SSL_PKEY_RSA 0
+#define SSL_PKEY_RSA_PSS_SIGN 1
+#define SSL_PKEY_DSA_SIGN 2
+#define SSL_PKEY_ECC 3
+#define SSL_PKEY_GOST01 4
+#define SSL_PKEY_GOST12_256 5
+#define SSL_PKEY_GOST12_512 6
+#define SSL_PKEY_ED25519 7
+#define SSL_PKEY_ED448 8
+#define SSL_PKEY_NUM 9
 
-# define SSL_ENC_DES_IDX         0
-# define SSL_ENC_3DES_IDX        1
-# define SSL_ENC_RC4_IDX         2
-# define SSL_ENC_RC2_IDX         3
-# define SSL_ENC_IDEA_IDX        4
-# define SSL_ENC_NULL_IDX        5
-# define SSL_ENC_AES128_IDX      6
-# define SSL_ENC_AES256_IDX      7
-# define SSL_ENC_CAMELLIA128_IDX 8
-# define SSL_ENC_CAMELLIA256_IDX 9
-# define SSL_ENC_GOST89_IDX      10
-# define SSL_ENC_SEED_IDX        11
-# define SSL_ENC_AES128GCM_IDX   12
-# define SSL_ENC_AES256GCM_IDX   13
-# define SSL_ENC_AES128CCM_IDX   14
-# define SSL_ENC_AES256CCM_IDX   15
-# define SSL_ENC_AES128CCM8_IDX  16
-# define SSL_ENC_AES256CCM8_IDX  17
-# define SSL_ENC_GOST8912_IDX    18
-# define SSL_ENC_CHACHA_IDX      19
-# define SSL_ENC_ARIA128GCM_IDX  20
-# define SSL_ENC_ARIA256GCM_IDX  21
-# define SSL_ENC_MAGMA_IDX       22
-# define SSL_ENC_KUZNYECHIK_IDX  23
-# define SSL_ENC_NUM_IDX         24
+#define SSL_ENC_DES_IDX 0
+#define SSL_ENC_3DES_IDX 1
+#define SSL_ENC_RC4_IDX 2
+#define SSL_ENC_RC2_IDX 3
+#define SSL_ENC_IDEA_IDX 4
+#define SSL_ENC_NULL_IDX 5
+#define SSL_ENC_AES128_IDX 6
+#define SSL_ENC_AES256_IDX 7
+#define SSL_ENC_CAMELLIA128_IDX 8
+#define SSL_ENC_CAMELLIA256_IDX 9
+#define SSL_ENC_GOST89_IDX 10
+#define SSL_ENC_SEED_IDX 11
+#define SSL_ENC_AES128GCM_IDX 12
+#define SSL_ENC_AES256GCM_IDX 13
+#define SSL_ENC_AES128CCM_IDX 14
+#define SSL_ENC_AES256CCM_IDX 15
+#define SSL_ENC_AES128CCM8_IDX 16
+#define SSL_ENC_AES256CCM8_IDX 17
+#define SSL_ENC_GOST8912_IDX 18
+#define SSL_ENC_CHACHA_IDX 19
+#define SSL_ENC_ARIA128GCM_IDX 20
+#define SSL_ENC_ARIA256GCM_IDX 21
+#define SSL_ENC_MAGMA_IDX 22
+#define SSL_ENC_KUZNYECHIK_IDX 23
+#define SSL_ENC_NUM_IDX 24
 
 /*-
  * SSL_kRSA <- RSA_ENC
@@ -363,43 +362,43 @@
  */
 
 /* Certificate Type State */
-# define OSSL_CERT_TYPE_CTOS_NONE    0
-# define OSSL_CERT_TYPE_CTOS_GOOD    1
-# define OSSL_CERT_TYPE_CTOS_ERROR   2
+#define OSSL_CERT_TYPE_CTOS_NONE 0
+#define OSSL_CERT_TYPE_CTOS_GOOD 1
+#define OSSL_CERT_TYPE_CTOS_ERROR 2
 
 /* Post-Handshake Authentication state */
 typedef enum {
     SSL_PHA_NONE = 0,
-    SSL_PHA_EXT_SENT,        /* client-side only: extension sent */
-    SSL_PHA_EXT_RECEIVED,    /* server-side only: extension received */
+    SSL_PHA_EXT_SENT, /* client-side only: extension sent */
+    SSL_PHA_EXT_RECEIVED, /* server-side only: extension received */
     SSL_PHA_REQUEST_PENDING, /* server-side only: request pending */
-    SSL_PHA_REQUESTED        /* request received by client, or sent by server */
+    SSL_PHA_REQUESTED /* request received by client, or sent by server */
 } SSL_PHA_STATE;
 
 /* CipherSuite length. SSLv3 and all TLS versions. */
-# define TLS_CIPHER_LEN 2
+#define TLS_CIPHER_LEN 2
 /* used to hold info on the particular ciphers used */
 struct ssl_cipher_st {
     uint32_t valid;
-    const char *name;           /* text name */
-    const char *stdname;        /* RFC name */
-    uint32_t id;                /* id, 4 bytes, first is version */
+    const char *name; /* text name */
+    const char *stdname; /* RFC name */
+    uint32_t id; /* id, 4 bytes, first is version */
     /*
      * changed in 1.0.0: these four used to be portions of a single value
      * 'algorithms'
      */
-    uint32_t algorithm_mkey;    /* key exchange algorithm */
-    uint32_t algorithm_auth;    /* server authentication */
-    uint32_t algorithm_enc;     /* symmetric encryption */
-    uint32_t algorithm_mac;     /* symmetric authentication */
-    int min_tls;                /* minimum SSL/TLS protocol version */
-    int max_tls;                /* maximum SSL/TLS protocol version */
-    int min_dtls;               /* minimum DTLS protocol version */
-    int max_dtls;               /* maximum DTLS protocol version */
-    uint32_t algo_strength;     /* strength and export flags */
-    uint32_t algorithm2;        /* Extra flags */
-    int32_t strength_bits;      /* Number of bits really used */
-    uint32_t alg_bits;          /* Number of bits for algorithm */
+    uint32_t algorithm_mkey; /* key exchange algorithm */
+    uint32_t algorithm_auth; /* server authentication */
+    uint32_t algorithm_enc; /* symmetric encryption */
+    uint32_t algorithm_mac; /* symmetric authentication */
+    int min_tls; /* minimum SSL/TLS protocol version */
+    int max_tls; /* maximum SSL/TLS protocol version */
+    int min_dtls; /* minimum DTLS protocol version */
+    int max_dtls; /* maximum DTLS protocol version */
+    uint32_t algo_strength; /* strength and export flags */
+    uint32_t algorithm2; /* Extra flags */
+    int32_t strength_bits; /* Number of bits really used */
+    uint32_t alg_bits; /* Number of bits for algorithm */
 };
 
 /* Used to hold SSL/TLS functions */
@@ -407,46 +406,46 @@ struct ssl_method_st {
     int version;
     unsigned flags;
     uint64_t mask;
-    SSL *(*ssl_new) (SSL_CTX *ctx);
-    void (*ssl_free) (SSL *s);
-    int (*ssl_reset) (SSL *s);
-    int (*ssl_init) (SSL *s);
-    int (*ssl_clear) (SSL *s);
-    void (*ssl_deinit) (SSL *s);
-    int (*ssl_accept) (SSL *s);
-    int (*ssl_connect) (SSL *s);
-    int (*ssl_read) (SSL *s, void *buf, size_t len, size_t *readbytes);
-    int (*ssl_peek) (SSL *s, void *buf, size_t len, size_t *readbytes);
-    int (*ssl_write) (SSL *s, const void *buf, size_t len, size_t *written);
-    int (*ssl_shutdown) (SSL *s);
-    int (*ssl_renegotiate) (SSL *s);
-    int (*ssl_renegotiate_check) (SSL *s, int);
-    int (*ssl_read_bytes) (SSL *s, uint8_t type, uint8_t *recvd_type,
-                           unsigned char *buf, size_t len, int peek,
-                           size_t *readbytes);
-    int (*ssl_write_bytes) (SSL *s, uint8_t type, const void *buf_, size_t len,
-                            size_t *written);
-    int (*ssl_dispatch_alert) (SSL *s);
-    long (*ssl_ctrl) (SSL *s, int cmd, long larg, void *parg);
-    long (*ssl_ctx_ctrl) (SSL_CTX *ctx, int cmd, long larg, void *parg);
-    const SSL_CIPHER *(*get_cipher_by_char) (const unsigned char *ptr);
-    int (*put_cipher_by_char) (const SSL_CIPHER *cipher, WPACKET *pkt,
-                               size_t *len);
-    size_t (*ssl_pending) (const SSL *s);
-    int (*num_ciphers) (void);
-    const SSL_CIPHER *(*get_cipher) (unsigned ncipher);
-    OSSL_TIME (*get_timeout) (void);
+    SSL *(*ssl_new)(SSL_CTX *ctx);
+    void (*ssl_free)(SSL *s);
+    int (*ssl_reset)(SSL *s);
+    int (*ssl_init)(SSL *s);
+    int (*ssl_clear)(SSL *s);
+    void (*ssl_deinit)(SSL *s);
+    int (*ssl_accept)(SSL *s);
+    int (*ssl_connect)(SSL *s);
+    int (*ssl_read)(SSL *s, void *buf, size_t len, size_t *readbytes);
+    int (*ssl_peek)(SSL *s, void *buf, size_t len, size_t *readbytes);
+    int (*ssl_write)(SSL *s, const void *buf, size_t len, size_t *written);
+    int (*ssl_shutdown)(SSL *s);
+    int (*ssl_renegotiate)(SSL *s);
+    int (*ssl_renegotiate_check)(SSL *s, int);
+    int (*ssl_read_bytes)(SSL *s, uint8_t type, uint8_t *recvd_type,
+        unsigned char *buf, size_t len, int peek,
+        size_t *readbytes);
+    int (*ssl_write_bytes)(SSL *s, uint8_t type, const void *buf_, size_t len,
+        size_t *written);
+    int (*ssl_dispatch_alert)(SSL *s);
+    long (*ssl_ctrl)(SSL *s, int cmd, long larg, void *parg);
+    long (*ssl_ctx_ctrl)(SSL_CTX *ctx, int cmd, long larg, void *parg);
+    const SSL_CIPHER *(*get_cipher_by_char)(const unsigned char *ptr);
+    int (*put_cipher_by_char)(const SSL_CIPHER *cipher, WPACKET *pkt,
+        size_t *len);
+    size_t (*ssl_pending)(const SSL *s);
+    int (*num_ciphers)(void);
+    const SSL_CIPHER *(*get_cipher)(unsigned ncipher);
+    OSSL_TIME (*get_timeout)(void);
     const struct ssl3_enc_method *ssl3_enc; /* Extra SSLv3/TLS stuff */
-    int (*ssl_version) (void);
-    long (*ssl_callback_ctrl) (SSL *s, int cb_id, void (*fp) (void));
-    long (*ssl_ctx_callback_ctrl) (SSL_CTX *s, int cb_id, void (*fp) (void));
+    int (*ssl_version)(void);
+    long (*ssl_callback_ctrl)(SSL *s, int cb_id, void (*fp)(void));
+    long (*ssl_ctx_callback_ctrl)(SSL_CTX *s, int cb_id, void (*fp)(void));
 };
 
 /*
  * Matches the length of PSK_MAX_PSK_LEN. We keep it the same value for
  * consistency, even in the event of OPENSSL_NO_PSK being defined.
  */
-# define TLS13_MAX_RESUMPTION_PSK_LENGTH      512
+#define TLS13_MAX_RESUMPTION_PSK_LENGTH 512
 
 /*-
  * Lets make this into an ASN.1 type structure as follows
@@ -475,8 +474,8 @@ struct ssl_method_st {
  * I'm using EXPLICIT tags so I can read the damn things using asn1parse :-).
  */
 struct ssl_session_st {
-    int ssl_version;            /* what ssl version session info is being kept
-                                 * in here? */
+    int ssl_version; /* what ssl version session info is being kept
+                      * in here? */
     size_t master_key_length;
 
     /* TLSv1.3 early_secret used for external PSKs */
@@ -496,10 +495,10 @@ struct ssl_session_st {
      */
     size_t sid_ctx_length;
     unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH];
-# ifndef OPENSSL_NO_PSK
+#ifndef OPENSSL_NO_PSK
     char *psk_identity_hint;
     char *psk_identity;
-# endif
+#endif
     /*
      * Used to indicate that session resumption is not allowed. Applications
      * can also set this bit for a new session via not_resumable_session_cb
@@ -516,22 +515,22 @@ struct ssl_session_st {
      * when app_verify_callback accepts a session where the peer's
      * certificate is not ok, we must remember the error for session reuse:
      */
-    long verify_result;         /* only for servers */
+    long verify_result; /* only for servers */
     OSSL_TIME timeout;
     OSSL_TIME time;
     OSSL_TIME calc_timeout;
     unsigned int compress_meth; /* Need to lookup the method */
     const SSL_CIPHER *cipher;
-    unsigned long cipher_id;    /* when ASN.1 loaded, this needs to be used to
-                                 * load the 'cipher' structure */
-    unsigned int kex_group;      /* TLS group from key exchange */
-    CRYPTO_EX_DATA ex_data;     /* application specific data */
+    unsigned long cipher_id; /* when ASN.1 loaded, this needs to be used to
+                              * load the 'cipher' structure */
+    unsigned int kex_group; /* TLS group from key exchange */
+    CRYPTO_EX_DATA ex_data; /* application specific data */
 
     struct {
         char *hostname;
         /* RFC4507 info */
         unsigned char *tick; /* Session ticket */
-        size_t ticklen;      /* Session ticket length */
+        size_t ticklen; /* Session ticket length */
         /* Session lifetime hint in seconds */
         unsigned long tick_lifetime_hint;
         uint32_t tick_age_add;
@@ -548,9 +547,9 @@ struct ssl_session_st {
          */
         uint8_t max_fragment_len_mode;
     } ext;
-# ifndef OPENSSL_NO_SRP
+#ifndef OPENSSL_NO_SRP
     char *srp_username;
-# endif
+#endif
     unsigned char *ticket_appdata;
     size_t ticket_appdata_len;
     uint32_t flags;
@@ -565,19 +564,19 @@ struct ssl_session_st {
 };
 
 /* Extended master secret support */
-# define SSL_SESS_FLAG_EXTMS             0x1
+#define SSL_SESS_FLAG_EXTMS 0x1
 
-# ifndef OPENSSL_NO_SRP
+#ifndef OPENSSL_NO_SRP
 
 typedef struct srp_ctx_st {
     /* param for all the callbacks */
     void *SRP_cb_arg;
     /* set client Hello login callback */
-    int (*TLS_ext_srp_username_callback) (SSL *, int *, void *);
+    int (*TLS_ext_srp_username_callback)(SSL *, int *, void *);
     /* set SRP N/g param callback for verification */
-    int (*SRP_verify_param_callback) (SSL *, void *);
+    int (*SRP_verify_param_callback)(SSL *, void *);
     /* set SRP client passwd callback */
-    char *(*SRP_give_srp_client_pwd_callback) (SSL *, void *);
+    char *(*SRP_give_srp_client_pwd_callback)(SSL *, void *);
     char *login;
     BIGNUM *N, *g, *s, *B, *A;
     BIGNUM *a, *b, *v;
@@ -586,7 +585,7 @@ typedef struct srp_ctx_st {
     unsigned long srp_Mask;
 } SRP_CTX;
 
-# endif
+#endif
 
 typedef enum {
     SSL_EARLY_DATA_NONE = 0,
@@ -614,7 +613,7 @@ typedef enum {
  * The longest tag length we know of is EVP_GCM_TLS_TAG_LEN. We don't count the
  * content of the alert record either which is 2 bytes.
  */
-# define EARLY_DATA_CIPHERTEXT_OVERHEAD ((6 * (EVP_GCM_TLS_TAG_LEN + 1)) + 2)
+#define EARLY_DATA_CIPHERTEXT_OVERHEAD ((6 * (EVP_GCM_TLS_TAG_LEN + 1)) + 2)
 
 /*
  * The allowance we have between the client's calculated ticket age and our own.
@@ -622,10 +621,9 @@ typedef enum {
  * client's age calculation is different by more than this than our own then we
  * do not allow that ticket for early_data.
  */
-# define TICKET_AGE_ALLOWANCE   ossl_seconds2time(10)
-
-#define MAX_COMPRESSIONS_SIZE   255
+#define TICKET_AGE_ALLOWANCE ossl_seconds2time(10)
 
+#define MAX_COMPRESSIONS_SIZE 255
 
 typedef struct raw_extension_st {
     /* Raw packet data for the extension */
@@ -698,8 +696,8 @@ DEFINE_LHASH_OF_EX(SSL_SESSION);
 /* Needed in ssl_cert.c */
 DEFINE_LHASH_OF_EX(X509_NAME);
 
-# define TLSEXT_KEYNAME_LENGTH  16
-# define TLSEXT_TICK_KEY_LENGTH 32
+#define TLSEXT_KEYNAME_LENGTH 16
+#define TLSEXT_TICK_KEY_LENGTH 32
 
 typedef struct ssl_ctx_ext_secure_st {
     unsigned char tick_hmac_key[TLSEXT_TICK_KEY_LENGTH];
@@ -715,57 +713,57 @@ typedef struct ssl_ctx_ext_secure_st {
  */
 typedef struct ssl_hmac_st {
     EVP_MAC_CTX *ctx;
-# ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DEPRECATED_3_0
     HMAC_CTX *old_ctx;
-# endif
+#endif
 } SSL_HMAC;
 
 SSL_HMAC *ssl_hmac_new(const SSL_CTX *ctx);
 void ssl_hmac_free(SSL_HMAC *ctx);
-# ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DEPRECATED_3_0
 HMAC_CTX *ssl_hmac_get0_HMAC_CTX(SSL_HMAC *ctx);
-# endif
+#endif
 EVP_MAC_CTX *ssl_hmac_get0_EVP_MAC_CTX(SSL_HMAC *ctx);
 int ssl_hmac_init(SSL_HMAC *ctx, void *key, size_t len, char *md);
 int ssl_hmac_update(SSL_HMAC *ctx, const unsigned char *data, size_t len);
 int ssl_hmac_final(SSL_HMAC *ctx, unsigned char *md, size_t *len,
-                   size_t max_size);
+    size_t max_size);
 size_t ssl_hmac_size(const SSL_HMAC *ctx);
 
 int ssl_get_EC_curve_nid(const EVP_PKEY *pkey);
 __owur int tls13_set_encoded_pub_key(EVP_PKEY *pkey,
-                                     const unsigned char *enckey,
-                                     size_t enckeylen);
+    const unsigned char *enckey,
+    size_t enckeylen);
 
 typedef struct tls_group_info_st {
-    char *tlsname;           /* Curve Name as in TLS specs */
-    char *realname;          /* Curve Name according to provider */
-    char *algorithm;         /* Algorithm name to fetch */
-    unsigned int secbits;    /* Bits of security (from SP800-57) */
-    uint16_t group_id;       /* Group ID */
-    int mintls;              /* Minimum TLS version, -1 unsupported */
-    int maxtls;              /* Maximum TLS version (or 0 for undefined) */
-    int mindtls;             /* Minimum DTLS version, -1 unsupported */
-    int maxdtls;             /* Maximum DTLS version (or 0 for undefined) */
-    char is_kem;             /* Mode for this Group: 0 is KEX, 1 is KEM */
+    char *tlsname; /* Curve Name as in TLS specs */
+    char *realname; /* Curve Name according to provider */
+    char *algorithm; /* Algorithm name to fetch */
+    unsigned int secbits; /* Bits of security (from SP800-57) */
+    uint16_t group_id; /* Group ID */
+    int mintls; /* Minimum TLS version, -1 unsupported */
+    int maxtls; /* Maximum TLS version (or 0 for undefined) */
+    int mindtls; /* Minimum DTLS version, -1 unsupported */
+    int maxdtls; /* Maximum DTLS version (or 0 for undefined) */
+    char is_kem; /* Mode for this Group: 0 is KEX, 1 is KEM */
 } TLS_GROUP_INFO;
 
 typedef struct tls_sigalg_info_st {
-    char *name;              /* name as in IANA TLS specs */
-    uint16_t code_point;     /* IANA-specified code point of sigalg-name */
-    char *sigalg_name;       /* (combined) sigalg name */
-    char *sigalg_oid;        /* (combined) sigalg OID */
-    char *sig_name;          /* pure signature algorithm name */
-    char *sig_oid;           /* pure signature algorithm OID */
-    char *hash_name;         /* hash algorithm name */
-    char *hash_oid;          /* hash algorithm OID */
-    char *keytype;           /* keytype name */
-    char *keytype_oid;       /* keytype OID */
-    unsigned int secbits;    /* Bits of security (from SP800-57) */
-    int mintls;              /* Minimum TLS version, -1 unsupported */
-    int maxtls;              /* Maximum TLS version (or 0 for undefined) */
-    int mindtls;             /* Minimum DTLS version, -1 unsupported */
-    int maxdtls;             /* Maximum DTLS version (or 0 for undefined) */
+    char *name; /* name as in IANA TLS specs */
+    uint16_t code_point; /* IANA-specified code point of sigalg-name */
+    char *sigalg_name; /* (combined) sigalg name */
+    char *sigalg_oid; /* (combined) sigalg OID */
+    char *sig_name; /* pure signature algorithm name */
+    char *sig_oid; /* pure signature algorithm OID */
+    char *hash_name; /* hash algorithm name */
+    char *hash_oid; /* hash algorithm OID */
+    char *keytype; /* keytype name */
+    char *keytype_oid; /* keytype OID */
+    unsigned int secbits; /* Bits of security (from SP800-57) */
+    int mintls; /* Minimum TLS version, -1 unsupported */
+    int maxtls; /* Maximum TLS version (or 0 for undefined) */
+    int mindtls; /* Minimum DTLS version, -1 unsupported */
+    int maxdtls; /* Maximum DTLS version (or 0 for undefined) */
 } TLS_SIGALG_INFO;
 
 /*
@@ -773,24 +771,24 @@ typedef struct tls_sigalg_info_st {
  * CERT_PKEY entries
  */
 typedef struct {
-    int nid; /* NID of public key algorithm */
+    int pkey_nid; /* NID of public key algorithm */
     uint32_t amask; /* authmask corresponding to key type */
 } SSL_CERT_LOOKUP;
 
 /* flags values */
-# define TLS_GROUP_TYPE             0x0000000FU /* Mask for group type */
-# define TLS_GROUP_CURVE_PRIME      0x00000001U
-# define TLS_GROUP_CURVE_CHAR2      0x00000002U
-# define TLS_GROUP_CURVE_CUSTOM     0x00000004U
-# define TLS_GROUP_FFDHE            0x00000008U
-# define TLS_GROUP_ONLY_FOR_TLS1_3  0x00000010U
+#define TLS_GROUP_TYPE 0x0000000FU /* Mask for group type */
+#define TLS_GROUP_CURVE_PRIME 0x00000001U
+#define TLS_GROUP_CURVE_CHAR2 0x00000002U
+#define TLS_GROUP_CURVE_CUSTOM 0x00000004U
+#define TLS_GROUP_FFDHE 0x00000008U
+#define TLS_GROUP_ONLY_FOR_TLS1_3 0x00000010U
 
-# define TLS_GROUP_FFDHE_FOR_TLS1_3 (TLS_GROUP_FFDHE|TLS_GROUP_ONLY_FOR_TLS1_3)
+#define TLS_GROUP_FFDHE_FOR_TLS1_3 (TLS_GROUP_FFDHE | TLS_GROUP_ONLY_FOR_TLS1_3)
 
 /* We limit the number of key shares sent */
-# ifndef OPENSSL_CLIENT_MAX_KEY_SHARES
-#  define OPENSSL_CLIENT_MAX_KEY_SHARES 4
-# endif
+#ifndef OPENSSL_CLIENT_MAX_KEY_SHARES
+#define OPENSSL_CLIENT_MAX_KEY_SHARES 4
+#endif
 
 struct ssl_ctx_st {
     OSSL_LIB_CTX *libctx;
@@ -831,29 +829,29 @@ struct ssl_ctx_st {
      * removed from the cache.  After the call, OpenSSL will
      * SSL_SESSION_free() it.
      */
-    int (*new_session_cb) (struct ssl_st *ssl, SSL_SESSION *sess);
-    void (*remove_session_cb) (struct ssl_ctx_st *ctx, SSL_SESSION *sess);
-    SSL_SESSION *(*get_session_cb) (struct ssl_st *ssl,
-                                    const unsigned char *data, int len,
-                                    int *copy);
+    int (*new_session_cb)(struct ssl_st *ssl, SSL_SESSION *sess);
+    void (*remove_session_cb)(struct ssl_ctx_st *ctx, SSL_SESSION *sess);
+    SSL_SESSION *(*get_session_cb)(struct ssl_st *ssl,
+        const unsigned char *data, int len,
+        int *copy);
     struct {
-        TSAN_QUALIFIER int sess_connect;       /* SSL new conn - started */
+        TSAN_QUALIFIER int sess_connect; /* SSL new conn - started */
         TSAN_QUALIFIER int sess_connect_renegotiate; /* SSL reneg - requested */
-        TSAN_QUALIFIER int sess_connect_good;  /* SSL new conne/reneg - finished */
-        TSAN_QUALIFIER int sess_accept;        /* SSL new accept - started */
+        TSAN_QUALIFIER int sess_connect_good; /* SSL new conne/reneg - finished */
+        TSAN_QUALIFIER int sess_accept; /* SSL new accept - started */
         TSAN_QUALIFIER int sess_accept_renegotiate; /* SSL reneg - requested */
-        TSAN_QUALIFIER int sess_accept_good;   /* SSL accept/reneg - finished */
-        TSAN_QUALIFIER int sess_miss;          /* session lookup misses */
-        TSAN_QUALIFIER int sess_timeout;       /* reuse attempt on timeouted session */
-        TSAN_QUALIFIER int sess_cache_full;    /* session removed due to full cache */
-        TSAN_QUALIFIER int sess_hit;           /* session reuse actually done */
-        TSAN_QUALIFIER int sess_cb_hit;        /* session-id that was not in
-                                                * the cache was passed back via
-                                                * the callback. This indicates
-                                                * that the application is
-                                                * supplying session-id's from
-                                                * other processes - spooky
-                                                * :-) */
+        TSAN_QUALIFIER int sess_accept_good; /* SSL accept/reneg - finished */
+        TSAN_QUALIFIER int sess_miss; /* session lookup misses */
+        TSAN_QUALIFIER int sess_timeout; /* reuse attempt on timeouted session */
+        TSAN_QUALIFIER int sess_cache_full; /* session removed due to full cache */
+        TSAN_QUALIFIER int sess_hit; /* session reuse actually done */
+        TSAN_QUALIFIER int sess_cb_hit; /* session-id that was not in
+                                         * the cache was passed back via
+                                         * the callback. This indicates
+                                         * that the application is
+                                         * supplying session-id's from
+                                         * other processes - spooky
+                                         * :-) */
     } stats;
 #ifdef TSAN_REQUIRES_LOCKING
     CRYPTO_RWLOCK *tsan_lock;
@@ -862,7 +860,7 @@ struct ssl_ctx_st {
     CRYPTO_REF_COUNT references;
 
     /* if defined, these override the X509_verify_cert() calls */
-    int (*app_verify_callback) (X509_STORE_CTX *, void *);
+    int (*app_verify_callback)(X509_STORE_CTX *, void *);
     void *app_verify_arg;
     /*
      * before OpenSSL 0.9.7, 'app_verify_arg' was ignored
@@ -876,28 +874,28 @@ struct ssl_ctx_st {
     void *default_passwd_callback_userdata;
 
     /* get client cert callback */
-    int (*client_cert_cb) (SSL *ssl, X509 **x509, EVP_PKEY **pkey);
+    int (*client_cert_cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey);
 
     /* cookie generate callback */
-    int (*app_gen_cookie_cb) (SSL *ssl, unsigned char *cookie,
-                              unsigned int *cookie_len);
+    int (*app_gen_cookie_cb)(SSL *ssl, unsigned char *cookie,
+        unsigned int *cookie_len);
 
     /* verify cookie callback */
-    int (*app_verify_cookie_cb) (SSL *ssl, const unsigned char *cookie,
-                                 unsigned int cookie_len);
+    int (*app_verify_cookie_cb)(SSL *ssl, const unsigned char *cookie,
+        unsigned int cookie_len);
 
     /* TLS1.3 app-controlled cookie generate callback */
-    int (*gen_stateless_cookie_cb) (SSL *ssl, unsigned char *cookie,
-                                    size_t *cookie_len);
+    int (*gen_stateless_cookie_cb)(SSL *ssl, unsigned char *cookie,
+        size_t *cookie_len);
 
     /* TLS1.3 verify app-controlled cookie callback */
-    int (*verify_stateless_cookie_cb) (SSL *ssl, const unsigned char *cookie,
-                                       size_t cookie_len);
+    int (*verify_stateless_cookie_cb)(SSL *ssl, const unsigned char *cookie,
+        size_t cookie_len);
 
     CRYPTO_EX_DATA ex_data;
 
-    const EVP_MD *md5;          /* For SSLv3/TLSv1 'ssl3-md5' */
-    const EVP_MD *sha1;         /* For SSLv3/TLSv1 'ssl3-sha1' */
+    const EVP_MD *md5; /* For SSLv3/TLSv1 'ssl3-md5' */
+    const EVP_MD *sha1; /* For SSLv3/TLSv1 'ssl3-sha1' */
 
     STACK_OF(X509) *extra_certs;
     STACK_OF(SSL_COMP) *comp_methods; /* stack of SSL_COMP, SSLv3/TLSv1 */
@@ -905,7 +903,7 @@ struct ssl_ctx_st {
     /* Default values used when no per-SSL value is defined follow */
 
     /* used if SSL's info_callback is NULL */
-    void (*info_callback) (const SSL *ssl, int type, int val);
+    void (*info_callback)(const SSL *ssl, int type, int val);
 
     /*
      * What we put in certificate_authorities extension for TLS 1.3
@@ -939,7 +937,7 @@ struct ssl_ctx_st {
     size_t sid_ctx_length;
     unsigned char sid_ctx[SSL_MAX_SID_CTX_LENGTH];
     /* called 'verify_callback' in the SSL */
-    int (*default_verify_callback) (int ok, X509_STORE_CTX *ctx);
+    int (*default_verify_callback)(int ok, X509_STORE_CTX *ctx);
 
     /* Default generate session ID callback. */
     GEN_SESSION_CB generate_session_id;
@@ -948,15 +946,15 @@ struct ssl_ctx_st {
 
     int quiet_shutdown;
 
-# ifndef OPENSSL_NO_CT
-    CTLOG_STORE *ctlog_store;   /* CT Log Store */
+#ifndef OPENSSL_NO_CT
+    CTLOG_STORE *ctlog_store; /* CT Log Store */
     /*
      * Validates that the SCTs (Signed Certificate Timestamps) are sufficient.
      * If they are not, the connection should be aborted.
      */
     ssl_ct_validation_cb ct_validation_callback;
     void *ct_validation_callback_arg;
-# endif
+#endif
 
     /*
      * If we're using more than one pipeline how should we divide the data
@@ -975,12 +973,12 @@ struct ssl_ctx_st {
     /* The default read buffer length to use (0 means not set) */
     size_t default_read_buf_len;
 
-# ifndef OPENSSL_NO_ENGINE
+#ifndef OPENSSL_NO_ENGINE
     /*
      * Engine to pass requests for client certs to
      */
     ENGINE *client_cert_engine;
-# endif
+#endif
 
     /* ClientHello callback.  Mostly for extensions, but not entirely. */
     SSL_client_hello_cb_fn client_hello_cb;
@@ -993,25 +991,25 @@ struct ssl_ctx_st {
     /* TLS extensions. */
     struct {
         /* TLS extensions servername callback */
-        int (*servername_cb) (SSL *, int *, void *);
+        int (*servername_cb)(SSL *, int *, void *);
         void *servername_arg;
         /* RFC 4507 session ticket keys */
         unsigned char tick_key_name[TLSEXT_KEYNAME_LENGTH];
         SSL_CTX_EXT_SECURE *secure;
-# ifndef OPENSSL_NO_DEPRECATED_3_0
+#ifndef OPENSSL_NO_DEPRECATED_3_0
         /* Callback to support customisation of ticket key setting */
-        int (*ticket_key_cb) (SSL *ssl,
-                              unsigned char *name, unsigned char *iv,
-                              EVP_CIPHER_CTX *ectx, HMAC_CTX *hctx, int enc);
+        int (*ticket_key_cb)(SSL *ssl,
+            unsigned char *name, unsigned char *iv,
+            EVP_CIPHER_CTX *ectx, HMAC_CTX *hctx, int enc);
 #endif
-        int (*ticket_key_evp_cb) (SSL *ssl,
-                                  unsigned char *name, unsigned char *iv,
-                                  EVP_CIPHER_CTX *ectx, EVP_MAC_CTX *hctx,
-                                  int enc);
+        int (*ticket_key_evp_cb)(SSL *ssl,
+            unsigned char *name, unsigned char *iv,
+            EVP_CIPHER_CTX *ectx, EVP_MAC_CTX *hctx,
+            int enc);
 
         /* certificate status request info */
         /* Callback for status request */
-        int (*status_cb) (SSL *ssl, void *arg);
+        int (*status_cb)(SSL *ssl, void *arg);
         void *status_arg;
         /* ext status type used for CSR extension (OCSP Stapling) */
         int status_type;
@@ -1046,11 +1044,11 @@ struct ssl_ctx_st {
          *       wire-format.
          *   inlen: the length of |in|.
          */
-        int (*alpn_select_cb) (SSL *s,
-                               const unsigned char **out,
-                               unsigned char *outlen,
-                               const unsigned char *in,
-                               unsigned int inlen, void *arg);
+        int (*alpn_select_cb)(SSL *s,
+            const unsigned char **out,
+            unsigned char *outlen,
+            const unsigned char *in,
+            unsigned int inlen, void *arg);
         void *alpn_select_cb_arg;
 
         /*
@@ -1060,7 +1058,7 @@ struct ssl_ctx_st {
         unsigned char *alpn;
         size_t alpn_len;
 
-# ifndef OPENSSL_NO_NEXTPROTONEG
+#ifndef OPENSSL_NO_NEXTPROTONEG
         /* Next protocol negotiation information */
 
         /*
@@ -1075,34 +1073,34 @@ struct ssl_ctx_st {
          */
         SSL_CTX_npn_select_cb_func npn_select_cb;
         void *npn_select_cb_arg;
-# endif
+#endif
 
         unsigned char cookie_hmac_key[SHA256_DIGEST_LENGTH];
     } ext;
 
-# ifndef OPENSSL_NO_PSK
+#ifndef OPENSSL_NO_PSK
     SSL_psk_client_cb_func psk_client_callback;
     SSL_psk_server_cb_func psk_server_callback;
-# endif
+#endif
     SSL_psk_find_session_cb_func psk_find_session_cb;
     SSL_psk_use_session_cb_func psk_use_session_cb;
 
-# ifndef OPENSSL_NO_SRP
-    SRP_CTX srp_ctx;            /* ctx for SRP authentication */
-# endif
+#ifndef OPENSSL_NO_SRP
+    SRP_CTX srp_ctx; /* ctx for SRP authentication */
+#endif
 
     /* Shared DANE context */
     struct dane_ctx_st dane;
 
-# ifndef OPENSSL_NO_SRTP
+#ifndef OPENSSL_NO_SRTP
     /* SRTP profiles we are willing to do from RFC 5764 */
     STACK_OF(SRTP_PROTECTION_PROFILE) *srtp_profiles;
-# endif
+#endif
     /*
      * Callback for disabling session caching and ticket support on a session
      * basis, depending on the chosen cipher.
      */
-    int (*not_resumable_session_cb) (SSL *ssl, int is_forward_secure);
+    int (*not_resumable_session_cb)(SSL *ssl, int is_forward_secure);
 
     CRYPTO_RWLOCK *lock;
 
@@ -1115,9 +1113,9 @@ struct ssl_ctx_st {
     /*
      * Private flag for internal key logging based on SSLKEYLOG env
      */
-# ifndef OPENSSL_NO_SSLKEYLOG
+#ifndef OPENSSL_NO_SSLKEYLOG
     uint32_t do_sslkeylog;
-# endif
+#endif
 
     /*
      * The maximum number of bytes advertised in session tickets that can be
@@ -1195,40 +1193,40 @@ struct ssl_ctx_st {
     unsigned char *server_cert_type;
     size_t server_cert_type_len;
 
-# ifndef OPENSSL_NO_QUIC
+#ifndef OPENSSL_NO_QUIC
     uint64_t domain_flags;
     SSL_TOKEN_STORE *tokencache;
-# endif
+#endif
 
-# ifndef OPENSSL_NO_QLOG
+#ifndef OPENSSL_NO_QLOG
     char *qlog_title; /* Session title for qlog */
-# endif
+#endif
 };
 
 typedef struct ossl_quic_tls_callbacks_st {
     int (*crypto_send_cb)(SSL *s, const unsigned char *buf, size_t buf_len,
-                          size_t *consumed, void *arg);
+        size_t *consumed, void *arg);
     int (*crypto_recv_rcd_cb)(SSL *s, const unsigned char **buf,
-                              size_t *bytes_read, void *arg);
+        size_t *bytes_read, void *arg);
     int (*crypto_release_rcd_cb)(SSL *s, size_t bytes_read, void *arg);
     int (*yield_secret_cb)(SSL *s, uint32_t prot_level, int direction,
-                           const unsigned char *secret, size_t secret_len,
-                           void *arg);
+        const unsigned char *secret, size_t secret_len,
+        void *arg);
     int (*got_transport_params_cb)(SSL *s, const unsigned char *params,
-                                   size_t params_len,
-                                   void *arg);
+        size_t params_len,
+        void *arg);
     int (*alert_cb)(SSL *s, unsigned char alert_code, void *arg);
 } OSSL_QUIC_TLS_CALLBACKS;
 
 typedef struct cert_pkey_st CERT_PKEY;
 
-#define SSL_TYPE_SSL_CONNECTION     0
-#define SSL_TYPE_QUIC_CONNECTION    0x80
-#define SSL_TYPE_QUIC_XSO           0x81
-#define SSL_TYPE_QUIC_LISTENER      0x82
-#define SSL_TYPE_QUIC_DOMAIN        0x83
+#define SSL_TYPE_SSL_CONNECTION 0
+#define SSL_TYPE_QUIC_CONNECTION 0x80
+#define SSL_TYPE_QUIC_XSO 0x81
+#define SSL_TYPE_QUIC_LISTENER 0x82
+#define SSL_TYPE_QUIC_DOMAIN 0x83
 
-#define SSL_TYPE_IS_QUIC(x)         (((x) & 0x80) != 0)
+#define SSL_TYPE_IS_QUIC(x) (((x) & 0x80) != 0)
 
 struct ssl_st {
     int type;
@@ -1272,7 +1270,7 @@ struct ssl_connection_st {
      * request needs re-doing when in SSL_accept or SSL_connect
      */
     int rwstate;
-    int (*handshake_func) (SSL *);
+    int (*handshake_func)(SSL *);
     /*
      * Imagine that here's a boolean member "init" that is switched as soon
      * as SSL_set_{accept/connect}_state is called for the first time, so
@@ -1299,11 +1297,11 @@ struct ssl_connection_st {
     /* where we are */
     OSSL_STATEM statem;
     SSL_EARLY_DATA_STATE early_data_state;
-    BUF_MEM *init_buf;          /* buffer used during init */
-    void *init_msg;             /* pointer to handshake message body, set by
-                                 * tls_get_message_header() */
-    size_t init_num;               /* amount read/written */
-    size_t init_off;               /* amount read/written */
+    BUF_MEM *init_buf; /* buffer used during init */
+    void *init_msg; /* pointer to handshake message body, set by
+                     * tls_get_message_header() */
+    size_t init_num; /* amount read/written */
+    size_t init_off; /* amount read/written */
 
     size_t ssl_pkey_num;
 
@@ -1357,7 +1355,7 @@ struct ssl_connection_st {
             int message_type;
             /* used to hold the new cipher we are going to use */
             const SSL_CIPHER *new_cipher;
-            EVP_PKEY *pkey;         /* holds short lived key exchange key */
+            EVP_PKEY *pkey; /* holds short lived key exchange key */
             /* holds the array of short lived key exchange key (pointers) */
             EVP_PKEY *ks_pkey[OPENSSL_CLIENT_MAX_KEY_SHARES];
             uint16_t ks_group_id[OPENSSL_CLIENT_MAX_KEY_SHARES]; /* The IDs of the keyshare keys */
@@ -1375,11 +1373,11 @@ struct ssl_connection_st {
             const EVP_MD *new_hash;
             int new_mac_pkey_type;
             size_t new_mac_secret_size;
-# ifndef OPENSSL_NO_COMP
+#ifndef OPENSSL_NO_COMP
             const SSL_COMP *new_compression;
-# else
+#else
             char *new_compression;
-# endif
+#endif
             int cert_request;
             /* Raw values of the cipher list from a client */
             unsigned char *ciphers_raw;
@@ -1387,11 +1385,11 @@ struct ssl_connection_st {
             /* Temporary storage for premaster secret */
             unsigned char *pms;
             size_t pmslen;
-# ifndef OPENSSL_NO_PSK
+#ifndef OPENSSL_NO_PSK
             /* Temporary storage for PSK key */
             unsigned char *psk;
             size_t psklen;
-# endif
+#endif
             /* Signature algorithm we actually use */
             const struct sigalg_lookup_st *sigalg;
             /* Pointer to certificate we use */
@@ -1438,12 +1436,12 @@ struct ssl_connection_st {
         size_t previous_server_finished_len;
         int send_connection_binding;
 
-# ifndef OPENSSL_NO_NEXTPROTONEG
+#ifndef OPENSSL_NO_NEXTPROTONEG
         /*
          * Set if we saw the Next Protocol Negotiation extension from our peer.
          */
         int npn_seen;
-# endif
+#endif
 
         /*
          * ALPN information (we are in the process of transitioning from NPN to
@@ -1484,12 +1482,12 @@ struct ssl_connection_st {
         uint16_t group_id_candidate;
     } s3;
 
-    struct dtls1_state_st *d1;  /* DTLSv1 variables */
+    struct dtls1_state_st *d1; /* DTLSv1 variables */
     /* callback that allows applications to peek at protocol messages */
-    void (*msg_callback) (int write_p, int version, int content_type,
-                          const void *buf, size_t len, SSL *ssl, void *arg);
+    void (*msg_callback)(int write_p, int version, int content_type,
+        const void *buf, size_t len, SSL *ssl, void *arg);
     void *msg_callback_arg;
-    int hit;                    /* reusing a previous session */
+    int hit; /* reusing a previous session */
     X509_VERIFY_PARAM *param;
     /* Per connection DANE state */
     SSL_DANE dane;
@@ -1533,8 +1531,9 @@ struct ssl_connection_st {
     size_t cert_verify_hash_len;
 
     /* Flag to indicate whether we should send a HelloRetryRequest or not */
-    enum {SSL_HRR_NONE = 0, SSL_HRR_PENDING, SSL_HRR_COMPLETE}
-        hello_retry_request;
+    enum { SSL_HRR_NONE = 0,
+        SSL_HRR_PENDING,
+        SSL_HRR_COMPLETE } hello_retry_request;
 
     /*
      * the session_id_context is used to ensure sessions are only reused in
@@ -1563,17 +1562,17 @@ struct ssl_connection_st {
      */
     uint32_t verify_mode;
     /* fail if callback returns 0 */
-    int (*verify_callback) (int ok, X509_STORE_CTX *ctx);
+    int (*verify_callback)(int ok, X509_STORE_CTX *ctx);
     /* optional informational callback */
-    void (*info_callback) (const SSL *ssl, int type, int val);
+    void (*info_callback)(const SSL *ssl, int type, int val);
     /* error bytes to be written */
     int error;
     /* actual code */
     int error_code;
-# ifndef OPENSSL_NO_PSK
+#ifndef OPENSSL_NO_PSK
     SSL_psk_client_cb_func psk_client_callback;
     SSL_psk_server_cb_func psk_server_callback;
-# endif
+#endif
     SSL_psk_find_session_cb_func psk_find_session_cb;
     SSL_psk_use_session_cb_func psk_use_session_cb;
 
@@ -1619,7 +1618,7 @@ struct ssl_connection_st {
         uint8_t extflags[TLSEXT_IDX_num_builtins];
         /* TLS extension debug callback */
         void (*debug_cb)(SSL *s, int client_server, int type,
-                         const unsigned char *data, int len, void *arg);
+            const unsigned char *data, int len, void *arg);
         void *debug_arg;
         char *hostname;
         /* certificate status request info */
@@ -1750,7 +1749,7 @@ struct ssl_connection_st {
      * 2 : don't call servername callback, no ack in server hello
      */
     int servername_done;
-# ifndef OPENSSL_NO_CT
+#ifndef OPENSSL_NO_CT
     /*
      * Validates that the SCTs (Signed Certificate Timestamps) are sufficient.
      * If they are not, the connection should be aborted.
@@ -1765,14 +1764,14 @@ struct ssl_connection_st {
     STACK_OF(SCT) *scts;
     /* Have we attempted to find/parse SCTs yet? */
     int scts_parsed;
-# endif
-    SSL_CTX *session_ctx;       /* initial ctx, used to store sessions */
-# ifndef OPENSSL_NO_SRTP
+#endif
+    SSL_CTX *session_ctx; /* initial ctx, used to store sessions */
+#ifndef OPENSSL_NO_SRTP
     /* What we'll do */
     STACK_OF(SRTP_PROTECTION_PROFILE) *srtp_profiles;
     /* What's been chosen */
     SRTP_PROTECTION_PROFILE *srtp_profile;
-# endif
+#endif
     /*-
      * 1 if we are renegotiating.
      * 2 if we are a server and are inside a handshake
@@ -1784,20 +1783,20 @@ struct ssl_connection_st {
     /* Post-handshake authentication state */
     SSL_PHA_STATE post_handshake_auth;
     int pha_enabled;
-    uint8_t* pha_context;
+    uint8_t *pha_context;
     size_t pha_context_len;
     int certreqs_sent;
     EVP_MD_CTX *pha_dgst; /* this is just the digest through ClientFinished */
 
-# ifndef OPENSSL_NO_SRP
+#ifndef OPENSSL_NO_SRP
     /* ctx for SRP authentication */
     SRP_CTX srp_ctx;
-# endif
+#endif
     /*
      * Callback for disabling session caching and ticket support on a session
      * basis, depending on the chosen cipher.
      */
-    int (*not_resumable_session_cb) (SSL *ssl, int is_forward_secure);
+    int (*not_resumable_session_cb)(SSL *ssl, int is_forward_secure);
 
     /* Record layer data */
     RECORD_LAYER rlayer;
@@ -1866,7 +1865,7 @@ struct ssl_connection_st {
 /*
  * Structure containing table entry of values associated with the signature
  * algorithms (signature scheme) extension
-*/
+ */
 typedef struct sigalg_lookup_st {
     /* TLS 1.3 signature scheme name */
     const char *name;
@@ -1899,12 +1898,12 @@ typedef struct sigalg_lookup_st {
 
 /* DTLS structures */
 
-# ifndef OPENSSL_NO_SCTP
-#  define DTLS1_SCTP_AUTH_LABEL   "EXPORTER_DTLS_OVER_SCTP"
-# endif
+#ifndef OPENSSL_NO_SCTP
+#define DTLS1_SCTP_AUTH_LABEL "EXPORTER_DTLS_OVER_SCTP"
+#endif
 
 /* Max MTU overhead we know about so far is 40 for IPv6 + 8 for UDP */
-# define DTLS1_MAX_MTU_OVERHEAD                   48
+#define DTLS1_MAX_MTU_OVERHEAD 48
 
 struct dtls1_retransmit_state {
     const OSSL_RECORD_METHOD *wrlmethod;
@@ -1931,7 +1930,7 @@ typedef struct pqueue_st pqueue;
 typedef struct pitem_st pitem;
 
 struct pitem_st {
-    unsigned char priority[8];  /* 64-bit value in big-endian encoding */
+    unsigned char priority[8]; /* 64-bit value in big-endian encoding */
     void *data;
     pitem *next;
 };
@@ -1962,8 +1961,8 @@ typedef struct dtls1_state_st {
     pqueue *buffered_messages;
     /* Buffered (sent) handshake records */
     pqueue *sent_messages;
-    size_t link_mtu;      /* max on-the-wire DTLS packet size */
-    size_t mtu;           /* max DTLS packet size */
+    size_t link_mtu; /* max on-the-wire DTLS packet size */
+    size_t mtu; /* max DTLS packet size */
     struct hm_header_st w_msg_hdr;
     struct hm_header_st r_msg_hdr;
     /* Number of alerts received so far */
@@ -1976,9 +1975,9 @@ typedef struct dtls1_state_st {
     unsigned int timeout_duration_us;
 
     unsigned int retransmitting;
-# ifndef OPENSSL_NO_SCTP
+#ifndef OPENSSL_NO_SCTP
     int shutdown_received;
-# endif
+#endif
 
     DTLS_timer_cb timer_cb;
 
@@ -1987,11 +1986,11 @@ typedef struct dtls1_state_st {
 /*
  * From ECC-TLS draft, used in encoding the curve type in ECParameters
  */
-#  define EXPLICIT_PRIME_CURVE_TYPE  1
-#  define EXPLICIT_CHAR2_CURVE_TYPE  2
-#  define NAMED_CURVE_TYPE           3
+#define EXPLICIT_PRIME_CURVE_TYPE 1
+#define EXPLICIT_CHAR2_CURVE_TYPE 2
+#define NAMED_CURVE_TYPE 3
 
-# ifndef OPENSSL_NO_COMP_ALG
+#ifndef OPENSSL_NO_COMP_ALG
 struct ossl_comp_cert_st {
     unsigned char *data;
     size_t len;
@@ -2003,7 +2002,7 @@ typedef struct ossl_comp_cert_st OSSL_COMP_CERT;
 
 void OSSL_COMP_CERT_free(OSSL_COMP_CERT *c);
 int OSSL_COMP_CERT_up_ref(OSSL_COMP_CERT *c);
-# endif
+#endif
 
 struct cert_pkey_st {
     X509 *x509;
@@ -2019,17 +2018,17 @@ struct cert_pkey_st {
      */
     unsigned char *serverinfo;
     size_t serverinfo_length;
-# ifndef OPENSSL_NO_COMP_ALG
+#ifndef OPENSSL_NO_COMP_ALG
     /* Compressed certificate data - index 0 is unused */
     OSSL_COMP_CERT *comp_cert[TLSEXT_comp_cert_limit];
     int cert_comp_used;
-# endif
+#endif
 };
 /* Retrieve Suite B flags */
-# define tls1_suiteb(s)  (s->cert->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS)
+#define tls1_suiteb(s) (s->cert->cert_flags & SSL_CERT_FLAG_SUITEB_128_LOS)
 /* Uses to check strict mode: suite B modes are always strict */
-# define SSL_CERT_FLAGS_CHECK_TLS_STRICT \
-        (SSL_CERT_FLAG_SUITEB_128_LOS|SSL_CERT_FLAG_TLS_STRICT)
+#define SSL_CERT_FLAGS_CHECK_TLS_STRICT \
+    (SSL_CERT_FLAG_SUITEB_128_LOS | SSL_CERT_FLAG_TLS_STRICT)
 
 typedef enum {
     ENDPOINT_CLIENT = 0,
@@ -2037,7 +2036,6 @@ typedef enum {
     ENDPOINT_BOTH
 } ENDPOINT;
 
-
 typedef struct {
     unsigned short ext_type;
     ENDPOINT role;
@@ -2061,17 +2059,17 @@ typedef struct {
  * Indicates an extension has been received. Used to check for unsolicited or
  * duplicate extensions.
  */
-# define SSL_EXT_FLAG_RECEIVED   0x1
+#define SSL_EXT_FLAG_RECEIVED 0x1
 /*
  * Indicates an extension has been sent: used to enable sending of
  * corresponding ServerHello extension.
  */
-# define SSL_EXT_FLAG_SENT       0x2
+#define SSL_EXT_FLAG_SENT 0x2
 /*
  * Indicates an extension that was set on SSL object and needs to be
  * preserved when switching SSL contexts.
  */
-# define SSL_EXT_FLAG_CONN       0x4
+#define SSL_EXT_FLAG_CONN 0x4
 
 typedef struct {
     custom_ext_method *meths;
@@ -2088,7 +2086,7 @@ typedef struct cert_st {
     CERT_PKEY *key;
 
     EVP_PKEY *dh_tmp;
-    DH *(*dh_tmp_cb) (SSL *ssl, int is_export, int keysize);
+    DH *(*dh_tmp_cb)(SSL *ssl, int is_export, int keysize);
     int dh_tmp_auto;
     /* Flags related to certificates */
     uint32_t cert_flags;
@@ -2122,7 +2120,7 @@ typedef struct cert_st {
      * allows advanced applications to select certificates on the fly: for
      * example based on supported signature algorithms or curves.
      */
-    int (*cert_cb) (SSL *ssl, void *arg);
+    int (*cert_cb)(SSL *ssl, void *arg);
     void *cert_cb_arg;
     /*
      * Optional X509_STORE for chain building or certificate validation If
@@ -2133,16 +2131,16 @@ typedef struct cert_st {
     /* Custom extensions */
     custom_ext_methods custext;
     /* Security callback */
-    int (*sec_cb) (const SSL *s, const SSL_CTX *ctx, int op, int bits, int nid,
-                   void *other, void *ex);
+    int (*sec_cb)(const SSL *s, const SSL_CTX *ctx, int op, int bits, int nid,
+        void *other, void *ex);
     /* Security level */
     int sec_level;
     void *sec_ex;
-# ifndef OPENSSL_NO_PSK
+#ifndef OPENSSL_NO_PSK
     /* If not NULL psk identity hint to use for servers */
     char *psk_identity_hint;
-# endif
-    CRYPTO_REF_COUNT references;             /* >1 only if SSL_copy_session_id is used */
+#endif
+    CRYPTO_REF_COUNT references; /* >1 only if SSL_copy_session_id is used */
 } CERT;
 
 /*
@@ -2150,50 +2148,50 @@ typedef struct cert_st {
  * of a mess of functions, but hell, think of it as an opaque structure :-)
  */
 typedef struct ssl3_enc_method {
-    int (*setup_key_block) (SSL_CONNECTION *);
-    int (*generate_master_secret) (SSL_CONNECTION *, unsigned char *,
-                                   unsigned char *, size_t, size_t *);
-    int (*change_cipher_state) (SSL_CONNECTION *, int);
-    size_t (*final_finish_mac) (SSL_CONNECTION *, const char *, size_t,
-                                unsigned char *);
+    int (*setup_key_block)(SSL_CONNECTION *);
+    int (*generate_master_secret)(SSL_CONNECTION *, unsigned char *,
+        unsigned char *, size_t, size_t *);
+    int (*change_cipher_state)(SSL_CONNECTION *, int);
+    size_t (*final_finish_mac)(SSL_CONNECTION *, const char *, size_t,
+        unsigned char *);
     const char *client_finished_label;
     size_t client_finished_label_len;
     const char *server_finished_label;
     size_t server_finished_label_len;
-    int (*alert_value) (int);
-    int (*export_keying_material) (SSL_CONNECTION *, unsigned char *, size_t,
-                                   const char *, size_t,
-                                   const unsigned char *, size_t,
-                                   int use_context);
+    int (*alert_value)(int);
+    int (*export_keying_material)(SSL_CONNECTION *, unsigned char *, size_t,
+        const char *, size_t,
+        const unsigned char *, size_t,
+        int use_context);
     /* Various flags indicating protocol version requirements */
     uint32_t enc_flags;
     /* Set the handshake header */
-    int (*set_handshake_header) (SSL_CONNECTION *s, WPACKET *pkt, int type);
+    int (*set_handshake_header)(SSL_CONNECTION *s, WPACKET *pkt, int type);
     /* Close construction of the handshake message */
-    int (*close_construct_packet) (SSL_CONNECTION *s, WPACKET *pkt, int htype);
+    int (*close_construct_packet)(SSL_CONNECTION *s, WPACKET *pkt, int htype);
     /* Write out handshake message */
-    int (*do_write) (SSL_CONNECTION *s);
+    int (*do_write)(SSL_CONNECTION *s);
 } SSL3_ENC_METHOD;
 
-# define ssl_set_handshake_header(s, pkt, htype) \
+#define ssl_set_handshake_header(s, pkt, htype) \
     SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->set_handshake_header((s), (pkt), (htype))
-# define ssl_close_construct_packet(s, pkt, htype) \
+#define ssl_close_construct_packet(s, pkt, htype) \
     SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->close_construct_packet((s), (pkt), (htype))
-# define ssl_do_write(s)  SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->do_write(s)
+#define ssl_do_write(s) SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->do_write(s)
 
 /* Values for enc_flags */
 
 /* Uses signature algorithms extension */
-# define SSL_ENC_FLAG_SIGALGS            0x2
+#define SSL_ENC_FLAG_SIGALGS 0x2
 /* Uses SHA256 default PRF */
-# define SSL_ENC_FLAG_SHA256_PRF         0x4
+#define SSL_ENC_FLAG_SHA256_PRF 0x4
 /* Is DTLS */
-# define SSL_ENC_FLAG_DTLS               0x8
+#define SSL_ENC_FLAG_DTLS 0x8
 /*
  * Allow TLS 1.2 ciphersuites: applies to DTLS 1.2 as well as TLS 1.2: may
  * apply to others in future.
  */
-# define SSL_ENC_FLAG_TLS1_2_CIPHERS     0x10
+#define SSL_ENC_FLAG_TLS1_2_CIPHERS 0x10
 
 typedef enum downgrade_en {
     DOWNGRADE_NONE,
@@ -2205,100 +2203,99 @@ typedef enum downgrade_en {
  * Dummy status type for the status_type extension. Indicates no status type
  * set
  */
-#define TLSEXT_STATUSTYPE_nothing  -1
+#define TLSEXT_STATUSTYPE_nothing -1
 
 /* Sigalgs values */
-#define TLSEXT_SIGALG_ecdsa_secp256r1_sha256                    0x0403
-#define TLSEXT_SIGALG_ecdsa_secp384r1_sha384                    0x0503
-#define TLSEXT_SIGALG_ecdsa_secp521r1_sha512                    0x0603
-#define TLSEXT_SIGALG_ecdsa_sha224                              0x0303
-#define TLSEXT_SIGALG_ecdsa_sha1                                0x0203
-#define TLSEXT_SIGALG_rsa_pss_rsae_sha256                       0x0804
-#define TLSEXT_SIGALG_rsa_pss_rsae_sha384                       0x0805
-#define TLSEXT_SIGALG_rsa_pss_rsae_sha512                       0x0806
-#define TLSEXT_SIGALG_rsa_pss_pss_sha256                        0x0809
-#define TLSEXT_SIGALG_rsa_pss_pss_sha384                        0x080a
-#define TLSEXT_SIGALG_rsa_pss_pss_sha512                        0x080b
-#define TLSEXT_SIGALG_rsa_pkcs1_sha256                          0x0401
-#define TLSEXT_SIGALG_rsa_pkcs1_sha384                          0x0501
-#define TLSEXT_SIGALG_rsa_pkcs1_sha512                          0x0601
-#define TLSEXT_SIGALG_rsa_pkcs1_sha224                          0x0301
-#define TLSEXT_SIGALG_rsa_pkcs1_sha1                            0x0201
-#define TLSEXT_SIGALG_dsa_sha256                                0x0402
-#define TLSEXT_SIGALG_dsa_sha384                                0x0502
-#define TLSEXT_SIGALG_dsa_sha512                                0x0602
-#define TLSEXT_SIGALG_dsa_sha224                                0x0302
-#define TLSEXT_SIGALG_dsa_sha1                                  0x0202
-#define TLSEXT_SIGALG_gostr34102012_256_intrinsic               0x0840
-#define TLSEXT_SIGALG_gostr34102012_512_intrinsic               0x0841
-#define TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256       0xeeee
-#define TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512       0xefef
-#define TLSEXT_SIGALG_gostr34102001_gostr3411                   0xeded
+#define TLSEXT_SIGALG_ecdsa_secp256r1_sha256 0x0403
+#define TLSEXT_SIGALG_ecdsa_secp384r1_sha384 0x0503
+#define TLSEXT_SIGALG_ecdsa_secp521r1_sha512 0x0603
+#define TLSEXT_SIGALG_ecdsa_sha224 0x0303
+#define TLSEXT_SIGALG_ecdsa_sha1 0x0203
+#define TLSEXT_SIGALG_rsa_pss_rsae_sha256 0x0804
+#define TLSEXT_SIGALG_rsa_pss_rsae_sha384 0x0805
+#define TLSEXT_SIGALG_rsa_pss_rsae_sha512 0x0806
+#define TLSEXT_SIGALG_rsa_pss_pss_sha256 0x0809
+#define TLSEXT_SIGALG_rsa_pss_pss_sha384 0x080a
+#define TLSEXT_SIGALG_rsa_pss_pss_sha512 0x080b
+#define TLSEXT_SIGALG_rsa_pkcs1_sha256 0x0401
+#define TLSEXT_SIGALG_rsa_pkcs1_sha384 0x0501
+#define TLSEXT_SIGALG_rsa_pkcs1_sha512 0x0601
+#define TLSEXT_SIGALG_rsa_pkcs1_sha224 0x0301
+#define TLSEXT_SIGALG_rsa_pkcs1_sha1 0x0201
+#define TLSEXT_SIGALG_dsa_sha256 0x0402
+#define TLSEXT_SIGALG_dsa_sha384 0x0502
+#define TLSEXT_SIGALG_dsa_sha512 0x0602
+#define TLSEXT_SIGALG_dsa_sha224 0x0302
+#define TLSEXT_SIGALG_dsa_sha1 0x0202
+#define TLSEXT_SIGALG_gostr34102012_256_intrinsic 0x0840
+#define TLSEXT_SIGALG_gostr34102012_512_intrinsic 0x0841
+#define TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256 0xeeee
+#define TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512 0xefef
+#define TLSEXT_SIGALG_gostr34102001_gostr3411 0xeded
 
-#define TLSEXT_SIGALG_ed25519                                   0x0807
-#define TLSEXT_SIGALG_ed448                                     0x0808
-#define TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256              0x081a
-#define TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384              0x081b
-#define TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512              0x081c
-#define TLSEXT_SIGALG_mldsa44                                   0x0904
-#define TLSEXT_SIGALG_mldsa65                                   0x0905
-#define TLSEXT_SIGALG_mldsa87                                   0x0906
+#define TLSEXT_SIGALG_ed25519 0x0807
+#define TLSEXT_SIGALG_ed448 0x0808
+#define TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256 0x081a
+#define TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384 0x081b
+#define TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512 0x081c
+#define TLSEXT_SIGALG_mldsa44 0x0904
+#define TLSEXT_SIGALG_mldsa65 0x0905
+#define TLSEXT_SIGALG_mldsa87 0x0906
 
 /* Sigalgs names */
-#define TLSEXT_SIGALG_ecdsa_secp256r1_sha256_name                    "ecdsa_secp256r1_sha256"
-#define TLSEXT_SIGALG_ecdsa_secp384r1_sha384_name                    "ecdsa_secp384r1_sha384"
-#define TLSEXT_SIGALG_ecdsa_secp521r1_sha512_name                    "ecdsa_secp521r1_sha512"
-#define TLSEXT_SIGALG_ecdsa_sha224_name                              "ecdsa_sha224"
-#define TLSEXT_SIGALG_ecdsa_sha1_name                                "ecdsa_sha1"
-#define TLSEXT_SIGALG_rsa_pss_rsae_sha256_name                       "rsa_pss_rsae_sha256"
-#define TLSEXT_SIGALG_rsa_pss_rsae_sha384_name                       "rsa_pss_rsae_sha384"
-#define TLSEXT_SIGALG_rsa_pss_rsae_sha512_name                       "rsa_pss_rsae_sha512"
-#define TLSEXT_SIGALG_rsa_pss_pss_sha256_name                        "rsa_pss_pss_sha256"
-#define TLSEXT_SIGALG_rsa_pss_pss_sha384_name                        "rsa_pss_pss_sha384"
-#define TLSEXT_SIGALG_rsa_pss_pss_sha512_name                        "rsa_pss_pss_sha512"
-#define TLSEXT_SIGALG_rsa_pkcs1_sha256_name                          "rsa_pkcs1_sha256"
-#define TLSEXT_SIGALG_rsa_pkcs1_sha384_name                          "rsa_pkcs1_sha384"
-#define TLSEXT_SIGALG_rsa_pkcs1_sha512_name                          "rsa_pkcs1_sha512"
-#define TLSEXT_SIGALG_rsa_pkcs1_sha224_name                          "rsa_pkcs1_sha224"
-#define TLSEXT_SIGALG_rsa_pkcs1_sha1_name                            "rsa_pkcs1_sha1"
-#define TLSEXT_SIGALG_dsa_sha256_name                                "dsa_sha256"
-#define TLSEXT_SIGALG_dsa_sha384_name                                "dsa_sha384"
-#define TLSEXT_SIGALG_dsa_sha512_name                                "dsa_sha512"
-#define TLSEXT_SIGALG_dsa_sha224_name                                "dsa_sha224"
-#define TLSEXT_SIGALG_dsa_sha1_name                                  "dsa_sha1"
-#define TLSEXT_SIGALG_gostr34102012_256_intrinsic_name               "gostr34102012_256"
-#define TLSEXT_SIGALG_gostr34102012_512_intrinsic_name               "gostr34102012_512"
-#define TLSEXT_SIGALG_gostr34102012_256_intrinsic_alias              "gost2012_256"
-#define TLSEXT_SIGALG_gostr34102012_512_intrinsic_alias              "gost2012_512"
-#define TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256_name       "gost2012_256"
-#define TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512_name       "gost2012_512"
-#define TLSEXT_SIGALG_gostr34102001_gostr3411_name                   "gost2001_gost94"
+#define TLSEXT_SIGALG_ecdsa_secp256r1_sha256_name "ecdsa_secp256r1_sha256"
+#define TLSEXT_SIGALG_ecdsa_secp384r1_sha384_name "ecdsa_secp384r1_sha384"
+#define TLSEXT_SIGALG_ecdsa_secp521r1_sha512_name "ecdsa_secp521r1_sha512"
+#define TLSEXT_SIGALG_ecdsa_sha224_name "ecdsa_sha224"
+#define TLSEXT_SIGALG_ecdsa_sha1_name "ecdsa_sha1"
+#define TLSEXT_SIGALG_rsa_pss_rsae_sha256_name "rsa_pss_rsae_sha256"
+#define TLSEXT_SIGALG_rsa_pss_rsae_sha384_name "rsa_pss_rsae_sha384"
+#define TLSEXT_SIGALG_rsa_pss_rsae_sha512_name "rsa_pss_rsae_sha512"
+#define TLSEXT_SIGALG_rsa_pss_pss_sha256_name "rsa_pss_pss_sha256"
+#define TLSEXT_SIGALG_rsa_pss_pss_sha384_name "rsa_pss_pss_sha384"
+#define TLSEXT_SIGALG_rsa_pss_pss_sha512_name "rsa_pss_pss_sha512"
+#define TLSEXT_SIGALG_rsa_pkcs1_sha256_name "rsa_pkcs1_sha256"
+#define TLSEXT_SIGALG_rsa_pkcs1_sha384_name "rsa_pkcs1_sha384"
+#define TLSEXT_SIGALG_rsa_pkcs1_sha512_name "rsa_pkcs1_sha512"
+#define TLSEXT_SIGALG_rsa_pkcs1_sha224_name "rsa_pkcs1_sha224"
+#define TLSEXT_SIGALG_rsa_pkcs1_sha1_name "rsa_pkcs1_sha1"
+#define TLSEXT_SIGALG_dsa_sha256_name "dsa_sha256"
+#define TLSEXT_SIGALG_dsa_sha384_name "dsa_sha384"
+#define TLSEXT_SIGALG_dsa_sha512_name "dsa_sha512"
+#define TLSEXT_SIGALG_dsa_sha224_name "dsa_sha224"
+#define TLSEXT_SIGALG_dsa_sha1_name "dsa_sha1"
+#define TLSEXT_SIGALG_gostr34102012_256_intrinsic_name "gostr34102012_256"
+#define TLSEXT_SIGALG_gostr34102012_512_intrinsic_name "gostr34102012_512"
+#define TLSEXT_SIGALG_gostr34102012_256_intrinsic_alias "gost2012_256"
+#define TLSEXT_SIGALG_gostr34102012_512_intrinsic_alias "gost2012_512"
+#define TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256_name "gost2012_256"
+#define TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512_name "gost2012_512"
+#define TLSEXT_SIGALG_gostr34102001_gostr3411_name "gost2001_gost94"
 
-#define TLSEXT_SIGALG_ed25519_name                                   "ed25519"
-#define TLSEXT_SIGALG_ed448_name                                     "ed448"
-#define TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256_name              "ecdsa_brainpoolP256r1tls13_sha256"
-#define TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384_name              "ecdsa_brainpoolP384r1tls13_sha384"
-#define TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512_name              "ecdsa_brainpoolP512r1tls13_sha512"
-#define TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256_alias             "ecdsa_brainpoolP256r1_sha256"
-#define TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384_alias             "ecdsa_brainpoolP384r1_sha384"
-#define TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512_alias             "ecdsa_brainpoolP512r1_sha512"
-#define TLSEXT_SIGALG_mldsa44_name                                   "mldsa44"
-#define TLSEXT_SIGALG_mldsa65_name                                   "mldsa65"
-#define TLSEXT_SIGALG_mldsa87_name                                   "mldsa87"
+#define TLSEXT_SIGALG_ed25519_name "ed25519"
+#define TLSEXT_SIGALG_ed448_name "ed448"
+#define TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256_name "ecdsa_brainpoolP256r1tls13_sha256"
+#define TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384_name "ecdsa_brainpoolP384r1tls13_sha384"
+#define TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512_name "ecdsa_brainpoolP512r1tls13_sha512"
+#define TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256_alias "ecdsa_brainpoolP256r1_sha256"
+#define TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384_alias "ecdsa_brainpoolP384r1_sha384"
+#define TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512_alias "ecdsa_brainpoolP512r1_sha512"
+#define TLSEXT_SIGALG_mldsa44_name "mldsa44"
+#define TLSEXT_SIGALG_mldsa65_name "mldsa65"
+#define TLSEXT_SIGALG_mldsa87_name "mldsa87"
 
 /* Known PSK key exchange modes */
-#define TLSEXT_KEX_MODE_KE                                      0x00
-#define TLSEXT_KEX_MODE_KE_DHE                                  0x01
+#define TLSEXT_KEX_MODE_KE 0x00
+#define TLSEXT_KEX_MODE_KE_DHE 0x01
 
 /*
  * Internal representations of key exchange modes
  */
-#define TLSEXT_KEX_MODE_FLAG_NONE                               0
-#define TLSEXT_KEX_MODE_FLAG_KE                                 1
-#define TLSEXT_KEX_MODE_FLAG_KE_DHE                             2
+#define TLSEXT_KEX_MODE_FLAG_NONE 0
+#define TLSEXT_KEX_MODE_FLAG_KE 1
+#define TLSEXT_KEX_MODE_FLAG_KE_DHE 2
 
-#define SSL_USE_PSS(s) (s->s3.tmp.peer_sigalg != NULL && \
-                        s->s3.tmp.peer_sigalg->sig == EVP_PKEY_RSA_PSS)
+#define SSL_USE_PSS(s) (s->s3.tmp.peer_sigalg != NULL && s->s3.tmp.peer_sigalg->sig == EVP_PKEY_RSA_PSS)
 
 /* TLSv1.3 downgrade protection sentinel values */
 extern const unsigned char tls11downgrade[8];
@@ -2340,133 +2337,133 @@ extern const SSL3_ENC_METHOD DTLSv1_2_enc_data;
 /*
  * Flags for SSL methods
  */
-# define SSL_METHOD_NO_FIPS      (1U<<0)
-# define SSL_METHOD_NO_SUITEB    (1U<<1)
+#define SSL_METHOD_NO_FIPS (1U << 0)
+#define SSL_METHOD_NO_SUITEB (1U << 1)
 
-# define IMPLEMENT_tls_meth_func(version, flags, mask, func_name, s_accept, \
-                                 s_connect, enc_data) \
-const SSL_METHOD *func_name(void)  \
-        { \
-        static const SSL_METHOD func_name##_data= { \
-                version, \
-                flags, \
-                mask, \
-                ossl_ssl_connection_new, \
-                ossl_ssl_connection_free, \
-                ossl_ssl_connection_reset, \
-                tls1_new, \
-                tls1_clear, \
-                tls1_free, \
-                s_accept, \
-                s_connect, \
-                ssl3_read, \
-                ssl3_peek, \
-                ssl3_write, \
-                ssl3_shutdown, \
-                ssl3_renegotiate, \
-                ssl3_renegotiate_check, \
-                ssl3_read_bytes, \
-                ssl3_write_bytes, \
-                ssl3_dispatch_alert, \
-                ssl3_ctrl, \
-                ssl3_ctx_ctrl, \
-                ssl3_get_cipher_by_char, \
-                ssl3_put_cipher_by_char, \
-                ssl3_pending, \
-                ssl3_num_ciphers, \
-                ssl3_get_cipher, \
-                tls1_default_timeout, \
-                &enc_data, \
-                ssl_undefined_void_function, \
-                ssl3_callback_ctrl, \
-                ssl3_ctx_callback_ctrl, \
-        }; \
-        return &func_name##_data; \
-        }
+#define IMPLEMENT_tls_meth_func(version, flags, mask, func_name, s_accept, \
+    s_connect, enc_data)                                                   \
+    const SSL_METHOD *func_name(void)                                      \
+    {                                                                      \
+        static const SSL_METHOD func_name##_data = {                       \
+            version,                                                       \
+            flags,                                                         \
+            mask,                                                          \
+            ossl_ssl_connection_new,                                       \
+            ossl_ssl_connection_free,                                      \
+            ossl_ssl_connection_reset,                                     \
+            tls1_new,                                                      \
+            tls1_clear,                                                    \
+            tls1_free,                                                     \
+            s_accept,                                                      \
+            s_connect,                                                     \
+            ssl3_read,                                                     \
+            ssl3_peek,                                                     \
+            ssl3_write,                                                    \
+            ssl3_shutdown,                                                 \
+            ssl3_renegotiate,                                              \
+            ssl3_renegotiate_check,                                        \
+            ssl3_read_bytes,                                               \
+            ssl3_write_bytes,                                              \
+            ssl3_dispatch_alert,                                           \
+            ssl3_ctrl,                                                     \
+            ssl3_ctx_ctrl,                                                 \
+            ssl3_get_cipher_by_char,                                       \
+            ssl3_put_cipher_by_char,                                       \
+            ssl3_pending,                                                  \
+            ssl3_num_ciphers,                                              \
+            ssl3_get_cipher,                                               \
+            tls1_default_timeout,                                          \
+            &enc_data,                                                     \
+            ssl_undefined_void_function,                                   \
+            ssl3_callback_ctrl,                                            \
+            ssl3_ctx_callback_ctrl,                                        \
+        };                                                                 \
+        return &func_name##_data;                                          \
+    }
 
-# define IMPLEMENT_ssl3_meth_func(func_name, s_accept, s_connect) \
-const SSL_METHOD *func_name(void)  \
-        { \
-        static const SSL_METHOD func_name##_data= { \
-                SSL3_VERSION, \
-                SSL_METHOD_NO_FIPS | SSL_METHOD_NO_SUITEB, \
-                SSL_OP_NO_SSLv3, \
-                ossl_ssl_connection_new, \
-                ossl_ssl_connection_free, \
-                ossl_ssl_connection_reset, \
-                ssl3_new, \
-                ssl3_clear, \
-                ssl3_free, \
-                s_accept, \
-                s_connect, \
-                ssl3_read, \
-                ssl3_peek, \
-                ssl3_write, \
-                ssl3_shutdown, \
-                ssl3_renegotiate, \
-                ssl3_renegotiate_check, \
-                ssl3_read_bytes, \
-                ssl3_write_bytes, \
-                ssl3_dispatch_alert, \
-                ssl3_ctrl, \
-                ssl3_ctx_ctrl, \
-                ssl3_get_cipher_by_char, \
-                ssl3_put_cipher_by_char, \
-                ssl3_pending, \
-                ssl3_num_ciphers, \
-                ssl3_get_cipher, \
-                ssl3_default_timeout, \
-                &SSLv3_enc_data, \
-                ssl_undefined_void_function, \
-                ssl3_callback_ctrl, \
-                ssl3_ctx_callback_ctrl, \
-        }; \
-        return &func_name##_data; \
-        }
+#define IMPLEMENT_ssl3_meth_func(func_name, s_accept, s_connect) \
+    const SSL_METHOD *func_name(void)                            \
+    {                                                            \
+        static const SSL_METHOD func_name##_data = {             \
+            SSL3_VERSION,                                        \
+            SSL_METHOD_NO_FIPS | SSL_METHOD_NO_SUITEB,           \
+            SSL_OP_NO_SSLv3,                                     \
+            ossl_ssl_connection_new,                             \
+            ossl_ssl_connection_free,                            \
+            ossl_ssl_connection_reset,                           \
+            ssl3_new,                                            \
+            ssl3_clear,                                          \
+            ssl3_free,                                           \
+            s_accept,                                            \
+            s_connect,                                           \
+            ssl3_read,                                           \
+            ssl3_peek,                                           \
+            ssl3_write,                                          \
+            ssl3_shutdown,                                       \
+            ssl3_renegotiate,                                    \
+            ssl3_renegotiate_check,                              \
+            ssl3_read_bytes,                                     \
+            ssl3_write_bytes,                                    \
+            ssl3_dispatch_alert,                                 \
+            ssl3_ctrl,                                           \
+            ssl3_ctx_ctrl,                                       \
+            ssl3_get_cipher_by_char,                             \
+            ssl3_put_cipher_by_char,                             \
+            ssl3_pending,                                        \
+            ssl3_num_ciphers,                                    \
+            ssl3_get_cipher,                                     \
+            ssl3_default_timeout,                                \
+            &SSLv3_enc_data,                                     \
+            ssl_undefined_void_function,                         \
+            ssl3_callback_ctrl,                                  \
+            ssl3_ctx_callback_ctrl,                              \
+        };                                                       \
+        return &func_name##_data;                                \
+    }
 
-# define IMPLEMENT_dtls1_meth_func(version, flags, mask, func_name, s_accept, \
-                                        s_connect, enc_data) \
-const SSL_METHOD *func_name(void)  \
-        { \
-        static const SSL_METHOD func_name##_data= { \
-                version, \
-                flags, \
-                mask, \
-                ossl_ssl_connection_new, \
-                ossl_ssl_connection_free, \
-                ossl_ssl_connection_reset, \
-                dtls1_new, \
-                dtls1_clear, \
-                dtls1_free, \
-                s_accept, \
-                s_connect, \
-                ssl3_read, \
-                ssl3_peek, \
-                ssl3_write, \
-                dtls1_shutdown, \
-                ssl3_renegotiate, \
-                ssl3_renegotiate_check, \
-                dtls1_read_bytes, \
-                dtls1_write_app_data_bytes, \
-                dtls1_dispatch_alert, \
-                dtls1_ctrl, \
-                ssl3_ctx_ctrl, \
-                ssl3_get_cipher_by_char, \
-                ssl3_put_cipher_by_char, \
-                ssl3_pending, \
-                ssl3_num_ciphers, \
-                ssl3_get_cipher, \
-                dtls1_default_timeout, \
-                &enc_data, \
-                ssl_undefined_void_function, \
-                ssl3_callback_ctrl, \
-                ssl3_ctx_callback_ctrl, \
-        }; \
-        return &func_name##_data; \
-        }
+#define IMPLEMENT_dtls1_meth_func(version, flags, mask, func_name, s_accept, \
+    s_connect, enc_data)                                                     \
+    const SSL_METHOD *func_name(void)                                        \
+    {                                                                        \
+        static const SSL_METHOD func_name##_data = {                         \
+            version,                                                         \
+            flags,                                                           \
+            mask,                                                            \
+            ossl_ssl_connection_new,                                         \
+            ossl_ssl_connection_free,                                        \
+            ossl_ssl_connection_reset,                                       \
+            dtls1_new,                                                       \
+            dtls1_clear,                                                     \
+            dtls1_free,                                                      \
+            s_accept,                                                        \
+            s_connect,                                                       \
+            ssl3_read,                                                       \
+            ssl3_peek,                                                       \
+            ssl3_write,                                                      \
+            dtls1_shutdown,                                                  \
+            ssl3_renegotiate,                                                \
+            ssl3_renegotiate_check,                                          \
+            dtls1_read_bytes,                                                \
+            dtls1_write_app_data_bytes,                                      \
+            dtls1_dispatch_alert,                                            \
+            dtls1_ctrl,                                                      \
+            ssl3_ctx_ctrl,                                                   \
+            ssl3_get_cipher_by_char,                                         \
+            ssl3_put_cipher_by_char,                                         \
+            ssl3_pending,                                                    \
+            ssl3_num_ciphers,                                                \
+            ssl3_get_cipher,                                                 \
+            dtls1_default_timeout,                                           \
+            &enc_data,                                                       \
+            ssl_undefined_void_function,                                     \
+            ssl3_callback_ctrl,                                              \
+            ssl3_ctx_callback_ctrl,                                          \
+        };                                                                   \
+        return &func_name##_data;                                            \
+    }
 
 struct openssl_ssl_test_functions {
-    int (*p_ssl_init_wbio_buffer) (SSL_CONNECTION *s);
+    int (*p_ssl_init_wbio_buffer)(SSL_CONNECTION *s);
 };
 
 const char *ssl_protocol_to_string(int version);
@@ -2478,7 +2475,7 @@ static ossl_inline int tls12_rpk_and_privkey(const SSL_CONNECTION *sc, int idx)
      * a private key, and NO CERTIFICATE
      */
     return ((sc->server && sc->ext.server_cert_type == TLSEXT_cert_type_rpk)
-            || (!sc->server && sc->ext.client_cert_type == TLSEXT_cert_type_rpk))
+               || (!sc->server && sc->ext.client_cert_type == TLSEXT_cert_type_rpk))
         && sc->cert->pkeys[idx].privatekey != NULL
         && sc->cert->pkeys[idx].x509 == NULL;
 }
@@ -2517,26 +2514,26 @@ static ossl_inline int ssl_has_cert(const SSL_CONNECTION *s, int idx)
 }
 
 static ossl_inline void tls1_get_peer_groups(SSL_CONNECTION *s,
-                                             const uint16_t **pgroups,
-                                             size_t *pgroupslen)
+    const uint16_t **pgroups,
+    size_t *pgroupslen)
 {
     *pgroups = s->ext.peer_supportedgroups;
     *pgroupslen = s->ext.peer_supportedgroups_len;
 }
 
-# ifndef OPENSSL_UNIT_TEST
+#ifndef OPENSSL_UNIT_TEST
 
 __owur int ossl_ssl_init(SSL *ssl, SSL_CTX *ctx, const SSL_METHOD *method,
-                         int type);
+    int type);
 __owur SSL *ossl_ssl_connection_new_int(SSL_CTX *ctx, SSL *user_ssl,
-                                        const SSL_METHOD *method);
+    const SSL_METHOD *method);
 __owur SSL *ossl_ssl_connection_new(SSL_CTX *ctx);
 void ossl_ssl_connection_free(SSL *ssl);
 __owur int ossl_ssl_connection_reset(SSL *ssl);
 
 __owur int ssl_read_internal(SSL *s, void *buf, size_t num, size_t *readbytes);
 __owur int ssl_write_internal(SSL *s, const void *buf, size_t num,
-                              uint64_t flags, size_t *written);
+    uint64_t flags, size_t *written);
 int ssl_clear_bad_session(SSL_CONNECTION *s);
 __owur CERT *ssl_cert_new(size_t ssl_pkey_num);
 __owur CERT *ssl_cert_dup(CERT *cert);
@@ -2545,77 +2542,77 @@ void ssl_cert_free(CERT *c);
 __owur int ssl_generate_session_id(SSL_CONNECTION *s, SSL_SESSION *ss);
 __owur int ssl_get_new_session(SSL_CONNECTION *s, int session);
 __owur SSL_SESSION *lookup_sess_in_cache(SSL_CONNECTION *s,
-                                         const unsigned char *sess_id,
-                                         size_t sess_id_len);
+    const unsigned char *sess_id,
+    size_t sess_id_len);
 __owur int ssl_get_prev_session(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello);
 __owur SSL_SESSION *ssl_session_dup(const SSL_SESSION *src, int ticket);
 __owur int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b);
 DECLARE_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER, ssl_cipher_id);
 __owur int ssl_cipher_ptr_id_cmp(const SSL_CIPHER *const *ap,
-                                 const SSL_CIPHER *const *bp);
+    const SSL_CIPHER *const *bp);
 __owur STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(SSL_CTX *ctx,
-                                                    STACK_OF(SSL_CIPHER) *tls13_ciphersuites,
-                                                    STACK_OF(SSL_CIPHER) **cipher_list,
-                                                    STACK_OF(SSL_CIPHER) **cipher_list_by_id,
-                                                    const char *rule_str,
-                                                    CERT *c);
+    STACK_OF(SSL_CIPHER) *tls13_ciphersuites,
+    STACK_OF(SSL_CIPHER) **cipher_list,
+    STACK_OF(SSL_CIPHER) **cipher_list_by_id,
+    const char *rule_str,
+    CERT *c);
 __owur int ssl_cache_cipherlist(SSL_CONNECTION *s, PACKET *cipher_suites,
-                                int sslv2format);
+    int sslv2format);
 __owur int ossl_bytes_to_cipher_list(SSL_CONNECTION *s, PACKET *cipher_suites,
-                                     STACK_OF(SSL_CIPHER) **skp,
-                                     STACK_OF(SSL_CIPHER) **scsvs, int sslv2format,
-                                     int fatal);
+    STACK_OF(SSL_CIPHER) **skp,
+    STACK_OF(SSL_CIPHER) **scsvs, int sslv2format,
+    int fatal);
 void ssl_update_cache(SSL_CONNECTION *s, int mode);
 __owur int ssl_cipher_get_evp_cipher(SSL_CTX *ctx, const SSL_CIPHER *sslc,
-                                     const EVP_CIPHER **enc);
+    const EVP_CIPHER **enc);
 __owur int ssl_cipher_get_evp_md_mac(SSL_CTX *ctx, const SSL_CIPHER *sslc,
-                                     const EVP_MD **md,
-                                     int *mac_pkey_type, size_t *mac_secret_size);
+    const EVP_MD **md,
+    int *mac_pkey_type, size_t *mac_secret_size);
 __owur int ssl_cipher_get_evp(SSL_CTX *ctxc, const SSL_SESSION *s,
-                              const EVP_CIPHER **enc, const EVP_MD **md,
-                              int *mac_pkey_type, size_t *mac_secret_size,
-                              SSL_COMP **comp, int use_etm);
+    const EVP_CIPHER **enc, const EVP_MD **md,
+    int *mac_pkey_type, size_t *mac_secret_size,
+    SSL_COMP **comp, int use_etm);
 __owur int ssl_cipher_get_overhead(const SSL_CIPHER *c, size_t *mac_overhead,
-                                   size_t *int_overhead, size_t *blocksize,
-                                   size_t *ext_overhead);
+    size_t *int_overhead, size_t *blocksize,
+    size_t *ext_overhead);
 __owur int ssl_cert_is_disabled(SSL_CTX *ctx, size_t idx);
 __owur const SSL_CIPHER *ssl_get_cipher_by_char(SSL_CONNECTION *ssl,
-                                                const unsigned char *ptr,
-                                                int all);
+    const unsigned char *ptr,
+    int all);
 __owur int ssl_cert_set0_chain(SSL_CONNECTION *s, SSL_CTX *ctx,
-                               STACK_OF(X509) *chain);
+    STACK_OF(X509) *chain);
 __owur int ssl_cert_set1_chain(SSL_CONNECTION *s, SSL_CTX *ctx,
-                               STACK_OF(X509) *chain);
+    STACK_OF(X509) *chain);
 __owur int ssl_cert_add0_chain_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x);
 __owur int ssl_cert_add1_chain_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x);
 __owur int ssl_cert_select_current(CERT *c, X509 *x);
 __owur int ssl_cert_set_current(CERT *c, long arg);
-void ssl_cert_set_cert_cb(CERT *c, int (*cb) (SSL *ssl, void *arg), void *arg);
+void ssl_cert_set_cert_cb(CERT *c, int (*cb)(SSL *ssl, void *arg), void *arg);
 
 __owur int ssl_verify_cert_chain(SSL_CONNECTION *s, STACK_OF(X509) *sk);
 __owur int ssl_verify_rpk(SSL_CONNECTION *s, EVP_PKEY *rpk);
 __owur int ssl_build_cert_chain(SSL_CONNECTION *s, SSL_CTX *ctx, int flags);
 __owur int ssl_cert_set_cert_store(CERT *c, X509_STORE *store, int chain,
-                                   int ref);
+    int ref);
 __owur int ssl_cert_get_cert_store(CERT *c, X509_STORE **pstore, int chain);
 
 __owur int ssl_security(const SSL_CONNECTION *s, int op, int bits, int nid,
-                        void *other);
+    void *other);
 __owur int ssl_ctx_security(const SSL_CTX *ctx, int op, int bits, int nid,
-                            void *other);
+    void *other);
 int ssl_get_security_level_bits(const SSL *s, const SSL_CTX *ctx, int *levelp);
 
 __owur int ssl_cert_lookup_by_nid(int nid, size_t *pidx, SSL_CTX *ctx);
 __owur const SSL_CERT_LOOKUP *ssl_cert_lookup_by_pkey(const EVP_PKEY *pk,
-                                                      size_t *pidx,
-                                                      SSL_CTX *ctx);
+    size_t *pidx,
+    SSL_CTX *ctx);
 __owur const SSL_CERT_LOOKUP *ssl_cert_lookup_by_idx(size_t idx, SSL_CTX *ctx);
 
 int ssl_undefined_function(SSL *s);
 __owur int ssl_undefined_void_function(void);
 __owur int ssl_get_server_cert_serverinfo(SSL_CONNECTION *s,
-                                          const unsigned char **serverinfo,
-                                          size_t *serverinfo_length);
+    const unsigned char **serverinfo,
+    size_t *serverinfo_length);
 void ssl_set_masks(SSL_CONNECTION *s);
 __owur STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL_CONNECTION *sc);
 __owur int ssl_x509err2alert(int type);
@@ -2625,25 +2622,25 @@ __owur int ssl_setup_sigalgs(SSL_CTX *ctx);
 int ssl_load_groups(SSL_CTX *ctx);
 int ssl_load_sigalgs(SSL_CTX *ctx);
 __owur int ssl_fill_hello_random(SSL_CONNECTION *s, int server,
-                                 unsigned char *field, size_t len,
-                                 DOWNGRADE dgrd);
+    unsigned char *field, size_t len,
+    DOWNGRADE dgrd);
 __owur int ssl_generate_master_secret(SSL_CONNECTION *s, unsigned char *pms,
-                                      size_t pmslen, int free_pms);
+    size_t pmslen, int free_pms);
 __owur EVP_PKEY *ssl_generate_pkey(SSL_CONNECTION *s, EVP_PKEY *pm);
 __owur int ssl_gensecret(SSL_CONNECTION *s, unsigned char *pms, size_t pmslen);
 __owur int ssl_derive(SSL_CONNECTION *s, EVP_PKEY *privkey, EVP_PKEY *pubkey,
-                      int genmaster);
+    int genmaster);
 __owur int ssl_decapsulate(SSL_CONNECTION *s, EVP_PKEY *privkey,
-                           const unsigned char *ct, size_t ctlen,
-                           int gensecret);
+    const unsigned char *ct, size_t ctlen,
+    int gensecret);
 __owur int ssl_encapsulate(SSL_CONNECTION *s, EVP_PKEY *pubkey,
-                           unsigned char **ctp, size_t *ctlenp,
-                           int gensecret);
+    unsigned char **ctp, size_t *ctlenp,
+    int gensecret);
 __owur EVP_PKEY *ssl_dh_to_pkey(DH *dh);
 __owur int ssl_set_tmp_ecdh_groups(uint16_t **pext, size_t *pextlen,
-                                   uint16_t **ksext, size_t *ksextlen,
-                                   size_t **tplext, size_t *tplextlen,
-                                   void *key);
+    uint16_t **ksext, size_t *ksextlen,
+    size_t **tplext, size_t *tplextlen,
+    void *key);
 __owur unsigned int ssl_get_max_send_fragment(const SSL_CONNECTION *sc);
 __owur unsigned int ssl_get_split_send_fragment(const SSL_CONNECTION *sc);
 
@@ -2651,7 +2648,7 @@ __owur const SSL_CIPHER *ssl3_get_cipher_by_id(uint32_t id);
 __owur const SSL_CIPHER *ssl3_get_cipher_by_std_name(const char *stdname);
 __owur const SSL_CIPHER *ssl3_get_cipher_by_char(const unsigned char *p);
 __owur int ssl3_put_cipher_by_char(const SSL_CIPHER *c, WPACKET *pkt,
-                                   size_t *len);
+    size_t *len);
 int ssl3_init_finished_mac(SSL_CONNECTION *s);
 __owur int ssl3_setup_key_block(SSL_CONNECTION *s);
 __owur int ssl3_change_cipher_state(SSL_CONNECTION *s, int which);
@@ -2659,26 +2656,26 @@ void ssl3_cleanup_key_block(SSL_CONNECTION *s);
 __owur int ssl3_do_write(SSL_CONNECTION *s, uint8_t type);
 int ssl3_send_alert(SSL_CONNECTION *s, int level, int desc);
 __owur int ssl3_generate_master_secret(SSL_CONNECTION *s, unsigned char *out,
-                                       unsigned char *p, size_t len,
-                                       size_t *secret_size);
+    unsigned char *p, size_t len,
+    size_t *secret_size);
 __owur int ssl3_get_req_cert_type(SSL_CONNECTION *s, WPACKET *pkt);
 __owur int ssl3_num_ciphers(void);
 __owur const SSL_CIPHER *ssl3_get_cipher(unsigned int u);
 int ssl3_renegotiate(SSL *ssl);
 int ssl3_renegotiate_check(SSL *ssl, int initok);
 void ssl3_digest_master_key_set_params(const SSL_SESSION *session,
-                                       OSSL_PARAM params[]);
+    OSSL_PARAM params[]);
 __owur int ssl3_dispatch_alert(SSL *s);
 __owur size_t ssl3_final_finish_mac(SSL_CONNECTION *s, const char *sender,
-                                    size_t slen, unsigned char *p);
+    size_t slen, unsigned char *p);
 __owur int ssl3_finish_mac(SSL_CONNECTION *s, const unsigned char *buf,
-                           size_t len);
+    size_t len);
 void ssl3_free_digest_list(SSL_CONNECTION *s);
 __owur unsigned long ssl3_output_cert_chain(SSL_CONNECTION *s, WPACKET *pkt,
-                                            CERT_PKEY *cpk, int for_comp);
+    CERT_PKEY *cpk, int for_comp);
 __owur const SSL_CIPHER *ssl3_choose_cipher(SSL_CONNECTION *s,
-                                            STACK_OF(SSL_CIPHER) *clnt,
-                                            STACK_OF(SSL_CIPHER) *srvr);
+    STACK_OF(SSL_CIPHER) *clnt,
+    STACK_OF(SSL_CIPHER) *srvr);
 __owur int ssl3_digest_cached_records(SSL_CONNECTION *s, int keep);
 __owur int ssl3_new(SSL *s);
 void ssl3_free(SSL *s);
@@ -2689,14 +2686,14 @@ __owur int ssl3_shutdown(SSL *s);
 int ssl3_clear(SSL *s);
 __owur long ssl3_ctrl(SSL *s, int cmd, long larg, void *parg);
 __owur long ssl3_ctx_ctrl(SSL_CTX *s, int cmd, long larg, void *parg);
-__owur long ssl3_callback_ctrl(SSL *s, int cmd, void (*fp) (void));
-__owur long ssl3_ctx_callback_ctrl(SSL_CTX *s, int cmd, void (*fp) (void));
+__owur long ssl3_callback_ctrl(SSL *s, int cmd, void (*fp)(void));
+__owur long ssl3_ctx_callback_ctrl(SSL_CTX *s, int cmd, void (*fp)(void));
 
 __owur int ssl3_do_change_cipher_spec(SSL_CONNECTION *s);
 __owur OSSL_TIME ssl3_default_timeout(void);
 
 __owur int ssl3_set_handshake_header(SSL_CONNECTION *s, WPACKET *pkt,
-                                     int htype);
+    int htype);
 __owur int tls_close_construct_packet(SSL_CONNECTION *s, WPACKET *pkt, int htype);
 __owur int tls_setup_handshake(SSL_CONNECTION *s);
 __owur int dtls1_set_handshake_header(SSL_CONNECTION *s, WPACKET *pkt, int htype);
@@ -2707,38 +2704,38 @@ __owur int ssl_allow_compression(SSL_CONNECTION *s);
 
 __owur int ssl_version_cmp(const SSL_CONNECTION *s, int versiona, int versionb);
 __owur int ssl_version_supported(const SSL_CONNECTION *s, int version,
-                                 const SSL_METHOD **meth);
+    const SSL_METHOD **meth);
 
 __owur int ssl_set_client_hello_version(SSL_CONNECTION *s);
 __owur int ssl_check_version_downgrade(SSL_CONNECTION *s);
 __owur int ssl_set_version_bound(int method_version, int version, int *bound);
 __owur int ssl_choose_server_version(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello,
-                                     DOWNGRADE *dgrd);
+    DOWNGRADE *dgrd);
 __owur int ssl_choose_client_version(SSL_CONNECTION *s, int version,
-                                     RAW_EXTENSION *extensions);
+    RAW_EXTENSION *extensions);
 __owur int ssl_get_min_max_version(const SSL_CONNECTION *s, int *min_version,
-                                   int *max_version, int *real_max);
+    int *max_version, int *real_max);
 
 __owur OSSL_TIME tls1_default_timeout(void);
 __owur int dtls1_do_write(SSL_CONNECTION *s, uint8_t type);
 void dtls1_set_message_header(SSL_CONNECTION *s,
-                              unsigned char mt,
-                              size_t len,
-                              size_t frag_off, size_t frag_len);
+    unsigned char mt,
+    size_t len,
+    size_t frag_off, size_t frag_len);
 
 int dtls1_write_app_data_bytes(SSL *s, uint8_t type, const void *buf_,
-                               size_t len, size_t *written);
+    size_t len, size_t *written);
 
 __owur int dtls1_read_failed(SSL_CONNECTION *s, int code);
 __owur int dtls1_buffer_message(SSL_CONNECTION *s, int ccs);
 __owur int dtls1_retransmit_message(SSL_CONNECTION *s, unsigned short seq,
-                                    int *found);
+    int *found);
 __owur int dtls1_get_queue_priority(unsigned short seq, int is_ccs);
 int dtls1_retransmit_buffered_messages(SSL_CONNECTION *s);
 void dtls1_clear_received_buffer(SSL_CONNECTION *s);
 void dtls1_clear_sent_buffer(SSL_CONNECTION *s);
 void dtls1_get_message_header(const unsigned char *data,
-                              struct hm_header_st *msg_hdr);
+    struct hm_header_st *msg_hdr);
 __owur OSSL_TIME dtls1_default_timeout(void);
 __owur int dtls1_get_timeout(const SSL_CONNECTION *s, OSSL_TIME *timeleft);
 __owur int dtls1_check_timeout_num(SSL_CONNECTION *s);
@@ -2747,7 +2744,7 @@ void dtls1_start_timer(SSL_CONNECTION *s);
 void dtls1_stop_timer(SSL_CONNECTION *s);
 __owur int dtls1_is_timer_expired(SSL_CONNECTION *s);
 __owur int dtls_raw_hello_verify_request(WPACKET *pkt, unsigned char *cookie,
-                                         size_t cookie_len);
+    size_t cookie_len);
 __owur size_t dtls1_min_mtu(SSL_CONNECTION *s);
 void dtls1_hm_fragment_free(hm_fragment *frag);
 __owur int dtls1_query_mtu(SSL_CONNECTION *s);
@@ -2770,65 +2767,65 @@ int ssl_free_wbio_buffer(SSL_CONNECTION *s);
 __owur int tls1_change_cipher_state(SSL_CONNECTION *s, int which);
 __owur int tls1_setup_key_block(SSL_CONNECTION *s);
 __owur size_t tls1_final_finish_mac(SSL_CONNECTION *s, const char *str,
-                                    size_t slen, unsigned char *p);
+    size_t slen, unsigned char *p);
 __owur int tls1_generate_master_secret(SSL_CONNECTION *s, unsigned char *out,
-                                       unsigned char *p, size_t len,
-                                       size_t *secret_size);
+    unsigned char *p, size_t len,
+    size_t *secret_size);
 __owur int tls13_setup_key_block(SSL_CONNECTION *s);
 __owur size_t tls13_final_finish_mac(SSL_CONNECTION *s, const char *str, size_t slen,
-                                     unsigned char *p);
+    unsigned char *p);
 __owur int tls13_store_handshake_traffic_hash(SSL_CONNECTION *s);
 __owur int tls13_store_server_finished_hash(SSL_CONNECTION *s);
 __owur int tls13_change_cipher_state(SSL_CONNECTION *s, int which);
 __owur int tls13_update_key(SSL_CONNECTION *s, int send);
 __owur int tls13_hkdf_expand(SSL_CONNECTION *s,
-                             const EVP_MD *md,
-                             const unsigned char *secret,
-                             const unsigned char *label, size_t labellen,
-                             const unsigned char *data, size_t datalen,
-                             unsigned char *out, size_t outlen, int fatal);
+    const EVP_MD *md,
+    const unsigned char *secret,
+    const unsigned char *label, size_t labellen,
+    const unsigned char *data, size_t datalen,
+    unsigned char *out, size_t outlen, int fatal);
 __owur int tls13_hkdf_expand_ex(OSSL_LIB_CTX *libctx, const char *propq,
-                                const EVP_MD *md,
-                                const unsigned char *secret,
-                                const unsigned char *label, size_t labellen,
-                                const unsigned char *data, size_t datalen,
-                                unsigned char *out, size_t outlen,
-                                int raise_error);
+    const EVP_MD *md,
+    const unsigned char *secret,
+    const unsigned char *label, size_t labellen,
+    const unsigned char *data, size_t datalen,
+    unsigned char *out, size_t outlen,
+    int raise_error);
 __owur int tls13_derive_key(SSL_CONNECTION *s, const EVP_MD *md,
-                            const unsigned char *secret, unsigned char *key,
-                            size_t keylen);
+    const unsigned char *secret, unsigned char *key,
+    size_t keylen);
 __owur int tls13_derive_iv(SSL_CONNECTION *s, const EVP_MD *md,
-                           const unsigned char *secret, unsigned char *iv,
-                           size_t ivlen);
+    const unsigned char *secret, unsigned char *iv,
+    size_t ivlen);
 __owur int tls13_derive_finishedkey(SSL_CONNECTION *s, const EVP_MD *md,
-                                    const unsigned char *secret,
-                                    unsigned char *fin, size_t finlen);
+    const unsigned char *secret,
+    unsigned char *fin, size_t finlen);
 int tls13_generate_secret(SSL_CONNECTION *s, const EVP_MD *md,
-                          const unsigned char *prevsecret,
-                          const unsigned char *insecret,
-                          size_t insecretlen,
-                          unsigned char *outsecret);
+    const unsigned char *prevsecret,
+    const unsigned char *insecret,
+    size_t insecretlen,
+    unsigned char *outsecret);
 __owur int tls13_generate_handshake_secret(SSL_CONNECTION *s,
-                                           const unsigned char *insecret,
-                                           size_t insecretlen);
+    const unsigned char *insecret,
+    size_t insecretlen);
 __owur int tls13_generate_master_secret(SSL_CONNECTION *s, unsigned char *out,
-                                        unsigned char *prev, size_t prevlen,
-                                        size_t *secret_size);
+    unsigned char *prev, size_t prevlen,
+    size_t *secret_size);
 __owur int tls1_export_keying_material(SSL_CONNECTION *s,
-                                       unsigned char *out, size_t olen,
-                                       const char *label, size_t llen,
-                                       const unsigned char *p, size_t plen,
-                                       int use_context);
+    unsigned char *out, size_t olen,
+    const char *label, size_t llen,
+    const unsigned char *p, size_t plen,
+    int use_context);
 __owur int tls13_export_keying_material(SSL_CONNECTION *s,
-                                        unsigned char *out, size_t olen,
-                                        const char *label, size_t llen,
-                                        const unsigned char *context,
-                                        size_t contextlen, int use_context);
+    unsigned char *out, size_t olen,
+    const char *label, size_t llen,
+    const unsigned char *context,
+    size_t contextlen, int use_context);
 __owur int tls13_export_keying_material_early(SSL_CONNECTION *s,
-                                              unsigned char *out, size_t olen,
-                                              const char *label, size_t llen,
-                                              const unsigned char *context,
-                                              size_t contextlen);
+    unsigned char *out, size_t olen,
+    const char *label, size_t llen,
+    const unsigned char *context,
+    size_t contextlen);
 __owur int tls1_alert_code(int code);
 __owur int tls13_alert_code(int code);
 __owur int ssl3_alert_code(int code);
@@ -2842,48 +2839,48 @@ __owur const char *tls1_group_id2name(SSL_CTX *ctx, uint16_t group_id);
 __owur int tls1_group_id2nid(uint16_t group_id, int include_unknown);
 __owur uint16_t tls1_nid2group_id(int nid);
 __owur int tls1_check_group_id(SSL_CONNECTION *s, uint16_t group_id,
-                               int check_own_curves);
+    int check_own_curves);
 __owur int tls1_get0_implemented_groups(int min_proto_version,
-                                        int max_proto_version,
-                                        TLS_GROUP_INFO *grps,
-                                        size_t num, long all,
-                                        STACK_OF(OPENSSL_CSTRING) *out);
+    int max_proto_version,
+    TLS_GROUP_INFO *grps,
+    size_t num, long all,
+    STACK_OF(OPENSSL_CSTRING) *out);
 __owur uint16_t tls1_shared_group(SSL_CONNECTION *s, int nmatch);
 __owur int tls1_set_groups(uint16_t **grpext, size_t *grpextlen,
-                           uint16_t **ksext, size_t *ksextlen,
-                           size_t **tplext, size_t *tplextlen,
-                           int *curves, size_t ncurves);
+    uint16_t **ksext, size_t *ksextlen,
+    size_t **tplext, size_t *tplextlen,
+    int *curves, size_t ncurves);
 __owur int tls1_set_groups_list(SSL_CTX *ctx,
-                                uint16_t **grpext, size_t *grpextlen,
-                                uint16_t **ksext, size_t *ksextlen,
-                                size_t **tplext, size_t *tplextlen,
-                                const char *str);
+    uint16_t **grpext, size_t *grpextlen,
+    uint16_t **ksext, size_t *ksextlen,
+    size_t **tplext, size_t *tplextlen,
+    const char *str);
 __owur EVP_PKEY *ssl_generate_pkey_group(SSL_CONNECTION *s, uint16_t id);
 __owur int tls_valid_group(SSL_CONNECTION *s, uint16_t group_id, int minversion,
-                           int maxversion, int isec, int *okfortls13);
+    int maxversion, int isec, int *okfortls13);
 __owur EVP_PKEY *ssl_generate_param_group(SSL_CONNECTION *s, uint16_t id);
 void tls1_get_formatlist(SSL_CONNECTION *s, const unsigned char **pformats,
-                         size_t *num_formats);
+    size_t *num_formats);
 __owur int tls1_check_ec_tmp_key(SSL_CONNECTION *s, unsigned long id);
 
 __owur int tls_group_allowed(SSL_CONNECTION *s, uint16_t curve, int op);
 void tls1_get_supported_groups(SSL_CONNECTION *s, const uint16_t **pgroups,
-                               size_t *pgroupslen);
+    size_t *pgroupslen);
 void tls1_get_requested_keyshare_groups(SSL_CONNECTION *s, const uint16_t **pgroups,
-                                        size_t *pgroupslen);
+    size_t *pgroupslen);
 void tls1_get_group_tuples(SSL_CONNECTION *s, const size_t **ptuples,
-                           size_t *ptupleslen);
+    size_t *ptupleslen);
 
 __owur int tls1_set_server_sigalgs(SSL_CONNECTION *s);
 
 __owur SSL_TICKET_STATUS tls_get_ticket_from_client(SSL_CONNECTION *s,
-                                                    CLIENTHELLO_MSG *hello,
-                                                    SSL_SESSION **ret);
+    CLIENTHELLO_MSG *hello,
+    SSL_SESSION **ret);
 __owur SSL_TICKET_STATUS tls_decrypt_ticket(SSL_CONNECTION *s,
-                                            const unsigned char *etick,
-                                            size_t eticklen,
-                                            const unsigned char *sess_id,
-                                            size_t sesslen, SSL_SESSION **psess);
+    const unsigned char *etick,
+    size_t eticklen,
+    const unsigned char *sess_id,
+    size_t sesslen, SSL_SESSION **psess);
 
 __owur int tls_use_ticket(SSL_CONNECTION *s);
 
@@ -2891,53 +2888,53 @@ void ssl_set_sig_mask(uint32_t *pmask_a, SSL_CONNECTION *s, int op);
 
 __owur int tls1_set_sigalgs_list(SSL_CTX *ctx, CERT *c, const char *str, int client);
 __owur int tls1_set_raw_sigalgs(CERT *c, const uint16_t *psigs, size_t salglen,
-                                int client);
+    int client);
 __owur int tls1_set_sigalgs(CERT *c, const int *salg, size_t salglen,
-                            int client);
+    int client);
 int tls1_check_chain(SSL_CONNECTION *s, X509 *x, EVP_PKEY *pk,
-                     STACK_OF(X509) *chain, int idx);
+    STACK_OF(X509) *chain, int idx);
 void tls1_set_cert_validity(SSL_CONNECTION *s);
 
-#  ifndef OPENSSL_NO_CT
+#ifndef OPENSSL_NO_CT
 __owur int ssl_validate_ct(SSL_CONNECTION *s);
-#  endif
+#endif
 
 __owur EVP_PKEY *ssl_get_auto_dh(SSL_CONNECTION *s);
 
 __owur int ssl_security_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x, int vfy,
-                             int is_ee);
+    int is_ee);
 __owur int ssl_security_cert_chain(SSL_CONNECTION *s, STACK_OF(X509) *sk,
-                                   X509 *ex, int vfy);
+    X509 *ex, int vfy);
 
 int tls_choose_sigalg(SSL_CONNECTION *s, int fatalerrs);
 
 __owur long ssl_get_algorithm2(SSL_CONNECTION *s);
 __owur int tls12_copy_sigalgs(SSL_CONNECTION *s, WPACKET *pkt,
-                              const uint16_t *psig, size_t psiglen);
+    const uint16_t *psig, size_t psiglen);
 __owur int tls1_save_u16(PACKET *pkt, uint16_t **pdest, size_t *pdestlen);
 __owur int tls1_save_sigalgs(SSL_CONNECTION *s, PACKET *pkt, int cert);
 __owur int tls1_process_sigalgs(SSL_CONNECTION *s);
 __owur int tls1_set_peer_legacy_sigalg(SSL_CONNECTION *s, const EVP_PKEY *pkey);
 __owur int tls1_lookup_md(SSL_CTX *ctx, const SIGALG_LOOKUP *lu,
-                          const EVP_MD **pmd);
+    const EVP_MD **pmd);
 __owur size_t tls12_get_psigalgs(SSL_CONNECTION *s, int sent,
-                                 const uint16_t **psigs);
+    const uint16_t **psigs);
 __owur int tls_check_sigalg_curve(const SSL_CONNECTION *s, int curve);
 __owur int tls12_check_peer_sigalg(SSL_CONNECTION *s, uint16_t, EVP_PKEY *pkey);
 __owur int ssl_set_client_disabled(SSL_CONNECTION *s);
 __owur int ssl_cipher_disabled(const SSL_CONNECTION *s, const SSL_CIPHER *c,
-                               int op, int echde);
+    int op, int echde);
 
 __owur int ssl_handshake_hash(SSL_CONNECTION *s,
-                              unsigned char *out, size_t outlen,
-                              size_t *hashlen);
+    unsigned char *out, size_t outlen,
+    size_t *hashlen);
 __owur const EVP_MD *ssl_md(SSL_CTX *ctx, int idx);
 int ssl_get_md_idx(int md_nid);
 __owur const EVP_MD *ssl_handshake_md(SSL_CONNECTION *s);
 __owur const EVP_MD *ssl_prf_md(SSL_CONNECTION *s);
 
 __owur int ossl_adjust_domain_flags(uint64_t domain_flags,
-                                    uint64_t *p_domain_flags);
+    uint64_t *p_domain_flags);
 
 /*
  * ssl_log_rsa_client_key_exchange logs |premaster| to the SSL_CTX associated
@@ -2946,10 +2943,10 @@ __owur int ossl_adjust_domain_flags(uint64_t domain_flags,
  * |encrypted_premaster|.
  */
 __owur int ssl_log_rsa_client_key_exchange(SSL_CONNECTION *s,
-                                           const uint8_t *encrypted_premaster,
-                                           size_t encrypted_premaster_len,
-                                           const uint8_t *premaster,
-                                           size_t premaster_len);
+    const uint8_t *encrypted_premaster,
+    size_t encrypted_premaster_len,
+    const uint8_t *premaster,
+    size_t premaster_len);
 
 /*
  * ssl_log_secret logs |secret| to the SSL_CTX associated with |ssl|, if
@@ -2957,7 +2954,7 @@ __owur int ssl_log_rsa_client_key_exchange(SSL_CONNECTION *s,
  * the entry with |label|.
  */
 __owur int ssl_log_secret(SSL_CONNECTION *s, const char *label,
-                          const uint8_t *secret, size_t secret_len);
+    const uint8_t *secret, size_t secret_len);
 
 #define MASTER_SECRET_LABEL "CLIENT_RANDOM"
 #define CLIENT_EARLY_LABEL "CLIENT_EARLY_TRAFFIC_SECRET"
@@ -2981,45 +2978,45 @@ __owur int send_certificate_request(SSL_CONNECTION *s);
 /* statem/extensions_cust.c */
 
 custom_ext_method *custom_ext_find(const custom_ext_methods *exts,
-                                   ENDPOINT role, unsigned int ext_type,
-                                   size_t *idx);
+    ENDPOINT role, unsigned int ext_type,
+    size_t *idx);
 
 void custom_ext_init(custom_ext_methods *meths);
 
 int ossl_tls_add_custom_ext_intern(SSL_CTX *ctx, custom_ext_methods *exts,
-                                   ENDPOINT role, unsigned int ext_type,
-                                   unsigned int context,
-                                   SSL_custom_ext_add_cb_ex add_cb,
-                                   SSL_custom_ext_free_cb_ex free_cb,
-                                   void *add_arg,
-                                   SSL_custom_ext_parse_cb_ex parse_cb,
-                                   void *parse_arg);
+    ENDPOINT role, unsigned int ext_type,
+    unsigned int context,
+    SSL_custom_ext_add_cb_ex add_cb,
+    SSL_custom_ext_free_cb_ex free_cb,
+    void *add_arg,
+    SSL_custom_ext_parse_cb_ex parse_cb,
+    void *parse_arg);
 __owur int custom_ext_parse(SSL_CONNECTION *s, unsigned int context,
-                            unsigned int ext_type,
-                            const unsigned char *ext_data, size_t ext_size,
-                            X509 *x, size_t chainidx);
+    unsigned int ext_type,
+    const unsigned char *ext_data, size_t ext_size,
+    X509 *x, size_t chainidx);
 __owur int custom_ext_add(SSL_CONNECTION *s, int context, WPACKET *pkt, X509 *x,
-                          size_t chainidx, int maxversion);
+    size_t chainidx, int maxversion);
 
 __owur int custom_exts_copy(custom_ext_methods *dst,
-                            const custom_ext_methods *src);
+    const custom_ext_methods *src);
 __owur int custom_exts_copy_conn(custom_ext_methods *dst,
-                                 const custom_ext_methods *src);
+    const custom_ext_methods *src);
 __owur int custom_exts_copy_flags(custom_ext_methods *dst,
-                                  const custom_ext_methods *src);
+    const custom_ext_methods *src);
 void custom_exts_free(custom_ext_methods *exts);
 
 /* ssl_mcnf.c */
 int ssl_ctx_system_config(SSL_CTX *ctx);
 
 const EVP_CIPHER *ssl_evp_cipher_fetch(OSSL_LIB_CTX *libctx,
-                                       int nid,
-                                       const char *properties);
+    int nid,
+    const char *properties);
 int ssl_evp_cipher_up_ref(const EVP_CIPHER *cipher);
 void ssl_evp_cipher_free(const EVP_CIPHER *cipher);
 const EVP_MD *ssl_evp_md_fetch(OSSL_LIB_CTX *libctx,
-                               int nid,
-                               const char *properties);
+    int nid,
+    const char *properties);
 int ssl_evp_md_up_ref(const EVP_MD *md);
 void ssl_evp_md_free(const EVP_MD *md);
 
@@ -3027,7 +3024,7 @@ void tls_engine_finish(ENGINE *e);
 const EVP_CIPHER *tls_get_cipher_from_engine(int nid);
 const EVP_MD *tls_get_digest_from_engine(int nid);
 int tls_engine_load_ssl_client_cert(SSL_CONNECTION *s, X509 **px509,
-                                    EVP_PKEY **ppkey);
+    EVP_PKEY **ppkey);
 int ssl_hmac_old_new(SSL_HMAC *ret);
 void ssl_hmac_old_free(SSL_HMAC *ctx);
 int ssl_hmac_old_init(SSL_HMAC *ctx, void *key, size_t len, char *md);
@@ -3045,11 +3042,11 @@ int ssl_srp_server_param_with_username_intern(SSL_CONNECTION *s, int *ad);
 
 void ssl_session_calculate_timeout(SSL_SESSION *ss);
 
-# else /* OPENSSL_UNIT_TEST */
+#else /* OPENSSL_UNIT_TEST */
 
-#  define ssl_init_wbio_buffer SSL_test_functions()->p_ssl_init_wbio_buffer
+#define ssl_init_wbio_buffer SSL_test_functions()->p_ssl_init_wbio_buffer
 
-# endif
+#endif
 
 /* Some helper routines to support TSAN operations safely */
 static ossl_unused ossl_inline int ssl_tsan_lock(const SSL_CTX *ctx)
@@ -3069,7 +3066,7 @@ static ossl_unused ossl_inline void ssl_tsan_unlock(const SSL_CTX *ctx)
 }
 
 static ossl_unused ossl_inline void ssl_tsan_counter(const SSL_CTX *ctx,
-                                                     TSAN_QUALIFIER int *stat)
+    TSAN_QUALIFIER int *stat)
 {
     if (ssl_tsan_lock(ctx)) {
         tsan_counter(stat);
@@ -3081,8 +3078,8 @@ int ossl_comp_has_alg(int a);
 size_t ossl_calculate_comp_expansion(int alg, size_t length);
 
 void ossl_ssl_set_custom_record_layer(SSL_CONNECTION *s,
-                                      const OSSL_RECORD_METHOD *meth,
-                                      void *rlarg);
+    const OSSL_RECORD_METHOD *meth,
+    void *rlarg);
 
 long ossl_ctrl_internal(SSL *s, int cmd, long larg, void *parg, int no_quic);
 
@@ -3090,81 +3087,34 @@ long ossl_ctrl_internal(SSL *s, int cmd, long larg, void *parg, int no_quic);
  * Options which no longer have any effect, but which can be implemented
  * as no-ops for QUIC.
  */
-#define OSSL_LEGACY_SSL_OPTIONS                 \
-    (SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG  | \
-     SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER        | \
-     SSL_OP_SSLEAY_080_CLIENT_DH_BUG          | \
-     SSL_OP_TLS_D5_BUG                        | \
-     SSL_OP_TLS_BLOCK_PADDING_BUG             | \
-     SSL_OP_MSIE_SSLV2_RSA_PADDING            | \
-     SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG       | \
-     SSL_OP_MICROSOFT_SESS_ID_BUG             | \
-     SSL_OP_NETSCAPE_CHALLENGE_BUG            | \
-     SSL_OP_PKCS1_CHECK_1                     | \
-     SSL_OP_PKCS1_CHECK_2                     | \
-     SSL_OP_SINGLE_DH_USE                     | \
-     SSL_OP_SINGLE_ECDH_USE                   | \
-     SSL_OP_EPHEMERAL_RSA                     )
+#define OSSL_LEGACY_SSL_OPTIONS \
+    (SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG | SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER | SSL_OP_SSLEAY_080_CLIENT_DH_BUG | SSL_OP_TLS_D5_BUG | SSL_OP_TLS_BLOCK_PADDING_BUG | SSL_OP_MSIE_SSLV2_RSA_PADDING | SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG | SSL_OP_MICROSOFT_SESS_ID_BUG | SSL_OP_NETSCAPE_CHALLENGE_BUG | SSL_OP_PKCS1_CHECK_1 | SSL_OP_PKCS1_CHECK_2 | SSL_OP_SINGLE_DH_USE | SSL_OP_SINGLE_ECDH_USE | SSL_OP_EPHEMERAL_RSA)
 
 /* This option is undefined in public headers with no-dtls1-method. */
 #ifndef SSL_OP_CISCO_ANYCONNECT
-# define SSL_OP_CISCO_ANYCONNECT 0
+#define SSL_OP_CISCO_ANYCONNECT 0
 #endif
 /*
  * Options which are no-ops under QUIC or TLSv1.3 and which are therefore
  * allowed but ignored under QUIC.
  */
-#define OSSL_TLS1_2_OPTIONS                     \
-    (SSL_OP_CRYPTOPRO_TLSEXT_BUG              | \
-     SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS       | \
-     SSL_OP_ALLOW_CLIENT_RENEGOTIATION        | \
-     SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION | \
-     SSL_OP_NO_COMPRESSION                    | \
-     SSL_OP_NO_SSLv3                          | \
-     SSL_OP_NO_TLSv1                          | \
-     SSL_OP_NO_TLSv1_1                        | \
-     SSL_OP_NO_TLSv1_2                        | \
-     SSL_OP_NO_DTLSv1                         | \
-     SSL_OP_NO_DTLSv1_2                       | \
-     SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION | \
-     SSL_OP_CISCO_ANYCONNECT                  | \
-     SSL_OP_NO_RENEGOTIATION                  | \
-     SSL_OP_NO_EXTENDED_MASTER_SECRET         | \
-     SSL_OP_NO_ENCRYPT_THEN_MAC               | \
-     SSL_OP_COOKIE_EXCHANGE                   | \
-     SSL_OP_LEGACY_SERVER_CONNECT             | \
-     SSL_OP_IGNORE_UNEXPECTED_EOF             )
+#define OSSL_TLS1_2_OPTIONS \
+    (SSL_OP_CRYPTOPRO_TLSEXT_BUG | SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS | SSL_OP_ALLOW_CLIENT_RENEGOTIATION | SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION | SSL_OP_NO_COMPRESSION | SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1 | SSL_OP_NO_TLSv1_2 | SSL_OP_NO_DTLSv1 | SSL_OP_NO_DTLSv1_2 | SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION | SSL_OP_CISCO_ANYCONNECT | SSL_OP_NO_RENEGOTIATION | SSL_OP_NO_EXTENDED_MASTER_SECRET | SSL_OP_NO_ENCRYPT_THEN_MAC | SSL_OP_COOKIE_EXCHANGE | SSL_OP_LEGACY_SERVER_CONNECT | SSL_OP_IGNORE_UNEXPECTED_EOF)
 
 /* Total mask of connection-level options permitted or ignored under QUIC. */
-#define OSSL_QUIC_PERMITTED_OPTIONS_CONN        \
-    (OSSL_LEGACY_SSL_OPTIONS                  | \
-     OSSL_TLS1_2_OPTIONS                      | \
-     SSL_OP_CIPHER_SERVER_PREFERENCE          | \
-     SSL_OP_DISABLE_TLSEXT_CA_NAMES           | \
-     SSL_OP_NO_TX_CERTIFICATE_COMPRESSION     | \
-     SSL_OP_NO_RX_CERTIFICATE_COMPRESSION     | \
-     SSL_OP_PRIORITIZE_CHACHA                 | \
-     SSL_OP_NO_QUERY_MTU                      | \
-     SSL_OP_NO_TICKET                         | \
-     SSL_OP_NO_ANTI_REPLAY                    )
+#define OSSL_QUIC_PERMITTED_OPTIONS_CONN \
+    (OSSL_LEGACY_SSL_OPTIONS | OSSL_TLS1_2_OPTIONS | SSL_OP_CIPHER_SERVER_PREFERENCE | SSL_OP_DISABLE_TLSEXT_CA_NAMES | SSL_OP_NO_TX_CERTIFICATE_COMPRESSION | SSL_OP_NO_RX_CERTIFICATE_COMPRESSION | SSL_OP_PRIORITIZE_CHACHA | SSL_OP_NO_QUERY_MTU | SSL_OP_NO_TICKET | SSL_OP_NO_ANTI_REPLAY)
 
 /* Total mask of stream-level options permitted or ignored under QUIC. */
-#define OSSL_QUIC_PERMITTED_OPTIONS_STREAM      \
-    (OSSL_LEGACY_SSL_OPTIONS                  | \
-     OSSL_TLS1_2_OPTIONS                      | \
-     SSL_OP_CLEANSE_PLAINTEXT                 )
+#define OSSL_QUIC_PERMITTED_OPTIONS_STREAM \
+    (OSSL_LEGACY_SSL_OPTIONS | OSSL_TLS1_2_OPTIONS | SSL_OP_CLEANSE_PLAINTEXT)
 
 /* Total mask of options permitted on either connections or streams. */
-#define OSSL_QUIC_PERMITTED_OPTIONS             \
-    (OSSL_QUIC_PERMITTED_OPTIONS_CONN |         \
-     OSSL_QUIC_PERMITTED_OPTIONS_STREAM)
+#define OSSL_QUIC_PERMITTED_OPTIONS \
+    (OSSL_QUIC_PERMITTED_OPTIONS_CONN | OSSL_QUIC_PERMITTED_OPTIONS_STREAM)
 
 /* Total mask of domain flags supported on a QUIC SSL_CTX. */
-#define OSSL_QUIC_SUPPORTED_DOMAIN_FLAGS        \
-    (SSL_DOMAIN_FLAG_SINGLE_THREAD |            \
-     SSL_DOMAIN_FLAG_MULTI_THREAD |             \
-     SSL_DOMAIN_FLAG_THREAD_ASSISTED |          \
-     SSL_DOMAIN_FLAG_BLOCKING |                 \
-     SSL_DOMAIN_FLAG_LEGACY_BLOCKING)
+#define OSSL_QUIC_SUPPORTED_DOMAIN_FLAGS \
+    (SSL_DOMAIN_FLAG_SINGLE_THREAD | SSL_DOMAIN_FLAG_MULTI_THREAD | SSL_DOMAIN_FLAG_THREAD_ASSISTED | SSL_DOMAIN_FLAG_BLOCKING | SSL_DOMAIN_FLAG_LEGACY_BLOCKING)
 
 #endif
diff --git a/crypto/openssl/ssl/ssl_mcnf.c b/crypto/openssl/ssl/ssl_mcnf.c
index 06a23344b27d..14e1f9f5d7b4 100644
--- a/crypto/openssl/ssl/ssl_mcnf.c
+++ b/crypto/openssl/ssl/ssl_mcnf.c
@@ -42,7 +42,7 @@ static int ssl_do_config(SSL *s, SSL_CTX *ctx, const char *name, int system)
     if (!conf_ssl_name_find(name, &idx)) {
         if (!system)
             ERR_raise_data(ERR_LIB_SSL, SSL_R_INVALID_CONFIGURATION_NAME,
-                           "name=%s", name);
+                "name=%s", name);
         goto err;
     }
     cmds = conf_ssl_get(idx, &name, &cmd_count);
@@ -85,7 +85,7 @@ static int ssl_do_config(SSL *s, SSL_CTX *ctx, const char *name, int system)
     }
     if (!SSL_CONF_CTX_finish(cctx))
         ++err;
- err:
+err:
     OSSL_LIB_CTX_set0_default(prev_libctx);
     SSL_CONF_CTX_free(cctx);
     return err == 0 || (system && !conf_diagnostics);
diff --git a/crypto/openssl/ssl/ssl_rsa.c b/crypto/openssl/ssl/ssl_rsa.c
index f4731a87af90..17ccb5462fb4 100644
--- a/crypto/openssl/ssl/ssl_rsa.c
+++ b/crypto/openssl/ssl/ssl_rsa.c
@@ -21,10 +21,10 @@
 static int ssl_set_cert(CERT *c, X509 *x509, SSL_CTX *ctx);
 static int ssl_set_pkey(CERT *c, EVP_PKEY *pkey, SSL_CTX *ctx);
 
-#define  SYNTHV1CONTEXT     (SSL_EXT_TLS1_2_AND_BELOW_ONLY \
-                             | SSL_EXT_CLIENT_HELLO \
-                             | SSL_EXT_TLS1_2_SERVER_HELLO \
-                             | SSL_EXT_IGNORE_ON_RESUMPTION)
+#define SYNTHV1CONTEXT (SSL_EXT_TLS1_2_AND_BELOW_ONLY \
+    | SSL_EXT_CLIENT_HELLO                            \
+    | SSL_EXT_TLS1_2_SERVER_HELLO                     \
+    | SSL_EXT_IGNORE_ON_RESUMPTION)
 
 #define NAME_PREFIX1 "SERVERINFO FOR "
 #define NAME_PREFIX2 "SERVERINFOV2 FOR "
@@ -90,7 +90,7 @@ int SSL_use_certificate_file(SSL *ssl, const char *file, int type)
 
         j = ERR_R_PEM_LIB;
         cert = PEM_read_bio_X509(in, &x, sc->default_passwd_callback,
-                                 sc->default_passwd_callback_userdata);
+            sc->default_passwd_callback_userdata);
     } else {
         ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE);
         goto end;
@@ -102,7 +102,7 @@ int SSL_use_certificate_file(SSL *ssl, const char *file, int type)
     }
 
     ret = SSL_use_certificate(ssl, x);
- end:
+end:
     X509_free(x);
     BIO_free(in);
     return ret;
@@ -119,7 +119,7 @@ int SSL_use_certificate_ASN1(SSL *ssl, const unsigned char *d, int len)
         return 0;
     }
 
-    if (d2i_X509(&x, &d, (long)len)== NULL) {
+    if (d2i_X509(&x, &d, (long)len) == NULL) {
         X509_free(x);
         ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB);
         return 0;
@@ -140,7 +140,7 @@ static int ssl_set_pkey(CERT *c, EVP_PKEY *pkey, SSL_CTX *ctx)
     }
 
     if (c->pkeys[i].x509 != NULL
-            && !X509_check_private_key(c->pkeys[i].x509, pkey))
+        && !X509_check_private_key(c->pkeys[i].x509, pkey))
         return 0;
     if (!EVP_PKEY_up_ref(pkey))
         return 0;
@@ -196,14 +196,14 @@ int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type)
 
         j = ERR_R_PEM_LIB;
         pkey = PEM_read_bio_PrivateKey_ex(in, NULL,
-                                          sc->default_passwd_callback,
-                                          sc->default_passwd_callback_userdata,
-                                          ssl->ctx->libctx,
-                                          ssl->ctx->propq);
+            sc->default_passwd_callback,
+            sc->default_passwd_callback_userdata,
+            ssl->ctx->libctx,
+            ssl->ctx->propq);
     } else if (type == SSL_FILETYPE_ASN1) {
         j = ERR_R_ASN1_LIB;
         pkey = d2i_PrivateKey_ex_bio(in, NULL, ssl->ctx->libctx,
-                                     ssl->ctx->propq);
+            ssl->ctx->propq);
     } else {
         ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE);
         goto end;
@@ -214,13 +214,13 @@ int SSL_use_PrivateKey_file(SSL *ssl, const char *file, int type)
     }
     ret = SSL_use_PrivateKey(ssl, pkey);
     EVP_PKEY_free(pkey);
- end:
+end:
     BIO_free(in);
     return ret;
 }
 
 int SSL_use_PrivateKey_ASN1(int type, SSL *ssl, const unsigned char *d,
-                            long len)
+    long len)
 {
     int ret;
     const unsigned char *p;
@@ -228,7 +228,8 @@ int SSL_use_PrivateKey_ASN1(int type, SSL *ssl, const unsigned char *d,
 
     p = d;
     if ((pkey = d2i_PrivateKey_ex(type, NULL, &p, (long)len, ssl->ctx->libctx,
-                                  ssl->ctx->propq)) == NULL) {
+             ssl->ctx->propq))
+        == NULL) {
         ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB);
         return 0;
     }
@@ -341,7 +342,7 @@ int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file, int type)
     } else if (type == SSL_FILETYPE_PEM) {
         j = ERR_R_PEM_LIB;
         cert = PEM_read_bio_X509(in, &x, ctx->default_passwd_callback,
-                                 ctx->default_passwd_callback_userdata);
+            ctx->default_passwd_callback_userdata);
     } else {
         ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE);
         goto end;
@@ -352,7 +353,7 @@ int SSL_CTX_use_certificate_file(SSL_CTX *ctx, const char *file, int type)
     }
 
     ret = SSL_CTX_use_certificate(ctx, x);
- end:
+end:
     X509_free(x);
     BIO_free(in);
     return ret;
@@ -413,9 +414,9 @@ int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, int type)
     if (type == SSL_FILETYPE_PEM) {
         j = ERR_R_PEM_LIB;
         pkey = PEM_read_bio_PrivateKey_ex(in, NULL,
-                                       ctx->default_passwd_callback,
-                                       ctx->default_passwd_callback_userdata,
-                                       ctx->libctx, ctx->propq);
+            ctx->default_passwd_callback,
+            ctx->default_passwd_callback_userdata,
+            ctx->libctx, ctx->propq);
     } else if (type == SSL_FILETYPE_ASN1) {
         j = ERR_R_ASN1_LIB;
         pkey = d2i_PrivateKey_ex_bio(in, NULL, ctx->libctx, ctx->propq);
@@ -429,13 +430,13 @@ int SSL_CTX_use_PrivateKey_file(SSL_CTX *ctx, const char *file, int type)
     }
     ret = SSL_CTX_use_PrivateKey(ctx, pkey);
     EVP_PKEY_free(pkey);
- end:
+end:
     BIO_free(in);
     return ret;
 }
 
 int SSL_CTX_use_PrivateKey_ASN1(int type, SSL_CTX *ctx,
-                                const unsigned char *d, long len)
+    const unsigned char *d, long len)
 {
     int ret;
     const unsigned char *p;
@@ -443,7 +444,8 @@ int SSL_CTX_use_PrivateKey_ASN1(int type, SSL_CTX *ctx,
 
     p = d;
     if ((pkey = d2i_PrivateKey_ex(type, NULL, &p, (long)len, ctx->libctx,
-                                  ctx->propq)) == NULL) {
+             ctx->propq))
+        == NULL) {
         ERR_raise(ERR_LIB_SSL, ERR_R_ASN1_LIB);
         return 0;
     }
@@ -470,8 +472,8 @@ static int use_certificate_chain_file(SSL_CTX *ctx, SSL *ssl, const char *file)
     if (ctx == NULL && ssl == NULL)
         return 0;
 
-    ERR_clear_error();          /* clear error stack for
-                                 * SSL_CTX_use_certificate() */
+    ERR_clear_error(); /* clear error stack for
+                        * SSL_CTX_use_certificate() */
 
     if (ctx != NULL) {
         passwd_callback = ctx->default_passwd_callback;
@@ -508,7 +510,8 @@ static int use_certificate_chain_file(SSL_CTX *ctx, SSL *ssl, const char *file)
         goto end;
     }
     if (PEM_read_bio_X509_AUX(in, &x, passwd_callback,
-                              passwd_callback_userdata) == NULL) {
+            passwd_callback_userdata)
+        == NULL) {
         ERR_raise(ERR_LIB_SSL, ERR_R_PEM_LIB);
         goto end;
     }
@@ -519,8 +522,8 @@ static int use_certificate_chain_file(SSL_CTX *ctx, SSL *ssl, const char *file)
         ret = SSL_use_certificate(ssl, x);
 
     if (ERR_peek_error() != 0)
-        ret = 0;                /* Key/certificate mismatch doesn't imply
-                                 * ret==0 ... */
+        ret = 0; /* Key/certificate mismatch doesn't imply
+                  * ret==0 ... */
     if (ret) {
         /*
          * If we could set up our certificate, now proceed to the CA
@@ -547,7 +550,8 @@ static int use_certificate_chain_file(SSL_CTX *ctx, SSL *ssl, const char *file)
                 goto end;
             }
             if (PEM_read_bio_X509(in, &ca, passwd_callback,
-                                  passwd_callback_userdata) != NULL) {
+                    passwd_callback_userdata)
+                != NULL) {
                 if (ctx)
                     r = SSL_CTX_add0_chain_cert(ctx, ca);
                 else
@@ -573,10 +577,10 @@ static int use_certificate_chain_file(SSL_CTX *ctx, SSL *ssl, const char *file)
             && ERR_GET_REASON(err) == PEM_R_NO_START_LINE)
             ERR_clear_error();
         else
-            ret = 0;            /* some real error */
+            ret = 0; /* some real error */
     }
 
- end:
+end:
     X509_free(x);
     BIO_free(in);
     return ret;
@@ -593,10 +597,10 @@ int SSL_use_certificate_chain_file(SSL *ssl, const char *file)
 }
 
 static int serverinfo_find_extension(const unsigned char *serverinfo,
-                                     size_t serverinfo_length,
-                                     unsigned int extension_type,
-                                     const unsigned char **extension_data,
-                                     size_t *extension_length)
+    size_t serverinfo_length,
+    unsigned int extension_type,
+    const unsigned char **extension_data,
+    size_t *extension_length)
 {
     PACKET pkt, data;
 
@@ -614,27 +618,27 @@ static int serverinfo_find_extension(const unsigned char *serverinfo,
 
         /* end of serverinfo */
         if (PACKET_remaining(&pkt) == 0)
-            return 0;           /* Extension not found */
+            return 0; /* Extension not found */
 
         if (!PACKET_get_net_4(&pkt, &context)
-                || !PACKET_get_net_2(&pkt, &type)
-                || !PACKET_get_length_prefixed_2(&pkt, &data))
+            || !PACKET_get_net_2(&pkt, &type)
+            || !PACKET_get_length_prefixed_2(&pkt, &data))
             return -1;
 
         if (type == extension_type) {
             *extension_data = PACKET_data(&data);
             *extension_length = PACKET_remaining(&data);
-            return 1;           /* Success */
+            return 1; /* Success */
         }
     }
     /* Unreachable */
 }
 
 static int serverinfoex_srv_parse_cb(SSL *s, unsigned int ext_type,
-                                     unsigned int context,
-                                     const unsigned char *in,
-                                     size_t inlen, X509 *x, size_t chainidx,
-                                     int *al, void *arg)
+    unsigned int context,
+    const unsigned char *in,
+    size_t inlen, X509 *x, size_t chainidx,
+    int *al, void *arg)
 {
 
     if (inlen != 0) {
@@ -646,18 +650,18 @@ static int serverinfoex_srv_parse_cb(SSL *s, unsigned int ext_type,
 }
 
 static int serverinfo_srv_parse_cb(SSL *s, unsigned int ext_type,
-                                   const unsigned char *in,
-                                   size_t inlen, int *al, void *arg)
+    const unsigned char *in,
+    size_t inlen, int *al, void *arg)
 {
     return serverinfoex_srv_parse_cb(s, ext_type, 0, in, inlen, NULL, 0, al,
-                                     arg);
+        arg);
 }
 
 static int serverinfoex_srv_add_cb(SSL *s, unsigned int ext_type,
-                                   unsigned int context,
-                                   const unsigned char **out,
-                                   size_t *outlen, X509 *x, size_t chainidx,
-                                   int *al, void *arg)
+    unsigned int context,
+    const unsigned char **out,
+    size_t *outlen, X509 *x, size_t chainidx,
+    int *al, void *arg)
 {
     const unsigned char *serverinfo = NULL;
     size_t serverinfo_length = 0;
@@ -674,28 +678,29 @@ static int serverinfoex_srv_add_cb(SSL *s, unsigned int ext_type,
 
     /* Is there serverinfo data for the chosen server cert? */
     if ((ssl_get_server_cert_serverinfo(sc, &serverinfo,
-                                        &serverinfo_length)) != 0) {
+            &serverinfo_length))
+        != 0) {
         /* Find the relevant extension from the serverinfo */
         int retval = serverinfo_find_extension(serverinfo, serverinfo_length,
-                                               ext_type, out, outlen);
+            ext_type, out, outlen);
         if (retval == -1) {
             *al = SSL_AD_INTERNAL_ERROR;
-            return -1;          /* Error */
+            return -1; /* Error */
         }
         if (retval == 0)
-            return 0;           /* No extension found, don't send extension */
-        return 1;               /* Send extension */
+            return 0; /* No extension found, don't send extension */
+        return 1; /* Send extension */
     }
-    return 0;                   /* No serverinfo data found, don't send
-                                 * extension */
+    return 0; /* No serverinfo data found, don't send
+               * extension */
 }
 
 static int serverinfo_srv_add_cb(SSL *s, unsigned int ext_type,
-                                 const unsigned char **out, size_t *outlen,
-                                 int *al, void *arg)
+    const unsigned char **out, size_t *outlen,
+    int *al, void *arg)
 {
     return serverinfoex_srv_add_cb(s, ext_type, 0, out, outlen, NULL, 0, al,
-                                   arg);
+        arg);
 }
 
 /*
@@ -704,8 +709,8 @@ static int serverinfo_srv_add_cb(SSL *s, unsigned int ext_type,
  * the included extensions.
  */
 static int serverinfo_process_buffer(unsigned int version,
-                                     const unsigned char *serverinfo,
-                                     size_t serverinfo_length, SSL_CTX *ctx)
+    const unsigned char *serverinfo,
+    size_t serverinfo_length, SSL_CTX *ctx)
 {
     PACKET pkt;
 
@@ -724,8 +729,8 @@ static int serverinfo_process_buffer(unsigned int version,
         PACKET data;
 
         if ((version == SSL_SERVERINFOV2 && !PACKET_get_net_4(&pkt, &context))
-                || !PACKET_get_net_2(&pkt, &ext_type)
-                || !PACKET_get_length_prefixed_2(&pkt, &data))
+            || !PACKET_get_net_2(&pkt, &ext_type)
+            || !PACKET_get_length_prefixed_2(&pkt, &data))
             return 0;
 
         if (ctx == NULL)
@@ -744,17 +749,17 @@ static int serverinfo_process_buffer(unsigned int version,
          */
         if (version == SSL_SERVERINFOV1 || context == SYNTHV1CONTEXT) {
             if (!SSL_CTX_add_server_custom_ext(ctx, ext_type,
-                                               serverinfo_srv_add_cb,
-                                               NULL, NULL,
-                                               serverinfo_srv_parse_cb,
-                                               NULL))
+                    serverinfo_srv_add_cb,
+                    NULL, NULL,
+                    serverinfo_srv_parse_cb,
+                    NULL))
                 return 0;
         } else {
             if (!SSL_CTX_add_custom_ext(ctx, ext_type, context,
-                                        serverinfoex_srv_add_cb,
-                                        NULL, NULL,
-                                        serverinfoex_srv_parse_cb,
-                                        NULL))
+                    serverinfoex_srv_add_cb,
+                    NULL, NULL,
+                    serverinfoex_srv_parse_cb,
+                    NULL))
                 return 0;
         }
     }
@@ -773,9 +778,9 @@ static size_t extension_append_length(unsigned int version, size_t extension_len
 }
 
 static void extension_append(unsigned int version,
-                             const unsigned char *extension,
-                             const size_t extension_length,
-                             unsigned char *serverinfo)
+    const unsigned char *extension,
+    const size_t extension_length,
+    unsigned char *serverinfo)
 {
     const size_t contextoff = extension_contextoff(version);
 
@@ -791,8 +796,8 @@ static void extension_append(unsigned int version,
 }
 
 int SSL_CTX_use_serverinfo_ex(SSL_CTX *ctx, unsigned int version,
-                              const unsigned char *serverinfo,
-                              size_t serverinfo_length)
+    const unsigned char *serverinfo,
+    size_t serverinfo_length)
 {
     unsigned char *new_serverinfo = NULL;
 
@@ -806,7 +811,7 @@ int SSL_CTX_use_serverinfo_ex(SSL_CTX *ctx, unsigned int version,
          * over the converted serverinfo.
          */
         const size_t sinfo_length = extension_append_length(SSL_SERVERINFOV1,
-                                                            serverinfo_length);
+            serverinfo_length);
         unsigned char *sinfo;
         int ret;
 
@@ -817,13 +822,13 @@ int SSL_CTX_use_serverinfo_ex(SSL_CTX *ctx, unsigned int version,
         extension_append(SSL_SERVERINFOV1, serverinfo, serverinfo_length, sinfo);
 
         ret = SSL_CTX_use_serverinfo_ex(ctx, SSL_SERVERINFOV2, sinfo,
-                                        sinfo_length);
+            sinfo_length);
 
         OPENSSL_free(sinfo);
         return ret;
     }
     if (!serverinfo_process_buffer(version, serverinfo, serverinfo_length,
-                                   NULL)) {
+            NULL)) {
         ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_SERVERINFO_DATA);
         return 0;
     }
@@ -832,7 +837,7 @@ int SSL_CTX_use_serverinfo_ex(SSL_CTX *ctx, unsigned int version,
         return 0;
     }
     new_serverinfo = OPENSSL_realloc(ctx->cert->key->serverinfo,
-                                     serverinfo_length);
+        serverinfo_length);
     if (new_serverinfo == NULL)
         return 0;
     ctx->cert->key->serverinfo = new_serverinfo;
@@ -844,7 +849,7 @@ int SSL_CTX_use_serverinfo_ex(SSL_CTX *ctx, unsigned int version,
      * register callbacks.
      */
     if (!serverinfo_process_buffer(version, serverinfo, serverinfo_length,
-                                   ctx)) {
+            ctx)) {
         ERR_raise(ERR_LIB_SSL, SSL_R_INVALID_SERVERINFO_DATA);
         return 0;
     }
@@ -852,10 +857,10 @@ int SSL_CTX_use_serverinfo_ex(SSL_CTX *ctx, unsigned int version,
 }
 
 int SSL_CTX_use_serverinfo(SSL_CTX *ctx, const unsigned char *serverinfo,
-                           size_t serverinfo_length)
+    size_t serverinfo_length)
 {
     return SSL_CTX_use_serverinfo_ex(ctx, SSL_SERVERINFOV1, serverinfo,
-                                     serverinfo_length);
+        serverinfo_length);
 }
 
 int SSL_CTX_use_serverinfo_file(SSL_CTX *ctx, const char *file)
@@ -899,7 +904,7 @@ int SSL_CTX_use_serverinfo_file(SSL_CTX *ctx, const char *file)
             if (num_extensions == 0) {
                 ERR_raise(ERR_LIB_SSL, SSL_R_NO_PEM_EXTENSIONS);
                 goto end;
-            } else              /* End of file, we're done */
+            } else /* End of file, we're done */
                 break;
         }
         /* Check that PEM name starts with "BEGIN SERVERINFO FOR " */
@@ -927,16 +932,16 @@ int SSL_CTX_use_serverinfo_file(SSL_CTX *ctx, const char *file)
         if (version == SSL_SERVERINFOV1) {
             /* 4 byte header: 2 bytes type, 2 bytes len */
             if (extension_length < 4
-                    || (extension[2] << 8) + extension[3]
-                       != extension_length - 4) {
+                || (extension[2] << 8) + extension[3]
+                    != extension_length - 4) {
                 ERR_raise(ERR_LIB_SSL, SSL_R_BAD_DATA);
                 goto end;
             }
         } else {
             /* 8 byte header: 4 bytes context, 2 bytes type, 2 bytes len */
             if (extension_length < 8
-                    || (extension[6] << 8) + extension[7]
-                       != extension_length - 8) {
+                || (extension[6] << 8) + extension[7]
+                    != extension_length - 8) {
                 ERR_raise(ERR_LIB_SSL, SSL_R_BAD_DATA);
                 goto end;
             }
@@ -948,7 +953,7 @@ int SSL_CTX_use_serverinfo_file(SSL_CTX *ctx, const char *file)
             goto end;
         serverinfo = tmp;
         extension_append(version, extension, extension_length,
-                         serverinfo + serverinfo_length);
+            serverinfo + serverinfo_length);
         serverinfo_length += append_length;
 
         OPENSSL_free(name);
@@ -960,8 +965,8 @@ int SSL_CTX_use_serverinfo_file(SSL_CTX *ctx, const char *file)
     }
 
     ret = SSL_CTX_use_serverinfo_ex(ctx, SSL_SERVERINFOV2, serverinfo,
-                                    serverinfo_length);
- end:
+        serverinfo_length);
+end:
     /* SSL_CTX_use_serverinfo makes a local copy of the serverinfo. */
     OPENSSL_free(name);
     OPENSSL_free(header);
@@ -972,7 +977,7 @@ int SSL_CTX_use_serverinfo_file(SSL_CTX *ctx, const char *file)
 }
 
 static int ssl_set_cert_and_key(SSL *ssl, SSL_CTX *ctx, X509 *x509, EVP_PKEY *privatekey,
-                                STACK_OF(X509) *chain, int override)
+    STACK_OF(X509) *chain, int override)
 {
     int ret = 0;
     size_t i;
@@ -983,8 +988,7 @@ static int ssl_set_cert_and_key(SSL *ssl, SSL_CTX *ctx, X509 *x509, EVP_PKEY *pr
     EVP_PKEY *pubkey = NULL;
     SSL_CONNECTION *sc = NULL;
 
-    if (ctx == NULL &&
-        (sc = SSL_CONNECTION_FROM_SSL(ssl)) == NULL)
+    if (ctx == NULL && (sc = SSL_CONNECTION_FROM_SSL(ssl)) == NULL)
         return 0;
 
     c = sc != NULL ? sc->cert : ctx->cert;
@@ -1040,9 +1044,7 @@ static int ssl_set_cert_and_key(SSL *ssl, SSL_CTX *ctx, X509 *x509, EVP_PKEY *pr
         goto out;
     }
 
-    if (!override && (c->pkeys[i].x509 != NULL
-                      || c->pkeys[i].privatekey != NULL
-                      || c->pkeys[i].chain != NULL)) {
+    if (!override && (c->pkeys[i].x509 != NULL || c->pkeys[i].privatekey != NULL || c->pkeys[i].chain != NULL)) {
         /* No override, and something already there */
         ERR_raise(ERR_LIB_SSL, SSL_R_NOT_REPLACING_CERTIFICATE);
         goto out;
@@ -1079,19 +1081,19 @@ static int ssl_set_cert_and_key(SSL *ssl, SSL_CTX *ctx, X509 *x509, EVP_PKEY *pr
     c->key = &(c->pkeys[i]);
 
     ret = 1;
- out:
+out:
     EVP_PKEY_free(pubkey);
     return ret;
 }
 
 int SSL_use_cert_and_key(SSL *ssl, X509 *x509, EVP_PKEY *privatekey,
-                         STACK_OF(X509) *chain, int override)
+    STACK_OF(X509) *chain, int override)
 {
     return ssl_set_cert_and_key(ssl, NULL, x509, privatekey, chain, override);
 }
 
 int SSL_CTX_use_cert_and_key(SSL_CTX *ctx, X509 *x509, EVP_PKEY *privatekey,
-                             STACK_OF(X509) *chain, int override)
+    STACK_OF(X509) *chain, int override)
 {
     return ssl_set_cert_and_key(NULL, ctx, x509, privatekey, chain, override);
 }
diff --git a/crypto/openssl/ssl/ssl_rsa_legacy.c b/crypto/openssl/ssl/ssl_rsa_legacy.c
index ce03fcd9907e..ed95be5af825 100644
--- a/crypto/openssl/ssl/ssl_rsa_legacy.c
+++ b/crypto/openssl/ssl/ssl_rsa_legacy.c
@@ -71,8 +71,8 @@ int SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file, int type)
     } else if (type == SSL_FILETYPE_PEM) {
         j = ERR_R_PEM_LIB;
         rsa = PEM_read_bio_RSAPrivateKey(in, NULL,
-                                         SSL_get_default_passwd_cb(ssl),
-                                         SSL_get_default_passwd_cb_userdata(ssl));
+            SSL_get_default_passwd_cb(ssl),
+            SSL_get_default_passwd_cb_userdata(ssl));
     } else {
         ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE);
         goto end;
@@ -83,7 +83,7 @@ int SSL_use_RSAPrivateKey_file(SSL *ssl, const char *file, int type)
     }
     ret = SSL_use_RSAPrivateKey(ssl, rsa);
     RSA_free(rsa);
- end:
+end:
     BIO_free(in);
     return ret;
 }
@@ -162,8 +162,8 @@ int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file, int type)
     } else if (type == SSL_FILETYPE_PEM) {
         j = ERR_R_PEM_LIB;
         rsa = PEM_read_bio_RSAPrivateKey(in, NULL,
-                                         SSL_CTX_get_default_passwd_cb(ctx),
-                                         SSL_CTX_get_default_passwd_cb_userdata(ctx));
+            SSL_CTX_get_default_passwd_cb(ctx),
+            SSL_CTX_get_default_passwd_cb_userdata(ctx));
     } else {
         ERR_raise(ERR_LIB_SSL, SSL_R_BAD_SSL_FILETYPE);
         goto end;
@@ -174,13 +174,13 @@ int SSL_CTX_use_RSAPrivateKey_file(SSL_CTX *ctx, const char *file, int type)
     }
     ret = SSL_CTX_use_RSAPrivateKey(ctx, rsa);
     RSA_free(rsa);
- end:
+end:
     BIO_free(in);
     return ret;
 }
 
 int SSL_CTX_use_RSAPrivateKey_ASN1(SSL_CTX *ctx, const unsigned char *d,
-                                   long len)
+    long len)
 {
     int ret;
     const unsigned char *p;
diff --git a/crypto/openssl/ssl/ssl_sess.c b/crypto/openssl/ssl/ssl_sess.c
index a50f7ce96b64..04cbfa5cfa94 100644
--- a/crypto/openssl/ssl/ssl_sess.c
+++ b/crypto/openssl/ssl/ssl_sess.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 1995-2025 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
  * Copyright 2005 Nokia. All rights reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
@@ -9,8 +9,8 @@
  */
 
 #if defined(__TANDEM) && defined(_SPT_MODEL_)
-# include <spthread.h>
-# include <spt_extensions.h> /* timeval */
+#include <spthread.h>
+#include <spt_extensions.h> /* timeval */
 #endif
 #include <stdio.h>
 #include <openssl/rand.h>
@@ -111,8 +111,8 @@ SSL_SESSION *SSL_SESSION_new(void)
         return NULL;
 
     ss->ext.max_fragment_len_mode = TLSEXT_max_fragment_length_UNSPECIFIED;
-    ss->verify_result = 1;      /* avoid 0 (= X509_V_OK) just in case */
-   /* 5 minute timeout by default */
+    ss->verify_result = 1; /* avoid 0 (= X509_V_OK) just in case */
+    /* 5 minute timeout by default */
     ss->timeout = ossl_seconds2time(60 * 5 + 4);
     ss->time = ossl_time_now();
     ssl_session_calculate_timeout(ss);
@@ -218,7 +218,7 @@ static SSL_SESSION *ssl_session_dup_intern(const SSL_SESSION *src, int ticket)
 #endif
 
     if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL_SESSION,
-                            &dest->ex_data, &src->ex_data)) {
+            &dest->ex_data, &src->ex_data)) {
         ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
         goto err;
     }
@@ -230,8 +230,7 @@ static SSL_SESSION *ssl_session_dup_intern(const SSL_SESSION *src, int ticket)
     }
 
     if (ticket != 0 && src->ext.tick != NULL) {
-        dest->ext.tick =
-            OPENSSL_memdup(src->ext.tick, src->ext.ticklen);
+        dest->ext.tick = OPENSSL_memdup(src->ext.tick, src->ext.ticklen);
         if (dest->ext.tick == NULL)
             goto err;
     } else {
@@ -241,7 +240,7 @@ static SSL_SESSION *ssl_session_dup_intern(const SSL_SESSION *src, int ticket)
 
     if (src->ext.alpn_selected != NULL) {
         dest->ext.alpn_selected = OPENSSL_memdup(src->ext.alpn_selected,
-                                                 src->ext.alpn_selected_len);
+            src->ext.alpn_selected_len);
         if (dest->ext.alpn_selected == NULL)
             goto err;
     }
@@ -255,14 +254,13 @@ static SSL_SESSION *ssl_session_dup_intern(const SSL_SESSION *src, int ticket)
 #endif
 
     if (src->ticket_appdata != NULL) {
-        dest->ticket_appdata =
-            OPENSSL_memdup(src->ticket_appdata, src->ticket_appdata_len);
+        dest->ticket_appdata = OPENSSL_memdup(src->ticket_appdata, src->ticket_appdata_len);
         if (dest->ticket_appdata == NULL)
             goto err;
     }
 
     return dest;
- err:
+err:
     SSL_SESSION_free(dest);
     return NULL;
 }
@@ -296,7 +294,7 @@ const unsigned char *SSL_SESSION_get_id(const SSL_SESSION *s, unsigned int *len)
 }
 
 const unsigned char *SSL_SESSION_get0_id_context(const SSL_SESSION *s,
-                                                unsigned int *len)
+    unsigned int *len)
 {
     if (len != NULL)
         *len = (unsigned int)s->sid_ctx_length;
@@ -321,7 +319,7 @@ unsigned int SSL_SESSION_get_compress_id(const SSL_SESSION *s)
 
 #define MAX_SESS_ID_ATTEMPTS 10
 static int def_generate_session_id(SSL *ssl, unsigned char *id,
-                                   unsigned int *id_len)
+    unsigned int *id_len)
 {
     unsigned int retry = 0;
     do {
@@ -332,8 +330,7 @@ static int def_generate_session_id(SSL *ssl, unsigned char *id,
             id[0]++;
         }
 #endif
-    } while (SSL_has_matching_session_id(ssl, id, *id_len) &&
-           (++retry < MAX_SESS_ID_ATTEMPTS)) ;
+    } while (SSL_has_matching_session_id(ssl, id, *id_len) && (++retry < MAX_SESS_ID_ATTEMPTS));
     if (retry < MAX_SESS_ID_ATTEMPTS)
         return 1;
     /* else - woops a session_id match */
@@ -396,7 +393,7 @@ int ssl_generate_session_id(SSL_CONNECTION *s, SSL_SESSION *ss)
     if (!CRYPTO_THREAD_read_lock(s->session_ctx->lock)) {
         CRYPTO_THREAD_unlock(ssl->lock);
         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                 SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED);
+            SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED);
         return 0;
     }
     if (s->generate_session_id)
@@ -411,7 +408,7 @@ int ssl_generate_session_id(SSL_CONNECTION *s, SSL_SESSION *ss)
     if (!cb(ssl, ss->session_id, &tmp)) {
         /* The callback failed */
         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                 SSL_R_SSL_SESSION_ID_CALLBACK_FAILED);
+            SSL_R_SSL_SESSION_ID_CALLBACK_FAILED);
         return 0;
     }
     /*
@@ -421,13 +418,13 @@ int ssl_generate_session_id(SSL_CONNECTION *s, SSL_SESSION *ss)
     if (tmp == 0 || tmp > ss->session_id_length) {
         /* The callback set an illegal length */
         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                 SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH);
+            SSL_R_SSL_SESSION_ID_HAS_BAD_LENGTH);
         return 0;
     }
     ss->session_id_length = tmp;
     /* Finally, check for a conflict */
     if (SSL_has_matching_session_id(ssl, ss->session_id,
-                                    (unsigned int)ss->session_id_length)) {
+            (unsigned int)ss->session_id_length)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_SSL_SESSION_ID_CONFLICT);
         return 0;
     }
@@ -492,13 +489,14 @@ int ssl_get_new_session(SSL_CONNECTION *s, int session)
 }
 
 SSL_SESSION *lookup_sess_in_cache(SSL_CONNECTION *s,
-                                  const unsigned char *sess_id,
-                                  size_t sess_id_len)
+    const unsigned char *sess_id,
+    size_t sess_id_len)
 {
     SSL_SESSION *ret = NULL;
 
     if ((s->session_ctx->session_cache_mode
-         & SSL_SESS_CACHE_NO_INTERNAL_LOOKUP) == 0) {
+            & SSL_SESS_CACHE_NO_INTERNAL_LOOKUP)
+        == 0) {
         SSL_SESSION data;
 
         data.ssl_version = s->version;
@@ -527,7 +525,7 @@ SSL_SESSION *lookup_sess_in_cache(SSL_CONNECTION *s,
         int copy = 1;
 
         ret = s->session_ctx->get_session_cb(SSL_CONNECTION_GET_USER_SSL(s),
-                                             sess_id, sess_id_len, &copy);
+            sess_id, sess_id_len, &copy);
 
         if (ret != NULL) {
             if (ret->not_resumable) {
@@ -537,7 +535,7 @@ SSL_SESSION *lookup_sess_in_cache(SSL_CONNECTION *s,
                 return NULL;
             }
             ssl_tsan_counter(s->session_ctx,
-                             &s->session_ctx->stats.sess_cb_hit);
+                &s->session_ctx->stats.sess_cb_hit);
 
             /*
              * Increment reference count now if the session callback asks us
@@ -553,8 +551,7 @@ SSL_SESSION *lookup_sess_in_cache(SSL_CONNECTION *s,
              * Add the externally cached session to the internal cache as
              * well if and only if we are supposed to.
              */
-            if ((s->session_ctx->session_cache_mode &
-                 SSL_SESS_CACHE_NO_INTERNAL_STORE) == 0) {
+            if ((s->session_ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_STORE) == 0) {
                 /*
                  * Either return value of SSL_CTX_add_session should not
                  * interrupt the session resumption process. The return
@@ -603,10 +600,10 @@ int ssl_get_prev_session(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello)
          */
         s->ext.ticket_expected = 1;
         if (!tls_parse_extension(s, TLSEXT_IDX_psk_kex_modes,
-                                 SSL_EXT_CLIENT_HELLO, hello->pre_proc_exts,
-                                 NULL, 0)
-                || !tls_parse_extension(s, TLSEXT_IDX_psk, SSL_EXT_CLIENT_HELLO,
-                                        hello->pre_proc_exts, NULL, 0))
+                SSL_EXT_CLIENT_HELLO, hello->pre_proc_exts,
+                NULL, 0)
+            || !tls_parse_extension(s, TLSEXT_IDX_psk, SSL_EXT_CLIENT_HELLO,
+                hello->pre_proc_exts, NULL, 0))
             return -1;
 
         /* If we resumed, s->session will now be set */
@@ -625,7 +622,7 @@ int ssl_get_prev_session(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello)
             if (hello->session_id_len > 0) {
                 try_session_cache = 1;
                 ret = lookup_sess_in_cache(s, hello->session_id,
-                                           hello->session_id_len);
+                    hello->session_id_len);
             }
             break;
         case SSL_TICKET_NO_DECRYPT:
@@ -650,7 +647,7 @@ int ssl_get_prev_session(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello)
          * We have the session requested by the client, but we don't want to
          * use it in this context.
          */
-        goto err;               /* treat like cache miss */
+        goto err; /* treat like cache miss */
     }
 
     if ((s->verify_mode & SSL_VERIFY_PEER) && s->sid_ctx_length == 0) {
@@ -665,7 +662,7 @@ int ssl_get_prev_session(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello)
          */
 
         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                 SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED);
+            SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED);
         fatal = 1;
         goto err;
     }
@@ -683,7 +680,7 @@ int ssl_get_prev_session(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello)
     if (ret->flags & SSL_SESS_FLAG_EXTMS) {
         /* If old session includes extms, but new does not: abort handshake */
         if (!(s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS)) {
-            SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INCONSISTENT_EXTMS);
+            SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_INCONSISTENT_EXTMS);
             fatal = 1;
             goto err;
         }
@@ -702,7 +699,7 @@ int ssl_get_prev_session(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello)
     s->verify_result = s->session->verify_result;
     return 1;
 
- err:
+err:
     if (ret != NULL) {
         SSL_SESSION_free(ret);
         /* In TLSv1.3 s->session was already set to ret, so we NULL it out */
@@ -761,8 +758,7 @@ int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *c)
          * obtain the same session from an external cache)
          */
         s = NULL;
-    } else if (s == NULL &&
-               lh_SSL_SESSION_retrieve(ctx->sessions, c) == NULL) {
+    } else if (s == NULL && lh_SSL_SESSION_retrieve(ctx->sessions, c) == NULL) {
         /* s == NULL can also mean OOM error in lh_SSL_SESSION_insert ... */
 
         /*
@@ -794,9 +790,9 @@ int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *c)
                     ssl_tsan_counter(ctx, &ctx->stats.sess_cache_full);
             }
         }
-    }
 
-    SSL_SESSION_list_add(ctx, c);
+        SSL_SESSION_list_add(ctx, c);
+    }
 
     if (s != NULL) {
         /*
@@ -804,7 +800,7 @@ int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *c)
          * count because it already takes into account the cache
          */
 
-        SSL_SESSION_free(s);    /* s == c */
+        SSL_SESSION_free(s); /* s == c */
         ret = 0;
     }
     CRYPTO_THREAD_unlock(ctx->lock);
@@ -919,11 +915,11 @@ int SSL_set_session(SSL *s, SSL_SESSION *session)
 }
 
 int SSL_SESSION_set1_id(SSL_SESSION *s, const unsigned char *sid,
-                        unsigned int sid_len)
+    unsigned int sid_len)
 {
     if (sid_len > SSL_MAX_SSL_SESSION_ID_LENGTH) {
-      ERR_raise(ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_TOO_LONG);
-      return 0;
+        ERR_raise(ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_TOO_LONG);
+        return 0;
     }
     s->session_id_length = sid_len;
     if (sid != s->session_id && sid_len > 0)
@@ -962,7 +958,7 @@ long SSL_SESSION_get_timeout(const SSL_SESSION *s)
 #ifndef OPENSSL_NO_DEPRECATED_3_4
 long SSL_SESSION_get_time(const SSL_SESSION *s)
 {
-    return (long) SSL_SESSION_get_time_ex(s);
+    return (long)SSL_SESSION_get_time_ex(s);
 }
 #endif
 
@@ -996,7 +992,7 @@ time_t SSL_SESSION_set_time_ex(SSL_SESSION *s, time_t t)
 #ifndef OPENSSL_NO_DEPRECATED_3_4
 long SSL_SESSION_set_time(SSL_SESSION *s, long t)
 {
-    return (long) SSL_SESSION_set_time_ex(s, (time_t) t);
+    return (long)SSL_SESSION_set_time_ex(s, (time_t)t);
 }
 #endif
 
@@ -1050,7 +1046,7 @@ unsigned long SSL_SESSION_get_ticket_lifetime_hint(const SSL_SESSION *s)
 }
 
 void SSL_SESSION_get0_ticket(const SSL_SESSION *s, const unsigned char **tick,
-                             size_t *len)
+    size_t *len)
 {
     *len = s->ext.ticklen;
     if (tick != NULL)
@@ -1070,15 +1066,15 @@ int SSL_SESSION_set_max_early_data(SSL_SESSION *s, uint32_t max_early_data)
 }
 
 void SSL_SESSION_get0_alpn_selected(const SSL_SESSION *s,
-                                    const unsigned char **alpn,
-                                    size_t *len)
+    const unsigned char **alpn,
+    size_t *len)
 {
     *alpn = s->ext.alpn_selected;
     *len = s->ext.alpn_selected_len;
 }
 
 int SSL_SESSION_set1_alpn_selected(SSL_SESSION *s, const unsigned char *alpn,
-                                   size_t len)
+    size_t len)
 {
     OPENSSL_free(s->ext.alpn_selected);
     if (alpn == NULL || len == 0) {
@@ -1107,7 +1103,7 @@ EVP_PKEY *SSL_SESSION_get0_peer_rpk(SSL_SESSION *s)
 }
 
 int SSL_SESSION_set1_id_context(SSL_SESSION *s, const unsigned char *sid_ctx,
-                                unsigned int sid_ctx_len)
+    unsigned int sid_ctx_len)
 {
     if (sid_ctx_len > SSL_MAX_SID_CTX_LENGTH) {
         ERR_raise(ERR_LIB_SSL, SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
@@ -1127,7 +1123,7 @@ int SSL_SESSION_is_resumable(const SSL_SESSION *s)
      * session ID.
      */
     return !s->not_resumable
-           && (s->session_id_length > 0 || s->ext.ticklen > 0);
+        && (s->session_id_length > 0 || s->ext.ticklen > 0);
 }
 
 long SSL_CTX_set_timeout(SSL_CTX *s, long t)
@@ -1149,8 +1145,8 @@ long SSL_CTX_get_timeout(const SSL_CTX *s)
 }
 
 int SSL_set_session_secret_cb(SSL *s,
-                              tls_session_secret_cb_fn tls_session_secret_cb,
-                              void *arg)
+    tls_session_secret_cb_fn tls_session_secret_cb,
+    void *arg)
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 
@@ -1163,7 +1159,7 @@ int SSL_set_session_secret_cb(SSL *s,
 }
 
 int SSL_set_session_ticket_ext_cb(SSL *s, tls_session_ticket_ext_cb_fn cb,
-                                  void *arg)
+    void *arg)
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 
@@ -1185,8 +1181,7 @@ int SSL_set_session_ticket_ext(SSL *s, void *ext_data, int ext_len)
     if (sc->version >= TLS1_VERSION) {
         OPENSSL_free(sc->ext.session_ticket);
         sc->ext.session_ticket = NULL;
-        sc->ext.session_ticket =
-            OPENSSL_malloc(sizeof(TLS_SESSION_TICKET_EXT) + ext_len);
+        sc->ext.session_ticket = OPENSSL_malloc(sizeof(TLS_SESSION_TICKET_EXT) + ext_len);
         if (sc->ext.session_ticket == NULL)
             return 0;
 
@@ -1208,7 +1203,7 @@ int SSL_set_session_ticket_ext(SSL *s, void *ext_data, int ext_len)
 #ifndef OPENSSL_NO_DEPRECATED_3_4
 void SSL_CTX_flush_sessions(SSL_CTX *s, long t)
 {
-    SSL_CTX_flush_sessions_ex(s, (time_t) t);
+    SSL_CTX_flush_sessions_ex(s, (time_t)t);
 }
 #endif
 
@@ -1263,10 +1258,7 @@ void SSL_CTX_flush_sessions_ex(SSL_CTX *s, time_t t)
 
 int ssl_clear_bad_session(SSL_CONNECTION *s)
 {
-    if ((s->session != NULL) &&
-        !(s->shutdown & SSL_SENT_SHUTDOWN) &&
-        !(SSL_in_init(SSL_CONNECTION_GET_SSL(s))
-          || SSL_in_before(SSL_CONNECTION_GET_SSL(s)))) {
+    if ((s->session != NULL) && !(s->shutdown & SSL_SENT_SHUTDOWN) && !(SSL_in_init(SSL_CONNECTION_GET_SSL(s)) || SSL_in_before(SSL_CONNECTION_GET_SSL(s)))) {
         SSL_CTX_remove_session(s->session_ctx, s->session);
         return 1;
     } else
@@ -1338,7 +1330,7 @@ static void SSL_SESSION_list_add(SSL_CTX *ctx, SSL_SESSION *s)
              * one session in the cache it will be caught above
              */
             next = ctx->session_cache_head->next;
-            while (next != (SSL_SESSION*)&(ctx->session_cache_tail)) {
+            while (next != (SSL_SESSION *)&(ctx->session_cache_tail)) {
                 if (timeoutcmp(s, next) >= 0) {
                     s->next = next;
                     s->prev = next->prev;
@@ -1354,76 +1346,82 @@ static void SSL_SESSION_list_add(SSL_CTX *ctx, SSL_SESSION *s)
 }
 
 void SSL_CTX_sess_set_new_cb(SSL_CTX *ctx,
-                             int (*cb) (struct ssl_st *ssl, SSL_SESSION *sess))
+    int (*cb)(struct ssl_st *ssl, SSL_SESSION *sess))
 {
     ctx->new_session_cb = cb;
 }
 
-int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx)) (SSL *ssl, SSL_SESSION *sess) {
+int (*SSL_CTX_sess_get_new_cb(SSL_CTX *ctx))(SSL *ssl, SSL_SESSION *sess)
+{
     return ctx->new_session_cb;
 }
 
 void SSL_CTX_sess_set_remove_cb(SSL_CTX *ctx,
-                                void (*cb) (SSL_CTX *ctx, SSL_SESSION *sess))
+    void (*cb)(SSL_CTX *ctx, SSL_SESSION *sess))
 {
     ctx->remove_session_cb = cb;
 }
 
-void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx)) (SSL_CTX *ctx,
-                                                  SSL_SESSION *sess) {
+void (*SSL_CTX_sess_get_remove_cb(SSL_CTX *ctx))(SSL_CTX *ctx,
+    SSL_SESSION *sess)
+{
     return ctx->remove_session_cb;
 }
 
 void SSL_CTX_sess_set_get_cb(SSL_CTX *ctx,
-                             SSL_SESSION *(*cb) (SSL *ssl,
-                                                 const unsigned char *data,
-                                                 int len, int *copy))
+    SSL_SESSION *(*cb)(SSL *ssl,
+        const unsigned char *data,
+        int len, int *copy))
 {
     ctx->get_session_cb = cb;
 }
 
-SSL_SESSION *(*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx)) (SSL *ssl,
-                                                       const unsigned char
-                                                       *data, int len,
-                                                       int *copy) {
+SSL_SESSION *(*SSL_CTX_sess_get_get_cb(SSL_CTX *ctx))(SSL *ssl,
+    const unsigned char
+        *data,
+    int len,
+    int *copy)
+{
     return ctx->get_session_cb;
 }
 
 void SSL_CTX_set_info_callback(SSL_CTX *ctx,
-                               void (*cb) (const SSL *ssl, int type, int val))
+    void (*cb)(const SSL *ssl, int type, int val))
 {
     ctx->info_callback = cb;
 }
 
-void (*SSL_CTX_get_info_callback(SSL_CTX *ctx)) (const SSL *ssl, int type,
-                                                 int val) {
+void (*SSL_CTX_get_info_callback(SSL_CTX *ctx))(const SSL *ssl, int type,
+    int val)
+{
     return ctx->info_callback;
 }
 
 void SSL_CTX_set_client_cert_cb(SSL_CTX *ctx,
-                                int (*cb) (SSL *ssl, X509 **x509,
-                                           EVP_PKEY **pkey))
+    int (*cb)(SSL *ssl, X509 **x509,
+        EVP_PKEY **pkey))
 {
     ctx->client_cert_cb = cb;
 }
 
-int (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx)) (SSL *ssl, X509 **x509,
-                                                 EVP_PKEY **pkey) {
+int (*SSL_CTX_get_client_cert_cb(SSL_CTX *ctx))(SSL *ssl, X509 **x509,
+    EVP_PKEY **pkey)
+{
     return ctx->client_cert_cb;
 }
 
 void SSL_CTX_set_cookie_generate_cb(SSL_CTX *ctx,
-                                    int (*cb) (SSL *ssl,
-                                               unsigned char *cookie,
-                                               unsigned int *cookie_len))
+    int (*cb)(SSL *ssl,
+        unsigned char *cookie,
+        unsigned int *cookie_len))
 {
     ctx->app_gen_cookie_cb = cb;
 }
 
 void SSL_CTX_set_cookie_verify_cb(SSL_CTX *ctx,
-                                  int (*cb) (SSL *ssl,
-                                             const unsigned char *cookie,
-                                             unsigned int cookie_len))
+    int (*cb)(SSL *ssl,
+        const unsigned char *cookie,
+        unsigned int cookie_len))
 {
     ctx->app_verify_cookie_cb = cb;
 }
@@ -1453,18 +1451,18 @@ int SSL_SESSION_get0_ticket_appdata(SSL_SESSION *ss, void **data, size_t *len)
 
 void SSL_CTX_set_stateless_cookie_generate_cb(
     SSL_CTX *ctx,
-    int (*cb) (SSL *ssl,
-               unsigned char *cookie,
-               size_t *cookie_len))
+    int (*cb)(SSL *ssl,
+        unsigned char *cookie,
+        size_t *cookie_len))
 {
     ctx->gen_stateless_cookie_cb = cb;
 }
 
 void SSL_CTX_set_stateless_cookie_verify_cb(
     SSL_CTX *ctx,
-    int (*cb) (SSL *ssl,
-               const unsigned char *cookie,
-               size_t cookie_len))
+    int (*cb)(SSL *ssl,
+        const unsigned char *cookie,
+        size_t cookie_len))
 {
     ctx->verify_stateless_cookie_cb = cb;
 }
diff --git a/crypto/openssl/ssl/ssl_txt.c b/crypto/openssl/ssl/ssl_txt.c
index d928cb9bbd6f..aeb03bfeb2bd 100644
--- a/crypto/openssl/ssl/ssl_txt.c
+++ b/crypto/openssl/ssl/ssl_txt.c
@@ -49,17 +49,20 @@ int SSL_SESSION_print(BIO *bp, const SSL_SESSION *x)
     if (x->cipher == NULL) {
         if (((x->cipher_id) & 0xff000000) == 0x02000000) {
             if (BIO_printf(bp, "    Cipher    : %06lX\n",
-                           x->cipher_id & 0xffffff) <= 0)
+                    x->cipher_id & 0xffffff)
+                <= 0)
                 goto err;
         } else {
             if (BIO_printf(bp, "    Cipher    : %04lX\n",
-                           x->cipher_id & 0xffff) <= 0)
+                    x->cipher_id & 0xffff)
+                <= 0)
                 goto err;
         }
     } else {
         if (BIO_printf(bp, "    Cipher    : %s\n",
-                       ((x->cipher->name == NULL) ? "unknown"
-                                                  : x->cipher->name)) <= 0)
+                ((x->cipher->name == NULL) ? "unknown"
+                                           : x->cipher->name))
+            <= 0)
             goto err;
     }
     if (BIO_puts(bp, "    Session-ID: ") <= 0)
@@ -90,8 +93,7 @@ int SSL_SESSION_print(BIO *bp, const SSL_SESSION *x)
         goto err;
     if (BIO_puts(bp, "\n    PSK identity hint: ") <= 0)
         goto err;
-    if (BIO_printf
-        (bp, "%s", x->psk_identity_hint ? x->psk_identity_hint : "None") <= 0)
+    if (BIO_printf(bp, "%s", x->psk_identity_hint ? x->psk_identity_hint : "None") <= 0)
         goto err;
 #endif
 #ifndef OPENSSL_NO_SRP
@@ -102,15 +104,15 @@ int SSL_SESSION_print(BIO *bp, const SSL_SESSION *x)
 #endif
     if (x->ext.tick_lifetime_hint) {
         if (BIO_printf(bp,
-                       "\n    TLS session ticket lifetime hint: %ld (seconds)",
-                       x->ext.tick_lifetime_hint) <= 0)
+                "\n    TLS session ticket lifetime hint: %ld (seconds)",
+                x->ext.tick_lifetime_hint)
+            <= 0)
             goto err;
     }
     if (x->ext.tick) {
         if (BIO_puts(bp, "\n    TLS session ticket:\n") <= 0)
             goto err;
-        if (BIO_dump_indent
-            (bp, (const char *)x->ext.tick, (int)x->ext.ticklen, 4)
+        if (BIO_dump_indent(bp, (const char *)x->ext.tick, (int)x->ext.ticklen, 4)
             <= 0)
             goto err;
     }
@@ -125,19 +127,22 @@ int SSL_SESSION_print(BIO *bp, const SSL_SESSION *x)
                 goto err;
         } else {
             if (BIO_printf(bp, "\n    Compression: %d (%s)", comp->id,
-                           comp->name) <= 0)
+                    comp->name)
+                <= 0)
                 goto err;
         }
     }
 #endif
     if (!ossl_time_is_zero(x->time)) {
         if (BIO_printf(bp, "\n    Start Time: %lld",
-                       (long long)ossl_time_to_time_t(x->time)) <= 0)
+                (long long)ossl_time_to_time_t(x->time))
+            <= 0)
             goto err;
     }
     if (!ossl_time_is_zero(x->timeout)) {
         if (BIO_printf(bp, "\n    Timeout   : %lld (sec)",
-                       (long long)ossl_time2seconds(x->timeout)) <= 0)
+                (long long)ossl_time2seconds(x->timeout))
+            <= 0)
             goto err;
     }
     if (BIO_puts(bp, "\n") <= 0)
@@ -146,21 +151,24 @@ int SSL_SESSION_print(BIO *bp, const SSL_SESSION *x)
     if (BIO_puts(bp, "    Verify return code: ") <= 0)
         goto err;
     if (BIO_printf(bp, "%ld (%s)\n", x->verify_result,
-                   X509_verify_cert_error_string(x->verify_result)) <= 0)
+            X509_verify_cert_error_string(x->verify_result))
+        <= 0)
         goto err;
 
     if (BIO_printf(bp, "    Extended master secret: %s\n",
-                   x->flags & SSL_SESS_FLAG_EXTMS ? "yes" : "no") <= 0)
+            x->flags & SSL_SESS_FLAG_EXTMS ? "yes" : "no")
+        <= 0)
         goto err;
 
     if (istls13) {
         if (BIO_printf(bp, "    Max Early Data: %u\n",
-                       (unsigned int)x->ext.max_early_data) <= 0)
+                (unsigned int)x->ext.max_early_data)
+            <= 0)
             goto err;
     }
 
     return 1;
- err:
+err:
     return 0;
 }
 
@@ -201,6 +209,6 @@ int SSL_SESSION_print_keylog(BIO *bp, const SSL_SESSION *x)
         goto err;
 
     return 1;
- err:
+err:
     return 0;
 }
diff --git a/crypto/openssl/ssl/statem/extensions.c b/crypto/openssl/ssl/statem/extensions.c
index 9811e5c94b93..2de540f828f0 100644
--- a/crypto/openssl/ssl/statem/extensions.c
+++ b/crypto/openssl/ssl/statem/extensions.c
@@ -8,8 +8,8 @@
  */
 
 #if defined(__TANDEM) && defined(_SPT_MODEL_)
-# include <spthread.h>
-# include <spt_extensions.h> /* timeval */
+#include <spthread.h>
+#include <spt_extensions.h> /* timeval */
 #endif
 
 #include <string.h>
@@ -23,7 +23,7 @@ static int final_renegotiate(SSL_CONNECTION *s, unsigned int context, int sent);
 static int init_server_name(SSL_CONNECTION *s, unsigned int context);
 static int final_server_name(SSL_CONNECTION *s, unsigned int context, int sent);
 static int final_ec_pt_formats(SSL_CONNECTION *s, unsigned int context,
-                               int sent);
+    int sent);
 static int init_session_ticket(SSL_CONNECTION *s, unsigned int context);
 #ifndef OPENSSL_NO_OCSP
 static int init_status_request(SSL_CONNECTION *s, unsigned int context);
@@ -38,15 +38,15 @@ static int init_sig_algs(SSL_CONNECTION *s, unsigned int context);
 static int init_server_cert_type(SSL_CONNECTION *sc, unsigned int context);
 static int init_client_cert_type(SSL_CONNECTION *sc, unsigned int context);
 static int init_certificate_authorities(SSL_CONNECTION *s,
-                                        unsigned int context);
+    unsigned int context);
 static EXT_RETURN tls_construct_certificate_authorities(SSL_CONNECTION *s,
-                                                        WPACKET *pkt,
-                                                        unsigned int context,
-                                                        X509 *x,
-                                                        size_t chainidx);
+    WPACKET *pkt,
+    unsigned int context,
+    X509 *x,
+    size_t chainidx);
 static int tls_parse_certificate_authorities(SSL_CONNECTION *s, PACKET *pkt,
-                                             unsigned int context, X509 *x,
-                                             size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 #ifndef OPENSSL_NO_SRP
 static int init_srp(SSL_CONNECTION *s, unsigned int context);
 #endif
@@ -61,19 +61,19 @@ static int init_srtp(SSL_CONNECTION *s, unsigned int context);
 #endif
 static int final_sig_algs(SSL_CONNECTION *s, unsigned int context, int sent);
 static int final_supported_versions(SSL_CONNECTION *s, unsigned int context,
-                                    int sent);
+    int sent);
 static int final_early_data(SSL_CONNECTION *s, unsigned int context, int sent);
 static int final_maxfragmentlen(SSL_CONNECTION *s, unsigned int context,
-                                int sent);
+    int sent);
 static int init_post_handshake_auth(SSL_CONNECTION *s, unsigned int context);
 static int final_psk(SSL_CONNECTION *s, unsigned int context, int sent);
 static int tls_init_compress_certificate(SSL_CONNECTION *sc, unsigned int context);
 static EXT_RETURN tls_construct_compress_certificate(SSL_CONNECTION *sc, WPACKET *pkt,
-                                                     unsigned int context,
-                                                     X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 static int tls_parse_compress_certificate(SSL_CONNECTION *sc, PACKET *pkt,
-                                          unsigned int context,
-                                          X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 
 /* Structure to define a built-in extension */
 typedef struct extensions_definition_st {
@@ -91,18 +91,18 @@ typedef struct extensions_definition_st {
     int (*init)(SSL_CONNECTION *s, unsigned int context);
     /* Parse extension sent from client to server */
     int (*parse_ctos)(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                      X509 *x, size_t chainidx);
+        X509 *x, size_t chainidx);
     /* Parse extension send from server to client */
     int (*parse_stoc)(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                      X509 *x, size_t chainidx);
+        X509 *x, size_t chainidx);
     /* Construct extension sent from server to client */
     EXT_RETURN (*construct_stoc)(SSL_CONNECTION *s, WPACKET *pkt,
-                                 unsigned int context,
-                                 X509 *x, size_t chainidx);
+        unsigned int context,
+        X509 *x, size_t chainidx);
     /* Construct extension sent from client to server */
     EXT_RETURN (*construct_ctos)(SSL_CONNECTION *s, WPACKET *pkt,
-                                 unsigned int context,
-                                 X509 *x, size_t chainidx);
+        unsigned int context,
+        X509 *x, size_t chainidx);
     /*
      * Finalise extension after parsing. Always called where an extensions was
      * initialised even if the extension was not present. |sent| is set to 1 if
@@ -140,296 +140,246 @@ typedef struct extensions_definition_st {
  */
 #define INVALID_EXTENSION { TLSEXT_TYPE_invalid, 0, NULL, NULL, NULL, NULL, NULL, NULL }
 static const EXTENSION_DEFINITION ext_defs[] = {
-    {
-        TLSEXT_TYPE_renegotiate,
+    { TLSEXT_TYPE_renegotiate,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
-        | SSL_EXT_SSL3_ALLOWED | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
+            | SSL_EXT_SSL3_ALLOWED | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
         NULL, tls_parse_ctos_renegotiate, tls_parse_stoc_renegotiate,
         tls_construct_stoc_renegotiate, tls_construct_ctos_renegotiate,
-        final_renegotiate
-    },
-    {
-        TLSEXT_TYPE_server_name,
+        final_renegotiate },
+    { TLSEXT_TYPE_server_name,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
-        | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
+            | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
         init_server_name,
         tls_parse_ctos_server_name, tls_parse_stoc_server_name,
         tls_construct_stoc_server_name, tls_construct_ctos_server_name,
-        final_server_name
-    },
-    {
-        TLSEXT_TYPE_max_fragment_length,
+        final_server_name },
+    { TLSEXT_TYPE_max_fragment_length,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
-        | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
+            | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
         NULL, tls_parse_ctos_maxfragmentlen, tls_parse_stoc_maxfragmentlen,
         tls_construct_stoc_maxfragmentlen, tls_construct_ctos_maxfragmentlen,
-        final_maxfragmentlen
-    },
+        final_maxfragmentlen },
 #ifndef OPENSSL_NO_SRP
-    {
-        TLSEXT_TYPE_srp,
+    { TLSEXT_TYPE_srp,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
-        init_srp, tls_parse_ctos_srp, NULL, NULL, tls_construct_ctos_srp, NULL
-    },
+        init_srp, tls_parse_ctos_srp, NULL, NULL, tls_construct_ctos_srp, NULL },
 #else
     INVALID_EXTENSION,
 #endif
-    {
-        TLSEXT_TYPE_ec_point_formats,
+    { TLSEXT_TYPE_ec_point_formats,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
-        | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
+            | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
         init_ec_point_formats, tls_parse_ctos_ec_pt_formats, tls_parse_stoc_ec_pt_formats,
         tls_construct_stoc_ec_pt_formats, tls_construct_ctos_ec_pt_formats,
-        final_ec_pt_formats
-    },
-    {
-        /*
-         * "supported_groups" is spread across several specifications.
-         * It was originally specified as "elliptic_curves" in RFC 4492,
-         * and broadened to include named FFDH groups by RFC 7919.
-         * Both RFCs 4492 and 7919 do not include a provision for the server
-         * to indicate to the client the complete list of groups supported
-         * by the server, with the server instead just indicating the
-         * selected group for this connection in the ServerKeyExchange
-         * message.  TLS 1.3 adds a scheme for the server to indicate
-         * to the client its list of supported groups in the
-         * EncryptedExtensions message, but none of the relevant
-         * specifications permit sending supported_groups in the ServerHello.
-         * Nonetheless (possibly due to the close proximity to the
-         * "ec_point_formats" extension, which is allowed in the ServerHello),
-         * there are several servers that send this extension in the
-         * ServerHello anyway.  Up to and including the 1.1.0 release,
-         * we did not check for the presence of nonpermitted extensions,
-         * so to avoid a regression, we must permit this extension in the
-         * TLS 1.2 ServerHello as well.
-         *
-         * Note that there is no tls_parse_stoc_supported_groups function,
-         * so we do not perform any additional parsing, validation, or
-         * processing on the server's group list -- this is just a minimal
-         * change to preserve compatibility with these misbehaving servers.
-         */
+        final_ec_pt_formats },
+    { /*
+       * "supported_groups" is spread across several specifications.
+       * It was originally specified as "elliptic_curves" in RFC 4492,
+       * and broadened to include named FFDH groups by RFC 7919.
+       * Both RFCs 4492 and 7919 do not include a provision for the server
+       * to indicate to the client the complete list of groups supported
+       * by the server, with the server instead just indicating the
+       * selected group for this connection in the ServerKeyExchange
+       * message.  TLS 1.3 adds a scheme for the server to indicate
+       * to the client its list of supported groups in the
+       * EncryptedExtensions message, but none of the relevant
+       * specifications permit sending supported_groups in the ServerHello.
+       * Nonetheless (possibly due to the close proximity to the
+       * "ec_point_formats" extension, which is allowed in the ServerHello),
+       * there are several servers that send this extension in the
+       * ServerHello anyway.  Up to and including the 1.1.0 release,
+       * we did not check for the presence of nonpermitted extensions,
+       * so to avoid a regression, we must permit this extension in the
+       * TLS 1.2 ServerHello as well.
+       *
+       * Note that there is no tls_parse_stoc_supported_groups function,
+       * so we do not perform any additional parsing, validation, or
+       * processing on the server's group list -- this is just a minimal
+       * change to preserve compatibility with these misbehaving servers.
+       */
         TLSEXT_TYPE_supported_groups,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
-        | SSL_EXT_TLS1_2_SERVER_HELLO,
+            | SSL_EXT_TLS1_2_SERVER_HELLO,
         NULL, tls_parse_ctos_supported_groups, NULL,
         tls_construct_stoc_supported_groups,
-        tls_construct_ctos_supported_groups, NULL
-    },
-    {
-        TLSEXT_TYPE_session_ticket,
+        tls_construct_ctos_supported_groups, NULL },
+    { TLSEXT_TYPE_session_ticket,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
-        | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
+            | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
         init_session_ticket, tls_parse_ctos_session_ticket,
         tls_parse_stoc_session_ticket, tls_construct_stoc_session_ticket,
-        tls_construct_ctos_session_ticket, NULL
-    },
+        tls_construct_ctos_session_ticket, NULL },
 #ifndef OPENSSL_NO_OCSP
-    {
-        TLSEXT_TYPE_status_request,
+    { TLSEXT_TYPE_status_request,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
-        | SSL_EXT_TLS1_3_CERTIFICATE | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
+            | SSL_EXT_TLS1_3_CERTIFICATE | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
         init_status_request, tls_parse_ctos_status_request,
         tls_parse_stoc_status_request, tls_construct_stoc_status_request,
-        tls_construct_ctos_status_request, NULL
-    },
+        tls_construct_ctos_status_request, NULL },
 #else
     INVALID_EXTENSION,
 #endif
 #ifndef OPENSSL_NO_NEXTPROTONEG
-    {
-        TLSEXT_TYPE_next_proto_neg,
+    { TLSEXT_TYPE_next_proto_neg,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
-        | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
+            | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
         init_npn, tls_parse_ctos_npn, tls_parse_stoc_npn,
-        tls_construct_stoc_next_proto_neg, tls_construct_ctos_npn, NULL
-    },
+        tls_construct_stoc_next_proto_neg, tls_construct_ctos_npn, NULL },
 #else
     INVALID_EXTENSION,
 #endif
-    {
-        /*
-         * Must appear in this list after server_name so that finalisation
-         * happens after server_name callbacks
-         */
+    { /*
+       * Must appear in this list after server_name so that finalisation
+       * happens after server_name callbacks
+       */
         TLSEXT_TYPE_application_layer_protocol_negotiation,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
-        | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
+            | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
         init_alpn, tls_parse_ctos_alpn, tls_parse_stoc_alpn,
-        tls_construct_stoc_alpn, tls_construct_ctos_alpn, final_alpn
-    },
+        tls_construct_stoc_alpn, tls_construct_ctos_alpn, final_alpn },
 #ifndef OPENSSL_NO_SRTP
-    {
-        TLSEXT_TYPE_use_srtp,
+    { TLSEXT_TYPE_use_srtp,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
-        | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS | SSL_EXT_DTLS_ONLY,
+            | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS | SSL_EXT_DTLS_ONLY,
         init_srtp, tls_parse_ctos_use_srtp, tls_parse_stoc_use_srtp,
-        tls_construct_stoc_use_srtp, tls_construct_ctos_use_srtp, NULL
-    },
+        tls_construct_stoc_use_srtp, tls_construct_ctos_use_srtp, NULL },
 #else
     INVALID_EXTENSION,
 #endif
-    {
-        TLSEXT_TYPE_encrypt_then_mac,
+    { TLSEXT_TYPE_encrypt_then_mac,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
-        | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
+            | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
         init_etm, tls_parse_ctos_etm, tls_parse_stoc_etm,
-        tls_construct_stoc_etm, tls_construct_ctos_etm, NULL
-    },
+        tls_construct_stoc_etm, tls_construct_ctos_etm, NULL },
 #ifndef OPENSSL_NO_CT
-    {
-        TLSEXT_TYPE_signed_certificate_timestamp,
+    { TLSEXT_TYPE_signed_certificate_timestamp,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
-        | SSL_EXT_TLS1_3_CERTIFICATE | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
+            | SSL_EXT_TLS1_3_CERTIFICATE | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
         NULL,
         /*
          * No server side support for this, but can be provided by a custom
          * extension. This is an exception to the rule that custom extensions
          * cannot override built in ones.
          */
-        NULL, tls_parse_stoc_sct, NULL, tls_construct_ctos_sct,  NULL
-    },
+        NULL, tls_parse_stoc_sct, NULL, tls_construct_ctos_sct, NULL },
 #else
     INVALID_EXTENSION,
 #endif
-    {
-        TLSEXT_TYPE_extended_master_secret,
+    { TLSEXT_TYPE_extended_master_secret,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
-        | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
+            | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
         init_ems, tls_parse_ctos_ems, tls_parse_stoc_ems,
-        tls_construct_stoc_ems, tls_construct_ctos_ems, final_ems
-    },
-    {
-        TLSEXT_TYPE_signature_algorithms_cert,
+        tls_construct_stoc_ems, tls_construct_ctos_ems, final_ems },
+    { TLSEXT_TYPE_signature_algorithms_cert,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
         init_sig_algs_cert, tls_parse_ctos_sig_algs_cert,
         tls_parse_ctos_sig_algs_cert,
         /* We do not generate signature_algorithms_cert at present. */
-        NULL, NULL, NULL
-    },
+        NULL, NULL, NULL },
     {
         TLSEXT_TYPE_post_handshake_auth,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ONLY,
         init_post_handshake_auth,
-        tls_parse_ctos_post_handshake_auth, NULL,
-        NULL, tls_construct_ctos_post_handshake_auth,
+        tls_parse_ctos_post_handshake_auth,
+        NULL,
+        NULL,
+        tls_construct_ctos_post_handshake_auth,
         NULL,
     },
-    {
-        TLSEXT_TYPE_client_cert_type,
+    { TLSEXT_TYPE_client_cert_type,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
-        | SSL_EXT_TLS1_2_SERVER_HELLO,
+            | SSL_EXT_TLS1_2_SERVER_HELLO,
         init_client_cert_type,
         tls_parse_ctos_client_cert_type, tls_parse_stoc_client_cert_type,
         tls_construct_stoc_client_cert_type, tls_construct_ctos_client_cert_type,
-        NULL
-    },
-    {
-        TLSEXT_TYPE_server_cert_type,
+        NULL },
+    { TLSEXT_TYPE_server_cert_type,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
-        | SSL_EXT_TLS1_2_SERVER_HELLO,
+            | SSL_EXT_TLS1_2_SERVER_HELLO,
         init_server_cert_type,
         tls_parse_ctos_server_cert_type, tls_parse_stoc_server_cert_type,
         tls_construct_stoc_server_cert_type, tls_construct_ctos_server_cert_type,
-        NULL
-    },
-    {
-        TLSEXT_TYPE_signature_algorithms,
+        NULL },
+    { TLSEXT_TYPE_signature_algorithms,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
         init_sig_algs, tls_parse_ctos_sig_algs,
         tls_parse_ctos_sig_algs, tls_construct_ctos_sig_algs,
-        tls_construct_ctos_sig_algs, final_sig_algs
-    },
-    {
-        TLSEXT_TYPE_supported_versions,
+        tls_construct_ctos_sig_algs, final_sig_algs },
+    { TLSEXT_TYPE_supported_versions,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO
-        | SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST | SSL_EXT_TLS_IMPLEMENTATION_ONLY,
+            | SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST | SSL_EXT_TLS_IMPLEMENTATION_ONLY,
         NULL,
         /* Processed inline as part of version selection */
         NULL, tls_parse_stoc_supported_versions,
         tls_construct_stoc_supported_versions,
-        tls_construct_ctos_supported_versions, final_supported_versions
-    },
-    {
-        TLSEXT_TYPE_psk_kex_modes,
+        tls_construct_ctos_supported_versions, final_supported_versions },
+    { TLSEXT_TYPE_psk_kex_modes,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS_IMPLEMENTATION_ONLY
-        | SSL_EXT_TLS1_3_ONLY,
+            | SSL_EXT_TLS1_3_ONLY,
         init_psk_kex_modes, tls_parse_ctos_psk_kex_modes, NULL, NULL,
-        tls_construct_ctos_psk_kex_modes, NULL
-    },
-    {
-        /*
-         * Must be in this list after supported_groups. We need that to have
-         * been parsed before we do this one.
-         */
+        tls_construct_ctos_psk_kex_modes, NULL },
+    { /*
+       * Must be in this list after supported_groups. We need that to have
+       * been parsed before we do this one.
+       */
         TLSEXT_TYPE_key_share,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO
-        | SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST | SSL_EXT_TLS_IMPLEMENTATION_ONLY
-        | SSL_EXT_TLS1_3_ONLY,
+            | SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST | SSL_EXT_TLS_IMPLEMENTATION_ONLY
+            | SSL_EXT_TLS1_3_ONLY,
         NULL, tls_parse_ctos_key_share, tls_parse_stoc_key_share,
         tls_construct_stoc_key_share, tls_construct_ctos_key_share,
-        final_key_share
-    },
-    {
-        /* Must be after key_share */
+        final_key_share },
+    { /* Must be after key_share */
         TLSEXT_TYPE_cookie,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST
-        | SSL_EXT_TLS_IMPLEMENTATION_ONLY | SSL_EXT_TLS1_3_ONLY,
+            | SSL_EXT_TLS_IMPLEMENTATION_ONLY | SSL_EXT_TLS1_3_ONLY,
         NULL, tls_parse_ctos_cookie, tls_parse_stoc_cookie,
-        tls_construct_stoc_cookie, tls_construct_ctos_cookie, NULL
-    },
-    {
-        /*
-         * Special unsolicited ServerHello extension only used when
-         * SSL_OP_CRYPTOPRO_TLSEXT_BUG is set. We allow it in a ClientHello but
-         * ignore it.
-         */
+        tls_construct_stoc_cookie, tls_construct_ctos_cookie, NULL },
+    { /*
+       * Special unsolicited ServerHello extension only used when
+       * SSL_OP_CRYPTOPRO_TLSEXT_BUG is set. We allow it in a ClientHello but
+       * ignore it.
+       */
         TLSEXT_TYPE_cryptopro_bug,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
-        | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
-        NULL, NULL, NULL, tls_construct_stoc_cryptopro_bug, NULL, NULL
-    },
-    {
-        TLSEXT_TYPE_compress_certificate,
+            | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
+        NULL, NULL, NULL, tls_construct_stoc_cryptopro_bug, NULL, NULL },
+    { TLSEXT_TYPE_compress_certificate,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST
-        | SSL_EXT_TLS_IMPLEMENTATION_ONLY | SSL_EXT_TLS1_3_ONLY,
+            | SSL_EXT_TLS_IMPLEMENTATION_ONLY | SSL_EXT_TLS1_3_ONLY,
         tls_init_compress_certificate,
         tls_parse_compress_certificate, tls_parse_compress_certificate,
         tls_construct_compress_certificate, tls_construct_compress_certificate,
-        NULL
-    },
-    {
-        TLSEXT_TYPE_early_data,
+        NULL },
+    { TLSEXT_TYPE_early_data,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
-        | SSL_EXT_TLS1_3_NEW_SESSION_TICKET | SSL_EXT_TLS1_3_ONLY,
+            | SSL_EXT_TLS1_3_NEW_SESSION_TICKET | SSL_EXT_TLS1_3_ONLY,
         NULL, tls_parse_ctos_early_data, tls_parse_stoc_early_data,
         tls_construct_stoc_early_data, tls_construct_ctos_early_data,
-        final_early_data
-    },
+        final_early_data },
     {
         TLSEXT_TYPE_certificate_authorities,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST
-        | SSL_EXT_TLS1_3_ONLY,
+            | SSL_EXT_TLS1_3_ONLY,
         init_certificate_authorities,
-        tls_parse_certificate_authorities, tls_parse_certificate_authorities,
+        tls_parse_certificate_authorities,
+        tls_parse_certificate_authorities,
+        tls_construct_certificate_authorities,
         tls_construct_certificate_authorities,
-        tls_construct_certificate_authorities, NULL,
+        NULL,
     },
-    {
-        /* Must be immediately before pre_shared_key */
+    { /* Must be immediately before pre_shared_key */
         TLSEXT_TYPE_padding,
         SSL_EXT_CLIENT_HELLO,
         NULL,
         /* We send this, but don't read it */
-        NULL, NULL, NULL, tls_construct_ctos_padding, NULL
-    },
-    {
-        /* Required by the TLSv1.3 spec to always be the last extension */
+        NULL, NULL, NULL, tls_construct_ctos_padding, NULL },
+    { /* Required by the TLSv1.3 spec to always be the last extension */
         TLSEXT_TYPE_psk,
         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO
-        | SSL_EXT_TLS_IMPLEMENTATION_ONLY | SSL_EXT_TLS1_3_ONLY,
+            | SSL_EXT_TLS_IMPLEMENTATION_ONLY | SSL_EXT_TLS1_3_ONLY,
         NULL, tls_parse_ctos_psk, tls_parse_stoc_psk, tls_construct_stoc_psk,
-        tls_construct_ctos_psk, final_psk
-    }
+        tls_construct_ctos_psk, final_psk }
 };
 
 /* Returns a TLSEXT_TYPE for the given index */
@@ -445,7 +395,7 @@ unsigned int ossl_get_extension_type(size_t idx)
 
 /* Check whether an extension's context matches the current context */
 static int validate_context(SSL_CONNECTION *s, unsigned int extctx,
-                            unsigned int thisctx)
+    unsigned int thisctx)
 {
     /* Check we're allowed to use this extension in this context */
     if ((thisctx & extctx) == 0)
@@ -462,7 +412,7 @@ static int validate_context(SSL_CONNECTION *s, unsigned int extctx,
 }
 
 int tls_validate_all_contexts(SSL_CONNECTION *s, unsigned int thisctx,
-                              RAW_EXTENSION *exts)
+    RAW_EXTENSION *exts)
 {
     size_t i, num_exts, builtin_num = OSSL_NELEM(ext_defs), offset;
     RAW_EXTENSION *thisext;
@@ -487,7 +437,7 @@ int tls_validate_all_contexts(SSL_CONNECTION *s, unsigned int thisctx,
             custom_ext_method *meth = NULL;
 
             meth = custom_ext_find(&s->cert->custext, role, thisext->type,
-                                   &offset);
+                &offset);
             if (!ossl_assert(meth != NULL))
                 return 0;
             context = meth->context;
@@ -507,8 +457,8 @@ int tls_validate_all_contexts(SSL_CONNECTION *s, unsigned int thisctx,
  * the definition for the extension we found.
  */
 static int verify_extension(SSL_CONNECTION *s, unsigned int context,
-                            unsigned int type, custom_ext_methods *meths,
-                            RAW_EXTENSION *rawexlist, RAW_EXTENSION **found)
+    unsigned int type, custom_ext_methods *meths,
+    RAW_EXTENSION *rawexlist, RAW_EXTENSION **found)
 {
     size_t i;
     size_t builtin_num = OSSL_NELEM(ext_defs);
@@ -555,7 +505,7 @@ static int verify_extension(SSL_CONNECTION *s, unsigned int context,
  * 1 if the extension is relevant for this context, and 0 otherwise
  */
 int extension_is_relevant(SSL_CONNECTION *s, unsigned int extctx,
-                          unsigned int thisctx)
+    unsigned int thisctx)
 {
     int is_tls13;
 
@@ -569,22 +519,22 @@ int extension_is_relevant(SSL_CONNECTION *s, unsigned int extctx,
         is_tls13 = SSL_CONNECTION_IS_TLS13(s);
 
     if ((SSL_CONNECTION_IS_DTLS(s)
-                && (extctx & SSL_EXT_TLS_IMPLEMENTATION_ONLY) != 0)
-            || (s->version == SSL3_VERSION
-                    && (extctx & SSL_EXT_SSL3_ALLOWED) == 0)
-            /*
-             * Note that SSL_IS_TLS13() means "TLS 1.3 has been negotiated",
-             * which is never true when generating the ClientHello.
-             * However, version negotiation *has* occurred by the time the
-             * ClientHello extensions are being parsed.
-             * Be careful to allow TLS 1.3-only extensions when generating
-             * the ClientHello.
-             */
-            || (is_tls13 && (extctx & SSL_EXT_TLS1_2_AND_BELOW_ONLY) != 0)
-            || (!is_tls13 && (extctx & SSL_EXT_TLS1_3_ONLY) != 0
-                && (thisctx & SSL_EXT_CLIENT_HELLO) == 0)
-            || (s->server && !is_tls13 && (extctx & SSL_EXT_TLS1_3_ONLY) != 0)
-            || (s->hit && (extctx & SSL_EXT_IGNORE_ON_RESUMPTION) != 0))
+            && (extctx & SSL_EXT_TLS_IMPLEMENTATION_ONLY) != 0)
+        || (s->version == SSL3_VERSION
+            && (extctx & SSL_EXT_SSL3_ALLOWED) == 0)
+        /*
+         * Note that SSL_IS_TLS13() means "TLS 1.3 has been negotiated",
+         * which is never true when generating the ClientHello.
+         * However, version negotiation *has* occurred by the time the
+         * ClientHello extensions are being parsed.
+         * Be careful to allow TLS 1.3-only extensions when generating
+         * the ClientHello.
+         */
+        || (is_tls13 && (extctx & SSL_EXT_TLS1_2_AND_BELOW_ONLY) != 0)
+        || (!is_tls13 && (extctx & SSL_EXT_TLS1_3_ONLY) != 0
+            && (thisctx & SSL_EXT_CLIENT_HELLO) == 0)
+        || (s->server && !is_tls13 && (extctx & SSL_EXT_TLS1_3_ONLY) != 0)
+        || (s->hit && (extctx & SSL_EXT_IGNORE_ON_RESUMPTION) != 0))
         return 0;
     return 1;
 }
@@ -606,8 +556,8 @@ int extension_is_relevant(SSL_CONNECTION *s, unsigned int extctx,
  * extensions that we know about. We ignore others.
  */
 int tls_collect_extensions(SSL_CONNECTION *s, PACKET *packet,
-                           unsigned int context,
-                           RAW_EXTENSION **res, size_t *len, int init)
+    unsigned int context,
+    RAW_EXTENSION **res, size_t *len, int init)
 {
     PACKET extensions = *packet;
     size_t i = 0;
@@ -638,8 +588,7 @@ int tls_collect_extensions(SSL_CONNECTION *s, PACKET *packet,
         PACKET extension;
         RAW_EXTENSION *thisex;
 
-        if (!PACKET_get_net_2(&extensions, &type) ||
-            !PACKET_get_length_prefixed_2(&extensions, &extension)) {
+        if (!PACKET_get_net_2(&extensions, &type) || !PACKET_get_length_prefixed_2(&extensions, &extension)) {
             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
             goto err;
         }
@@ -649,10 +598,10 @@ int tls_collect_extensions(SSL_CONNECTION *s, PACKET *packet,
          * PSK extension, which must be the last one in the ClientHello.
          */
         if (!verify_extension(s, context, type, exts, raw_extensions, &thisex)
-                || (thisex != NULL && thisex->present == 1)
-                || (type == TLSEXT_TYPE_psk
-                    && (context & SSL_EXT_CLIENT_HELLO) != 0
-                    && PACKET_remaining(&extensions) != 0)) {
+            || (thisex != NULL && thisex->present == 1)
+            || (type == TLSEXT_TYPE_psk
+                && (context & SSL_EXT_CLIENT_HELLO) != 0
+                && PACKET_remaining(&extensions) != 0)) {
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_EXTENSION);
             goto err;
         }
@@ -672,20 +621,18 @@ int tls_collect_extensions(SSL_CONNECTION *s, PACKET *packet,
          * itself handle unsolicited response checks.
          */
         if (idx < OSSL_NELEM(ext_defs)
-                && (context & (SSL_EXT_CLIENT_HELLO
-                               | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST
-                               | SSL_EXT_TLS1_3_NEW_SESSION_TICKET)) == 0
-                && type != TLSEXT_TYPE_cookie
-                && type != TLSEXT_TYPE_renegotiate
-                && type != TLSEXT_TYPE_signed_certificate_timestamp
-                && (s->ext.extflags[idx] & SSL_EXT_FLAG_SENT) == 0
+            && (context & (SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST | SSL_EXT_TLS1_3_NEW_SESSION_TICKET)) == 0
+            && type != TLSEXT_TYPE_cookie
+            && type != TLSEXT_TYPE_renegotiate
+            && type != TLSEXT_TYPE_signed_certificate_timestamp
+            && (s->ext.extflags[idx] & SSL_EXT_FLAG_SENT) == 0
 #ifndef OPENSSL_NO_GOST
-                && !((context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0
-                     && type == TLSEXT_TYPE_cryptopro_bug)
+            && !((context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0
+                && type == TLSEXT_TYPE_cryptopro_bug)
 #endif
-                                                                ) {
+        ) {
             SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION,
-                     SSL_R_UNSOLICITED_EXTENSION);
+                SSL_R_UNSOLICITED_EXTENSION);
             goto err;
         }
         if (thisex != NULL) {
@@ -695,9 +642,9 @@ int tls_collect_extensions(SSL_CONNECTION *s, PACKET *packet,
             thisex->received_order = i++;
             if (s->ext.debug_cb)
                 s->ext.debug_cb(SSL_CONNECTION_GET_USER_SSL(s), !s->server,
-                                thisex->type, PACKET_data(&thisex->data),
-                                PACKET_remaining(&thisex->data),
-                                s->ext.debug_arg);
+                    thisex->type, PACKET_data(&thisex->data),
+                    PACKET_remaining(&thisex->data),
+                    s->ext.debug_arg);
         }
     }
 
@@ -707,7 +654,7 @@ int tls_collect_extensions(SSL_CONNECTION *s, PACKET *packet,
          * whether we have found them or not
          */
         for (thisexd = ext_defs, i = 0; i < OSSL_NELEM(ext_defs);
-             i++, thisexd++) {
+            i++, thisexd++) {
             if (thisexd->init != NULL && (thisexd->context & context) != 0
                 && extension_is_relevant(s, thisexd->context, context)
                 && !thisexd->init(s, context)) {
@@ -722,7 +669,7 @@ int tls_collect_extensions(SSL_CONNECTION *s, PACKET *packet,
         *len = num_exts;
     return 1;
 
- err:
+err:
     OPENSSL_free(raw_extensions);
     return 0;
 }
@@ -738,11 +685,12 @@ int tls_collect_extensions(SSL_CONNECTION *s, PACKET *packet,
  * present this counted as success.
  */
 int tls_parse_extension(SSL_CONNECTION *s, TLSEXT_INDEX idx, int context,
-                        RAW_EXTENSION *exts, X509 *x, size_t chainidx)
+    RAW_EXTENSION *exts, X509 *x, size_t chainidx)
 {
     RAW_EXTENSION *currext = &exts[idx];
     int (*parser)(SSL_CONNECTION *s, PACKET *pkt, unsigned int context, X509 *x,
-                  size_t chainidx) = NULL;
+        size_t chainidx)
+        = NULL;
 
     /* Skip if the extension is not present */
     if (!currext->present)
@@ -775,9 +723,9 @@ int tls_parse_extension(SSL_CONNECTION *s, TLSEXT_INDEX idx, int context,
 
     /* Parse custom extensions */
     return custom_ext_parse(s, context, currext->type,
-                            PACKET_data(&currext->data),
-                            PACKET_remaining(&currext->data),
-                            x, chainidx);
+        PACKET_data(&currext->data),
+        PACKET_remaining(&currext->data),
+        x, chainidx);
 }
 
 /*
@@ -788,8 +736,8 @@ int tls_parse_extension(SSL_CONNECTION *s, TLSEXT_INDEX idx, int context,
  * its position in the |chainidx|, with 0 being the first certificate.
  */
 int tls_parse_all_extensions(SSL_CONNECTION *s, int context,
-                             RAW_EXTENSION *exts, X509 *x,
-                             size_t chainidx, int fin)
+    RAW_EXTENSION *exts, X509 *x,
+    size_t chainidx, int fin)
 {
     size_t i, numexts = OSSL_NELEM(ext_defs);
     const EXTENSION_DEFINITION *thisexd;
@@ -811,7 +759,7 @@ int tls_parse_all_extensions(SSL_CONNECTION *s, int context,
          * whether we have found them or not
          */
         for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs);
-             i++, thisexd++) {
+            i++, thisexd++) {
             if (thisexd->final != NULL && (thisexd->context & context) != 0
                 && !thisexd->final(s, context, exts[i].present)) {
                 /* SSLfatal() already called */
@@ -824,7 +772,7 @@ int tls_parse_all_extensions(SSL_CONNECTION *s, int context,
 }
 
 int should_add_extension(SSL_CONNECTION *s, unsigned int extctx,
-                         unsigned int thisctx, int max_version)
+    unsigned int thisctx, int max_version)
 {
     /* Skip if not relevant for our context */
     if ((extctx & thisctx) == 0)
@@ -832,9 +780,9 @@ int should_add_extension(SSL_CONNECTION *s, unsigned int extctx,
 
     /* Check if this extension is defined for our protocol. If not, skip */
     if (!extension_is_relevant(s, extctx, thisctx)
-            || ((extctx & SSL_EXT_TLS1_3_ONLY) != 0
-                && (thisctx & SSL_EXT_CLIENT_HELLO) != 0
-                && (SSL_CONNECTION_IS_DTLS(s) || max_version < TLS1_3_VERSION)))
+        || ((extctx & SSL_EXT_TLS1_3_ONLY) != 0
+            && (thisctx & SSL_EXT_CLIENT_HELLO) != 0
+            && (SSL_CONNECTION_IS_DTLS(s) || max_version < TLS1_3_VERSION)))
         return 0;
 
     return 1;
@@ -849,8 +797,8 @@ int should_add_extension(SSL_CONNECTION *s, unsigned int extctx,
  * failure construction stops at the first extension to fail to construct.
  */
 int tls_construct_extensions(SSL_CONNECTION *s, WPACKET *pkt,
-                             unsigned int context,
-                             X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     size_t i;
     int min_version, max_version = 0, reason;
@@ -858,15 +806,14 @@ int tls_construct_extensions(SSL_CONNECTION *s, WPACKET *pkt,
     int for_comp = (context & SSL_EXT_TLS1_3_CERTIFICATE_COMPRESSION) != 0;
 
     if (!WPACKET_start_sub_packet_u16(pkt)
-               /*
-                * If extensions are of zero length then we don't even add the
-                * extensions length bytes to a ClientHello/ServerHello
-                * (for non-TLSv1.3).
-                */
-            || ((context &
-                 (SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO)) != 0
-                && !WPACKET_set_flags(pkt,
-                                      WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))) {
+        /*
+         * If extensions are of zero length then we don't even add the
+         * extensions length bytes to a ClientHello/ServerHello
+         * (for non-TLSv1.3).
+         */
+        || ((context & (SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO)) != 0
+            && !WPACKET_set_flags(pkt,
+                WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))) {
         if (!for_comp)
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
@@ -893,8 +840,8 @@ int tls_construct_extensions(SSL_CONNECTION *s, WPACKET *pkt,
 
     for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs); i++, thisexd++) {
         EXT_RETURN (*construct)(SSL_CONNECTION *s, WPACKET *pkt,
-                                unsigned int context,
-                                X509 *x, size_t chainidx);
+            unsigned int context,
+            X509 *x, size_t chainidx);
         EXT_RETURN ret;
 
         /* Skip if not relevant for our context */
@@ -913,9 +860,7 @@ int tls_construct_extensions(SSL_CONNECTION *s, WPACKET *pkt,
             return 0;
         }
         if (ret == EXT_RETURN_SENT
-                && (context & (SSL_EXT_CLIENT_HELLO
-                               | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST
-                               | SSL_EXT_TLS1_3_NEW_SESSION_TICKET)) != 0)
+            && (context & (SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST | SSL_EXT_TLS1_3_NEW_SESSION_TICKET)) != 0)
             s->ext.extflags[i] |= SSL_EXT_FLAG_SENT;
     }
 
@@ -943,10 +888,10 @@ static int final_renegotiate(SSL_CONNECTION *s, unsigned int context, int sent)
          * renegotiation
          */
         if (!(s->options & SSL_OP_LEGACY_SERVER_CONNECT)
-                && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
-                && !sent) {
+            && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
+            && !sent) {
             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                     SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
+                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
             return 0;
         }
 
@@ -955,19 +900,18 @@ static int final_renegotiate(SSL_CONNECTION *s, unsigned int context, int sent)
 
     /* Need RI if renegotiating */
     if (s->renegotiate
-            && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
-            && !sent) {
+        && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
+        && !sent) {
         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                 SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
+            SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
         return 0;
     }
 
-
     return 1;
 }
 
 static ossl_inline void ssl_tsan_decr(const SSL_CTX *ctx,
-                                      TSAN_QUALIFIER int *stat)
+    TSAN_QUALIFIER int *stat)
 {
     if (ssl_tsan_lock(ctx)) {
         tsan_decr(stat);
@@ -1003,10 +947,10 @@ static int final_server_name(SSL_CONNECTION *s, unsigned int context, int sent)
 
     if (sctx->ext.servername_cb != NULL)
         ret = sctx->ext.servername_cb(ussl, &altmp,
-                                      sctx->ext.servername_arg);
+            sctx->ext.servername_arg);
     else if (s->session_ctx->ext.servername_cb != NULL)
         ret = s->session_ctx->ext.servername_cb(ussl, &altmp,
-                                                s->session_ctx->ext.servername_arg);
+            s->session_ctx->ext.servername_arg);
 
     /*
      * For servers, propagate the SNI hostname from the temporary
@@ -1034,7 +978,7 @@ static int final_server_name(SSL_CONNECTION *s, unsigned int context, int sent)
      * exceed sess_accept (zero) for the new context.
      */
     if (SSL_IS_FIRST_HANDSHAKE(s) && sctx != s->session_ctx
-            && s->hello_retry_request == SSL_HRR_NONE) {
+        && s->hello_retry_request == SSL_HRR_NONE) {
         ssl_tsan_counter(sctx, &sctx->stats.sess_accept);
         ssl_tsan_decr(s->session_ctx, &s->session_ctx->stats.sess_accept);
     }
@@ -1045,10 +989,10 @@ static int final_server_name(SSL_CONNECTION *s, unsigned int context, int sent)
      * Also, if this is not a resumption, create a new session ID
      */
     if (ret == SSL_TLSEXT_ERR_OK && s->ext.ticket_expected
-            && was_ticket && (SSL_get_options(ssl) & SSL_OP_NO_TICKET) != 0) {
+        && was_ticket && (SSL_get_options(ssl) & SSL_OP_NO_TICKET) != 0) {
         s->ext.ticket_expected = 0;
         if (!s->hit) {
-            SSL_SESSION* ss = SSL_get_session(ssl);
+            SSL_SESSION *ss = SSL_get_session(ssl);
 
             if (ss != NULL) {
                 OPENSSL_free(ss->ext.tick);
@@ -1089,7 +1033,7 @@ static int final_server_name(SSL_CONNECTION *s, unsigned int context, int sent)
 }
 
 static int final_ec_pt_formats(SSL_CONNECTION *s, unsigned int context,
-                               int sent)
+    int sent)
 {
     unsigned long alg_k, alg_a;
 
@@ -1105,10 +1049,10 @@ static int final_ec_pt_formats(SSL_CONNECTION *s, unsigned int context,
      * must contain uncompressed.
      */
     if (s->ext.ecpointformats != NULL
-            && s->ext.ecpointformats_len > 0
-            && s->ext.peer_ecpointformats != NULL
-            && s->ext.peer_ecpointformats_len > 0
-            && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) {
+        && s->ext.ecpointformats_len > 0
+        && s->ext.peer_ecpointformats != NULL
+        && s->ext.peer_ecpointformats_len > 0
+        && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) {
         /* we are using an ECC cipher */
         size_t i;
         unsigned char *list = s->ext.peer_ecpointformats;
@@ -1119,7 +1063,7 @@ static int final_ec_pt_formats(SSL_CONNECTION *s, unsigned int context,
         }
         if (i == s->ext.peer_ecpointformats_len) {
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                     SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
+                SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
             return 0;
         }
     }
@@ -1179,7 +1123,7 @@ static int init_alpn(SSL_CONNECTION *s, unsigned int context)
 static int final_alpn(SSL_CONNECTION *s, unsigned int context, int sent)
 {
     if (!s->server && !sent && s->session->ext.alpn_selected != NULL)
-            s->ext.early_data_ok = 0;
+        s->ext.early_data_ok = 0;
 
     if (!s->server || !SSL_CONNECTION_IS_TLS13(s))
         return 1;
@@ -1207,7 +1151,7 @@ static int init_sig_algs(SSL_CONNECTION *s, unsigned int context)
 }
 
 static int init_sig_algs_cert(SSL_CONNECTION *s,
-                              ossl_unused unsigned int context)
+    ossl_unused unsigned int context)
 {
     /* Clear any signature algorithms extension received */
     OPENSSL_free(s->s3.tmp.peer_cert_sigalgs);
@@ -1269,8 +1213,7 @@ static int final_ems(SSL_CONNECTION *s, unsigned int context, int sent)
          * Check extended master secret extension is consistent with
          * original session.
          */
-        if (!(s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) !=
-            !(s->session->flags & SSL_SESS_FLAG_EXTMS)) {
+        if (!(s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) != !(s->session->flags & SSL_SESS_FLAG_EXTMS)) {
             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_INCONSISTENT_EXTMS);
             return 0;
         }
@@ -1287,10 +1230,10 @@ static int init_certificate_authorities(SSL_CONNECTION *s, unsigned int context)
 }
 
 static EXT_RETURN tls_construct_certificate_authorities(SSL_CONNECTION *s,
-                                                        WPACKET *pkt,
-                                                        unsigned int context,
-                                                        X509 *x,
-                                                        size_t chainidx)
+    WPACKET *pkt,
+    unsigned int context,
+    X509 *x,
+    size_t chainidx)
 {
     const STACK_OF(X509_NAME) *ca_sk = get_ca_names(s);
 
@@ -1317,8 +1260,8 @@ static EXT_RETURN tls_construct_certificate_authorities(SSL_CONNECTION *s,
 }
 
 static int tls_parse_certificate_authorities(SSL_CONNECTION *s, PACKET *pkt,
-                                             unsigned int context, X509 *x,
-                                             size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     if (!parse_ca_names(s, pkt))
         return 0;
@@ -1343,7 +1286,7 @@ static int final_sig_algs(SSL_CONNECTION *s, unsigned int context, int sent)
 {
     if (!sent && SSL_CONNECTION_IS_TLS13(s) && !s->hit) {
         SSLfatal(s, TLS13_AD_MISSING_EXTENSION,
-                 SSL_R_MISSING_SIGALGS_EXTENSION);
+            SSL_R_MISSING_SIGALGS_EXTENSION);
         return 0;
     }
 
@@ -1351,11 +1294,11 @@ static int final_sig_algs(SSL_CONNECTION *s, unsigned int context, int sent)
 }
 
 static int final_supported_versions(SSL_CONNECTION *s, unsigned int context,
-                                    int sent)
+    int sent)
 {
     if (!sent && context == SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) {
         SSLfatal(s, TLS13_AD_MISSING_EXTENSION,
-                 SSL_R_MISSING_SUPPORTED_VERSIONS_EXTENSION);
+            SSL_R_MISSING_SUPPORTED_VERSIONS_EXTENSION);
         return 0;
     }
 
@@ -1384,7 +1327,7 @@ static int final_key_share(SSL_CONNECTION *s, unsigned int context, int sent)
      *     fail;
      */
     if (!s->server
-            && !sent) {
+        && !sent) {
         if ((s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) == 0) {
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_NO_SUITABLE_KEY_SHARE);
             return 0;
@@ -1432,7 +1375,7 @@ static int final_key_share(SSL_CONNECTION *s, unsigned int context, int sent)
         if (s->s3.peer_tmp != NULL) {
             /* We have a suitable key_share */
             if ((s->s3.flags & TLS1_FLAGS_STATELESS) != 0
-                    && !s->ext.cookieok) {
+                && !s->ext.cookieok) {
                 if (!ossl_assert(s->hello_retry_request == SSL_HRR_NONE)) {
                     /*
                      * If we are stateless then we wouldn't know about any
@@ -1448,8 +1391,8 @@ static int final_key_share(SSL_CONNECTION *s, unsigned int context, int sent)
         } else {
             /* No suitable key_share */
             if (s->hello_retry_request == SSL_HRR_NONE && sent
-                    && (!s->hit
-                        || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE_DHE) != 0)) {
+                && (!s->hit
+                    || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE_DHE) != 0)) {
 
                 /* Did we detect group overlap in tls_parse_ctos_key_share ? */
                 if (s->s3.group_id_candidate != 0) {
@@ -1460,16 +1403,15 @@ static int final_key_share(SSL_CONNECTION *s, unsigned int context, int sent)
                 }
             }
             if (!s->hit
-                    || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) == 0) {
+                || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) == 0) {
                 /* Nothing left we can do - just fail */
-                SSLfatal(s, sent ? SSL_AD_HANDSHAKE_FAILURE
-                                 : SSL_AD_MISSING_EXTENSION,
-                         SSL_R_NO_SUITABLE_KEY_SHARE);
+                SSLfatal(s, sent ? SSL_AD_HANDSHAKE_FAILURE : SSL_AD_MISSING_EXTENSION,
+                    SSL_R_NO_SUITABLE_KEY_SHARE);
                 return 0;
             }
 
             if ((s->s3.flags & TLS1_FLAGS_STATELESS) != 0
-                    && !s->ext.cookieok) {
+                && !s->ext.cookieok) {
                 if (!ossl_assert(s->hello_retry_request == SSL_HRR_NONE)) {
                     /*
                      * If we are stateless then we wouldn't know about any
@@ -1512,10 +1454,10 @@ static int init_psk_kex_modes(SSL_CONNECTION *s, unsigned int context)
 }
 
 int tls_psk_do_binder(SSL_CONNECTION *s, const EVP_MD *md,
-                      const unsigned char *msgstart,
-                      size_t binderoffset, const unsigned char *binderin,
-                      unsigned char *binderout, SSL_SESSION *sess, int sign,
-                      int external)
+    const unsigned char *msgstart,
+    size_t binderoffset, const unsigned char *binderin,
+    unsigned char *binderout, SSL_SESSION *sess, int sign,
+    int external)
 {
     EVP_PKEY *mackey = NULL;
     EVP_MD_CTX *mctx = NULL;
@@ -1541,9 +1483,9 @@ int tls_psk_do_binder(SSL_CONNECTION *s, const EVP_MD *md,
     hashsize = (size_t)hashsizei;
 
     if (external
-            && s->early_data_state == SSL_EARLY_DATA_CONNECTING
-            && s->session->ext.max_early_data == 0
-            && sess->ext.max_early_data > 0)
+        && s->early_data_state == SSL_EARLY_DATA_CONNECTING
+        && s->session->ext.max_early_data == 0
+        && sess->ext.max_early_data > 0)
         usepskfored = 1;
 
     if (external) {
@@ -1568,7 +1510,7 @@ int tls_psk_do_binder(SSL_CONNECTION *s, const EVP_MD *md,
         early_secret = (unsigned char *)sess->early_secret;
 
     if (!tls13_generate_secret(s, md, NULL, sess->master_key,
-                               sess->master_key_length, early_secret)) {
+            sess->master_key_length, early_secret)) {
         /* SSLfatal() already called */
         goto err;
     }
@@ -1579,15 +1521,15 @@ int tls_psk_do_binder(SSL_CONNECTION *s, const EVP_MD *md,
      */
     mctx = EVP_MD_CTX_new();
     if (mctx == NULL
-            || EVP_DigestInit_ex(mctx, md, NULL) <= 0
-            || EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) {
+        || EVP_DigestInit_ex(mctx, md, NULL) <= 0
+        || EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
 
     /* Generate the binder key */
     if (!tls13_hkdf_expand(s, md, early_secret, label, labelsize, hash,
-                           hashsize, binderkey, hashsize, 1)) {
+            hashsize, binderkey, hashsize, 1)) {
         /* SSLfatal() already called */
         goto err;
     }
@@ -1613,8 +1555,7 @@ int tls_psk_do_binder(SSL_CONNECTION *s, const EVP_MD *md,
         long hdatalen_l;
         void *hdata;
 
-        hdatalen = hdatalen_l =
-            BIO_get_mem_data(s->s3.handshake_buffer, &hdata);
+        hdatalen = hdatalen_l = BIO_get_mem_data(s->s3.handshake_buffer, &hdata);
         if (hdatalen_l <= 0) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_HANDSHAKE_LENGTH);
             goto err;
@@ -1629,10 +1570,10 @@ int tls_psk_do_binder(SSL_CONNECTION *s, const EVP_MD *md,
 
             /* Find how many bytes are left after the first two messages */
             if (!PACKET_buf_init(&hashprefix, hdata, hdatalen)
-                    || !PACKET_forward(&hashprefix, 1)
-                    || !PACKET_get_length_prefixed_3(&hashprefix, &msg)
-                    || !PACKET_forward(&hashprefix, 1)
-                    || !PACKET_get_length_prefixed_3(&hashprefix, &msg)) {
+                || !PACKET_forward(&hashprefix, 1)
+                || !PACKET_get_length_prefixed_3(&hashprefix, &msg)
+                || !PACKET_forward(&hashprefix, 1)
+                || !PACKET_get_length_prefixed_3(&hashprefix, &msg)) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 goto err;
             }
@@ -1646,14 +1587,14 @@ int tls_psk_do_binder(SSL_CONNECTION *s, const EVP_MD *md,
     }
 
     if (EVP_DigestUpdate(mctx, msgstart, binderoffset) <= 0
-            || EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) {
+        || EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
 
     mackey = EVP_PKEY_new_raw_private_key_ex(sctx->libctx, "HMAC",
-                                             sctx->propq, finishedkey,
-                                             hashsize);
+        sctx->propq, finishedkey,
+        hashsize);
     if (mackey == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
@@ -1664,10 +1605,11 @@ int tls_psk_do_binder(SSL_CONNECTION *s, const EVP_MD *md,
 
     bindersize = hashsize;
     if (EVP_DigestSignInit_ex(mctx, NULL, EVP_MD_get0_name(md), sctx->libctx,
-                              sctx->propq, mackey, NULL) <= 0
-            || EVP_DigestSignUpdate(mctx, hash, hashsize) <= 0
-            || EVP_DigestSignFinal(mctx, binderout, &bindersize) <= 0
-            || bindersize != hashsize) {
+            sctx->propq, mackey, NULL)
+            <= 0
+        || EVP_DigestSignUpdate(mctx, hash, hashsize) <= 0
+        || EVP_DigestSignFinal(mctx, binderout, &bindersize) <= 0
+        || bindersize != hashsize) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
@@ -1681,7 +1623,7 @@ int tls_psk_do_binder(SSL_CONNECTION *s, const EVP_MD *md,
             SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_BINDER_DOES_NOT_VERIFY);
     }
 
- err:
+err:
     OPENSSL_cleanse(binderkey, sizeof(binderkey));
     OPENSSL_cleanse(finishedkey, sizeof(finishedkey));
     EVP_PKEY_free(mackey);
@@ -1697,8 +1639,8 @@ static int final_early_data(SSL_CONNECTION *s, unsigned int context, int sent)
 
     if (!s->server) {
         if (context == SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
-                && sent
-                && !s->ext.early_data_ok) {
+            && sent
+            && !s->ext.early_data_ok) {
             /*
              * If we get here then the server accepted our early_data but we
              * later realised that it shouldn't have done (e.g. inconsistent
@@ -1712,19 +1654,19 @@ static int final_early_data(SSL_CONNECTION *s, unsigned int context, int sent)
     }
 
     if (s->max_early_data == 0
-            || !s->hit
-            || s->early_data_state != SSL_EARLY_DATA_ACCEPTING
-            || !s->ext.early_data_ok
-            || s->hello_retry_request != SSL_HRR_NONE
-            || (s->allow_early_data_cb != NULL
-                && !s->allow_early_data_cb(SSL_CONNECTION_GET_USER_SSL(s),
-                                           s->allow_early_data_cb_data))) {
+        || !s->hit
+        || s->early_data_state != SSL_EARLY_DATA_ACCEPTING
+        || !s->ext.early_data_ok
+        || s->hello_retry_request != SSL_HRR_NONE
+        || (s->allow_early_data_cb != NULL
+            && !s->allow_early_data_cb(SSL_CONNECTION_GET_USER_SSL(s),
+                s->allow_early_data_cb_data))) {
         s->ext.early_data = SSL_EARLY_DATA_REJECTED;
     } else {
         s->ext.early_data = SSL_EARLY_DATA_ACCEPTED;
 
         if (!tls13_change_cipher_state(s,
-                    SSL3_CC_EARLY | SSL3_CHANGE_CIPHER_SERVER_READ)) {
+                SSL3_CC_EARLY | SSL3_CHANGE_CIPHER_SERVER_READ)) {
             /* SSLfatal() already called */
             return 0;
         }
@@ -1734,7 +1676,7 @@ static int final_early_data(SSL_CONNECTION *s, unsigned int context, int sent)
 }
 
 static int final_maxfragmentlen(SSL_CONNECTION *s, unsigned int context,
-                                int sent)
+    int sent)
 {
     if (s->session == NULL)
         return 1;
@@ -1745,16 +1687,16 @@ static int final_maxfragmentlen(SSL_CONNECTION *s, unsigned int context,
 
     if (USE_MAX_FRAGMENT_LENGTH_EXT(s->session)) {
         s->rlayer.rrlmethod->set_max_frag_len(s->rlayer.rrl,
-                                              GET_MAX_FRAGMENT_LENGTH(s->session));
+            GET_MAX_FRAGMENT_LENGTH(s->session));
         s->rlayer.wrlmethod->set_max_frag_len(s->rlayer.wrl,
-                                              ssl_get_max_send_fragment(s));
+            ssl_get_max_send_fragment(s));
     }
 
     return 1;
 }
 
 static int init_post_handshake_auth(SSL_CONNECTION *s,
-                                    ossl_unused unsigned int context)
+    ossl_unused unsigned int context)
 {
     s->post_handshake_auth = SSL_PHA_NONE;
 
@@ -1768,9 +1710,9 @@ static int init_post_handshake_auth(SSL_CONNECTION *s,
 static int final_psk(SSL_CONNECTION *s, unsigned int context, int sent)
 {
     if (s->server && sent && s->clienthello != NULL
-            && !s->clienthello->pre_proc_exts[TLSEXT_IDX_psk_kex_modes].present) {
+        && !s->clienthello->pre_proc_exts[TLSEXT_IDX_psk_kex_modes].present) {
         SSLfatal(s, TLS13_AD_MISSING_EXTENSION,
-                 SSL_R_MISSING_PSK_KEX_MODES_EXTENSION);
+            SSL_R_MISSING_PSK_KEX_MODES_EXTENSION);
         return 0;
     }
 
@@ -1780,14 +1722,14 @@ static int final_psk(SSL_CONNECTION *s, unsigned int context, int sent)
 static int tls_init_compress_certificate(SSL_CONNECTION *sc, unsigned int context)
 {
     memset(sc->ext.compress_certificate_from_peer, 0,
-           sizeof(sc->ext.compress_certificate_from_peer));
+        sizeof(sc->ext.compress_certificate_from_peer));
     return 1;
 }
 
 /* The order these are put into the packet imply a preference order: [brotli, zlib, zstd] */
 static EXT_RETURN tls_construct_compress_certificate(SSL_CONNECTION *sc, WPACKET *pkt,
-                                                     unsigned int context,
-                                                     X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
 #ifndef OPENSSL_NO_COMP_ALG
     int i;
@@ -1815,8 +1757,8 @@ static EXT_RETURN tls_construct_compress_certificate(SSL_CONNECTION *sc, WPACKET
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_compress_certificate)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_start_sub_packet_u8(pkt))
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_start_sub_packet_u8(pkt))
         goto err;
 
     for (i = 0; sc->cert_comp_prefs[i] != TLSEXT_comp_cert_none; i++) {
@@ -1828,7 +1770,7 @@ static EXT_RETURN tls_construct_compress_certificate(SSL_CONNECTION *sc, WPACKET
 
     sc->ext.compress_certificate_sent = 1;
     return EXT_RETURN_SENT;
- err:
+err:
     SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
     return EXT_RETURN_FAIL;
 #else
@@ -1859,7 +1801,7 @@ static int tls_comp_in_pref(SSL_CONNECTION *sc, int alg)
 #endif
 
 int tls_parse_compress_certificate(SSL_CONNECTION *sc, PACKET *pkt, unsigned int context,
-                                   X509 *x, size_t chainidx)
+    X509 *x, size_t chainidx)
 {
 #ifndef OPENSSL_NO_COMP_ALG
     PACKET supported_comp_algs;
@@ -1882,7 +1824,7 @@ int tls_parse_compress_certificate(SSL_CONNECTION *sc, PACKET *pkt, unsigned int
         return 1;
 
     if (!PACKET_as_length_prefixed_1(pkt, &supported_comp_algs)
-            || PACKET_remaining(&supported_comp_algs) == 0) {
+        || PACKET_remaining(&supported_comp_algs) == 0) {
         SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
         return 0;
     }
diff --git a/crypto/openssl/ssl/statem/extensions_clnt.c b/crypto/openssl/ssl/statem/extensions_clnt.c
index d958373875a3..305ca4ab46c9 100644
--- a/crypto/openssl/ssl/statem/extensions_clnt.c
+++ b/crypto/openssl/ssl/statem/extensions_clnt.c
@@ -14,14 +14,14 @@
 #include "statem_local.h"
 
 EXT_RETURN tls_construct_ctos_renegotiate(SSL_CONNECTION *s, WPACKET *pkt,
-                                          unsigned int context, X509 *x,
-                                          size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     if (!s->renegotiate) {
         /* If not renegotiating, send an empty RI extension to indicate support */
 
 #if DTLS_MAX_VERSION_INTERNAL != DTLS1_2_VERSION
-# error Internal DTLS version error
+#error Internal DTLS version error
 #endif
 
         if (!SSL_CONNECTION_IS_DTLS(s)
@@ -35,7 +35,6 @@ EXT_RETURN tls_construct_ctos_renegotiate(SSL_CONNECTION *s, WPACKET *pkt,
             return EXT_RETURN_NOT_SENT;
         }
 
-
         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
             || !WPACKET_start_sub_packet_u16(pkt)
             || !WPACKET_put_bytes_u8(pkt, 0)
@@ -49,10 +48,10 @@ EXT_RETURN tls_construct_ctos_renegotiate(SSL_CONNECTION *s, WPACKET *pkt,
 
     /* Add a complete RI extension if renegotiating */
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_sub_memcpy_u8(pkt, s->s3.previous_client_finished,
-                               s->s3.previous_client_finished_len)
-            || !WPACKET_close(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_sub_memcpy_u8(pkt, s->s3.previous_client_finished,
+            s->s3.previous_client_finished_len)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -61,23 +60,23 @@ EXT_RETURN tls_construct_ctos_renegotiate(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_ctos_server_name(SSL_CONNECTION *s, WPACKET *pkt,
-                                          unsigned int context, X509 *x,
-                                          size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     if (s->ext.hostname == NULL)
         return EXT_RETURN_NOT_SENT;
 
     /* Add TLS extension servername to the Client Hello message */
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
-               /* Sub-packet for server_name extension */
-            || !WPACKET_start_sub_packet_u16(pkt)
-               /* Sub-packet for servername list (always 1 hostname)*/
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_put_bytes_u8(pkt, TLSEXT_NAMETYPE_host_name)
-            || !WPACKET_sub_memcpy_u16(pkt, s->ext.hostname,
-                                       strlen(s->ext.hostname))
-            || !WPACKET_close(pkt)
-            || !WPACKET_close(pkt)) {
+        /* Sub-packet for server_name extension */
+        || !WPACKET_start_sub_packet_u16(pkt)
+        /* Sub-packet for servername list (always 1 hostname)*/
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_put_bytes_u8(pkt, TLSEXT_NAMETYPE_host_name)
+        || !WPACKET_sub_memcpy_u16(pkt, s->ext.hostname,
+            strlen(s->ext.hostname))
+        || !WPACKET_close(pkt)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -87,8 +86,8 @@ EXT_RETURN tls_construct_ctos_server_name(SSL_CONNECTION *s, WPACKET *pkt,
 
 /* Push a Max Fragment Len extension into ClientHello */
 EXT_RETURN tls_construct_ctos_maxfragmentlen(SSL_CONNECTION *s, WPACKET *pkt,
-                                             unsigned int context, X509 *x,
-                                             size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     if (s->ext.max_fragment_len_mode == TLSEXT_max_fragment_length_DISABLED)
         return EXT_RETURN_NOT_SENT;
@@ -99,10 +98,10 @@ EXT_RETURN tls_construct_ctos_maxfragmentlen(SSL_CONNECTION *s, WPACKET *pkt,
      * 1 byte for the Max Fragment Length code value.
      */
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_max_fragment_length)
-            /* Sub-packet for Max Fragment Length extension (1 byte) */
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_put_bytes_u8(pkt, s->ext.max_fragment_len_mode)
-            || !WPACKET_close(pkt)) {
+        /* Sub-packet for Max Fragment Length extension (1 byte) */
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_put_bytes_u8(pkt, s->ext.max_fragment_len_mode)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -112,23 +111,23 @@ EXT_RETURN tls_construct_ctos_maxfragmentlen(SSL_CONNECTION *s, WPACKET *pkt,
 
 #ifndef OPENSSL_NO_SRP
 EXT_RETURN tls_construct_ctos_srp(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     /* Add SRP username if there is one */
     if (s->srp_ctx.login == NULL)
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_srp)
-               /* Sub-packet for SRP extension */
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_start_sub_packet_u8(pkt)
-               /* login must not be zero...internal error if so */
-            || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
-            || !WPACKET_memcpy(pkt, s->srp_ctx.login,
-                               strlen(s->srp_ctx.login))
-            || !WPACKET_close(pkt)
-            || !WPACKET_close(pkt)) {
+        /* Sub-packet for SRP extension */
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_start_sub_packet_u8(pkt)
+        /* login must not be zero...internal error if so */
+        || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
+        || !WPACKET_memcpy(pkt, s->srp_ctx.login,
+            strlen(s->srp_ctx.login))
+        || !WPACKET_close(pkt)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -158,8 +157,8 @@ static int use_ecc(SSL_CONNECTION *s, int min_version, int max_version)
         alg_k = c->algorithm_mkey;
         alg_a = c->algorithm_auth;
         if ((alg_k & (SSL_kECDHE | SSL_kECDHEPSK))
-                || (alg_a & SSL_aECDSA)
-                || c->min_tls >= TLS1_3_VERSION) {
+            || (alg_a & SSL_aECDSA)
+            || c->min_tls >= TLS1_3_VERSION) {
             ret = 1;
             break;
         }
@@ -174,7 +173,7 @@ static int use_ecc(SSL_CONNECTION *s, int min_version, int max_version)
         uint16_t ctmp = pgroups[j];
 
         if (tls_valid_group(s, ctmp, min_version, max_version, 1, NULL)
-                && tls_group_allowed(s, ctmp, SSL_SECOP_CURVE_SUPPORTED))
+            && tls_group_allowed(s, ctmp, SSL_SECOP_CURVE_SUPPORTED))
             return 1;
     }
 
@@ -182,8 +181,8 @@ static int use_ecc(SSL_CONNECTION *s, int min_version, int max_version)
 }
 
 EXT_RETURN tls_construct_ctos_ec_pt_formats(SSL_CONNECTION *s, WPACKET *pkt,
-                                            unsigned int context, X509 *x,
-                                            size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     const unsigned char *pformats;
     size_t num_formats;
@@ -201,10 +200,10 @@ EXT_RETURN tls_construct_ctos_ec_pt_formats(SSL_CONNECTION *s, WPACKET *pkt,
     tls1_get_formatlist(s, &pformats, &num_formats);
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
-               /* Sub-packet for formats extension */
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_sub_memcpy_u8(pkt, pformats, num_formats)
-            || !WPACKET_close(pkt)) {
+        /* Sub-packet for formats extension */
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_sub_memcpy_u8(pkt, pformats, num_formats)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -213,8 +212,8 @@ EXT_RETURN tls_construct_ctos_ec_pt_formats(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_ctos_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
-                                               unsigned int context, X509 *x,
-                                               size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     const uint16_t *pgroups = NULL;
     size_t num_groups = 0, i, tls13added = 0, added = 0;
@@ -231,7 +230,7 @@ EXT_RETURN tls_construct_ctos_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
      * if we don't have EC support then we don't send this extension.
      */
     if (!use_ecc(s, min_version, max_version)
-            && (SSL_CONNECTION_IS_DTLS(s) || max_version < TLS1_3_VERSION))
+        && (SSL_CONNECTION_IS_DTLS(s) || max_version < TLS1_3_VERSION))
         return EXT_RETURN_NOT_SENT;
 
     /*
@@ -240,10 +239,10 @@ EXT_RETURN tls_construct_ctos_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
     tls1_get_supported_groups(s, &pgroups, &num_groups);
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups)
-               /* Sub-packet for supported_groups extension */
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)) {
+        /* Sub-packet for supported_groups extension */
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -253,7 +252,7 @@ EXT_RETURN tls_construct_ctos_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
         int okfortls13;
 
         if (tls_valid_group(s, ctmp, min_version, max_version, 0, &okfortls13)
-                && tls_group_allowed(s, ctmp, SSL_SECOP_CURVE_SUPPORTED)) {
+            && tls_group_allowed(s, ctmp, SSL_SECOP_CURVE_SUPPORTED)) {
             if (!WPACKET_put_bytes_u16(pkt, ctmp)) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 return EXT_RETURN_FAIL;
@@ -266,7 +265,7 @@ EXT_RETURN tls_construct_ctos_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
         if (added == 0)
             SSLfatal_data(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_GROUPS,
-                          "No groups enabled for max supported SSL/TLS version");
+                "No groups enabled for max supported SSL/TLS version");
         else
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
@@ -274,7 +273,7 @@ EXT_RETURN tls_construct_ctos_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
 
     if (tls13added == 0 && max_version == TLS1_3_VERSION) {
         SSLfatal_data(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_GROUPS,
-                      "No groups enabled for max supported SSL/TLS version");
+            "No groups enabled for max supported SSL/TLS version");
         return EXT_RETURN_FAIL;
     }
 
@@ -282,8 +281,8 @@ EXT_RETURN tls_construct_ctos_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_ctos_session_ticket(SSL_CONNECTION *s, WPACKET *pkt,
-                                             unsigned int context, X509 *x,
-                                             size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     size_t ticklen;
 
@@ -291,11 +290,11 @@ EXT_RETURN tls_construct_ctos_session_ticket(SSL_CONNECTION *s, WPACKET *pkt,
         return EXT_RETURN_NOT_SENT;
 
     if (!s->new_session && s->session != NULL
-            && s->session->ext.tick != NULL
-            && s->session->ssl_version != TLS1_3_VERSION) {
+        && s->session->ext.tick != NULL
+        && s->session->ssl_version != TLS1_3_VERSION) {
         ticklen = s->session->ext.ticklen;
     } else if (s->session && s->ext.session_ticket != NULL
-               && s->ext.session_ticket->data != NULL) {
+        && s->ext.session_ticket->data != NULL) {
         ticklen = s->ext.session_ticket->length;
         s->session->ext.tick = OPENSSL_malloc(ticklen);
         if (s->session->ext.tick == NULL) {
@@ -303,18 +302,17 @@ EXT_RETURN tls_construct_ctos_session_ticket(SSL_CONNECTION *s, WPACKET *pkt,
             return EXT_RETURN_FAIL;
         }
         memcpy(s->session->ext.tick,
-               s->ext.session_ticket->data, ticklen);
+            s->ext.session_ticket->data, ticklen);
         s->session->ext.ticklen = ticklen;
     } else {
         ticklen = 0;
     }
 
-    if (ticklen == 0 && s->ext.session_ticket != NULL &&
-            s->ext.session_ticket->data == NULL)
+    if (ticklen == 0 && s->ext.session_ticket != NULL && s->ext.session_ticket->data == NULL)
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
-            || !WPACKET_sub_memcpy_u16(pkt, s->session->ext.tick, ticklen)) {
+        || !WPACKET_sub_memcpy_u16(pkt, s->session->ext.tick, ticklen)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -323,8 +321,8 @@ EXT_RETURN tls_construct_ctos_session_ticket(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_ctos_sig_algs(SSL_CONNECTION *s, WPACKET *pkt,
-                                       unsigned int context, X509 *x,
-                                       size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     size_t salglen;
     const uint16_t *salg;
@@ -338,23 +336,23 @@ EXT_RETURN tls_construct_ctos_sig_algs(SSL_CONNECTION *s, WPACKET *pkt,
         if (s->client_version < TLS1_2_VERSION
             || (s->ssl.method->version != TLS_ANY_VERSION
                 && s->version < TLS1_2_VERSION))
-        return EXT_RETURN_NOT_SENT;
+            return EXT_RETURN_NOT_SENT;
     } else {
         if (DTLS_VERSION_LT(s->client_version, DTLS1_2_VERSION)
             || (s->ssl.method->version != DTLS_ANY_VERSION
                 && DTLS_VERSION_LT(s->version, DTLS1_2_VERSION)))
-        return EXT_RETURN_NOT_SENT;
+            return EXT_RETURN_NOT_SENT;
     }
 
     salglen = tls12_get_psigalgs(s, 1, &salg);
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signature_algorithms)
-               /* Sub-packet for sig-algs extension */
-            || !WPACKET_start_sub_packet_u16(pkt)
-               /* Sub-packet for the actual list */
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !tls12_copy_sigalgs(s, pkt, salg, salglen)
-            || !WPACKET_close(pkt)
-            || !WPACKET_close(pkt)) {
+        /* Sub-packet for sig-algs extension */
+        || !WPACKET_start_sub_packet_u16(pkt)
+        /* Sub-packet for the actual list */
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !tls12_copy_sigalgs(s, pkt, salg, salglen)
+        || !WPACKET_close(pkt)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -364,8 +362,8 @@ EXT_RETURN tls_construct_ctos_sig_algs(SSL_CONNECTION *s, WPACKET *pkt,
 
 #ifndef OPENSSL_NO_OCSP
 EXT_RETURN tls_construct_ctos_status_request(SSL_CONNECTION *s, WPACKET *pkt,
-                                             unsigned int context, X509 *x,
-                                             size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     int i;
 
@@ -377,11 +375,11 @@ EXT_RETURN tls_construct_ctos_status_request(SSL_CONNECTION *s, WPACKET *pkt,
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
-               /* Sub-packet for status request extension */
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_put_bytes_u8(pkt, TLSEXT_STATUSTYPE_ocsp)
-               /* Sub-packet for the ids */
-            || !WPACKET_start_sub_packet_u16(pkt)) {
+        /* Sub-packet for status request extension */
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_put_bytes_u8(pkt, TLSEXT_STATUSTYPE_ocsp)
+        /* Sub-packet for the ids */
+        || !WPACKET_start_sub_packet_u16(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -391,15 +389,15 @@ EXT_RETURN tls_construct_ctos_status_request(SSL_CONNECTION *s, WPACKET *pkt,
         int idlen = i2d_OCSP_RESPID(id, NULL);
 
         if (idlen <= 0
-                   /* Sub-packet for an individual id */
-                || !WPACKET_sub_allocate_bytes_u16(pkt, idlen, &idbytes)
-                || i2d_OCSP_RESPID(id, &idbytes) != idlen) {
+            /* Sub-packet for an individual id */
+            || !WPACKET_sub_allocate_bytes_u16(pkt, idlen, &idbytes)
+            || i2d_OCSP_RESPID(id, &idbytes) != idlen) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return EXT_RETURN_FAIL;
         }
     }
     if (!WPACKET_close(pkt)
-            || !WPACKET_start_sub_packet_u16(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -412,11 +410,11 @@ EXT_RETURN tls_construct_ctos_status_request(SSL_CONNECTION *s, WPACKET *pkt,
             return EXT_RETURN_FAIL;
         }
         if (!WPACKET_allocate_bytes(pkt, extlen, &extbytes)
-                || i2d_X509_EXTENSIONS(s->ext.ocsp.exts, &extbytes)
-                   != extlen) {
+            || i2d_X509_EXTENSIONS(s->ext.ocsp.exts, &extbytes)
+                != extlen) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return EXT_RETURN_FAIL;
-       }
+        }
     }
     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
@@ -429,8 +427,8 @@ EXT_RETURN tls_construct_ctos_status_request(SSL_CONNECTION *s, WPACKET *pkt,
 
 #ifndef OPENSSL_NO_NEXTPROTONEG
 EXT_RETURN tls_construct_ctos_npn(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     if (SSL_CONNECTION_GET_CTX(s)->ext.npn_select_cb == NULL
         || !SSL_IS_FIRST_HANDSHAKE(s))
@@ -441,7 +439,7 @@ EXT_RETURN tls_construct_ctos_npn(SSL_CONNECTION *s, WPACKET *pkt,
      * for Next Protocol Negotiation
      */
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
-            || !WPACKET_put_bytes_u16(pkt, 0)) {
+        || !WPACKET_put_bytes_u16(pkt, 0)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -451,8 +449,8 @@ EXT_RETURN tls_construct_ctos_npn(SSL_CONNECTION *s, WPACKET *pkt,
 #endif
 
 EXT_RETURN tls_construct_ctos_alpn(SSL_CONNECTION *s, WPACKET *pkt,
-                                   unsigned int context,
-                                   X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     s->s3.alpn_sent = 0;
 
@@ -460,11 +458,11 @@ EXT_RETURN tls_construct_ctos_alpn(SSL_CONNECTION *s, WPACKET *pkt,
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt,
-                TLSEXT_TYPE_application_layer_protocol_negotiation)
-               /* Sub-packet ALPN extension */
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_sub_memcpy_u16(pkt, s->ext.alpn, s->ext.alpn_len)
-            || !WPACKET_close(pkt)) {
+            TLSEXT_TYPE_application_layer_protocol_negotiation)
+        /* Sub-packet ALPN extension */
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_sub_memcpy_u16(pkt, s->ext.alpn, s->ext.alpn_len)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -473,11 +471,10 @@ EXT_RETURN tls_construct_ctos_alpn(SSL_CONNECTION *s, WPACKET *pkt,
     return EXT_RETURN_SENT;
 }
 
-
 #ifndef OPENSSL_NO_SRTP
 EXT_RETURN tls_construct_ctos_use_srtp(SSL_CONNECTION *s, WPACKET *pkt,
-                                       unsigned int context, X509 *x,
-                                       size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     SSL *ssl = SSL_CONNECTION_GET_SSL(s);
     STACK_OF(SRTP_PROTECTION_PROFILE) *clnt = SSL_get_srtp_profiles(ssl);
@@ -487,18 +484,17 @@ EXT_RETURN tls_construct_ctos_use_srtp(SSL_CONNECTION *s, WPACKET *pkt,
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
-               /* Sub-packet for SRTP extension */
-            || !WPACKET_start_sub_packet_u16(pkt)
-               /* Sub-packet for the protection profile list */
-            || !WPACKET_start_sub_packet_u16(pkt)) {
+        /* Sub-packet for SRTP extension */
+        || !WPACKET_start_sub_packet_u16(pkt)
+        /* Sub-packet for the protection profile list */
+        || !WPACKET_start_sub_packet_u16(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
 
     end = sk_SRTP_PROTECTION_PROFILE_num(clnt);
     for (i = 0; i < end; i++) {
-        const SRTP_PROTECTION_PROFILE *prof =
-            sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
+        const SRTP_PROTECTION_PROFILE *prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
 
         if (prof == NULL || !WPACKET_put_bytes_u16(pkt, prof->id)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
@@ -506,9 +502,9 @@ EXT_RETURN tls_construct_ctos_use_srtp(SSL_CONNECTION *s, WPACKET *pkt,
         }
     }
     if (!WPACKET_close(pkt)
-               /* Add an empty use_mki value */
-            || !WPACKET_put_bytes_u8(pkt, 0)
-            || !WPACKET_close(pkt)) {
+        /* Add an empty use_mki value */
+        || !WPACKET_put_bytes_u8(pkt, 0)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -518,14 +514,14 @@ EXT_RETURN tls_construct_ctos_use_srtp(SSL_CONNECTION *s, WPACKET *pkt,
 #endif
 
 EXT_RETURN tls_construct_ctos_etm(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     if (s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
-            || !WPACKET_put_bytes_u16(pkt, 0)) {
+        || !WPACKET_put_bytes_u16(pkt, 0)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -535,8 +531,8 @@ EXT_RETURN tls_construct_ctos_etm(SSL_CONNECTION *s, WPACKET *pkt,
 
 #ifndef OPENSSL_NO_CT
 EXT_RETURN tls_construct_ctos_sct(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     if (s->ct_validation_callback == NULL)
         return EXT_RETURN_NOT_SENT;
@@ -546,7 +542,7 @@ EXT_RETURN tls_construct_ctos_sct(SSL_CONNECTION *s, WPACKET *pkt,
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signed_certificate_timestamp)
-            || !WPACKET_put_bytes_u16(pkt, 0)) {
+        || !WPACKET_put_bytes_u16(pkt, 0)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -556,14 +552,14 @@ EXT_RETURN tls_construct_ctos_sct(SSL_CONNECTION *s, WPACKET *pkt,
 #endif
 
 EXT_RETURN tls_construct_ctos_ems(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     if (s->options & SSL_OP_NO_EXTENDED_MASTER_SECRET)
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
-            || !WPACKET_put_bytes_u16(pkt, 0)) {
+        || !WPACKET_put_bytes_u16(pkt, 0)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -572,8 +568,8 @@ EXT_RETURN tls_construct_ctos_ems(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_ctos_supported_versions(SSL_CONNECTION *s, WPACKET *pkt,
-                                                 unsigned int context, X509 *x,
-                                                 size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     int currv, min_version, max_version, reason;
 
@@ -591,8 +587,8 @@ EXT_RETURN tls_construct_ctos_supported_versions(SSL_CONNECTION *s, WPACKET *pkt
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_start_sub_packet_u8(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_start_sub_packet_u8(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -615,19 +611,19 @@ EXT_RETURN tls_construct_ctos_supported_versions(SSL_CONNECTION *s, WPACKET *pkt
  * Construct a psk_kex_modes extension.
  */
 EXT_RETURN tls_construct_ctos_psk_kex_modes(SSL_CONNECTION *s, WPACKET *pkt,
-                                            unsigned int context, X509 *x,
-                                            size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
 #ifndef OPENSSL_NO_TLS1_3
     int nodhe = s->options & SSL_OP_ALLOW_NO_DHE_KEX;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk_kex_modes)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_start_sub_packet_u8(pkt)
-            || !WPACKET_put_bytes_u8(pkt, TLSEXT_KEX_MODE_KE_DHE)
-            || (nodhe && !WPACKET_put_bytes_u8(pkt, TLSEXT_KEX_MODE_KE))
-            || !WPACKET_close(pkt)
-            || !WPACKET_close(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_start_sub_packet_u8(pkt)
+        || !WPACKET_put_bytes_u8(pkt, TLSEXT_KEX_MODE_KE_DHE)
+        || (nodhe && !WPACKET_put_bytes_u8(pkt, TLSEXT_KEX_MODE_KE))
+        || !WPACKET_close(pkt)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -667,7 +663,7 @@ static int add_key_share(SSL_CONNECTION *s, WPACKET *pkt, unsigned int group_id,
 
     /* Encode the public key. */
     encodedlen = EVP_PKEY_get1_encoded_public_key(key_share_key,
-                                                  &encoded_pubkey);
+        &encoded_pubkey);
     if (encodedlen == 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EC_LIB);
         goto err;
@@ -675,7 +671,7 @@ static int add_key_share(SSL_CONNECTION *s, WPACKET *pkt, unsigned int group_id,
 
     /* Create KeyShareEntry */
     if (!WPACKET_put_bytes_u16(pkt, group_id)
-            || !WPACKET_sub_memcpy_u16(pkt, encoded_pubkey, encodedlen)) {
+        || !WPACKET_sub_memcpy_u16(pkt, encoded_pubkey, encodedlen)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
@@ -694,7 +690,7 @@ static int add_key_share(SSL_CONNECTION *s, WPACKET *pkt, unsigned int group_id,
     OPENSSL_free(encoded_pubkey);
 
     return 1;
- err:
+err:
     if (key_share_key != s->s3.tmp.ks_pkey[loop_num])
         EVP_PKEY_free(key_share_key);
     OPENSSL_free(encoded_pubkey);
@@ -703,8 +699,8 @@ static int add_key_share(SSL_CONNECTION *s, WPACKET *pkt, unsigned int group_id,
 #endif
 
 EXT_RETURN tls_construct_ctos_key_share(SSL_CONNECTION *s, WPACKET *pkt,
-                                        unsigned int context, X509 *x,
-                                        size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
 #ifndef OPENSSL_NO_TLS1_3
     size_t i, num_groups = 0;
@@ -715,10 +711,10 @@ EXT_RETURN tls_construct_ctos_key_share(SSL_CONNECTION *s, WPACKET *pkt,
 
     /* key_share extension */
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
-            /* Extension data sub-packet */
-            || !WPACKET_start_sub_packet_u16(pkt)
-            /* KeyShare list sub-packet */
-            || !WPACKET_start_sub_packet_u16(pkt)) {
+        /* Extension data sub-packet */
+        || !WPACKET_start_sub_packet_u16(pkt)
+        /* KeyShare list sub-packet */
+        || !WPACKET_start_sub_packet_u16(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -754,7 +750,7 @@ EXT_RETURN tls_construct_ctos_key_share(SSL_CONNECTION *s, WPACKET *pkt,
             if (!tls_group_allowed(s, pgroups[i], SSL_SECOP_CURVE_SUPPORTED))
                 continue;
             if (!tls_valid_group(s, pgroups[i], TLS1_3_VERSION, TLS1_3_VERSION,
-                                 0, NULL))
+                    0, NULL))
                 continue;
 
             group_id = pgroups[i];
@@ -790,8 +786,8 @@ EXT_RETURN tls_construct_ctos_key_share(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_ctos_cookie(SSL_CONNECTION *s, WPACKET *pkt,
-                                     unsigned int context,
-                                     X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     EXT_RETURN ret = EXT_RETURN_FAIL;
 
@@ -800,17 +796,17 @@ EXT_RETURN tls_construct_ctos_cookie(SSL_CONNECTION *s, WPACKET *pkt,
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_cookie)
-               /* Extension data sub-packet */
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_sub_memcpy_u16(pkt, s->ext.tls13_cookie,
-                                       s->ext.tls13_cookie_len)
-            || !WPACKET_close(pkt)) {
+        /* Extension data sub-packet */
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_sub_memcpy_u16(pkt, s->ext.tls13_cookie,
+            s->ext.tls13_cookie_len)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto end;
     }
 
     ret = EXT_RETURN_SENT;
- end:
+end:
     OPENSSL_free(s->ext.tls13_cookie);
     s->ext.tls13_cookie = NULL;
     s->ext.tls13_cookie_len = 0;
@@ -819,12 +815,12 @@ EXT_RETURN tls_construct_ctos_cookie(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION *s, WPACKET *pkt,
-                                         unsigned int context, X509 *x,
-                                         size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
 #ifndef OPENSSL_NO_PSK
     char identity[PSK_MAX_IDENTITY_LEN + 1];
-#endif  /* OPENSSL_NO_PSK */
+#endif /* OPENSSL_NO_PSK */
     const unsigned char *id = NULL;
     size_t idlen = 0;
     SSL_SESSION *psksess = NULL;
@@ -836,9 +832,9 @@ EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION *s, WPACKET *pkt,
         handmd = ssl_handshake_md(s);
 
     if (s->psk_use_session_cb != NULL
-            && (!s->psk_use_session_cb(ussl, handmd, &id, &idlen, &psksess)
-                || (psksess != NULL
-                    && psksess->ssl_version != TLS1_3_VERSION))) {
+        && (!s->psk_use_session_cb(ussl, handmd, &id, &idlen, &psksess)
+            || (psksess != NULL
+                && psksess->ssl_version != TLS1_3_VERSION))) {
         SSL_SESSION_free(psksess);
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_PSK);
         return EXT_RETURN_FAIL;
@@ -851,8 +847,8 @@ EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION *s, WPACKET *pkt,
 
         memset(identity, 0, sizeof(identity));
         psklen = s->psk_client_callback(ussl, NULL,
-                                        identity, sizeof(identity) - 1,
-                                        psk, sizeof(psk));
+            identity, sizeof(identity) - 1,
+            psk, sizeof(psk));
 
         if (psklen > PSK_MAX_PSK_LEN) {
             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, ERR_R_INTERNAL_ERROR);
@@ -873,7 +869,7 @@ EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION *s, WPACKET *pkt,
              * the digest so we default to SHA256 as per the TLSv1.3 spec
              */
             cipher = SSL_CIPHER_find(SSL_CONNECTION_GET_SSL(s),
-                                     tls13_aes128gcmsha256_id);
+                tls13_aes128gcmsha256_id);
             if (cipher == NULL) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 return EXT_RETURN_FAIL;
@@ -881,9 +877,9 @@ EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION *s, WPACKET *pkt,
 
             psksess = SSL_SESSION_new();
             if (psksess == NULL
-                    || !SSL_SESSION_set1_master_key(psksess, psk, psklen)
-                    || !SSL_SESSION_set_cipher(psksess, cipher)
-                    || !SSL_SESSION_set_protocol_version(psksess, TLS1_3_VERSION)) {
+                || !SSL_SESSION_set1_master_key(psksess, psk, psklen)
+                || !SSL_SESSION_set_cipher(psksess, cipher)
+                || !SSL_SESSION_set_protocol_version(psksess, TLS1_3_VERSION)) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 OPENSSL_cleanse(psk, psklen);
                 return EXT_RETURN_FAIL;
@@ -891,7 +887,7 @@ EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION *s, WPACKET *pkt,
             OPENSSL_cleanse(psk, psklen);
         }
     }
-#endif  /* OPENSSL_NO_PSK */
+#endif /* OPENSSL_NO_PSK */
 
     SSL_SESSION_free(s->psksession);
     s->psksession = psksess;
@@ -907,8 +903,8 @@ EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION *s, WPACKET *pkt,
     }
 
     if (s->early_data_state != SSL_EARLY_DATA_CONNECTING
-            || (s->session->ext.max_early_data == 0
-                && (psksess == NULL || psksess->ext.max_early_data == 0))) {
+        || (s->session->ext.max_early_data == 0
+            && (psksess == NULL || psksess->ext.max_early_data == 0))) {
         s->max_early_data = 0;
         return EXT_RETURN_NOT_SENT;
     }
@@ -917,10 +913,10 @@ EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION *s, WPACKET *pkt,
 
     if (edsess->ext.hostname != NULL) {
         if (s->ext.hostname == NULL
-                || (s->ext.hostname != NULL
-                    && strcmp(s->ext.hostname, edsess->ext.hostname) != 0)) {
+            || (s->ext.hostname != NULL
+                && strcmp(s->ext.hostname, edsess->ext.hostname) != 0)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                     SSL_R_INCONSISTENT_EARLY_DATA_SNI);
+                SSL_R_INCONSISTENT_EARLY_DATA_SNI);
             return EXT_RETURN_FAIL;
         }
     }
@@ -944,21 +940,21 @@ EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION *s, WPACKET *pkt,
         }
         while (PACKET_get_length_prefixed_1(&prots, &alpnpkt)) {
             if (PACKET_equal(&alpnpkt, edsess->ext.alpn_selected,
-                             edsess->ext.alpn_selected_len)) {
+                    edsess->ext.alpn_selected_len)) {
                 found = 1;
                 break;
             }
         }
         if (!found) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                     SSL_R_INCONSISTENT_EARLY_DATA_ALPN);
+                SSL_R_INCONSISTENT_EARLY_DATA_ALPN);
             return EXT_RETURN_FAIL;
         }
     }
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_close(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -973,8 +969,8 @@ EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION *s, WPACKET *pkt,
     return EXT_RETURN_SENT;
 }
 
-#define F5_WORKAROUND_MIN_MSG_LEN   0xff
-#define F5_WORKAROUND_MAX_MSG_LEN   0x200
+#define F5_WORKAROUND_MIN_MSG_LEN 0xff
+#define F5_WORKAROUND_MAX_MSG_LEN 0x200
 
 /*
  * PSK pre binder overhead =
@@ -991,8 +987,8 @@ EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION *s, WPACKET *pkt,
 #define PSK_PRE_BINDER_OVERHEAD (2 + 2 + 2 + 2 + 4 + 2 + 1)
 
 EXT_RETURN tls_construct_ctos_padding(SSL_CONNECTION *s, WPACKET *pkt,
-                                      unsigned int context, X509 *x,
-                                      size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     unsigned char *padbytes;
     size_t hlen;
@@ -1016,10 +1012,10 @@ EXT_RETURN tls_construct_ctos_padding(SSL_CONNECTION *s, WPACKET *pkt,
      * extension, so we need to calculate how long it is going to be.
      */
     if (s->session->ssl_version == TLS1_3_VERSION
-            && s->session->ext.ticklen != 0
-            && s->session->cipher != NULL) {
+        && s->session->ext.ticklen != 0
+        && s->session->cipher != NULL) {
         const EVP_MD *md = ssl_md(SSL_CONNECTION_GET_CTX(s),
-                                  s->session->cipher->algorithm2);
+            s->session->cipher->algorithm2);
 
         if (md != NULL) {
             /*
@@ -1030,8 +1026,8 @@ EXT_RETURN tls_construct_ctos_padding(SSL_CONNECTION *s, WPACKET *pkt,
 
             if (md_size <= 0)
                 return EXT_RETURN_FAIL;
-            hlen +=  PSK_PRE_BINDER_OVERHEAD + s->session->ext.ticklen
-                     + md_size;
+            hlen += PSK_PRE_BINDER_OVERHEAD + s->session->ext.ticklen
+                + md_size;
         }
     }
 
@@ -1051,7 +1047,7 @@ EXT_RETURN tls_construct_ctos_padding(SSL_CONNECTION *s, WPACKET *pkt,
             hlen = 1;
 
         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_padding)
-                || !WPACKET_sub_allocate_bytes_u16(pkt, hlen, &padbytes)) {
+            || !WPACKET_sub_allocate_bytes_u16(pkt, hlen, &padbytes)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return EXT_RETURN_FAIL;
         }
@@ -1065,8 +1061,8 @@ EXT_RETURN tls_construct_ctos_padding(SSL_CONNECTION *s, WPACKET *pkt,
  * Construct the pre_shared_key extension
  */
 EXT_RETURN tls_construct_ctos_psk(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
 #ifndef OPENSSL_NO_TLS1_3
     uint32_t agesec, agems = 0;
@@ -1091,7 +1087,7 @@ EXT_RETURN tls_construct_ctos_psk(SSL_CONNECTION *s, WPACKET *pkt,
      * so don't add this extension.
      */
     if (s->session->ssl_version != TLS1_3_VERSION
-            || (s->session->ext.ticklen == 0 && s->psksession == NULL))
+        || (s->session->ext.ticklen == 0 && s->psksession == NULL))
         return EXT_RETURN_NOT_SENT;
 
     if (s->hello_retry_request == SSL_HRR_PENDING)
@@ -1173,7 +1169,7 @@ EXT_RETURN tls_construct_ctos_psk(SSL_CONNECTION *s, WPACKET *pkt,
         dores = 1;
     }
 
- dopsksess:
+dopsksess:
     if (!dores && s->psksession == NULL)
         return EXT_RETURN_NOT_SENT;
 
@@ -1206,16 +1202,16 @@ EXT_RETURN tls_construct_ctos_psk(SSL_CONNECTION *s, WPACKET *pkt,
 
     /* Create the extension, but skip over the binder for now */
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_start_sub_packet_u16(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_start_sub_packet_u16(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
 
     if (dores) {
         if (!WPACKET_sub_memcpy_u16(pkt, s->session->ext.tick,
-                                           s->session->ext.ticklen)
-                || !WPACKET_put_bytes_u32(pkt, agems)) {
+                s->session->ext.ticklen)
+            || !WPACKET_put_bytes_u32(pkt, agems)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return EXT_RETURN_FAIL;
         }
@@ -1223,8 +1219,8 @@ EXT_RETURN tls_construct_ctos_psk(SSL_CONNECTION *s, WPACKET *pkt,
 
     if (s->psksession != NULL) {
         if (!WPACKET_sub_memcpy_u16(pkt, s->psksession_id,
-                                    s->psksession_id_len)
-                || !WPACKET_put_bytes_u32(pkt, 0)) {
+                s->psksession_id_len)
+            || !WPACKET_put_bytes_u32(pkt, 0)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return EXT_RETURN_FAIL;
         }
@@ -1232,20 +1228,20 @@ EXT_RETURN tls_construct_ctos_psk(SSL_CONNECTION *s, WPACKET *pkt,
     }
 
     if (!WPACKET_close(pkt)
-            || !WPACKET_get_total_written(pkt, &binderoffset)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || (dores
-                && !WPACKET_sub_allocate_bytes_u8(pkt, reshashsize, &resbinder))
-            || (s->psksession != NULL
-                && !WPACKET_sub_allocate_bytes_u8(pkt, pskhashsize, &pskbinder))
-            || !WPACKET_close(pkt)
-            || !WPACKET_close(pkt)
-            || !WPACKET_get_total_written(pkt, &msglen)
-               /*
-                * We need to fill in all the sub-packet lengths now so we can
-                * calculate the HMAC of the message up to the binders
-                */
-            || !WPACKET_fill_lengths(pkt)) {
+        || !WPACKET_get_total_written(pkt, &binderoffset)
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || (dores
+            && !WPACKET_sub_allocate_bytes_u8(pkt, reshashsize, &resbinder))
+        || (s->psksession != NULL
+            && !WPACKET_sub_allocate_bytes_u8(pkt, pskhashsize, &pskbinder))
+        || !WPACKET_close(pkt)
+        || !WPACKET_close(pkt)
+        || !WPACKET_get_total_written(pkt, &msglen)
+        /*
+         * We need to fill in all the sub-packet lengths now so we can
+         * calculate the HMAC of the message up to the binders
+         */
+        || !WPACKET_fill_lengths(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -1253,15 +1249,17 @@ EXT_RETURN tls_construct_ctos_psk(SSL_CONNECTION *s, WPACKET *pkt,
     msgstart = WPACKET_get_curr(pkt) - msglen;
 
     if (dores
-            && tls_psk_do_binder(s, mdres, msgstart, binderoffset, NULL,
-                                 resbinder, s->session, 1, 0) != 1) {
+        && tls_psk_do_binder(s, mdres, msgstart, binderoffset, NULL,
+               resbinder, s->session, 1, 0)
+            != 1) {
         /* SSLfatal() already called */
         return EXT_RETURN_FAIL;
     }
 
     if (s->psksession != NULL
-            && tls_psk_do_binder(s, mdpsk, msgstart, binderoffset, NULL,
-                                 pskbinder, s->psksession, 1, 1) != 1) {
+        && tls_psk_do_binder(s, mdpsk, msgstart, binderoffset, NULL,
+               pskbinder, s->psksession, 1, 1)
+            != 1) {
         /* SSLfatal() already called */
         return EXT_RETURN_FAIL;
     }
@@ -1273,9 +1271,9 @@ EXT_RETURN tls_construct_ctos_psk(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_ctos_post_handshake_auth(SSL_CONNECTION *s, WPACKET *pkt,
-                                                  ossl_unused unsigned int context,
-                                                  ossl_unused X509 *x,
-                                                  ossl_unused size_t chainidx)
+    ossl_unused unsigned int context,
+    ossl_unused X509 *x,
+    ossl_unused size_t chainidx)
 {
 #ifndef OPENSSL_NO_TLS1_3
     if (!s->pha_enabled)
@@ -1283,8 +1281,8 @@ EXT_RETURN tls_construct_ctos_post_handshake_auth(SSL_CONNECTION *s, WPACKET *pk
 
     /* construct extension - 0 length, no contents */
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_post_handshake_auth)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_close(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -1297,13 +1295,12 @@ EXT_RETURN tls_construct_ctos_post_handshake_auth(SSL_CONNECTION *s, WPACKET *pk
 #endif
 }
 
-
 /*
  * Parse the server's renegotiation binding and abort if it's not right
  */
 int tls_parse_stoc_renegotiate(SSL_CONNECTION *s, PACKET *pkt,
-                               unsigned int context,
-                               X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     size_t expected_len = s->s3.previous_client_finished_len
         + s->s3.previous_server_finished_len;
@@ -1312,9 +1309,9 @@ int tls_parse_stoc_renegotiate(SSL_CONNECTION *s, PACKET *pkt,
 
     /* Check for logic errors */
     if (!ossl_assert(expected_len == 0
-                     || s->s3.previous_client_finished_len != 0)
+            || s->s3.previous_client_finished_len != 0)
         || !ossl_assert(expected_len == 0
-                        || s->s3.previous_server_finished_len != 0)) {
+            || s->s3.previous_server_finished_len != 0)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
@@ -1339,14 +1336,16 @@ int tls_parse_stoc_renegotiate(SSL_CONNECTION *s, PACKET *pkt,
 
     if (!PACKET_get_bytes(pkt, &data, s->s3.previous_client_finished_len)
         || memcmp(data, s->s3.previous_client_finished,
-                  s->s3.previous_client_finished_len) != 0) {
+               s->s3.previous_client_finished_len)
+            != 0) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_RENEGOTIATION_MISMATCH);
         return 0;
     }
 
     if (!PACKET_get_bytes(pkt, &data, s->s3.previous_server_finished_len)
         || memcmp(data, s->s3.previous_server_finished,
-                  s->s3.previous_server_finished_len) != 0) {
+               s->s3.previous_server_finished_len)
+            != 0) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_RENEGOTIATION_MISMATCH);
         return 0;
     }
@@ -1357,8 +1356,8 @@ int tls_parse_stoc_renegotiate(SSL_CONNECTION *s, PACKET *pkt,
 
 /* Parse the server's max fragment len extension packet */
 int tls_parse_stoc_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     unsigned int value;
 
@@ -1370,7 +1369,7 @@ int tls_parse_stoc_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt,
     /* |value| should contains a valid max-fragment-length code. */
     if (!IS_MAX_FRAGMENT_LENGTH_EXT_VALID(value)) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                 SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
+            SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
         return 0;
     }
 
@@ -1382,7 +1381,7 @@ int tls_parse_stoc_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt,
      */
     if (value != s->ext.max_fragment_len_mode) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                 SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
+            SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
         return 0;
     }
 
@@ -1396,8 +1395,8 @@ int tls_parse_stoc_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt,
 }
 
 int tls_parse_stoc_server_name(SSL_CONNECTION *s, PACKET *pkt,
-                               unsigned int context,
-                               X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     if (s->ext.hostname == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
@@ -1425,8 +1424,8 @@ int tls_parse_stoc_server_name(SSL_CONNECTION *s, PACKET *pkt,
 }
 
 int tls_parse_stoc_ec_pt_formats(SSL_CONNECTION *s, PACKET *pkt,
-                                 unsigned int context,
-                                 X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     size_t ecpointformats_len;
     PACKET ecptformatlist;
@@ -1454,8 +1453,8 @@ int tls_parse_stoc_ec_pt_formats(SSL_CONNECTION *s, PACKET *pkt,
         s->ext.peer_ecpointformats_len = ecpointformats_len;
 
         if (!PACKET_copy_bytes(&ecptformatlist,
-                               s->ext.peer_ecpointformats,
-                               ecpointformats_len)) {
+                s->ext.peer_ecpointformats,
+                ecpointformats_len)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return 0;
         }
@@ -1465,15 +1464,12 @@ int tls_parse_stoc_ec_pt_formats(SSL_CONNECTION *s, PACKET *pkt,
 }
 
 int tls_parse_stoc_session_ticket(SSL_CONNECTION *s, PACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     SSL *ssl = SSL_CONNECTION_GET_USER_SSL(s);
 
-    if (s->ext.session_ticket_cb != NULL &&
-        !s->ext.session_ticket_cb(ssl, PACKET_data(pkt),
-                                  PACKET_remaining(pkt),
-                                  s->ext.session_ticket_cb_arg)) {
+    if (s->ext.session_ticket_cb != NULL && !s->ext.session_ticket_cb(ssl, PACKET_data(pkt), PACKET_remaining(pkt), s->ext.session_ticket_cb_arg)) {
         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_BAD_EXTENSION);
         return 0;
     }
@@ -1494,8 +1490,8 @@ int tls_parse_stoc_session_ticket(SSL_CONNECTION *s, PACKET *pkt,
 
 #ifndef OPENSSL_NO_OCSP
 int tls_parse_stoc_status_request(SSL_CONNECTION *s, PACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     if (context == SSL_EXT_TLS1_3_CERTIFICATE_REQUEST) {
         /* We ignore this if the server sends a CertificateRequest */
@@ -1533,10 +1529,9 @@ int tls_parse_stoc_status_request(SSL_CONNECTION *s, PACKET *pkt,
 }
 #endif
 
-
 #ifndef OPENSSL_NO_CT
 int tls_parse_stoc_sct(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx)
+    X509 *x, size_t chainidx)
 {
     if (context == SSL_EXT_TLS1_3_CERTIFICATE_REQUEST) {
         /* We ignore this if the server sends it in a CertificateRequest */
@@ -1570,23 +1565,25 @@ int tls_parse_stoc_sct(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
         }
     } else {
         ENDPOINT role = (context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0
-                        ? ENDPOINT_CLIENT : ENDPOINT_BOTH;
+            ? ENDPOINT_CLIENT
+            : ENDPOINT_BOTH;
 
         /*
          * If we didn't ask for it then there must be a custom extension,
          * otherwise this is unsolicited.
          */
         if (custom_ext_find(&s->cert->custext, role,
-                            TLSEXT_TYPE_signed_certificate_timestamp,
-                            NULL) == NULL) {
+                TLSEXT_TYPE_signed_certificate_timestamp,
+                NULL)
+            == NULL) {
             SSLfatal(s, TLS1_AD_UNSUPPORTED_EXTENSION, SSL_R_BAD_EXTENSION);
             return 0;
         }
 
         if (!custom_ext_parse(s, context,
-                             TLSEXT_TYPE_signed_certificate_timestamp,
-                             PACKET_data(pkt), PACKET_remaining(pkt),
-                             x, chainidx)) {
+                TLSEXT_TYPE_signed_certificate_timestamp,
+                PACKET_data(pkt), PACKET_remaining(pkt),
+                x, chainidx)) {
             /* SSLfatal already called */
             return 0;
         }
@@ -1596,7 +1593,6 @@ int tls_parse_stoc_sct(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
 }
 #endif
 
-
 #ifndef OPENSSL_NO_NEXTPROTONEG
 /*
  * ssl_next_proto_validate validates a Next Protocol Negotiation block. No
@@ -1619,7 +1615,7 @@ static int ssl_next_proto_validate(SSL_CONNECTION *s, PACKET *pkt)
 }
 
 int tls_parse_stoc_npn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx)
+    X509 *x, size_t chainidx)
 {
     unsigned char *selected;
     unsigned char selected_len;
@@ -1643,10 +1639,11 @@ int tls_parse_stoc_npn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
         return 0;
     }
     if (sctx->ext.npn_select_cb(SSL_CONNECTION_GET_USER_SSL(s),
-                                &selected, &selected_len,
-                                PACKET_data(pkt), PACKET_remaining(pkt),
-                                sctx->ext.npn_select_cb_arg) != SSL_TLSEXT_ERR_OK
-            || selected_len == 0) {
+            &selected, &selected_len,
+            PACKET_data(pkt), PACKET_remaining(pkt),
+            sctx->ext.npn_select_cb_arg)
+            != SSL_TLSEXT_ERR_OK
+        || selected_len == 0) {
         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_BAD_EXTENSION);
         return 0;
     }
@@ -1672,7 +1669,7 @@ int tls_parse_stoc_npn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
 #endif
 
 int tls_parse_stoc_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                        X509 *x, size_t chainidx)
+    X509 *x, size_t chainidx)
 {
     size_t len;
     PACKET confpkt, protpkt;
@@ -1731,9 +1728,9 @@ int tls_parse_stoc_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
     s->s3.alpn_selected_len = len;
 
     if (s->session->ext.alpn_selected == NULL
-            || s->session->ext.alpn_selected_len != len
-            || memcmp(s->session->ext.alpn_selected, s->s3.alpn_selected, len)
-               != 0) {
+        || s->session->ext.alpn_selected_len != len
+        || memcmp(s->session->ext.alpn_selected, s->s3.alpn_selected, len)
+            != 0) {
         /* ALPN not consistent with the old session so cannot use early_data */
         s->ext.early_data_ok = 0;
     }
@@ -1746,8 +1743,7 @@ int tls_parse_stoc_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return 0;
         }
-        s->session->ext.alpn_selected =
-            OPENSSL_memdup(s->s3.alpn_selected, s->s3.alpn_selected_len);
+        s->session->ext.alpn_selected = OPENSSL_memdup(s->s3.alpn_selected, s->s3.alpn_selected_len);
         if (s->session->ext.alpn_selected == NULL) {
             s->session->ext.alpn_selected_len = 0;
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
@@ -1761,7 +1757,7 @@ int tls_parse_stoc_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
 
 #ifndef OPENSSL_NO_SRTP
 int tls_parse_stoc_use_srtp(SSL_CONNECTION *s, PACKET *pkt,
-                            unsigned int context, X509 *x, size_t chainidx)
+    unsigned int context, X509 *x, size_t chainidx)
 {
     unsigned int id, ct, mki;
     int i;
@@ -1769,11 +1765,11 @@ int tls_parse_stoc_use_srtp(SSL_CONNECTION *s, PACKET *pkt,
     SRTP_PROTECTION_PROFILE *prof;
 
     if (!PACKET_get_net_2(pkt, &ct) || ct != 2
-            || !PACKET_get_net_2(pkt, &id)
-            || !PACKET_get_1(pkt, &mki)
-            || PACKET_remaining(pkt) != 0) {
+        || !PACKET_get_net_2(pkt, &id)
+        || !PACKET_get_1(pkt, &mki)
+        || PACKET_remaining(pkt) != 0) {
         SSLfatal(s, SSL_AD_DECODE_ERROR,
-                 SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
+            SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
         return 0;
     }
 
@@ -1804,29 +1800,29 @@ int tls_parse_stoc_use_srtp(SSL_CONNECTION *s, PACKET *pkt,
     }
 
     SSLfatal(s, SSL_AD_DECODE_ERROR,
-             SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
+        SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
     return 0;
 }
 #endif
 
 int tls_parse_stoc_etm(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx)
+    X509 *x, size_t chainidx)
 {
     /* Ignore if inappropriate ciphersuite */
     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)
-            && s->s3.tmp.new_cipher->algorithm_mac != SSL_AEAD
-            && s->s3.tmp.new_cipher->algorithm_enc != SSL_RC4
-            && s->s3.tmp.new_cipher->algorithm_enc != SSL_eGOST2814789CNT
-            && s->s3.tmp.new_cipher->algorithm_enc != SSL_eGOST2814789CNT12
-            && s->s3.tmp.new_cipher->algorithm_enc != SSL_MAGMA
-            && s->s3.tmp.new_cipher->algorithm_enc != SSL_KUZNYECHIK)
+        && s->s3.tmp.new_cipher->algorithm_mac != SSL_AEAD
+        && s->s3.tmp.new_cipher->algorithm_enc != SSL_RC4
+        && s->s3.tmp.new_cipher->algorithm_enc != SSL_eGOST2814789CNT
+        && s->s3.tmp.new_cipher->algorithm_enc != SSL_eGOST2814789CNT12
+        && s->s3.tmp.new_cipher->algorithm_enc != SSL_MAGMA
+        && s->s3.tmp.new_cipher->algorithm_enc != SSL_KUZNYECHIK)
         s->ext.use_etm = 1;
 
     return 1;
 }
 
 int tls_parse_stoc_ems(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx)
+    X509 *x, size_t chainidx)
 {
     if (s->options & SSL_OP_NO_EXTENDED_MASTER_SECRET)
         return 1;
@@ -1838,13 +1834,13 @@ int tls_parse_stoc_ems(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
 }
 
 int tls_parse_stoc_supported_versions(SSL_CONNECTION *s, PACKET *pkt,
-                                      unsigned int context,
-                                      X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     unsigned int version;
 
     if (!PACKET_get_net_2(pkt, &version)
-            || PACKET_remaining(pkt) != 0) {
+        || PACKET_remaining(pkt) != 0) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
         return 0;
     }
@@ -1855,7 +1851,7 @@ int tls_parse_stoc_supported_versions(SSL_CONNECTION *s, PACKET *pkt,
      */
     if (version != TLS1_3_VERSION) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                 SSL_R_BAD_PROTOCOL_VERSION_NUMBER);
+            SSL_R_BAD_PROTOCOL_VERSION_NUMBER);
         return 0;
     }
 
@@ -1874,8 +1870,8 @@ int tls_parse_stoc_supported_versions(SSL_CONNECTION *s, PACKET *pkt,
 }
 
 int tls_parse_stoc_key_share(SSL_CONNECTION *s, PACKET *pkt,
-                             unsigned int context, X509 *x,
-                             size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
 #ifndef OPENSSL_NO_TLS1_3
     unsigned int group_id;
@@ -1924,9 +1920,9 @@ int tls_parse_stoc_key_share(SSL_CONNECTION *s, PACKET *pkt,
                 break;
         }
         if (i >= num_groups
-                || !tls_group_allowed(s, group_id, SSL_SECOP_CURVE_SUPPORTED)
-                || !tls_valid_group(s, group_id, TLS1_3_VERSION, TLS1_3_VERSION,
-                                    0, NULL)) {
+            || !tls_group_allowed(s, group_id, SSL_SECOP_CURVE_SUPPORTED)
+            || !tls_valid_group(s, group_id, TLS1_3_VERSION, TLS1_3_VERSION,
+                0, NULL)) {
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE);
             return 0;
         }
@@ -1992,13 +1988,14 @@ int tls_parse_stoc_key_share(SSL_CONNECTION *s, PACKET *pkt,
     }
 
     if ((ginf = tls1_group_id_lookup(SSL_CONNECTION_GET_CTX(s),
-                                     group_id)) == NULL) {
+             group_id))
+        == NULL) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE);
         return 0;
     }
 
     if (!PACKET_as_length_prefixed_2(pkt, &encoded_pt)
-            || PACKET_remaining(&encoded_pt) == 0) {
+        || PACKET_remaining(&encoded_pt) == 0) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
         return 0;
     }
@@ -2013,7 +2010,8 @@ int tls_parse_stoc_key_share(SSL_CONNECTION *s, PACKET *pkt,
         }
 
         if (tls13_set_encoded_pub_key(skey, PACKET_data(&encoded_pt),
-                                      PACKET_remaining(&encoded_pt)) <= 0) {
+                PACKET_remaining(&encoded_pt))
+            <= 0) {
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_ECPOINT);
             EVP_PKEY_free(skey);
             return 0;
@@ -2042,13 +2040,13 @@ int tls_parse_stoc_key_share(SSL_CONNECTION *s, PACKET *pkt,
 }
 
 int tls_parse_stoc_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                          X509 *x, size_t chainidx)
+    X509 *x, size_t chainidx)
 {
     PACKET cookie;
 
     if (!PACKET_as_length_prefixed_2(pkt, &cookie)
-            || !PACKET_memdup(&cookie, &s->ext.tls13_cookie,
-                              &s->ext.tls13_cookie_len)) {
+        || !PACKET_memdup(&cookie, &s->ext.tls13_cookie,
+            &s->ext.tls13_cookie_len)) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
         return 0;
     }
@@ -2057,14 +2055,14 @@ int tls_parse_stoc_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
 }
 
 int tls_parse_stoc_early_data(SSL_CONNECTION *s, PACKET *pkt,
-                              unsigned int context,
-                              X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     if (context == SSL_EXT_TLS1_3_NEW_SESSION_TICKET) {
         unsigned long max_early_data;
 
         if (!PACKET_get_net_4(pkt, &max_early_data)
-                || PACKET_remaining(pkt) != 0) {
+            || PACKET_remaining(pkt) != 0) {
             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_INVALID_MAX_EARLY_DATA);
             return 0;
         }
@@ -2096,7 +2094,7 @@ int tls_parse_stoc_early_data(SSL_CONNECTION *s, PACKET *pkt,
     }
 
     if (!s->ext.early_data_ok
-            || !s->hit) {
+        || !s->hit) {
         /*
          * If we get here then we didn't send early data, or we didn't resume
          * using the first identity, or the SNI/ALPN is not consistent so the
@@ -2112,8 +2110,8 @@ int tls_parse_stoc_early_data(SSL_CONNECTION *s, PACKET *pkt,
 }
 
 int tls_parse_stoc_psk(SSL_CONNECTION *s, PACKET *pkt,
-                       unsigned int context, X509 *x,
-                       size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
 #ifndef OPENSSL_NO_TLS1_3
     unsigned int identity;
@@ -2152,9 +2150,9 @@ int tls_parse_stoc_psk(SSL_CONNECTION *s, PACKET *pkt,
      * early_secret across that we generated earlier.
      */
     if ((s->early_data_state != SSL_EARLY_DATA_WRITE_RETRY
-                && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING)
-            || s->session->ext.max_early_data > 0
-            || s->psksession->ext.max_early_data == 0)
+            && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING)
+        || s->session->ext.max_early_data > 0
+        || s->psksession->ext.max_early_data == 0)
         memcpy(s->early_secret, s->psksession->early_secret, EVP_MAX_MD_SIZE);
 
     SSL_SESSION_free(s->session);
@@ -2170,17 +2168,17 @@ int tls_parse_stoc_psk(SSL_CONNECTION *s, PACKET *pkt,
 }
 
 EXT_RETURN tls_construct_ctos_client_cert_type(SSL_CONNECTION *sc, WPACKET *pkt,
-                                               unsigned int context,
-                                               X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE;
     if (sc->client_cert_type == NULL)
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_client_cert_type)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_sub_memcpy_u8(pkt, sc->client_cert_type, sc->client_cert_type_len)
-            || !WPACKET_close(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_sub_memcpy_u8(pkt, sc->client_cert_type, sc->client_cert_type_len)
+        || !WPACKET_close(pkt)) {
         SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -2189,8 +2187,8 @@ EXT_RETURN tls_construct_ctos_client_cert_type(SSL_CONNECTION *sc, WPACKET *pkt,
 }
 
 int tls_parse_stoc_client_cert_type(SSL_CONNECTION *sc, PACKET *pkt,
-                                    unsigned int context,
-                                    X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     unsigned int type;
 
@@ -2222,17 +2220,17 @@ int tls_parse_stoc_client_cert_type(SSL_CONNECTION *sc, PACKET *pkt,
 }
 
 EXT_RETURN tls_construct_ctos_server_cert_type(SSL_CONNECTION *sc, WPACKET *pkt,
-                                               unsigned int context,
-                                               X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     sc->ext.server_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE;
     if (sc->server_cert_type == NULL)
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_cert_type)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_sub_memcpy_u8(pkt, sc->server_cert_type, sc->server_cert_type_len)
-            || !WPACKET_close(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_sub_memcpy_u8(pkt, sc->server_cert_type, sc->server_cert_type_len)
+        || !WPACKET_close(pkt)) {
         SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -2241,8 +2239,8 @@ EXT_RETURN tls_construct_ctos_server_cert_type(SSL_CONNECTION *sc, WPACKET *pkt,
 }
 
 int tls_parse_stoc_server_cert_type(SSL_CONNECTION *sc, PACKET *pkt,
-                                    unsigned int context,
-                                    X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     unsigned int type;
 
diff --git a/crypto/openssl/ssl/statem/extensions_cust.c b/crypto/openssl/ssl/statem/extensions_cust.c
index aa352529c4cc..ce1c69bbdc1d 100644
--- a/crypto/openssl/ssl/statem/extensions_cust.c
+++ b/crypto/openssl/ssl/statem/extensions_cust.c
@@ -30,10 +30,10 @@ typedef struct {
  * Provide thin wrapper callbacks which convert new style arguments to old style
  */
 static int custom_ext_add_old_cb_wrap(SSL *s, unsigned int ext_type,
-                                      unsigned int context,
-                                      const unsigned char **out,
-                                      size_t *outlen, X509 *x, size_t chainidx,
-                                      int *al, void *add_arg)
+    unsigned int context,
+    const unsigned char **out,
+    size_t *outlen, X509 *x, size_t chainidx,
+    int *al, void *add_arg)
 {
     custom_ext_add_cb_wrap *add_cb_wrap = (custom_ext_add_cb_wrap *)add_arg;
 
@@ -41,12 +41,12 @@ static int custom_ext_add_old_cb_wrap(SSL *s, unsigned int ext_type,
         return 1;
 
     return add_cb_wrap->add_cb(s, ext_type, out, outlen, al,
-                               add_cb_wrap->add_arg);
+        add_cb_wrap->add_arg);
 }
 
 static void custom_ext_free_old_cb_wrap(SSL *s, unsigned int ext_type,
-                                        unsigned int context,
-                                        const unsigned char *out, void *add_arg)
+    unsigned int context,
+    const unsigned char *out, void *add_arg)
 {
     custom_ext_add_cb_wrap *add_cb_wrap = (custom_ext_add_cb_wrap *)add_arg;
 
@@ -57,19 +57,18 @@ static void custom_ext_free_old_cb_wrap(SSL *s, unsigned int ext_type,
 }
 
 static int custom_ext_parse_old_cb_wrap(SSL *s, unsigned int ext_type,
-                                        unsigned int context,
-                                        const unsigned char *in,
-                                        size_t inlen, X509 *x, size_t chainidx,
-                                        int *al, void *parse_arg)
+    unsigned int context,
+    const unsigned char *in,
+    size_t inlen, X509 *x, size_t chainidx,
+    int *al, void *parse_arg)
 {
-    custom_ext_parse_cb_wrap *parse_cb_wrap =
-        (custom_ext_parse_cb_wrap *)parse_arg;
+    custom_ext_parse_cb_wrap *parse_cb_wrap = (custom_ext_parse_cb_wrap *)parse_arg;
 
     if (parse_cb_wrap->parse_cb == NULL)
         return 1;
 
     return parse_cb_wrap->parse_cb(s, ext_type, in, inlen, al,
-                                   parse_cb_wrap->parse_arg);
+        parse_cb_wrap->parse_arg);
 }
 
 /*
@@ -80,16 +79,16 @@ static int custom_ext_parse_old_cb_wrap(SSL *s, unsigned int ext_type,
  * client, or ENDPOINT_BOTH for either
  */
 custom_ext_method *custom_ext_find(const custom_ext_methods *exts,
-                                   ENDPOINT role, unsigned int ext_type,
-                                   size_t *idx)
+    ENDPOINT role, unsigned int ext_type,
+    size_t *idx)
 {
     size_t i;
     custom_ext_method *meth = exts->meths;
 
     for (i = 0; i < exts->meths_count; i++, meth++) {
         if (ext_type == meth->ext_type
-                && (role == ENDPOINT_BOTH || role == meth->role
-                    || meth->role == ENDPOINT_BOTH)) {
+            && (role == ENDPOINT_BOTH || role == meth->role
+                || meth->role == ENDPOINT_BOTH)) {
             if (idx != NULL)
                 *idx = i;
             return meth;
@@ -112,9 +111,9 @@ void custom_ext_init(custom_ext_methods *exts)
 
 /* Pass received custom extension data to the application for parsing. */
 int custom_ext_parse(SSL_CONNECTION *s, unsigned int context,
-                     unsigned int ext_type,
-                     const unsigned char *ext_data, size_t ext_size, X509 *x,
-                     size_t chainidx)
+    unsigned int ext_type,
+    const unsigned char *ext_data, size_t ext_size, X509 *x,
+    size_t chainidx)
 {
     int al = 0;
     custom_ext_methods *exts = &s->cert->custext;
@@ -133,9 +132,7 @@ int custom_ext_parse(SSL_CONNECTION *s, unsigned int context,
     if (!extension_is_relevant(s, meth->context, context))
         return 1;
 
-    if ((context & (SSL_EXT_TLS1_2_SERVER_HELLO
-                    | SSL_EXT_TLS1_3_SERVER_HELLO
-                    | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS)) != 0) {
+    if ((context & (SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS)) != 0) {
         /*
          * If it's ServerHello or EncryptedExtensions we can't have any
          * extensions not sent in ClientHello.
@@ -152,7 +149,7 @@ int custom_ext_parse(SSL_CONNECTION *s, unsigned int context,
      * extensions in the response messages
      */
     if ((context & (SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST))
-            != 0)
+        != 0)
         meth->ext_flags |= SSL_EXT_FLAG_RECEIVED;
 
     /* If no parse function set return success */
@@ -160,7 +157,8 @@ int custom_ext_parse(SSL_CONNECTION *s, unsigned int context,
         return 1;
 
     if (meth->parse_cb(SSL_CONNECTION_GET_USER_SSL(s), ext_type, context, ext_data,
-                       ext_size, x, chainidx, &al, meth->parse_arg) <= 0) {
+            ext_size, x, chainidx, &al, meth->parse_arg)
+        <= 0) {
         SSLfatal(s, al, SSL_R_BAD_EXTENSION);
         return 0;
     }
@@ -173,7 +171,7 @@ int custom_ext_parse(SSL_CONNECTION *s, unsigned int context,
  * buffer.
  */
 int custom_ext_add(SSL_CONNECTION *s, int context, WPACKET *pkt, X509 *x,
-                   size_t chainidx, int maxversion)
+    size_t chainidx, int maxversion)
 {
     custom_ext_methods *exts = &s->cert->custext;
     custom_ext_method *meth;
@@ -190,12 +188,7 @@ int custom_ext_add(SSL_CONNECTION *s, int context, WPACKET *pkt, X509 *x,
         if (!should_add_extension(s, meth->context, context, maxversion))
             continue;
 
-        if ((context & (SSL_EXT_TLS1_2_SERVER_HELLO
-                        | SSL_EXT_TLS1_3_SERVER_HELLO
-                        | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
-                        | SSL_EXT_TLS1_3_CERTIFICATE
-                        | SSL_EXT_TLS1_3_RAW_PUBLIC_KEY
-                        | SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST)) != 0) {
+        if ((context & (SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS | SSL_EXT_TLS1_3_CERTIFICATE | SSL_EXT_TLS1_3_RAW_PUBLIC_KEY | SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST)) != 0) {
             /* Only send extensions present in ClientHello/CertificateRequest */
             if (!(meth->ext_flags & SSL_EXT_FLAG_RECEIVED))
                 continue;
@@ -209,26 +202,26 @@ int custom_ext_add(SSL_CONNECTION *s, int context, WPACKET *pkt, X509 *x,
 
         if (meth->add_cb != NULL) {
             int cb_retval = meth->add_cb(SSL_CONNECTION_GET_USER_SSL(s),
-                                         meth->ext_type, context, &out,
-                                         &outlen, x, chainidx, &al,
-                                         meth->add_arg);
+                meth->ext_type, context, &out,
+                &outlen, x, chainidx, &al,
+                meth->add_arg);
 
             if (cb_retval < 0) {
                 if (!for_comp)
                     SSLfatal(s, al, SSL_R_CALLBACK_FAILED);
-                return 0;       /* error */
+                return 0; /* error */
             }
             if (cb_retval == 0)
-                continue;       /* skip this extension */
+                continue; /* skip this extension */
         }
 
         if (!WPACKET_put_bytes_u16(pkt, meth->ext_type)
-                || !WPACKET_start_sub_packet_u16(pkt)
-                || (outlen > 0 && !WPACKET_memcpy(pkt, out, outlen))
-                || !WPACKET_close(pkt)) {
+            || !WPACKET_start_sub_packet_u16(pkt)
+            || (outlen > 0 && !WPACKET_memcpy(pkt, out, outlen))
+            || !WPACKET_close(pkt)) {
             if (meth->free_cb != NULL)
                 meth->free_cb(SSL_CONNECTION_GET_USER_SSL(s), meth->ext_type,
-                              context, out, meth->add_arg);
+                    context, out, meth->add_arg);
             if (!for_comp)
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return 0;
@@ -240,7 +233,7 @@ int custom_ext_add(SSL_CONNECTION *s, int context, WPACKET *pkt, X509 *x,
             if (!ossl_assert((meth->ext_flags & SSL_EXT_FLAG_SENT) == 0)) {
                 if (meth->free_cb != NULL)
                     meth->free_cb(SSL_CONNECTION_GET_USER_SSL(s), meth->ext_type,
-                                  context, out, meth->add_arg);
+                        context, out, meth->add_arg);
                 if (!for_comp)
                     SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 return 0;
@@ -254,21 +247,21 @@ int custom_ext_add(SSL_CONNECTION *s, int context, WPACKET *pkt, X509 *x,
         }
         if (meth->free_cb != NULL)
             meth->free_cb(SSL_CONNECTION_GET_USER_SSL(s), meth->ext_type,
-                          context, out, meth->add_arg);
+                context, out, meth->add_arg);
     }
     return 1;
 }
 
 /* Copy the flags from src to dst for any extensions that exist in both */
 int custom_exts_copy_flags(custom_ext_methods *dst,
-                           const custom_ext_methods *src)
+    const custom_ext_methods *src)
 {
     size_t i;
     custom_ext_method *methsrc = src->meths;
 
     for (i = 0; i < src->meths_count; i++, methsrc++) {
         custom_ext_method *methdst = custom_ext_find(dst, methsrc->role,
-                                                     methsrc->ext_type, NULL);
+            methsrc->ext_type, NULL);
 
         if (methdst == NULL)
             continue;
@@ -281,8 +274,8 @@ int custom_exts_copy_flags(custom_ext_methods *dst,
 
 /* Copy old style API wrapper arguments */
 static void custom_ext_copy_old_cb(custom_ext_method *methdst,
-                                   const custom_ext_method *methsrc,
-                                   int *err)
+    const custom_ext_method *methsrc,
+    int *err)
 {
     if (methsrc->add_cb != custom_ext_add_old_cb_wrap)
         return;
@@ -294,9 +287,9 @@ static void custom_ext_copy_old_cb(custom_ext_method *methdst,
     }
 
     methdst->add_arg = OPENSSL_memdup(methsrc->add_arg,
-                                      sizeof(custom_ext_add_cb_wrap));
+        sizeof(custom_ext_add_cb_wrap));
     methdst->parse_arg = OPENSSL_memdup(methsrc->parse_arg,
-                                        sizeof(custom_ext_parse_cb_wrap));
+        sizeof(custom_ext_parse_cb_wrap));
 
     if (methdst->add_arg == NULL || methdst->parse_arg == NULL)
         *err = 1;
@@ -311,9 +304,8 @@ int custom_exts_copy(custom_ext_methods *dst, const custom_ext_methods *src)
     int err = 0;
 
     if (src->meths_count > 0) {
-        dst->meths =
-            OPENSSL_memdup(src->meths,
-                           sizeof(*src->meths) * src->meths_count);
+        dst->meths = OPENSSL_memdup(src->meths,
+            sizeof(*src->meths) * src->meths_count);
         if (dst->meths == NULL)
             return 0;
         dst->meths_count = src->meths_count;
@@ -332,7 +324,7 @@ int custom_exts_copy(custom_ext_methods *dst, const custom_ext_methods *src)
 
 /* Copy custom extensions that were set on connection */
 int custom_exts_copy_conn(custom_ext_methods *dst,
-                          const custom_ext_methods *src)
+    const custom_ext_methods *src)
 {
     size_t i;
     int err = 0;
@@ -345,10 +337,8 @@ int custom_exts_copy_conn(custom_ext_methods *dst,
                 meths_count++;
 
         if (meths_count > 0) {
-            custom_ext_method *methdst =
-                OPENSSL_realloc(dst->meths,
-                                (dst->meths_count + meths_count) *
-                                sizeof(custom_ext_method));
+            custom_ext_method *methdst = OPENSSL_realloc(dst->meths,
+                (dst->meths_count + meths_count) * sizeof(custom_ext_method));
 
             if (methdst == NULL)
                 return 0;
@@ -404,17 +394,18 @@ void custom_exts_free(custom_ext_methods *exts)
 int SSL_CTX_has_client_custom_ext(const SSL_CTX *ctx, unsigned int ext_type)
 {
     return custom_ext_find(&ctx->cert->custext, ENDPOINT_CLIENT, ext_type,
-                           NULL) != NULL;
+               NULL)
+        != NULL;
 }
 
 int ossl_tls_add_custom_ext_intern(SSL_CTX *ctx, custom_ext_methods *exts,
-                                   ENDPOINT role, unsigned int ext_type,
-                                   unsigned int context,
-                                   SSL_custom_ext_add_cb_ex add_cb,
-                                   SSL_custom_ext_free_cb_ex free_cb,
-                                   void *add_arg,
-                                   SSL_custom_ext_parse_cb_ex parse_cb,
-                                   void *parse_arg)
+    ENDPOINT role, unsigned int ext_type,
+    unsigned int context,
+    SSL_custom_ext_add_cb_ex add_cb,
+    SSL_custom_ext_free_cb_ex free_cb,
+    void *add_arg,
+    SSL_custom_ext_parse_cb_ex parse_cb,
+    void *parse_arg)
 {
     custom_ext_method *meth, *tmp;
 
@@ -435,9 +426,9 @@ int ossl_tls_add_custom_ext_intern(SSL_CTX *ctx, custom_ext_methods *exts,
      * these two things may not play well together.
      */
     if (ext_type == TLSEXT_TYPE_signed_certificate_timestamp
-            && (context & SSL_EXT_CLIENT_HELLO) != 0
-            && ctx != NULL
-            && SSL_CTX_ct_is_enabled(ctx))
+        && (context & SSL_EXT_CLIENT_HELLO) != 0
+        && ctx != NULL
+        && SSL_CTX_ct_is_enabled(ctx))
         return 0;
 #endif
 
@@ -446,7 +437,7 @@ int ossl_tls_add_custom_ext_intern(SSL_CTX *ctx, custom_ext_methods *exts,
      * for extension types that previously were not supported, but now are.
      */
     if (SSL_extension_supported(ext_type)
-            && ext_type != TLSEXT_TYPE_signed_certificate_timestamp)
+        && ext_type != TLSEXT_TYPE_signed_certificate_timestamp)
         return 0;
 
     /* Extension type must fit in 16 bits */
@@ -456,7 +447,7 @@ int ossl_tls_add_custom_ext_intern(SSL_CTX *ctx, custom_ext_methods *exts,
     if (custom_ext_find(exts, role, ext_type, NULL))
         return 0;
     tmp = OPENSSL_realloc(exts->meths,
-                          (exts->meths_count + 1) * sizeof(custom_ext_method));
+        (exts->meths_count + 1) * sizeof(custom_ext_method));
     if (tmp == NULL)
         return 0;
 
@@ -477,12 +468,12 @@ int ossl_tls_add_custom_ext_intern(SSL_CTX *ctx, custom_ext_methods *exts,
 }
 
 static int add_old_custom_ext(SSL_CTX *ctx, ENDPOINT role,
-                              unsigned int ext_type,
-                              unsigned int context,
-                              custom_ext_add_cb add_cb,
-                              custom_ext_free_cb free_cb,
-                              void *add_arg,
-                              custom_ext_parse_cb parse_cb, void *parse_arg)
+    unsigned int ext_type,
+    unsigned int context,
+    custom_ext_add_cb add_cb,
+    custom_ext_free_cb free_cb,
+    void *add_arg,
+    custom_ext_parse_cb parse_cb, void *parse_arg)
 {
     custom_ext_add_cb_wrap *add_cb_wrap
         = OPENSSL_malloc(sizeof(*add_cb_wrap));
@@ -503,12 +494,12 @@ static int add_old_custom_ext(SSL_CTX *ctx, ENDPOINT role,
     parse_cb_wrap->parse_cb = parse_cb;
 
     ret = ossl_tls_add_custom_ext_intern(ctx, NULL, role, ext_type,
-                                         context,
-                                         custom_ext_add_old_cb_wrap,
-                                         custom_ext_free_old_cb_wrap,
-                                         add_cb_wrap,
-                                         custom_ext_parse_old_cb_wrap,
-                                         parse_cb_wrap);
+        context,
+        custom_ext_add_old_cb_wrap,
+        custom_ext_free_old_cb_wrap,
+        add_cb_wrap,
+        custom_ext_parse_old_cb_wrap,
+        parse_cb_wrap);
 
     if (!ret) {
         OPENSSL_free(add_cb_wrap);
@@ -520,43 +511,43 @@ static int add_old_custom_ext(SSL_CTX *ctx, ENDPOINT role,
 
 /* Application level functions to add the old custom extension callbacks */
 int SSL_CTX_add_client_custom_ext(SSL_CTX *ctx, unsigned int ext_type,
-                                  custom_ext_add_cb add_cb,
-                                  custom_ext_free_cb free_cb,
-                                  void *add_arg,
-                                  custom_ext_parse_cb parse_cb, void *parse_arg)
+    custom_ext_add_cb add_cb,
+    custom_ext_free_cb free_cb,
+    void *add_arg,
+    custom_ext_parse_cb parse_cb, void *parse_arg)
 {
     return add_old_custom_ext(ctx, ENDPOINT_CLIENT, ext_type,
-                              SSL_EXT_TLS1_2_AND_BELOW_ONLY
-                              | SSL_EXT_CLIENT_HELLO
-                              | SSL_EXT_TLS1_2_SERVER_HELLO
-                              | SSL_EXT_IGNORE_ON_RESUMPTION,
-                              add_cb, free_cb, add_arg, parse_cb, parse_arg);
+        SSL_EXT_TLS1_2_AND_BELOW_ONLY
+            | SSL_EXT_CLIENT_HELLO
+            | SSL_EXT_TLS1_2_SERVER_HELLO
+            | SSL_EXT_IGNORE_ON_RESUMPTION,
+        add_cb, free_cb, add_arg, parse_cb, parse_arg);
 }
 
 int SSL_CTX_add_server_custom_ext(SSL_CTX *ctx, unsigned int ext_type,
-                                  custom_ext_add_cb add_cb,
-                                  custom_ext_free_cb free_cb,
-                                  void *add_arg,
-                                  custom_ext_parse_cb parse_cb, void *parse_arg)
+    custom_ext_add_cb add_cb,
+    custom_ext_free_cb free_cb,
+    void *add_arg,
+    custom_ext_parse_cb parse_cb, void *parse_arg)
 {
     return add_old_custom_ext(ctx, ENDPOINT_SERVER, ext_type,
-                              SSL_EXT_TLS1_2_AND_BELOW_ONLY
-                              | SSL_EXT_CLIENT_HELLO
-                              | SSL_EXT_TLS1_2_SERVER_HELLO
-                              | SSL_EXT_IGNORE_ON_RESUMPTION,
-                              add_cb, free_cb, add_arg, parse_cb, parse_arg);
+        SSL_EXT_TLS1_2_AND_BELOW_ONLY
+            | SSL_EXT_CLIENT_HELLO
+            | SSL_EXT_TLS1_2_SERVER_HELLO
+            | SSL_EXT_IGNORE_ON_RESUMPTION,
+        add_cb, free_cb, add_arg, parse_cb, parse_arg);
 }
 
 int SSL_CTX_add_custom_ext(SSL_CTX *ctx, unsigned int ext_type,
-                           unsigned int context,
-                           SSL_custom_ext_add_cb_ex add_cb,
-                           SSL_custom_ext_free_cb_ex free_cb,
-                           void *add_arg,
-                           SSL_custom_ext_parse_cb_ex parse_cb, void *parse_arg)
+    unsigned int context,
+    SSL_custom_ext_add_cb_ex add_cb,
+    SSL_custom_ext_free_cb_ex free_cb,
+    void *add_arg,
+    SSL_custom_ext_parse_cb_ex parse_cb, void *parse_arg)
 {
     return ossl_tls_add_custom_ext_intern(ctx, NULL, ENDPOINT_BOTH, ext_type,
-                                          context, add_cb, free_cb, add_arg,
-                                          parse_cb, parse_arg);
+        context, add_cb, free_cb, add_arg,
+        parse_cb, parse_arg);
 }
 
 int SSL_extension_supported(unsigned int ext_type)
diff --git a/crypto/openssl/ssl/statem/extensions_srvr.c b/crypto/openssl/ssl/statem/extensions_srvr.c
index 1a09913ad63f..cdb914daedcf 100644
--- a/crypto/openssl/ssl/statem/extensions_srvr.c
+++ b/crypto/openssl/ssl/statem/extensions_srvr.c
@@ -13,7 +13,7 @@
 #include "internal/cryptlib.h"
 #include "internal/ssl_unwrap.h"
 
-#define COOKIE_STATE_FORMAT_VERSION     1
+#define COOKIE_STATE_FORMAT_VERSION 1
 
 /*
  * 2 bytes for packet length, 2 bytes for format version, 2 bytes for
@@ -23,7 +23,7 @@
  * length bytes, SHA256_DIGEST_LENGTH bytes for the HMAC of the whole thing.
  */
 #define MAX_COOKIE_SIZE (2 + 2 + 2 + 2 + 2 + 1 + 8 + 2 + EVP_MAX_MD_SIZE + 1 \
-                         + SSL_COOKIE_LENGTH + SHA256_DIGEST_LENGTH)
+    + SSL_COOKIE_LENGTH + SHA256_DIGEST_LENGTH)
 
 /*
  * Message header + 2 bytes for protocol version + number of random bytes +
@@ -32,16 +32,16 @@
  * + 2 bytes for extension block length + 6 bytes for key_share extension
  * + 4 bytes for cookie extension header + the number of bytes in the cookie
  */
-#define MAX_HRR_SIZE    (SSL3_HM_HEADER_LENGTH + 2 + SSL3_RANDOM_SIZE + 1 \
-                         + SSL_MAX_SSL_SESSION_ID_LENGTH + 2 + 1 + 2 + 6 + 4 \
-                         + MAX_COOKIE_SIZE)
+#define MAX_HRR_SIZE (SSL3_HM_HEADER_LENGTH + 2 + SSL3_RANDOM_SIZE + 1 \
+    + SSL_MAX_SSL_SESSION_ID_LENGTH + 2 + 1 + 2 + 6 + 4                \
+    + MAX_COOKIE_SIZE)
 
 /*
  * Parse the client's renegotiation binding and abort if it's not right
  */
 int tls_parse_ctos_renegotiate(SSL_CONNECTION *s, PACKET *pkt,
-                               unsigned int context,
-                               X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     unsigned int ilen;
     const unsigned char *data;
@@ -61,7 +61,7 @@ int tls_parse_ctos_renegotiate(SSL_CONNECTION *s, PACKET *pkt,
     }
 
     ok = memcmp(data, s->s3.previous_client_finished,
-                    s->s3.previous_client_finished_len);
+        s->s3.previous_client_finished_len);
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     if (ok) {
         if ((data[0] ^ s->s3.previous_client_finished[0]) != 0xFF) {
@@ -103,7 +103,7 @@ int tls_parse_ctos_renegotiate(SSL_CONNECTION *s, PACKET *pkt,
  * - On session reconnect, the servername extension may be absent.
  */
 int tls_parse_ctos_server_name(SSL_CONNECTION *s, PACKET *pkt,
-                               unsigned int context, X509 *x, size_t chainidx)
+    unsigned int context, X509 *x, size_t chainidx)
 {
     unsigned int servname_type;
     PACKET sni, hostname;
@@ -168,15 +168,15 @@ int tls_parse_ctos_server_name(SSL_CONNECTION *s, PACKET *pkt,
          */
         s->servername_done = (s->session->ext.hostname != NULL)
             && PACKET_equal(&hostname, s->session->ext.hostname,
-                            strlen(s->session->ext.hostname));
+                strlen(s->session->ext.hostname));
     }
 
     return 1;
 }
 
 int tls_parse_ctos_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     unsigned int value;
 
@@ -188,7 +188,7 @@ int tls_parse_ctos_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt,
     /* Received |value| should be a valid max-fragment-length code. */
     if (!IS_MAX_FRAGMENT_LENGTH_EXT_VALID(value)) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                 SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
+            SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
         return 0;
     }
 
@@ -218,12 +218,12 @@ int tls_parse_ctos_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt,
 
 #ifndef OPENSSL_NO_SRP
 int tls_parse_ctos_srp(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx)
+    X509 *x, size_t chainidx)
 {
     PACKET srp_I;
 
     if (!PACKET_as_length_prefixed_1(pkt, &srp_I)
-            || PACKET_contains_zero_byte(&srp_I)) {
+        || PACKET_contains_zero_byte(&srp_I)) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
         return 0;
     }
@@ -238,8 +238,8 @@ int tls_parse_ctos_srp(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
 #endif
 
 int tls_parse_ctos_ec_pt_formats(SSL_CONNECTION *s, PACKET *pkt,
-                                 unsigned int context,
-                                 X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     PACKET ec_point_format_list;
 
@@ -251,8 +251,8 @@ int tls_parse_ctos_ec_pt_formats(SSL_CONNECTION *s, PACKET *pkt,
 
     if (!s->hit) {
         if (!PACKET_memdup(&ec_point_format_list,
-                           &s->ext.peer_ecpointformats,
-                           &s->ext.peer_ecpointformats_len)) {
+                &s->ext.peer_ecpointformats,
+                &s->ext.peer_ecpointformats_len)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return 0;
         }
@@ -262,13 +262,10 @@ int tls_parse_ctos_ec_pt_formats(SSL_CONNECTION *s, PACKET *pkt,
 }
 
 int tls_parse_ctos_session_ticket(SSL_CONNECTION *s, PACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
-    if (s->ext.session_ticket_cb &&
-            !s->ext.session_ticket_cb(SSL_CONNECTION_GET_USER_SSL(s),
-                                      PACKET_data(pkt), PACKET_remaining(pkt),
-                                      s->ext.session_ticket_cb_arg)) {
+    if (s->ext.session_ticket_cb && !s->ext.session_ticket_cb(SSL_CONNECTION_GET_USER_SSL(s), PACKET_data(pkt), PACKET_remaining(pkt), s->ext.session_ticket_cb_arg)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
@@ -277,14 +274,14 @@ int tls_parse_ctos_session_ticket(SSL_CONNECTION *s, PACKET *pkt,
 }
 
 int tls_parse_ctos_sig_algs_cert(SSL_CONNECTION *s, PACKET *pkt,
-                                 ossl_unused unsigned int context,
-                                 ossl_unused X509 *x,
-                                 ossl_unused size_t chainidx)
+    ossl_unused unsigned int context,
+    ossl_unused X509 *x,
+    ossl_unused size_t chainidx)
 {
     PACKET supported_sig_algs;
 
     if (!PACKET_as_length_prefixed_2(pkt, &supported_sig_algs)
-            || PACKET_remaining(&supported_sig_algs) == 0) {
+        || PACKET_remaining(&supported_sig_algs) == 0) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
         return 0;
     }
@@ -295,7 +292,7 @@ int tls_parse_ctos_sig_algs_cert(SSL_CONNECTION *s, PACKET *pkt,
      * of whether it was a resumption or not.
      */
     if ((!s->server || (s->server && !s->hit))
-            && !tls1_save_sigalgs(s, &supported_sig_algs, 1)) {
+        && !tls1_save_sigalgs(s, &supported_sig_algs, 1)) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
         return 0;
     }
@@ -304,12 +301,12 @@ int tls_parse_ctos_sig_algs_cert(SSL_CONNECTION *s, PACKET *pkt,
 }
 
 int tls_parse_ctos_sig_algs(SSL_CONNECTION *s, PACKET *pkt,
-                            unsigned int context, X509 *x, size_t chainidx)
+    unsigned int context, X509 *x, size_t chainidx)
 {
     PACKET supported_sig_algs;
 
     if (!PACKET_as_length_prefixed_2(pkt, &supported_sig_algs)
-            || PACKET_remaining(&supported_sig_algs) == 0) {
+        || PACKET_remaining(&supported_sig_algs) == 0) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
         return 0;
     }
@@ -320,7 +317,7 @@ int tls_parse_ctos_sig_algs(SSL_CONNECTION *s, PACKET *pkt,
      * of whether it was a resumption or not.
      */
     if ((!s->server || (s->server && !s->hit))
-            && !tls1_save_sigalgs(s, &supported_sig_algs, 0)) {
+        && !tls1_save_sigalgs(s, &supported_sig_algs, 0)) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
         return 0;
     }
@@ -330,8 +327,8 @@ int tls_parse_ctos_sig_algs(SSL_CONNECTION *s, PACKET *pkt,
 
 #ifndef OPENSSL_NO_OCSP
 int tls_parse_ctos_status_request(SSL_CONNECTION *s, PACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     PACKET responder_id_list, exts;
 
@@ -356,7 +353,7 @@ int tls_parse_ctos_status_request(SSL_CONNECTION *s, PACKET *pkt,
         return 1;
     }
 
-    if (!PACKET_get_length_prefixed_2 (pkt, &responder_id_list)) {
+    if (!PACKET_get_length_prefixed_2(pkt, &responder_id_list)) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
         return 0;
     }
@@ -382,14 +379,14 @@ int tls_parse_ctos_status_request(SSL_CONNECTION *s, PACKET *pkt,
         const unsigned char *id_data;
 
         if (!PACKET_get_length_prefixed_2(&responder_id_list, &responder_id)
-                || PACKET_remaining(&responder_id) == 0) {
+            || PACKET_remaining(&responder_id) == 0) {
             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
             return 0;
         }
 
         id_data = PACKET_data(&responder_id);
         id = d2i_OCSP_RESPID(NULL, &id_data,
-                             (int)PACKET_remaining(&responder_id));
+            (int)PACKET_remaining(&responder_id));
         if (id == NULL) {
             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
             return 0;
@@ -420,9 +417,8 @@ int tls_parse_ctos_status_request(SSL_CONNECTION *s, PACKET *pkt,
         const unsigned char *ext_data = PACKET_data(&exts);
 
         sk_X509_EXTENSION_pop_free(s->ext.ocsp.exts,
-                                   X509_EXTENSION_free);
-        s->ext.ocsp.exts =
-            d2i_X509_EXTENSIONS(NULL, &ext_data, (int)PACKET_remaining(&exts));
+            X509_EXTENSION_free);
+        s->ext.ocsp.exts = d2i_X509_EXTENSIONS(NULL, &ext_data, (int)PACKET_remaining(&exts));
         if (s->ext.ocsp.exts == NULL || ext_data != PACKET_end(&exts)) {
             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
             return 0;
@@ -435,7 +431,7 @@ int tls_parse_ctos_status_request(SSL_CONNECTION *s, PACKET *pkt,
 
 #ifndef OPENSSL_NO_NEXTPROTONEG
 int tls_parse_ctos_npn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx)
+    X509 *x, size_t chainidx)
 {
     /*
      * We shouldn't accept this extension on a
@@ -453,7 +449,7 @@ int tls_parse_ctos_npn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
  * extension, not including type and length. Returns: 1 on success, 0 on error.
  */
 int tls_parse_ctos_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                        X509 *x, size_t chainidx)
+    X509 *x, size_t chainidx)
 {
     PACKET protocol_list, save_protocol_list, protocol;
 
@@ -470,7 +466,7 @@ int tls_parse_ctos_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
     do {
         /* Protocol names can't be empty. */
         if (!PACKET_get_length_prefixed_1(&protocol_list, &protocol)
-                || PACKET_remaining(&protocol) == 0) {
+            || PACKET_remaining(&protocol) == 0) {
             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
             return 0;
         }
@@ -480,7 +476,7 @@ int tls_parse_ctos_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
     s->s3.alpn_proposed = NULL;
     s->s3.alpn_proposed_len = 0;
     if (!PACKET_memdup(&save_protocol_list,
-                       &s->s3.alpn_proposed, &s->s3.alpn_proposed_len)) {
+            &s->s3.alpn_proposed, &s->s3.alpn_proposed_len)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
@@ -490,7 +486,7 @@ int tls_parse_ctos_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
 
 #ifndef OPENSSL_NO_SRTP
 int tls_parse_ctos_use_srtp(SSL_CONNECTION *s, PACKET *pkt,
-                            unsigned int context, X509 *x, size_t chainidx)
+    unsigned int context, X509 *x, size_t chainidx)
 {
     STACK_OF(SRTP_PROTECTION_PROFILE) *srvr;
     unsigned int ct, mki_len, id;
@@ -504,9 +500,9 @@ int tls_parse_ctos_use_srtp(SSL_CONNECTION *s, PACKET *pkt,
 
     /* Pull off the length of the cipher suite list  and check it is even */
     if (!PACKET_get_net_2(pkt, &ct) || (ct & 1) != 0
-            || !PACKET_get_sub_packet(pkt, &subpkt, ct)) {
+        || !PACKET_get_sub_packet(pkt, &subpkt, ct)) {
         SSLfatal(s, SSL_AD_DECODE_ERROR,
-               SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
+            SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
         return 0;
     }
 
@@ -518,7 +514,7 @@ int tls_parse_ctos_use_srtp(SSL_CONNECTION *s, PACKET *pkt,
     while (PACKET_remaining(&subpkt)) {
         if (!PACKET_get_net_2(&subpkt, &id)) {
             SSLfatal(s, SSL_AD_DECODE_ERROR,
-                     SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
+                SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
             return 0;
         }
 
@@ -529,8 +525,7 @@ int tls_parse_ctos_use_srtp(SSL_CONNECTION *s, PACKET *pkt,
          * does nothing.
          */
         for (i = 0; i < srtp_pref; i++) {
-            SRTP_PROTECTION_PROFILE *sprof =
-                sk_SRTP_PROTECTION_PROFILE_value(srvr, i);
+            SRTP_PROTECTION_PROFILE *sprof = sk_SRTP_PROTECTION_PROFILE_value(srvr, i);
 
             if (sprof->id == id) {
                 s->srtp_profile = sprof;
@@ -543,7 +538,7 @@ int tls_parse_ctos_use_srtp(SSL_CONNECTION *s, PACKET *pkt,
     /* Now extract the MKI value as a sanity check, but discard it for now */
     if (!PACKET_get_1(pkt, &mki_len)) {
         SSLfatal(s, SSL_AD_DECODE_ERROR,
-                 SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
+            SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
         return 0;
     }
 
@@ -558,7 +553,7 @@ int tls_parse_ctos_use_srtp(SSL_CONNECTION *s, PACKET *pkt,
 #endif
 
 int tls_parse_ctos_etm(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx)
+    X509 *x, size_t chainidx)
 {
     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC))
         s->ext.use_etm = 1;
@@ -571,15 +566,15 @@ int tls_parse_ctos_etm(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
  * the raw PACKET data for the extension. Returns 1 on success or 0 on failure.
  */
 int tls_parse_ctos_psk_kex_modes(SSL_CONNECTION *s, PACKET *pkt,
-                                 unsigned int context,
-                                 X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
 #ifndef OPENSSL_NO_TLS1_3
     PACKET psk_kex_modes;
     unsigned int mode;
 
     if (!PACKET_as_length_prefixed_1(pkt, &psk_kex_modes)
-            || PACKET_remaining(&psk_kex_modes) == 0) {
+        || PACKET_remaining(&psk_kex_modes) == 0) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
         return 0;
     }
@@ -588,12 +583,12 @@ int tls_parse_ctos_psk_kex_modes(SSL_CONNECTION *s, PACKET *pkt,
         if (mode == TLSEXT_KEX_MODE_KE_DHE)
             s->ext.psk_kex_mode |= TLSEXT_KEX_MODE_FLAG_KE_DHE;
         else if (mode == TLSEXT_KEX_MODE_KE
-                && (s->options & SSL_OP_ALLOW_NO_DHE_KEX) != 0)
+            && (s->options & SSL_OP_ALLOW_NO_DHE_KEX) != 0)
             s->ext.psk_kex_mode |= TLSEXT_KEX_MODE_FLAG_KE;
     }
 
     if (((s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) != 0)
-            && (s->options & SSL_OP_PREFER_NO_DHE_KEX) != 0) {
+        && (s->options & SSL_OP_PREFER_NO_DHE_KEX) != 0) {
 
         /*
          * If NO_DHE is supported and preferred, then we only remember this
@@ -631,20 +626,21 @@ static int tls_accept_ksgroup(SSL_CONNECTION *s, uint16_t ksgroup, PACKET *encod
     s->session->kex_group = ksgroup;
     if ((s->s3.peer_tmp = ssl_generate_param_group(s, ksgroup)) == NULL) {
         SSLfatal(s,
-                 SSL_AD_INTERNAL_ERROR,
-                 SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
+            SSL_AD_INTERNAL_ERROR,
+            SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
         return 0;
     }
     if (tls13_set_encoded_pub_key(s->s3.peer_tmp,
-                                  PACKET_data(encoded_pubkey),
-                                  PACKET_remaining(encoded_pubkey)) <= 0) {
+            PACKET_data(encoded_pubkey),
+            PACKET_remaining(encoded_pubkey))
+        <= 0) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_ECPOINT);
         return 0;
     }
     return 1;
 }
 
-# define GROUPLIST_INCREMENT 32 /* Memory allocation chunk size (nominally 64 Bytes chunks) */
+#define GROUPLIST_INCREMENT 32 /* Memory allocation chunk size (nominally 64 Bytes chunks) */
 
 typedef enum KS_EXTRACTION_RESULT {
     EXTRACTION_FAILURE,
@@ -653,10 +649,10 @@ typedef enum KS_EXTRACTION_RESULT {
 } KS_EXTRACTION_RESULT;
 
 static KS_EXTRACTION_RESULT extract_keyshares(SSL_CONNECTION *s, PACKET *key_share_list,
-                                              const uint16_t *clntgroups, size_t clnt_num_groups,
-                                              const uint16_t *srvrgroups, size_t srvr_num_groups,
-                                              uint16_t **keyshares_arr, PACKET **encoded_pubkey_arr,
-                                              size_t *keyshares_cnt, size_t *keyshares_max)
+    const uint16_t *clntgroups, size_t clnt_num_groups,
+    const uint16_t *srvrgroups, size_t srvr_num_groups,
+    uint16_t **keyshares_arr, PACKET **encoded_pubkey_arr,
+    size_t *keyshares_cnt, size_t *keyshares_max)
 {
     PACKET encoded_pubkey;
     size_t key_share_pos = 0;
@@ -678,8 +674,8 @@ static KS_EXTRACTION_RESULT extract_keyshares(SSL_CONNECTION *s, PACKET *key_sha
     while (PACKET_remaining(key_share_list) > 0) {
         /* Get the group_id for the current share and its encoded_pubkey */
         if (!PACKET_get_net_2(key_share_list, &group_id)
-                || !PACKET_get_length_prefixed_2(key_share_list, &encoded_pubkey)
-                || PACKET_remaining(&encoded_pubkey) == 0) {
+            || !PACKET_get_length_prefixed_2(key_share_list, &encoded_pubkey)
+            || PACKET_remaining(&encoded_pubkey) == 0) {
             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
             goto failure;
         }
@@ -689,8 +685,8 @@ static KS_EXTRACTION_RESULT extract_keyshares(SSL_CONNECTION *s, PACKET *key_sha
          * we requested, and must be the only key_share sent.
          */
         if (s->s3.group_id != 0
-                && (group_id != s->s3.group_id
-                    || PACKET_remaining(key_share_list) != 0)) {
+            && (group_id != s->s3.group_id
+                || PACKET_remaining(key_share_list) != 0)) {
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_SHARE);
             goto failure;
         }
@@ -731,9 +727,9 @@ static KS_EXTRACTION_RESULT extract_keyshares(SSL_CONNECTION *s, PACKET *key_sha
          * suitable for TLSv1.3 or which is not supported by the server
          */
         if (!check_in_list(s, group_id, srvrgroups, srvr_num_groups, 1, NULL)
-                || !tls_group_allowed(s, group_id, SSL_SECOP_CURVE_SUPPORTED)
-                || !tls_valid_group(s, group_id, TLS1_3_VERSION, TLS1_3_VERSION,
-                                    0, NULL)) {
+            || !tls_group_allowed(s, group_id, SSL_SECOP_CURVE_SUPPORTED)
+            || !tls_valid_group(s, group_id, TLS1_3_VERSION, TLS1_3_VERSION,
+                0, NULL)) {
             /* Share not suitable or not supported, check next share */
             continue;
         }
@@ -749,23 +745,25 @@ static KS_EXTRACTION_RESULT extract_keyshares(SSL_CONNECTION *s, PACKET *key_sha
          */
         if (*keyshares_cnt == *keyshares_max) {
             PACKET *tmp_pkt;
-            uint16_t *tmp =
-                OPENSSL_realloc(*keyshares_arr,
-                                (*keyshares_max + GROUPLIST_INCREMENT) * sizeof(**keyshares_arr));
+            uint16_t *tmp = OPENSSL_realloc(*keyshares_arr,
+                (*keyshares_max + GROUPLIST_INCREMENT) * sizeof(**keyshares_arr));
 
-            if (tmp == NULL)
+            if (tmp == NULL) {
+                SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 goto failure;
+            }
+
             *keyshares_arr = tmp;
-            tmp_pkt =
-                OPENSSL_realloc(*encoded_pubkey_arr,
-                                (*keyshares_max + GROUPLIST_INCREMENT) *
-                                sizeof(**encoded_pubkey_arr));
-            if (tmp_pkt == NULL)
+            tmp_pkt = OPENSSL_realloc(*encoded_pubkey_arr,
+                (*keyshares_max + GROUPLIST_INCREMENT) * sizeof(**encoded_pubkey_arr));
+            if (tmp_pkt == NULL) {
+                SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 goto failure;
+            }
+
             *encoded_pubkey_arr = tmp_pkt;
             *keyshares_max += GROUPLIST_INCREMENT;
         }
-
     }
 
     return EXTRACTION_SUCCESS;
@@ -786,10 +784,10 @@ failure:
  */
 #ifndef OPENSSL_NO_TLS1_3
 static void check_overlap(SSL_CONNECTION *s,
-                          const uint16_t *prio_groups, size_t prio_num_groups,
-                          const uint16_t *candidate_groups, size_t candidate_num_groups,
-                          int *prio_group_idx, int *candidate_group_idx,
-                          uint16_t *selected_group)
+    const uint16_t *prio_groups, size_t prio_num_groups,
+    const uint16_t *candidate_groups, size_t candidate_num_groups,
+    int *prio_group_idx, int *candidate_group_idx,
+    uint16_t *selected_group)
 {
     uint16_t current_group;
     size_t group_idx = prio_num_groups;
@@ -801,11 +799,11 @@ static void check_overlap(SSL_CONNECTION *s,
 
     for (current_group = 0; current_group < candidate_num_groups; current_group++) {
         if (!check_in_list(s, candidate_groups[current_group], prio_groups,
-                           prio_num_groups, 1, &new_group_idx)
+                prio_num_groups, 1, &new_group_idx)
             || !tls_group_allowed(s, candidate_groups[current_group],
-                                  SSL_SECOP_CURVE_SUPPORTED)
+                SSL_SECOP_CURVE_SUPPORTED)
             || !tls_valid_group(s, candidate_groups[current_group], TLS1_3_VERSION,
-                                TLS1_3_VERSION, 0, NULL))
+                TLS1_3_VERSION, 0, NULL))
             /* No overlap or group not suitable, check next group */
             continue;
 
@@ -824,7 +822,7 @@ static void check_overlap(SSL_CONNECTION *s,
 #endif
 
 int tls_parse_ctos_key_share(SSL_CONNECTION *s, PACKET *pkt,
-                             unsigned int context, X509 *x, size_t chainidx)
+    unsigned int context, X509 *x, size_t chainidx)
 {
 #ifndef OPENSSL_NO_TLS1_3
     PACKET key_share_list;
@@ -870,7 +868,7 @@ int tls_parse_ctos_key_share(SSL_CONNECTION *s, PACKET *pkt,
          * extension.
          */
         SSLfatal(s, SSL_AD_MISSING_EXTENSION,
-                 SSL_R_MISSING_SUPPORTED_GROUPS_EXTENSION);
+            SSL_R_MISSING_SUPPORTED_GROUPS_EXTENSION);
         return 0;
     }
 
@@ -886,11 +884,11 @@ int tls_parse_ctos_key_share(SSL_CONNECTION *s, PACKET *pkt,
 
     /* We parse the key share extension and memorize the entries (after some checks) */
     ks_extraction_result = extract_keyshares(s,
-                                             &key_share_list,
-                                             clntgroups, clnt_num_groups,
-                                             srvrgroups, srvr_num_groups,
-                                             &keyshares_arr, &encoded_pubkey_arr,
-                                             &keyshares_cnt, &keyshares_max);
+        &key_share_list,
+        clntgroups, clnt_num_groups,
+        srvrgroups, srvr_num_groups,
+        &keyshares_arr, &encoded_pubkey_arr,
+        &keyshares_cnt, &keyshares_max);
 
     if (ks_extraction_result == EXTRACTION_FAILURE) /* Fatal error during tests */
         return 0; /* Memory already freed and SSLfatal already called */
@@ -898,7 +896,7 @@ int tls_parse_ctos_key_share(SSL_CONNECTION *s, PACKET *pkt,
         goto end;
 
     /*
-     * We now have the folowing lists available to make a decision for
+     * We now have the following lists available to make a decision for
      * which group the server should use for key exchange :
      * From client: clntgroups[clnt_num_groups],
      *              keyshares_arr[keyshares_cnt], encoded_pubkey_arr[keyshares_cnt]
@@ -924,13 +922,13 @@ int tls_parse_ctos_key_share(SSL_CONNECTION *s, PACKET *pkt,
             /* Server preference */
             /* Is there overlap with a key share group?  */
             check_overlap(s,
-                          first_group_in_tuple, number_of_groups_in_tuple,
-                          keyshares_arr, keyshares_cnt,
-                          &prio_group_idx, &candidate_group_idx,
-                          &group_id_candidate);
+                first_group_in_tuple, number_of_groups_in_tuple,
+                keyshares_arr, keyshares_cnt,
+                &prio_group_idx, &candidate_group_idx,
+                &group_id_candidate);
             if (group_id_candidate > 0) { /* Overlap found -> accept the key share group */
                 if (!tls_accept_ksgroup(s, group_id_candidate,
-                                        &encoded_pubkey_arr[candidate_group_idx]))
+                        &encoded_pubkey_arr[candidate_group_idx]))
                     goto err; /* SSLfatal already called */
                 /* We have all info for a SH, hence we're done here */
                 goto end;
@@ -940,10 +938,10 @@ int tls_parse_ctos_key_share(SSL_CONNECTION *s, PACKET *pkt,
                  * supported_group overlapping with the current tuple?
                  */
                 check_overlap(s,
-                              first_group_in_tuple, number_of_groups_in_tuple,
-                              clntgroups, clnt_num_groups,
-                              &prio_group_idx, &candidate_group_idx,
-                              &group_id_candidate);
+                    first_group_in_tuple, number_of_groups_in_tuple,
+                    clntgroups, clnt_num_groups,
+                    &prio_group_idx, &candidate_group_idx,
+                    &group_id_candidate);
                 if (group_id_candidate > 0) {
                     /*
                      * We did not have a key share overlap, but at least the supported
@@ -964,20 +962,20 @@ int tls_parse_ctos_key_share(SSL_CONNECTION *s, PACKET *pkt,
 
         } else { /* We have client preference */
             check_overlap(s,
-                          keyshares_arr, keyshares_cnt,
-                          first_group_in_tuple, number_of_groups_in_tuple,
-                          &prio_group_idx, &candidate_group_idx,
-                          &group_id_candidate);
+                keyshares_arr, keyshares_cnt,
+                first_group_in_tuple, number_of_groups_in_tuple,
+                &prio_group_idx, &candidate_group_idx,
+                &group_id_candidate);
             if (group_id_candidate > 0) {
                 if (!tls_accept_ksgroup(s, group_id_candidate, &encoded_pubkey_arr[prio_group_idx]))
                     goto err;
                 goto end;
             } else {
                 check_overlap(s,
-                              clntgroups, clnt_num_groups,
-                              first_group_in_tuple, number_of_groups_in_tuple,
-                              &prio_group_idx, &candidate_group_idx,
-                              &group_id_candidate);
+                    clntgroups, clnt_num_groups,
+                    first_group_in_tuple, number_of_groups_in_tuple,
+                    &prio_group_idx, &candidate_group_idx,
+                    &group_id_candidate);
                 if (group_id_candidate > 0) {
                     s->s3.group_id_candidate = group_id_candidate;
                     goto end;
@@ -1003,7 +1001,7 @@ err:
 }
 
 int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                          X509 *x, size_t chainidx)
+    X509 *x, size_t chainidx)
 {
 #ifndef OPENSSL_NO_TLS1_3
     unsigned int format, version, key_share, group_id;
@@ -1021,7 +1019,7 @@ int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
 
     /* Ignore any cookie if we're not set up to verify it */
     if (sctx->verify_stateless_cookie_cb == NULL
-            || (s->s3.flags & TLS1_FLAGS_STATELESS) == 0)
+        || (s->s3.flags & TLS1_FLAGS_STATELESS) == 0)
         return 1;
 
     if (!PACKET_as_length_prefixed_2(pkt, &cookie)) {
@@ -1033,7 +1031,7 @@ int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
     data = PACKET_data(&raw);
     rawlen = PACKET_remaining(&raw);
     if (rawlen < SHA256_DIGEST_LENGTH
-            || !PACKET_forward(&raw, rawlen - SHA256_DIGEST_LENGTH)) {
+        || !PACKET_forward(&raw, rawlen - SHA256_DIGEST_LENGTH)) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
         return 0;
     }
@@ -1042,9 +1040,9 @@ int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
     /* Verify the HMAC of the cookie */
     hctx = EVP_MD_CTX_create();
     pkey = EVP_PKEY_new_raw_private_key_ex(sctx->libctx, "HMAC",
-                                           sctx->propq,
-                                           s->session_ctx->ext.cookie_hmac_key,
-                                           sizeof(s->session_ctx->ext.cookie_hmac_key));
+        sctx->propq,
+        s->session_ctx->ext.cookie_hmac_key,
+        sizeof(s->session_ctx->ext.cookie_hmac_key));
     if (hctx == NULL || pkey == NULL) {
         EVP_MD_CTX_free(hctx);
         EVP_PKEY_free(pkey);
@@ -1054,10 +1052,12 @@ int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
 
     hmaclen = SHA256_DIGEST_LENGTH;
     if (EVP_DigestSignInit_ex(hctx, NULL, "SHA2-256", sctx->libctx,
-                              sctx->propq, pkey, NULL) <= 0
-            || EVP_DigestSign(hctx, hmac, &hmaclen, data,
-                              rawlen - SHA256_DIGEST_LENGTH) <= 0
-            || hmaclen != SHA256_DIGEST_LENGTH) {
+            sctx->propq, pkey, NULL)
+            <= 0
+        || EVP_DigestSign(hctx, hmac, &hmaclen, data,
+               rawlen - SHA256_DIGEST_LENGTH)
+            <= 0
+        || hmaclen != SHA256_DIGEST_LENGTH) {
         EVP_MD_CTX_free(hctx);
         EVP_PKEY_free(pkey);
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
@@ -1092,7 +1092,7 @@ int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
     }
     if (version != TLS1_3_VERSION) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                 SSL_R_BAD_PROTOCOL_VERSION_NUMBER);
+            SSL_R_BAD_PROTOCOL_VERSION_NUMBER);
         return 0;
     }
 
@@ -1107,8 +1107,8 @@ int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
         return 0;
     }
     if (group_id != s->s3.group_id
-            || s->s3.tmp.new_cipher
-               != ssl_get_cipher_by_char(s, ciphdata, 0)) {
+        || s->s3.tmp.new_cipher
+            != ssl_get_cipher_by_char(s, ciphdata, 0)) {
         /*
          * We chose a different cipher or group id this time around to what is
          * in the cookie. Something must have changed.
@@ -1118,10 +1118,10 @@ int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
     }
 
     if (!PACKET_get_1(&cookie, &key_share)
-            || !PACKET_get_net_8(&cookie, &tm)
-            || !PACKET_get_length_prefixed_2(&cookie, &chhash)
-            || !PACKET_get_length_prefixed_1(&cookie, &appcookie)
-            || PACKET_remaining(&cookie) != SHA256_DIGEST_LENGTH) {
+        || !PACKET_get_net_8(&cookie, &tm)
+        || !PACKET_get_length_prefixed_2(&cookie, &chhash)
+        || !PACKET_get_length_prefixed_1(&cookie, &appcookie)
+        || PACKET_remaining(&cookie) != SHA256_DIGEST_LENGTH) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
         return 0;
     }
@@ -1135,8 +1135,9 @@ int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
 
     /* Verify the app cookie */
     if (sctx->verify_stateless_cookie_cb(SSL_CONNECTION_GET_USER_SSL(s),
-                                         PACKET_data(&appcookie),
-                                         PACKET_remaining(&appcookie)) == 0) {
+            PACKET_data(&appcookie),
+            PACKET_remaining(&appcookie))
+        == 0) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_COOKIE_MISMATCH);
         return 0;
     }
@@ -1151,45 +1152,45 @@ int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
         return 0;
     }
     if (!WPACKET_put_bytes_u8(&hrrpkt, SSL3_MT_SERVER_HELLO)
-            || !WPACKET_start_sub_packet_u24(&hrrpkt)
-            || !WPACKET_put_bytes_u16(&hrrpkt, TLS1_2_VERSION)
-            || !WPACKET_memcpy(&hrrpkt, hrrrandom, SSL3_RANDOM_SIZE)
-            || !WPACKET_sub_memcpy_u8(&hrrpkt, s->tmp_session_id,
-                                      s->tmp_session_id_len)
-            || !ssl->method->put_cipher_by_char(s->s3.tmp.new_cipher, &hrrpkt,
-                                                &ciphlen)
-            || !WPACKET_put_bytes_u8(&hrrpkt, 0)
-            || !WPACKET_start_sub_packet_u16(&hrrpkt)) {
+        || !WPACKET_start_sub_packet_u24(&hrrpkt)
+        || !WPACKET_put_bytes_u16(&hrrpkt, TLS1_2_VERSION)
+        || !WPACKET_memcpy(&hrrpkt, hrrrandom, SSL3_RANDOM_SIZE)
+        || !WPACKET_sub_memcpy_u8(&hrrpkt, s->tmp_session_id,
+            s->tmp_session_id_len)
+        || !ssl->method->put_cipher_by_char(s->s3.tmp.new_cipher, &hrrpkt,
+            &ciphlen)
+        || !WPACKET_put_bytes_u8(&hrrpkt, 0)
+        || !WPACKET_start_sub_packet_u16(&hrrpkt)) {
         WPACKET_cleanup(&hrrpkt);
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
     if (!WPACKET_put_bytes_u16(&hrrpkt, TLSEXT_TYPE_supported_versions)
-            || !WPACKET_start_sub_packet_u16(&hrrpkt)
-            || !WPACKET_put_bytes_u16(&hrrpkt, s->version)
-            || !WPACKET_close(&hrrpkt)) {
+        || !WPACKET_start_sub_packet_u16(&hrrpkt)
+        || !WPACKET_put_bytes_u16(&hrrpkt, s->version)
+        || !WPACKET_close(&hrrpkt)) {
         WPACKET_cleanup(&hrrpkt);
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
     if (key_share) {
         if (!WPACKET_put_bytes_u16(&hrrpkt, TLSEXT_TYPE_key_share)
-                || !WPACKET_start_sub_packet_u16(&hrrpkt)
-                || !WPACKET_put_bytes_u16(&hrrpkt, s->s3.group_id)
-                || !WPACKET_close(&hrrpkt)) {
+            || !WPACKET_start_sub_packet_u16(&hrrpkt)
+            || !WPACKET_put_bytes_u16(&hrrpkt, s->s3.group_id)
+            || !WPACKET_close(&hrrpkt)) {
             WPACKET_cleanup(&hrrpkt);
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return 0;
         }
     }
     if (!WPACKET_put_bytes_u16(&hrrpkt, TLSEXT_TYPE_cookie)
-            || !WPACKET_start_sub_packet_u16(&hrrpkt)
-            || !WPACKET_sub_memcpy_u16(&hrrpkt, data, rawlen)
-            || !WPACKET_close(&hrrpkt) /* cookie extension */
-            || !WPACKET_close(&hrrpkt) /* extension block */
-            || !WPACKET_close(&hrrpkt) /* message */
-            || !WPACKET_get_total_written(&hrrpkt, &hrrlen)
-            || !WPACKET_finish(&hrrpkt)) {
+        || !WPACKET_start_sub_packet_u16(&hrrpkt)
+        || !WPACKET_sub_memcpy_u16(&hrrpkt, data, rawlen)
+        || !WPACKET_close(&hrrpkt) /* cookie extension */
+        || !WPACKET_close(&hrrpkt) /* extension block */
+        || !WPACKET_close(&hrrpkt) /* message */
+        || !WPACKET_get_total_written(&hrrpkt, &hrrlen)
+        || !WPACKET_finish(&hrrpkt)) {
         WPACKET_cleanup(&hrrpkt);
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
@@ -1197,8 +1198,8 @@ int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
 
     /* Reconstruct the transcript hash */
     if (!create_synthetic_message_hash(s, PACKET_data(&chhash),
-                                       PACKET_remaining(&chhash), hrr,
-                                       hrrlen)) {
+            PACKET_remaining(&chhash), hrr,
+            hrrlen)) {
         /* SSLfatal() already called */
         return 0;
     }
@@ -1213,15 +1214,15 @@ int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
 }
 
 int tls_parse_ctos_supported_groups(SSL_CONNECTION *s, PACKET *pkt,
-                                    unsigned int context,
-                                    X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     PACKET supported_groups_list;
 
     /* Each group is 2 bytes and we must have at least 1. */
     if (!PACKET_as_length_prefixed_2(pkt, &supported_groups_list)
-            || PACKET_remaining(&supported_groups_list) == 0
-            || (PACKET_remaining(&supported_groups_list) % 2) != 0) {
+        || PACKET_remaining(&supported_groups_list) == 0
+        || (PACKET_remaining(&supported_groups_list) % 2) != 0) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
         return 0;
     }
@@ -1231,8 +1232,8 @@ int tls_parse_ctos_supported_groups(SSL_CONNECTION *s, PACKET *pkt,
         s->ext.peer_supportedgroups = NULL;
         s->ext.peer_supportedgroups_len = 0;
         if (!tls1_save_u16(&supported_groups_list,
-                           &s->ext.peer_supportedgroups,
-                           &s->ext.peer_supportedgroups_len)) {
+                &s->ext.peer_supportedgroups,
+                &s->ext.peer_supportedgroups_len)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return 0;
         }
@@ -1242,7 +1243,7 @@ int tls_parse_ctos_supported_groups(SSL_CONNECTION *s, PACKET *pkt,
 }
 
 int tls_parse_ctos_ems(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx)
+    X509 *x, size_t chainidx)
 {
     /* The extension must always be empty */
     if (PACKET_remaining(pkt) != 0) {
@@ -1258,9 +1259,8 @@ int tls_parse_ctos_ems(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
     return 1;
 }
 
-
 int tls_parse_ctos_early_data(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                              X509 *x, size_t chainidx)
+    X509 *x, size_t chainidx)
 {
     if (PACKET_remaining(pkt) != 0) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
@@ -1276,25 +1276,25 @@ int tls_parse_ctos_early_data(SSL_CONNECTION *s, PACKET *pkt, unsigned int conte
 }
 
 static SSL_TICKET_STATUS tls_get_stateful_ticket(SSL_CONNECTION *s, PACKET *tick,
-                                                 SSL_SESSION **sess)
+    SSL_SESSION **sess)
 {
     SSL_SESSION *tmpsess = NULL;
 
     s->ext.ticket_expected = 1;
 
     switch (PACKET_remaining(tick)) {
-        case 0:
-            return SSL_TICKET_EMPTY;
+    case 0:
+        return SSL_TICKET_EMPTY;
 
-        case SSL_MAX_SSL_SESSION_ID_LENGTH:
-            break;
+    case SSL_MAX_SSL_SESSION_ID_LENGTH:
+        break;
 
-        default:
-            return SSL_TICKET_NO_DECRYPT;
+    default:
+        return SSL_TICKET_NO_DECRYPT;
     }
 
     tmpsess = lookup_sess_in_cache(s, PACKET_data(tick),
-                                   SSL_MAX_SSL_SESSION_ID_LENGTH);
+        SSL_MAX_SSL_SESSION_ID_LENGTH);
 
     if (tmpsess == NULL)
         return SSL_TICKET_NO_DECRYPT;
@@ -1304,7 +1304,7 @@ static SSL_TICKET_STATUS tls_get_stateful_ticket(SSL_CONNECTION *s, PACKET *tick
 }
 
 int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx)
+    X509 *x, size_t chainidx)
 {
     PACKET identities, binders, binder;
     size_t binderoffset;
@@ -1320,7 +1320,8 @@ int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
      * ignore this extension
      */
     if ((s->ext.psk_kex_mode
-            & (TLSEXT_KEX_MODE_FLAG_KE | TLSEXT_KEX_MODE_FLAG_KE_DHE)) == 0)
+            & (TLSEXT_KEX_MODE_FLAG_KE | TLSEXT_KEX_MODE_FLAG_KE_DHE))
+        == 0)
         return 1;
 
     if (!PACKET_get_length_prefixed_2(pkt, &identities)) {
@@ -1335,23 +1336,23 @@ int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
         size_t idlen;
 
         if (!PACKET_get_length_prefixed_2(&identities, &identity)
-                || !PACKET_get_net_4(&identities, &ticket_agel)) {
+            || !PACKET_get_net_4(&identities, &ticket_agel)) {
             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
             return 0;
         }
 
         idlen = PACKET_remaining(&identity);
         if (s->psk_find_session_cb != NULL
-                && !s->psk_find_session_cb(ussl, PACKET_data(&identity), idlen,
-                                           &sess)) {
+            && !s->psk_find_session_cb(ussl, PACKET_data(&identity), idlen,
+                &sess)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_EXTENSION);
             return 0;
         }
 
 #ifndef OPENSSL_NO_PSK
         if (sess == NULL
-                && s->psk_server_callback != NULL
-                && idlen <= PSK_MAX_IDENTITY_LEN) {
+            && s->psk_server_callback != NULL
+            && idlen <= PSK_MAX_IDENTITY_LEN) {
             char *pskid = NULL;
             unsigned char pskdata[PSK_MAX_PSK_LEN];
             unsigned int pskdatalen;
@@ -1361,7 +1362,7 @@ int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
                 return 0;
             }
             pskdatalen = s->psk_server_callback(ussl, pskid, pskdata,
-                                                sizeof(pskdata));
+                sizeof(pskdata));
             OPENSSL_free(pskid);
             if (pskdatalen > PSK_MAX_PSK_LEN) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
@@ -1375,7 +1376,7 @@ int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
                  * the digest so we default to SHA256 as per the TLSv1.3 spec
                  */
                 cipher = SSL_CIPHER_find(SSL_CONNECTION_GET_SSL(s),
-                                         tls13_aes128gcmsha256_id);
+                    tls13_aes128gcmsha256_id);
                 if (cipher == NULL) {
                     OPENSSL_cleanse(pskdata, pskdatalen);
                     SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
@@ -1384,11 +1385,11 @@ int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
 
                 sess = SSL_SESSION_new();
                 if (sess == NULL
-                        || !SSL_SESSION_set1_master_key(sess, pskdata,
-                                                        pskdatalen)
-                        || !SSL_SESSION_set_cipher(sess, cipher)
-                        || !SSL_SESSION_set_protocol_version(sess,
-                                                             TLS1_3_VERSION)) {
+                    || !SSL_SESSION_set1_master_key(sess, pskdata,
+                        pskdatalen)
+                    || !SSL_SESSION_set_cipher(sess, cipher)
+                    || !SSL_SESSION_set_protocol_version(sess,
+                        TLS1_3_VERSION)) {
                     OPENSSL_cleanse(pskdata, pskdatalen);
                     SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                     goto err;
@@ -1429,13 +1430,13 @@ int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
              * is no point in using full stateless tickets.
              */
             if ((s->options & SSL_OP_NO_TICKET) != 0
-                    || (s->max_early_data > 0
-                        && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0))
+                || (s->max_early_data > 0
+                    && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0))
                 ret = tls_get_stateful_ticket(s, &identity, &sess);
             else
                 ret = tls_decrypt_ticket(s, PACKET_data(&identity),
-                                         PACKET_remaining(&identity), NULL, 0,
-                                         &sess);
+                    PACKET_remaining(&identity), NULL, 0,
+                    &sess);
 
             if (ret == SSL_TICKET_EMPTY) {
                 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_EXTENSION);
@@ -1443,7 +1444,7 @@ int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
             }
 
             if (ret == SSL_TICKET_FATAL_ERR_MALLOC
-                    || ret == SSL_TICKET_FATAL_ERR_OTHER) {
+                || ret == SSL_TICKET_FATAL_ERR_OTHER) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 return 0;
             }
@@ -1452,15 +1453,15 @@ int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
 
             /* Check for replay */
             if (s->max_early_data > 0
-                    && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0
-                    && !SSL_CTX_remove_session(s->session_ctx, sess)) {
+                && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0
+                && !SSL_CTX_remove_session(s->session_ctx, sess)) {
                 SSL_SESSION_free(sess);
                 sess = NULL;
                 continue;
             }
 
             age = ossl_time_subtract(ossl_ms2time(ticket_agel),
-                                     ossl_ms2time(sess->ext.tick_age_add));
+                ossl_ms2time(sess->ext.tick_age_add));
             t = ossl_time_subtract(ossl_time_now(), sess->time);
 
             /*
@@ -1475,10 +1476,11 @@ int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
             expire = ossl_time_add(t, ossl_ms2time(1000));
 
             if (id == 0
-                    && ossl_time_compare(sess->timeout, t) >= 0
-                    && ossl_time_compare(age, expire) <= 0
-                    && ossl_time_compare(ossl_time_add(age, TICKET_AGE_ALLOWANCE),
-                                         expire) >= 0) {
+                && ossl_time_compare(sess->timeout, t) >= 0
+                && ossl_time_compare(age, expire) <= 0
+                && ossl_time_compare(ossl_time_add(age, TICKET_AGE_ALLOWANCE),
+                       expire)
+                    >= 0) {
                 /*
                  * Ticket age is within tolerance and not expired. We allow it
                  * for early data
@@ -1494,7 +1496,7 @@ int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
         }
         if (!EVP_MD_is_a(md,
                 EVP_MD_get0_name(ssl_md(sctx,
-                                        s->s3.tmp.new_cipher->algorithm2)))) {
+                    s->s3.tmp.new_cipher->algorithm2)))) {
             /* The ciphersuite is not compatible with this session. */
             SSL_SESSION_free(sess);
             sess = NULL;
@@ -1530,8 +1532,9 @@ int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
         goto err;
     }
     if (tls_psk_do_binder(s, md, (const unsigned char *)s->init_buf->data,
-                          binderoffset, PACKET_data(&binder), NULL, sess, 0,
-                          ext) != 1) {
+            binderoffset, PACKET_data(&binder), NULL, sess, 0,
+            ext)
+        != 1) {
         /* SSLfatal() already called */
         goto err;
     }
@@ -1547,13 +1550,13 @@ err:
 }
 
 int tls_parse_ctos_post_handshake_auth(SSL_CONNECTION *s, PACKET *pkt,
-                                       ossl_unused unsigned int context,
-                                       ossl_unused X509 *x,
-                                       ossl_unused size_t chainidx)
+    ossl_unused unsigned int context,
+    ossl_unused X509 *x,
+    ossl_unused size_t chainidx)
 {
     if (PACKET_remaining(pkt) != 0) {
         SSLfatal(s, SSL_AD_DECODE_ERROR,
-                 SSL_R_POST_HANDSHAKE_AUTH_ENCODING_ERR);
+            SSL_R_POST_HANDSHAKE_AUTH_ENCODING_ERR);
         return 0;
     }
 
@@ -1566,22 +1569,22 @@ int tls_parse_ctos_post_handshake_auth(SSL_CONNECTION *s, PACKET *pkt,
  * Add the server's renegotiation binding
  */
 EXT_RETURN tls_construct_stoc_renegotiate(SSL_CONNECTION *s, WPACKET *pkt,
-                                          unsigned int context, X509 *x,
-                                          size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     if (!s->s3.send_connection_binding)
         return EXT_RETURN_NOT_SENT;
 
     /* Still add this even if SSL_OP_NO_RENEGOTIATION is set */
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_start_sub_packet_u8(pkt)
-            || !WPACKET_memcpy(pkt, s->s3.previous_client_finished,
-                               s->s3.previous_client_finished_len)
-            || !WPACKET_memcpy(pkt, s->s3.previous_server_finished,
-                               s->s3.previous_server_finished_len)
-            || !WPACKET_close(pkt)
-            || !WPACKET_close(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_start_sub_packet_u8(pkt)
+        || !WPACKET_memcpy(pkt, s->s3.previous_client_finished,
+            s->s3.previous_client_finished_len)
+        || !WPACKET_memcpy(pkt, s->s3.previous_server_finished,
+            s->s3.previous_server_finished_len)
+        || !WPACKET_close(pkt)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -1590,8 +1593,8 @@ EXT_RETURN tls_construct_stoc_renegotiate(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_stoc_server_name(SSL_CONNECTION *s, WPACKET *pkt,
-                                          unsigned int context, X509 *x,
-                                          size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     if (s->servername_done != 1)
         return EXT_RETURN_NOT_SENT;
@@ -1604,7 +1607,7 @@ EXT_RETURN tls_construct_stoc_server_name(SSL_CONNECTION *s, WPACKET *pkt,
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
-            || !WPACKET_put_bytes_u16(pkt, 0)) {
+        || !WPACKET_put_bytes_u16(pkt, 0)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -1614,8 +1617,8 @@ EXT_RETURN tls_construct_stoc_server_name(SSL_CONNECTION *s, WPACKET *pkt,
 
 /* Add/include the server's max fragment len extension into ServerHello */
 EXT_RETURN tls_construct_stoc_maxfragmentlen(SSL_CONNECTION *s, WPACKET *pkt,
-                                             unsigned int context, X509 *x,
-                                             size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     if (!USE_MAX_FRAGMENT_LENGTH_EXT(s->session))
         return EXT_RETURN_NOT_SENT;
@@ -1636,13 +1639,13 @@ EXT_RETURN tls_construct_stoc_maxfragmentlen(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_stoc_ec_pt_formats(SSL_CONNECTION *s, WPACKET *pkt,
-                                            unsigned int context, X509 *x,
-                                            size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     unsigned long alg_k = s->s3.tmp.new_cipher->algorithm_mkey;
     unsigned long alg_a = s->s3.tmp.new_cipher->algorithm_auth;
     int using_ecc = ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))
-                    && (s->ext.peer_ecpointformats != NULL);
+        && (s->ext.peer_ecpointformats != NULL);
     const unsigned char *plist;
     size_t plistlen;
 
@@ -1651,9 +1654,9 @@ EXT_RETURN tls_construct_stoc_ec_pt_formats(SSL_CONNECTION *s, WPACKET *pkt,
 
     tls1_get_formatlist(s, &plist, &plistlen);
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_sub_memcpy_u8(pkt, plist, plistlen)
-            || !WPACKET_close(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_sub_memcpy_u8(pkt, plist, plistlen)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -1662,8 +1665,8 @@ EXT_RETURN tls_construct_stoc_ec_pt_formats(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_stoc_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
-                                               unsigned int context, X509 *x,
-                                               size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     const uint16_t *groups;
     size_t numgroups, i, first = 1;
@@ -1686,7 +1689,7 @@ EXT_RETURN tls_construct_stoc_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
         uint16_t group = groups[i];
 
         if (tls_valid_group(s, group, version, version, 0, NULL)
-                && tls_group_allowed(s, group, SSL_SECOP_CURVE_SUPPORTED)) {
+            && tls_group_allowed(s, group, SSL_SECOP_CURVE_SUPPORTED)) {
             if (first) {
                 /*
                  * Check if the client is already using our preferred group. If
@@ -1697,9 +1700,9 @@ EXT_RETURN tls_construct_stoc_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
 
                 /* Add extension header */
                 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups)
-                           /* Sub-packet for supported_groups extension */
-                        || !WPACKET_start_sub_packet_u16(pkt)
-                        || !WPACKET_start_sub_packet_u16(pkt)) {
+                    /* Sub-packet for supported_groups extension */
+                    || !WPACKET_start_sub_packet_u16(pkt)
+                    || !WPACKET_start_sub_packet_u16(pkt)) {
                     SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                     return EXT_RETURN_FAIL;
                 }
@@ -1707,9 +1710,9 @@ EXT_RETURN tls_construct_stoc_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
                 first = 0;
             }
             if (!WPACKET_put_bytes_u16(pkt, group)) {
-                    SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
-                    return EXT_RETURN_FAIL;
-                }
+                SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
+                return EXT_RETURN_FAIL;
+            }
         }
     }
 
@@ -1722,8 +1725,8 @@ EXT_RETURN tls_construct_stoc_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_stoc_session_ticket(SSL_CONNECTION *s, WPACKET *pkt,
-                                             unsigned int context, X509 *x,
-                                             size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     if (!s->ext.ticket_expected || !tls_use_ticket(s)) {
         s->ext.ticket_expected = 0;
@@ -1731,7 +1734,7 @@ EXT_RETURN tls_construct_stoc_session_ticket(SSL_CONNECTION *s, WPACKET *pkt,
     }
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
-            || !WPACKET_put_bytes_u16(pkt, 0)) {
+        || !WPACKET_put_bytes_u16(pkt, 0)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -1741,8 +1744,8 @@ EXT_RETURN tls_construct_stoc_session_ticket(SSL_CONNECTION *s, WPACKET *pkt,
 
 #ifndef OPENSSL_NO_OCSP
 EXT_RETURN tls_construct_stoc_status_request(SSL_CONNECTION *s, WPACKET *pkt,
-                                             unsigned int context, X509 *x,
-                                             size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     /* We don't currently support this extension inside a CertificateRequest */
     if (context == SSL_EXT_TLS1_3_CERTIFICATE_REQUEST)
@@ -1755,7 +1758,7 @@ EXT_RETURN tls_construct_stoc_status_request(SSL_CONNECTION *s, WPACKET *pkt,
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
-            || !WPACKET_start_sub_packet_u16(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -1766,8 +1769,8 @@ EXT_RETURN tls_construct_stoc_status_request(SSL_CONNECTION *s, WPACKET *pkt,
      * separate message
      */
     if (SSL_CONNECTION_IS_TLS13(s) && !tls_construct_cert_status_body(s, pkt)) {
-       /* SSLfatal() already called */
-       return EXT_RETURN_FAIL;
+        /* SSLfatal() already called */
+        return EXT_RETURN_FAIL;
     }
     if (!WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
@@ -1780,8 +1783,8 @@ EXT_RETURN tls_construct_stoc_status_request(SSL_CONNECTION *s, WPACKET *pkt,
 
 #ifndef OPENSSL_NO_NEXTPROTONEG
 EXT_RETURN tls_construct_stoc_next_proto_neg(SSL_CONNECTION *s, WPACKET *pkt,
-                                             unsigned int context, X509 *x,
-                                             size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     const unsigned char *npa;
     unsigned int npalen;
@@ -1794,10 +1797,10 @@ EXT_RETURN tls_construct_stoc_next_proto_neg(SSL_CONNECTION *s, WPACKET *pkt,
         return EXT_RETURN_NOT_SENT;
 
     ret = sctx->ext.npn_advertised_cb(SSL_CONNECTION_GET_USER_SSL(s), &npa,
-                                      &npalen, sctx->ext.npn_advertised_cb_arg);
+        &npalen, sctx->ext.npn_advertised_cb_arg);
     if (ret == SSL_TLSEXT_ERR_OK) {
         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
-                || !WPACKET_sub_memcpy_u16(pkt, npa, npalen)) {
+            || !WPACKET_sub_memcpy_u16(pkt, npa, npalen)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return EXT_RETURN_FAIL;
         }
@@ -1810,19 +1813,19 @@ EXT_RETURN tls_construct_stoc_next_proto_neg(SSL_CONNECTION *s, WPACKET *pkt,
 #endif
 
 EXT_RETURN tls_construct_stoc_alpn(SSL_CONNECTION *s, WPACKET *pkt, unsigned int context,
-                                   X509 *x, size_t chainidx)
+    X509 *x, size_t chainidx)
 {
     if (s->s3.alpn_selected == NULL)
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt,
-                TLSEXT_TYPE_application_layer_protocol_negotiation)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_sub_memcpy_u8(pkt, s->s3.alpn_selected,
-                                      s->s3.alpn_selected_len)
-            || !WPACKET_close(pkt)
-            || !WPACKET_close(pkt)) {
+            TLSEXT_TYPE_application_layer_protocol_negotiation)
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_sub_memcpy_u8(pkt, s->s3.alpn_selected,
+            s->s3.alpn_selected_len)
+        || !WPACKET_close(pkt)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -1832,18 +1835,18 @@ EXT_RETURN tls_construct_stoc_alpn(SSL_CONNECTION *s, WPACKET *pkt, unsigned int
 
 #ifndef OPENSSL_NO_SRTP
 EXT_RETURN tls_construct_stoc_use_srtp(SSL_CONNECTION *s, WPACKET *pkt,
-                                       unsigned int context, X509 *x,
-                                       size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     if (s->srtp_profile == NULL)
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_put_bytes_u16(pkt, 2)
-            || !WPACKET_put_bytes_u16(pkt, s->srtp_profile->id)
-            || !WPACKET_put_bytes_u8(pkt, 0)
-            || !WPACKET_close(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_put_bytes_u16(pkt, 2)
+        || !WPACKET_put_bytes_u16(pkt, s->srtp_profile->id)
+        || !WPACKET_put_bytes_u8(pkt, 0)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -1853,8 +1856,8 @@ EXT_RETURN tls_construct_stoc_use_srtp(SSL_CONNECTION *s, WPACKET *pkt,
 #endif
 
 EXT_RETURN tls_construct_stoc_etm(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     if (!s->ext.use_etm)
         return EXT_RETURN_NOT_SENT;
@@ -1874,7 +1877,7 @@ EXT_RETURN tls_construct_stoc_etm(SSL_CONNECTION *s, WPACKET *pkt,
     }
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
-            || !WPACKET_put_bytes_u16(pkt, 0)) {
+        || !WPACKET_put_bytes_u16(pkt, 0)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -1883,14 +1886,14 @@ EXT_RETURN tls_construct_stoc_etm(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_stoc_ems(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     if ((s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) == 0)
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
-            || !WPACKET_put_bytes_u16(pkt, 0)) {
+        || !WPACKET_put_bytes_u16(pkt, 0)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -1899,8 +1902,8 @@ EXT_RETURN tls_construct_stoc_ems(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_stoc_supported_versions(SSL_CONNECTION *s, WPACKET *pkt,
-                                                 unsigned int context, X509 *x,
-                                                 size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     if (!ossl_assert(SSL_CONNECTION_IS_TLS13(s))) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
@@ -1908,9 +1911,9 @@ EXT_RETURN tls_construct_stoc_supported_versions(SSL_CONNECTION *s, WPACKET *pkt
     }
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_put_bytes_u16(pkt, s->version)
-            || !WPACKET_close(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_put_bytes_u16(pkt, s->version)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -1919,8 +1922,8 @@ EXT_RETURN tls_construct_stoc_supported_versions(SSL_CONNECTION *s, WPACKET *pkt
 }
 
 EXT_RETURN tls_construct_stoc_key_share(SSL_CONNECTION *s, WPACKET *pkt,
-                                        unsigned int context, X509 *x,
-                                        size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
 #ifndef OPENSSL_NO_TLS1_3
     unsigned char *encoded_pubkey;
@@ -1934,9 +1937,9 @@ EXT_RETURN tls_construct_stoc_key_share(SSL_CONNECTION *s, WPACKET *pkt,
             return EXT_RETURN_NOT_SENT;
         }
         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
-                || !WPACKET_start_sub_packet_u16(pkt)
-                || !WPACKET_put_bytes_u16(pkt, s->s3.group_id)
-                || !WPACKET_close(pkt)) {
+            || !WPACKET_start_sub_packet_u16(pkt)
+            || !WPACKET_put_bytes_u16(pkt, s->s3.group_id)
+            || !WPACKET_close(pkt)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return EXT_RETURN_FAIL;
         }
@@ -1964,14 +1967,15 @@ EXT_RETURN tls_construct_stoc_key_share(SSL_CONNECTION *s, WPACKET *pkt,
     }
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_put_bytes_u16(pkt, s->s3.group_id)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_put_bytes_u16(pkt, s->s3.group_id)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
 
     if ((ginf = tls1_group_id_lookup(SSL_CONNECTION_GET_CTX(s),
-                                     s->s3.group_id)) == NULL) {
+             s->s3.group_id))
+        == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -1993,7 +1997,7 @@ EXT_RETURN tls_construct_stoc_key_share(SSL_CONNECTION *s, WPACKET *pkt,
         }
 
         if (!WPACKET_sub_memcpy_u16(pkt, encoded_pubkey, encoded_pubkey_len)
-                || !WPACKET_close(pkt)) {
+            || !WPACKET_close(pkt)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             EVP_PKEY_free(skey);
             OPENSSL_free(encoded_pubkey);
@@ -2032,7 +2036,7 @@ EXT_RETURN tls_construct_stoc_key_share(SSL_CONNECTION *s, WPACKET *pkt,
         }
 
         if (!WPACKET_sub_memcpy_u16(pkt, ct, ctlen)
-                || !WPACKET_close(pkt)) {
+            || !WPACKET_close(pkt)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             OPENSSL_free(ct);
             return EXT_RETURN_FAIL;
@@ -2055,8 +2059,8 @@ EXT_RETURN tls_construct_stoc_key_share(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_stoc_cookie(SSL_CONNECTION *s, WPACKET *pkt,
-                                     unsigned int context,
-                                     X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
 #ifndef OPENSSL_NO_TLS1_3
     unsigned char *hashval1, *hashval2, *appcookie1, *appcookie2, *cookie;
@@ -2078,20 +2082,20 @@ EXT_RETURN tls_construct_stoc_cookie(SSL_CONNECTION *s, WPACKET *pkt,
     }
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_cookie)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_get_total_written(pkt, &startlen)
-            || !WPACKET_reserve_bytes(pkt, MAX_COOKIE_SIZE, &cookie)
-            || !WPACKET_put_bytes_u16(pkt, COOKIE_STATE_FORMAT_VERSION)
-            || !WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION)
-            || !WPACKET_put_bytes_u16(pkt, s->s3.group_id)
-            || !ssl->method->put_cipher_by_char(s->s3.tmp.new_cipher, pkt,
-                                                &ciphlen)
-               /* Is there a key_share extension present in this HRR? */
-            || !WPACKET_put_bytes_u8(pkt, s->s3.peer_tmp == NULL)
-            || !WPACKET_put_bytes_u64(pkt, time(NULL))
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_reserve_bytes(pkt, EVP_MAX_MD_SIZE, &hashval1)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_get_total_written(pkt, &startlen)
+        || !WPACKET_reserve_bytes(pkt, MAX_COOKIE_SIZE, &cookie)
+        || !WPACKET_put_bytes_u16(pkt, COOKIE_STATE_FORMAT_VERSION)
+        || !WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION)
+        || !WPACKET_put_bytes_u16(pkt, s->s3.group_id)
+        || !ssl->method->put_cipher_by_char(s->s3.tmp.new_cipher, pkt,
+            &ciphlen)
+        /* Is there a key_share extension present in this HRR? */
+        || !WPACKET_put_bytes_u8(pkt, s->s3.peer_tmp == NULL)
+        || !WPACKET_put_bytes_u64(pkt, time(NULL))
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_reserve_bytes(pkt, EVP_MAX_MD_SIZE, &hashval1)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -2102,32 +2106,33 @@ EXT_RETURN tls_construct_stoc_cookie(SSL_CONNECTION *s, WPACKET *pkt,
      * subsequently allocate them (below)
      */
     if (!ssl3_digest_cached_records(s, 0)
-            || !ssl_handshake_hash(s, hashval1, EVP_MAX_MD_SIZE, &hashlen)) {
+        || !ssl_handshake_hash(s, hashval1, EVP_MAX_MD_SIZE, &hashlen)) {
         /* SSLfatal() already called */
         return EXT_RETURN_FAIL;
     }
 
     if (!WPACKET_allocate_bytes(pkt, hashlen, &hashval2)
-            || !ossl_assert(hashval1 == hashval2)
-            || !WPACKET_close(pkt)
-            || !WPACKET_start_sub_packet_u8(pkt)
-            || !WPACKET_reserve_bytes(pkt, SSL_COOKIE_LENGTH, &appcookie1)) {
+        || !ossl_assert(hashval1 == hashval2)
+        || !WPACKET_close(pkt)
+        || !WPACKET_start_sub_packet_u8(pkt)
+        || !WPACKET_reserve_bytes(pkt, SSL_COOKIE_LENGTH, &appcookie1)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
 
     /* Generate the application cookie */
     if (sctx->gen_stateless_cookie_cb(ussl, appcookie1,
-                                      &appcookielen) == 0) {
+            &appcookielen)
+        == 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_COOKIE_GEN_CALLBACK_FAILURE);
         return EXT_RETURN_FAIL;
     }
 
     if (!WPACKET_allocate_bytes(pkt, appcookielen, &appcookie2)
-            || !ossl_assert(appcookie1 == appcookie2)
-            || !WPACKET_close(pkt)
-            || !WPACKET_get_total_written(pkt, &totcookielen)
-            || !WPACKET_reserve_bytes(pkt, SHA256_DIGEST_LENGTH, &hmac)) {
+        || !ossl_assert(appcookie1 == appcookie2)
+        || !WPACKET_close(pkt)
+        || !WPACKET_get_total_written(pkt, &totcookielen)
+        || !WPACKET_reserve_bytes(pkt, SHA256_DIGEST_LENGTH, &hmac)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -2142,18 +2147,20 @@ EXT_RETURN tls_construct_stoc_cookie(SSL_CONNECTION *s, WPACKET *pkt,
     /* HMAC the cookie */
     hctx = EVP_MD_CTX_create();
     pkey = EVP_PKEY_new_raw_private_key_ex(sctx->libctx, "HMAC",
-                                           sctx->propq,
-                                           s->session_ctx->ext.cookie_hmac_key,
-                                           sizeof(s->session_ctx->ext.cookie_hmac_key));
+        sctx->propq,
+        s->session_ctx->ext.cookie_hmac_key,
+        sizeof(s->session_ctx->ext.cookie_hmac_key));
     if (hctx == NULL || pkey == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
         goto err;
     }
 
     if (EVP_DigestSignInit_ex(hctx, NULL, "SHA2-256", sctx->libctx,
-                              sctx->propq, pkey, NULL) <= 0
-            || EVP_DigestSign(hctx, hmac, &hmaclen, cookie,
-                              totcookielen) <= 0) {
+            sctx->propq, pkey, NULL)
+            <= 0
+        || EVP_DigestSign(hctx, hmac, &hmaclen, cookie,
+               totcookielen)
+            <= 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
@@ -2164,17 +2171,17 @@ EXT_RETURN tls_construct_stoc_cookie(SSL_CONNECTION *s, WPACKET *pkt,
     }
 
     if (!WPACKET_allocate_bytes(pkt, hmaclen, &hmac2)
-            || !ossl_assert(hmac == hmac2)
-            || !ossl_assert(cookie == hmac - totcookielen)
-            || !WPACKET_close(pkt)
-            || !WPACKET_close(pkt)) {
+        || !ossl_assert(hmac == hmac2)
+        || !ossl_assert(cookie == hmac - totcookielen)
+        || !WPACKET_close(pkt)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
 
     ret = EXT_RETURN_SENT;
 
- err:
+err:
     EVP_MD_CTX_free(hctx);
     EVP_PKEY_free(pkey);
     return ret;
@@ -2184,12 +2191,12 @@ EXT_RETURN tls_construct_stoc_cookie(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_stoc_cryptopro_bug(SSL_CONNECTION *s, WPACKET *pkt,
-                                            unsigned int context, X509 *x,
-                                            size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     const unsigned char cryptopro_ext[36] = {
-        0xfd, 0xe8,         /* 65000 */
-        0x00, 0x20,         /* 32 bytes length */
+        0xfd, 0xe8, /* 65000 */
+        0x00, 0x20, /* 32 bytes length */
         0x30, 0x1e, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85,
         0x03, 0x02, 0x02, 0x09, 0x30, 0x08, 0x06, 0x06,
         0x2a, 0x85, 0x03, 0x02, 0x02, 0x16, 0x30, 0x08,
@@ -2197,9 +2204,10 @@ EXT_RETURN tls_construct_stoc_cryptopro_bug(SSL_CONNECTION *s, WPACKET *pkt,
     };
 
     if (((s->s3.tmp.new_cipher->id & 0xFFFF) != 0x80
-         && (s->s3.tmp.new_cipher->id & 0xFFFF) != 0x81)
-            || (SSL_get_options(SSL_CONNECTION_GET_SSL(s))
-                & SSL_OP_CRYPTOPRO_TLSEXT_BUG) == 0)
+            && (s->s3.tmp.new_cipher->id & 0xFFFF) != 0x81)
+        || (SSL_get_options(SSL_CONNECTION_GET_SSL(s))
+               & SSL_OP_CRYPTOPRO_TLSEXT_BUG)
+            == 0)
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_memcpy(pkt, cryptopro_ext, sizeof(cryptopro_ext))) {
@@ -2211,17 +2219,17 @@ EXT_RETURN tls_construct_stoc_cryptopro_bug(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_stoc_early_data(SSL_CONNECTION *s, WPACKET *pkt,
-                                         unsigned int context, X509 *x,
-                                         size_t chainidx)
+    unsigned int context, X509 *x,
+    size_t chainidx)
 {
     if (context == SSL_EXT_TLS1_3_NEW_SESSION_TICKET) {
         if (s->max_early_data == 0)
             return EXT_RETURN_NOT_SENT;
 
         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data)
-                || !WPACKET_start_sub_packet_u16(pkt)
-                || !WPACKET_put_bytes_u32(pkt, s->max_early_data)
-                || !WPACKET_close(pkt)) {
+            || !WPACKET_start_sub_packet_u16(pkt)
+            || !WPACKET_put_bytes_u32(pkt, s->max_early_data)
+            || !WPACKET_close(pkt)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return EXT_RETURN_FAIL;
         }
@@ -2233,8 +2241,8 @@ EXT_RETURN tls_construct_stoc_early_data(SSL_CONNECTION *s, WPACKET *pkt,
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_close(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -2243,16 +2251,16 @@ EXT_RETURN tls_construct_stoc_early_data(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_stoc_psk(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     if (!s->hit)
         return EXT_RETURN_NOT_SENT;
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_put_bytes_u16(pkt, s->ext.tick_identity)
-            || !WPACKET_close(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_put_bytes_u16(pkt, s->ext.tick_identity)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -2261,8 +2269,8 @@ EXT_RETURN tls_construct_stoc_psk(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 EXT_RETURN tls_construct_stoc_client_cert_type(SSL_CONNECTION *sc, WPACKET *pkt,
-                                               unsigned int context,
-                                               X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     if (sc->ext.client_cert_type_ctos == OSSL_CERT_TYPE_CTOS_ERROR
         && (send_certificate_request(sc)
@@ -2282,8 +2290,8 @@ EXT_RETURN tls_construct_stoc_client_cert_type(SSL_CONNECTION *sc, WPACKET *pkt,
      * but TLSv1.3 could do a PHA request if the client supports it
      */
     if ((!send_certificate_request(sc) && sc->post_handshake_auth != SSL_PHA_EXT_RECEIVED)
-            || sc->ext.client_cert_type_ctos != OSSL_CERT_TYPE_CTOS_GOOD
-            || sc->client_cert_type == NULL) {
+        || sc->ext.client_cert_type_ctos != OSSL_CERT_TYPE_CTOS_GOOD
+        || sc->client_cert_type == NULL) {
         /* if we don't send it, reset to TLSEXT_cert_type_x509 */
         sc->ext.client_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE;
         sc->ext.client_cert_type = TLSEXT_cert_type_x509;
@@ -2291,9 +2299,9 @@ EXT_RETURN tls_construct_stoc_client_cert_type(SSL_CONNECTION *sc, WPACKET *pkt,
     }
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_client_cert_type)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_put_bytes_u8(pkt, sc->ext.client_cert_type)
-            || !WPACKET_close(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_put_bytes_u8(pkt, sc->ext.client_cert_type)
+        || !WPACKET_close(pkt)) {
         SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -2302,8 +2310,8 @@ EXT_RETURN tls_construct_stoc_client_cert_type(SSL_CONNECTION *sc, WPACKET *pkt,
 
 /* One of |pref|, |other| is configured and the values are sanitized */
 static int reconcile_cert_type(const unsigned char *pref, size_t pref_len,
-                               const unsigned char *other, size_t other_len,
-                               uint8_t *chosen_cert_type)
+    const unsigned char *other, size_t other_len,
+    uint8_t *chosen_cert_type)
 {
     size_t i;
 
@@ -2317,8 +2325,8 @@ static int reconcile_cert_type(const unsigned char *pref, size_t pref_len,
 }
 
 int tls_parse_ctos_client_cert_type(SSL_CONNECTION *sc, PACKET *pkt,
-                                    unsigned int context,
-                                    X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     PACKET supported_cert_types;
     const unsigned char *data;
@@ -2348,23 +2356,23 @@ int tls_parse_ctos_client_cert_type(SSL_CONNECTION *sc, PACKET *pkt,
     }
     /* client_cert_type: client (peer) has priority */
     sc->ext.client_cert_type_ctos = reconcile_cert_type(data, len,
-                                                        sc->client_cert_type, sc->client_cert_type_len,
-                                                        &sc->ext.client_cert_type);
+        sc->client_cert_type, sc->client_cert_type_len,
+        &sc->ext.client_cert_type);
 
     /* Ignore the error until sending - so we can check cert auth*/
     return 1;
 }
 
 EXT_RETURN tls_construct_stoc_server_cert_type(SSL_CONNECTION *sc, WPACKET *pkt,
-                                               unsigned int context,
-                                               X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     if (sc->ext.server_cert_type == TLSEXT_cert_type_x509) {
         sc->ext.server_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE;
         return EXT_RETURN_NOT_SENT;
     }
     if (sc->ext.server_cert_type_ctos != OSSL_CERT_TYPE_CTOS_GOOD
-            || sc->server_cert_type == NULL) {
+        || sc->server_cert_type == NULL) {
         /* if we don't send it, reset to TLSEXT_cert_type_x509 */
         sc->ext.server_cert_type_ctos = OSSL_CERT_TYPE_CTOS_NONE;
         sc->ext.server_cert_type = TLSEXT_cert_type_x509;
@@ -2372,9 +2380,9 @@ EXT_RETURN tls_construct_stoc_server_cert_type(SSL_CONNECTION *sc, WPACKET *pkt,
     }
 
     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_cert_type)
-            || !WPACKET_start_sub_packet_u16(pkt)
-            || !WPACKET_put_bytes_u8(pkt, sc->ext.server_cert_type)
-            || !WPACKET_close(pkt)) {
+        || !WPACKET_start_sub_packet_u16(pkt)
+        || !WPACKET_put_bytes_u8(pkt, sc->ext.server_cert_type)
+        || !WPACKET_close(pkt)) {
         SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return EXT_RETURN_FAIL;
     }
@@ -2382,8 +2390,8 @@ EXT_RETURN tls_construct_stoc_server_cert_type(SSL_CONNECTION *sc, WPACKET *pkt,
 }
 
 int tls_parse_ctos_server_cert_type(SSL_CONNECTION *sc, PACKET *pkt,
-                                    unsigned int context,
-                                    X509 *x, size_t chainidx)
+    unsigned int context,
+    X509 *x, size_t chainidx)
 {
     PACKET supported_cert_types;
     const unsigned char *data;
@@ -2411,8 +2419,8 @@ int tls_parse_ctos_server_cert_type(SSL_CONNECTION *sc, PACKET *pkt,
     }
     /* server_cert_type: server (this) has priority */
     sc->ext.server_cert_type_ctos = reconcile_cert_type(sc->server_cert_type, sc->server_cert_type_len,
-                                                        data, len,
-                                                        &sc->ext.server_cert_type);
+        data, len,
+        &sc->ext.server_cert_type);
     if (sc->ext.server_cert_type_ctos == OSSL_CERT_TYPE_CTOS_GOOD)
         return 1;
 
diff --git a/crypto/openssl/ssl/statem/statem.c b/crypto/openssl/ssl/statem/statem.c
index 05b491c3956a..3342cb06d208 100644
--- a/crypto/openssl/ssl/statem/statem.c
+++ b/crypto/openssl/ssl/statem/statem.c
@@ -10,8 +10,8 @@
 #include "internal/e_os.h"
 
 #if defined(__TANDEM) && defined(_SPT_MODEL_)
-# include <spthread.h>
-# include <spt_extensions.h> /* timeval */
+#include <spthread.h>
+#include <spt_extensions.h> /* timeval */
 #endif
 
 #include "internal/cryptlib.h"
@@ -148,7 +148,7 @@ void ossl_statem_send_fatal(SSL_CONNECTION *s, int al)
 {
     /* We shouldn't call SSLfatal() twice. Once is enough */
     if (s->statem.in_init && s->statem.state == MSG_FLOW_ERROR)
-      return;
+        return;
     ossl_statem_set_in_init(s, 1);
     s->statem.state = MSG_FLOW_ERROR;
     if (al != SSL_AD_NO_ALERT)
@@ -162,7 +162,7 @@ void ossl_statem_send_fatal(SSL_CONNECTION *s, int al)
  * This is a permanent error for the current connection.
  */
 void ossl_statem_fatal(SSL_CONNECTION *s, int al, int reason,
-                       const char *fmt, ...)
+    const char *fmt, ...)
 {
     va_list args;
 
@@ -178,10 +178,10 @@ void ossl_statem_fatal(SSL_CONNECTION *s, int al, int reason,
  * a fatal error state. We verify that we are, and set it if not (this would
  * indicate a bug).
  */
-#define check_fatal(s) \
-    do { \
-        if (!ossl_assert((s)->statem.in_init \
-                         && (s)->statem.state == MSG_FLOW_ERROR)) \
+#define check_fatal(s)                                               \
+    do {                                                             \
+        if (!ossl_assert((s)->statem.in_init                         \
+                && (s)->statem.state == MSG_FLOW_ERROR))             \
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_FATAL); \
     } while (0)
 
@@ -227,8 +227,8 @@ int ossl_statem_skip_early_data(SSL_CONNECTION *s)
         return 0;
 
     if (!s->server
-            || s->statem.hand_state != TLS_ST_EARLY_DATA
-            || s->hello_retry_request == SSL_HRR_COMPLETE)
+        || s->statem.hand_state != TLS_ST_EARLY_DATA
+        || s->hello_retry_request == SSL_HRR_COMPLETE)
         return 0;
 
     return 1;
@@ -246,7 +246,7 @@ int ossl_statem_check_finish_init(SSL_CONNECTION *s, int sending)
 {
     if (sending == -1) {
         if (s->statem.hand_state == TLS_ST_PENDING_EARLY_DATA_END
-                || s->statem.hand_state == TLS_ST_EARLY_DATA) {
+            || s->statem.hand_state == TLS_ST_EARLY_DATA) {
             ossl_statem_set_in_init(s, 1);
             if (s->early_data_state == SSL_EARLY_DATA_WRITE_RETRY) {
                 /*
@@ -257,10 +257,9 @@ int ossl_statem_check_finish_init(SSL_CONNECTION *s, int sending)
             }
         }
     } else if (!s->server) {
-        if ((sending && (s->statem.hand_state == TLS_ST_PENDING_EARLY_DATA_END
-                      || s->statem.hand_state == TLS_ST_EARLY_DATA)
-                  && s->early_data_state != SSL_EARLY_DATA_WRITING)
-                || (!sending && s->statem.hand_state == TLS_ST_EARLY_DATA)) {
+        if ((sending && (s->statem.hand_state == TLS_ST_PENDING_EARLY_DATA_END || s->statem.hand_state == TLS_ST_EARLY_DATA)
+                && s->early_data_state != SSL_EARLY_DATA_WRITING)
+            || (!sending && s->statem.hand_state == TLS_ST_EARLY_DATA)) {
             ossl_statem_set_in_init(s, 1);
             /*
              * SSL_write() has been called directly. We don't allow any more
@@ -271,7 +270,7 @@ int ossl_statem_check_finish_init(SSL_CONNECTION *s, int sending)
         }
     } else {
         if (s->early_data_state == SSL_EARLY_DATA_FINISHED_READING
-                && s->statem.hand_state == TLS_ST_EARLY_DATA)
+            && s->statem.hand_state == TLS_ST_EARLY_DATA)
             ossl_statem_set_in_init(s, 1);
     }
     return 1;
@@ -311,7 +310,7 @@ int ossl_statem_accept(SSL *s)
     return state_machine(sc, 1);
 }
 
-typedef void (*info_cb) (const SSL *, int, int);
+typedef void (*info_cb)(const SSL *, int, int);
 
 static info_cb get_callback(SSL_CONNECTION *s)
 {
@@ -356,7 +355,7 @@ static info_cb get_callback(SSL_CONNECTION *s)
 static int state_machine(SSL_CONNECTION *s, int server)
 {
     BUF_MEM *buf = NULL;
-    void (*cb) (const SSL *ssl, int type, int val) = NULL;
+    void (*cb)(const SSL *ssl, int type, int val) = NULL;
     OSSL_STATEM *st = &s->statem;
     int ret = -1;
     int ssret;
@@ -389,13 +388,13 @@ static int state_machine(SSL_CONNECTION *s, int server)
          * identifier other than 0.
          */
         BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE,
-                 st->in_handshake, NULL);
+            st->in_handshake, NULL);
     }
 #endif
 
     /* Initialise state machine */
     if (st->state == MSG_FLOW_UNINITED
-            || st->state == MSG_FLOW_FINISHED) {
+        || st->state == MSG_FLOW_FINISHED) {
         if (st->state == MSG_FLOW_UNINITED) {
             st->hand_state = TLS_ST_BEFORE;
             st->request_state = TLS_ST_BEFORE;
@@ -414,8 +413,7 @@ static int state_machine(SSL_CONNECTION *s, int server)
          */
 
         if (SSL_CONNECTION_IS_DTLS(s)) {
-            if ((s->version & 0xff00) != (DTLS1_VERSION & 0xff00) &&
-                (server || (s->version & 0xff00) != (DTLS1_BAD_VER & 0xff00))) {
+            if ((s->version & 0xff00) != (DTLS1_VERSION & 0xff00) && (server || (s->version & 0xff00) != (DTLS1_BAD_VER & 0xff00))) {
                 SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR);
                 goto end;
             }
@@ -464,7 +462,7 @@ static int state_machine(SSL_CONNECTION *s, int server)
             }
 
         if ((SSL_in_before(ssl))
-                || s->renegotiate) {
+            || s->renegotiate) {
             if (!tls_setup_handshake(s)) {
                 /* SSLfatal() already called */
                 goto end;
@@ -509,7 +507,7 @@ static int state_machine(SSL_CONNECTION *s, int server)
 
     ret = 1;
 
- end:
+end:
     st->in_handshake--;
 
 #ifndef OPENSSL_NO_SCTP
@@ -519,7 +517,7 @@ static int state_machine(SSL_CONNECTION *s, int server)
          * identifier other than 0.
          */
         BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_SET_IN_HANDSHAKE,
-                 st->in_handshake, NULL);
+            st->in_handshake, NULL);
     }
 #endif
 
@@ -543,7 +541,8 @@ static void init_read_state_machine(SSL_CONNECTION *s)
     st->read_state = READ_STATE_HEADER;
 }
 
-static int grow_init_buf(SSL_CONNECTION *s, size_t size) {
+static int grow_init_buf(SSL_CONNECTION *s, size_t size)
+{
 
     size_t msg_offset = (char *)s->init_msg - s->init_buf->data;
 
@@ -589,12 +588,12 @@ static SUB_STATE_RETURN read_state_machine(SSL_CONNECTION *s)
     OSSL_STATEM *st = &s->statem;
     int ret, mt;
     size_t len = 0;
-    int (*transition) (SSL_CONNECTION *s, int mt);
+    int (*transition)(SSL_CONNECTION *s, int mt);
     PACKET pkt;
-    MSG_PROCESS_RETURN(*process_message) (SSL_CONNECTION *s, PACKET *pkt);
-    WORK_STATE(*post_process_message) (SSL_CONNECTION *s, WORK_STATE wst);
-    size_t (*max_message_size) (SSL_CONNECTION *s);
-    void (*cb) (const SSL *ssl, int type, int val) = NULL;
+    MSG_PROCESS_RETURN (*process_message)(SSL_CONNECTION *s, PACKET *pkt);
+    WORK_STATE (*post_process_message)(SSL_CONNECTION *s, WORK_STATE wst);
+    size_t (*max_message_size)(SSL_CONNECTION *s);
+    void (*cb)(const SSL *ssl, int type, int val) = NULL;
     SSL *ssl = SSL_CONNECTION_GET_USER_SSL(s);
 
     cb = get_callback(s);
@@ -650,15 +649,14 @@ static SUB_STATE_RETURN read_state_machine(SSL_CONNECTION *s)
 
             if (s->s3.tmp.message_size > max_message_size(s)) {
                 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                         SSL_R_EXCESSIVE_MESSAGE_SIZE);
+                    SSL_R_EXCESSIVE_MESSAGE_SIZE);
                 return SUB_STATE_ERROR;
             }
 
             /* dtls_get_message already did this */
             if (!SSL_CONNECTION_IS_DTLS(s)
-                    && s->s3.tmp.message_size > 0
-                    && !grow_init_buf(s, s->s3.tmp.message_size
-                                         + SSL3_HM_HEADER_LENGTH)) {
+                && s->s3.tmp.message_size > 0
+                && !grow_init_buf(s, s->s3.tmp.message_size + SSL3_HM_HEADER_LENGTH)) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BUF_LIB);
                 return SUB_STATE_ERROR;
             }
@@ -808,15 +806,15 @@ static SUB_STATE_RETURN write_state_machine(SSL_CONNECTION *s)
 {
     OSSL_STATEM *st = &s->statem;
     int ret;
-    WRITE_TRAN(*transition) (SSL_CONNECTION *s);
-    WORK_STATE(*pre_work) (SSL_CONNECTION *s, WORK_STATE wst);
-    WORK_STATE(*post_work) (SSL_CONNECTION *s, WORK_STATE wst);
-    int (*get_construct_message_f) (SSL_CONNECTION *s,
-                                    CON_FUNC_RETURN (**confunc) (SSL_CONNECTION *s,
-                                                                 WPACKET *pkt),
-                                    int *mt);
-    void (*cb) (const SSL *ssl, int type, int val) = NULL;
-    CON_FUNC_RETURN (*confunc) (SSL_CONNECTION *s, WPACKET *pkt);
+    WRITE_TRAN (*transition)(SSL_CONNECTION *s);
+    WORK_STATE (*pre_work)(SSL_CONNECTION *s, WORK_STATE wst);
+    WORK_STATE (*post_work)(SSL_CONNECTION *s, WORK_STATE wst);
+    int (*get_construct_message_f)(SSL_CONNECTION *s,
+        CON_FUNC_RETURN (**confunc)(SSL_CONNECTION *s,
+            WPACKET *pkt),
+        int *mt);
+    void (*cb)(const SSL *ssl, int type, int val) = NULL;
+    CON_FUNC_RETURN (*confunc)(SSL_CONNECTION *s, WPACKET *pkt);
     int mt;
     WPACKET pkt;
     SSL *ssl = SSL_CONNECTION_GET_USER_SSL(s);
@@ -891,7 +889,7 @@ static SUB_STATE_RETURN write_state_machine(SSL_CONNECTION *s)
                 break;
             }
             if (!WPACKET_init(&pkt, s->init_buf)
-                    || !ssl_set_handshake_header(s, &pkt, mt)) {
+                || !ssl_set_handshake_header(s, &pkt, mt)) {
                 WPACKET_cleanup(&pkt);
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 return SUB_STATE_ERROR;
@@ -916,7 +914,7 @@ static SUB_STATE_RETURN write_state_machine(SSL_CONNECTION *s)
                 } /* else success */
             }
             if (!ssl_close_construct_packet(s, &pkt, mt)
-                    || !WPACKET_finish(&pkt)) {
+                || !WPACKET_finish(&pkt)) {
                 WPACKET_cleanup(&pkt);
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 return SUB_STATE_ERROR;
@@ -1024,7 +1022,7 @@ int ossl_statem_app_data_allowed(SSL_CONNECTION *s)
 int ossl_statem_export_allowed(SSL_CONNECTION *s)
 {
     return s->s3.previous_server_finished_len != 0
-           && s->statem.hand_state != TLS_ST_SW_FINISHED;
+        && s->statem.hand_state != TLS_ST_SW_FINISHED;
 }
 
 /*
@@ -1039,5 +1037,5 @@ int ossl_statem_export_early_allowed(SSL_CONNECTION *s)
      * as we have sent early_data.
      */
     return s->ext.early_data == SSL_EARLY_DATA_ACCEPTED
-           || (!s->server && s->ext.early_data != SSL_EARLY_DATA_NOT_SENT);
+        || (!s->server && s->ext.early_data != SSL_EARLY_DATA_NOT_SENT);
 }
diff --git a/crypto/openssl/ssl/statem/statem_clnt.c b/crypto/openssl/ssl/statem/statem_clnt.c
index ba4500dd6597..0619fbd6f13a 100644
--- a/crypto/openssl/ssl/statem/statem_clnt.c
+++ b/crypto/openssl/ssl/statem/statem_clnt.c
@@ -31,14 +31,14 @@
 #include "internal/ssl_unwrap.h"
 
 static MSG_PROCESS_RETURN tls_process_as_hello_retry_request(SSL_CONNECTION *s,
-                                                             PACKET *pkt);
+    PACKET *pkt);
 static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL_CONNECTION *s,
-                                                           PACKET *pkt);
+    PACKET *pkt);
 
 static ossl_inline int cert_req_allowed(SSL_CONNECTION *s);
 static int key_exchange_expected(SSL_CONNECTION *s);
 static int ssl_cipher_list_to_bytes(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *sk,
-                                    WPACKET *pkt);
+    WPACKET *pkt);
 
 static ossl_inline int received_server_cert(SSL_CONNECTION *sc)
 {
@@ -56,7 +56,7 @@ static ossl_inline int cert_req_allowed(SSL_CONNECTION *s)
 {
     /* TLS does not like anon-DH with client cert */
     if ((s->version > SSL3_VERSION
-         && (s->s3.tmp.new_cipher->algorithm_auth & SSL_aNULL))
+            && (s->s3.tmp.new_cipher->algorithm_auth & SSL_aNULL))
         || (s->s3.tmp.new_cipher->algorithm_auth & (SSL_aSRP | SSL_aPSK)))
         return 0;
 
@@ -78,8 +78,7 @@ static int key_exchange_expected(SSL_CONNECTION *s)
      * Can't skip server key exchange if this is an ephemeral
      * ciphersuite or for SRP
      */
-    if (alg_k & (SSL_kDHE | SSL_kECDHE | SSL_kDHEPSK | SSL_kECDHEPSK
-                 | SSL_kSRP)) {
+    if (alg_k & (SSL_kDHE | SSL_kECDHE | SSL_kDHEPSK | SSL_kECDHEPSK | SSL_kSRP)) {
         return 1;
     }
 
@@ -144,7 +143,7 @@ static int ossl_statem_client13_read_transition(SSL_CONNECTION *s, int mt)
             }
 #ifndef OPENSSL_NO_COMP_ALG
             if (mt == SSL3_MT_COMPRESSED_CERTIFICATE
-                    && s->ext.compress_certificate_sent) {
+                && s->ext.compress_certificate_sent) {
                 st->hand_state = TLS_ST_CR_COMP_CERT;
                 return 1;
             }
@@ -159,7 +158,7 @@ static int ossl_statem_client13_read_transition(SSL_CONNECTION *s, int mt)
         }
 #ifndef OPENSSL_NO_COMP_ALG
         if (mt == SSL3_MT_COMPRESSED_CERTIFICATE
-                && s->ext.compress_certificate_sent) {
+            && s->ext.compress_certificate_sent) {
             st->hand_state = TLS_ST_CR_COMP_CERT;
             return 1;
         }
@@ -193,7 +192,7 @@ static int ossl_statem_client13_read_transition(SSL_CONNECTION *s, int mt)
         if (mt == SSL3_MT_CERTIFICATE_REQUEST) {
 #if DTLS_MAX_VERSION_INTERNAL != DTLS1_2_VERSION
             /* Restore digest for PHA before adding message.*/
-# error Internal DTLS version error
+#error Internal DTLS version error
 #endif
             if (!SSL_CONNECTION_IS_DTLS(s)
                 && s->post_handshake_auth == SSL_PHA_EXT_SENT) {
@@ -290,9 +289,9 @@ int ossl_statem_client_read_transition(SSL_CONNECTION *s, int mt)
                 st->hand_state = DTLS_ST_CR_HELLO_VERIFY_REQUEST;
                 return 1;
             } else if (s->version >= TLS1_VERSION
-                       && s->ext.session_secret_cb != NULL
-                       && s->session->ext.tick != NULL
-                       && mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
+                && s->ext.session_secret_cb != NULL
+                && s->session->ext.tick != NULL
+                && mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
                 /*
                  * Normally, we can tell if the server is resuming the session
                  * from the session ID. EAP-FAST (RFC 4851), however, relies on
@@ -303,7 +302,7 @@ int ossl_statem_client_read_transition(SSL_CONNECTION *s, int mt)
                 st->hand_state = TLS_ST_CR_CHANGE;
                 return 1;
             } else if (!(s->s3.tmp.new_cipher->algorithm_auth
-                         & (SSL_aNULL | SSL_aSRP | SSL_aPSK))) {
+                           & (SSL_aNULL | SSL_aSRP | SSL_aPSK))) {
                 if (mt == SSL3_MT_CERTIFICATE) {
                     st->hand_state = TLS_ST_CR_CERT;
                     return 1;
@@ -319,7 +318,7 @@ int ossl_statem_client_read_transition(SSL_CONNECTION *s, int mt)
                         return 1;
                     }
                 } else if (mt == SSL3_MT_CERTIFICATE_REQUEST
-                           && cert_req_allowed(s)) {
+                    && cert_req_allowed(s)) {
                     st->hand_state = TLS_ST_CR_CERT_REQ;
                     return 1;
                 } else if (mt == SSL3_MT_SERVER_DONE) {
@@ -345,8 +344,7 @@ int ossl_statem_client_read_transition(SSL_CONNECTION *s, int mt)
     case TLS_ST_CR_CERT_STATUS:
         ske_expected = key_exchange_expected(s);
         /* SKE is optional for some PSK ciphersuites */
-        if (ske_expected || ((s->s3.tmp.new_cipher->algorithm_mkey & SSL_PSK)
-                             && mt == SSL3_MT_SERVER_KEY_EXCHANGE)) {
+        if (ske_expected || ((s->s3.tmp.new_cipher->algorithm_mkey & SSL_PSK) && mt == SSL3_MT_SERVER_KEY_EXCHANGE)) {
             if (mt == SSL3_MT_SERVER_KEY_EXCHANGE) {
                 st->hand_state = TLS_ST_CR_KEY_EXCH;
                 return 1;
@@ -406,7 +404,7 @@ int ossl_statem_client_read_transition(SSL_CONNECTION *s, int mt)
         break;
     }
 
- err:
+err:
     /* No valid transition found */
     if (SSL_CONNECTION_IS_DTLS(s) && mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
         BIO *rbio;
@@ -475,10 +473,10 @@ static WRITE_TRAN ossl_statem_client13_write_transition(SSL_CONNECTION *s)
 
     case TLS_ST_CR_FINISHED:
         if (s->early_data_state == SSL_EARLY_DATA_WRITE_RETRY
-                || s->early_data_state == SSL_EARLY_DATA_FINISHED_WRITING)
+            || s->early_data_state == SSL_EARLY_DATA_FINISHED_WRITING)
             st->hand_state = TLS_ST_PENDING_EARLY_DATA_END;
         else if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0
-                 && s->hello_retry_request == SSL_HRR_NONE)
+            && s->hello_retry_request == SSL_HRR_NONE)
             st->hand_state = TLS_ST_CW_CHANGE;
         else if (s->s3.tmp.cert_req == 0)
             st->hand_state = TLS_ST_CW_FINISHED;
@@ -511,7 +509,7 @@ static WRITE_TRAN ossl_statem_client13_write_transition(SSL_CONNECTION *s)
     case TLS_ST_CW_CERT:
         /* If a non-empty Certificate we also send CertificateVerify */
         st->hand_state = (s->s3.tmp.cert_req == 1) ? TLS_ST_CW_CERT_VRFY
-                                                    : TLS_ST_CW_FINISHED;
+                                                   : TLS_ST_CW_FINISHED;
         return WRITE_TRAN_CONTINUE;
 
     case TLS_ST_CW_CERT_VRFY:
@@ -574,7 +572,7 @@ WRITE_TRAN ossl_statem_client_write_transition(SSL_CONNECTION *s)
 
     case TLS_ST_CW_CLNT_HELLO:
         if (s->early_data_state == SSL_EARLY_DATA_CONNECTING
-                && !SSL_IS_QUIC_HANDSHAKE(s)) {
+            && !SSL_IS_QUIC_HANDSHAKE(s)) {
             /*
              * We are assuming this is a TLSv1.3 connection, although we haven't
              * actually selected a version yet.
@@ -599,7 +597,7 @@ WRITE_TRAN ossl_statem_client_write_transition(SSL_CONNECTION *s)
          * because we did early data.
          */
         if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0
-                && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING)
+            && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING)
             st->hand_state = TLS_ST_CW_CHANGE;
         else
             st->hand_state = TLS_ST_CW_CLNT_HELLO;
@@ -737,12 +735,12 @@ WORK_STATE ossl_statem_client_pre_work(SSL_CONNECTION *s, WORK_STATE wst)
              * write record layer in order to write in plaintext again.
              */
             if (!ssl_set_new_record_layer(s,
-                                          TLS_ANY_VERSION,
-                                          OSSL_RECORD_DIRECTION_WRITE,
-                                          OSSL_RECORD_PROTECTION_LEVEL_NONE,
-                                          NULL, 0, NULL, 0, NULL, 0, NULL,  0,
-                                          NULL, 0, NID_undef, NULL, NULL,
-                                          NULL)) {
+                    TLS_ANY_VERSION,
+                    OSSL_RECORD_DIRECTION_WRITE,
+                    OSSL_RECORD_PROTECTION_LEVEL_NONE,
+                    NULL, 0, NULL, 0, NULL, 0, NULL, 0,
+                    NULL, 0, NID_undef, NULL, NULL,
+                    NULL)) {
                 /* SSLfatal already called */
                 return WORK_ERROR;
             }
@@ -774,7 +772,7 @@ WORK_STATE ossl_statem_client_pre_work(SSL_CONNECTION *s, WORK_STATE wst)
          * on with the handshake. Otherwise we pause here.
          */
         if (s->early_data_state == SSL_EARLY_DATA_FINISHED_WRITING
-                || s->early_data_state == SSL_EARLY_DATA_NONE)
+            || s->early_data_state == SSL_EARLY_DATA_NONE)
             return WORK_FINISHED_CONTINUE;
         /* Fall through */
 
@@ -807,7 +805,7 @@ WORK_STATE ossl_statem_client_post_work(SSL_CONNECTION *s, WORK_STATE wst)
 
     case TLS_ST_CW_CLNT_HELLO:
         if (s->early_data_state == SSL_EARLY_DATA_CONNECTING
-                && s->max_early_data > 0) {
+            && s->max_early_data > 0) {
             /*
              * We haven't selected TLSv1.3 yet so we don't call the change
              * cipher state function associated with the SSL_METHOD. Instead
@@ -815,7 +813,7 @@ WORK_STATE ossl_statem_client_post_work(SSL_CONNECTION *s, WORK_STATE wst)
              */
             if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) == 0) {
                 if (!tls13_change_cipher_state(s,
-                            SSL3_CC_EARLY | SSL3_CHANGE_CIPHER_CLIENT_WRITE)) {
+                        SSL3_CC_EARLY | SSL3_CHANGE_CIPHER_CLIENT_WRITE)) {
                     /* SSLfatal() already called */
                     return WORK_ERROR;
                 }
@@ -843,14 +841,14 @@ WORK_STATE ossl_statem_client_post_work(SSL_CONNECTION *s, WORK_STATE wst)
             || s->hello_retry_request == SSL_HRR_PENDING)
             break;
         if (s->early_data_state == SSL_EARLY_DATA_CONNECTING
-                    && s->max_early_data > 0) {
+            && s->max_early_data > 0) {
             /*
              * We haven't selected TLSv1.3 yet so we don't call the change
              * cipher state function associated with the SSL_METHOD. Instead
              * we call tls13_change_cipher_state() directly.
              */
             if (!tls13_change_cipher_state(s,
-                        SSL3_CC_EARLY | SSL3_CHANGE_CIPHER_CLIENT_WRITE))
+                    SSL3_CC_EARLY | SSL3_CHANGE_CIPHER_CLIENT_WRITE))
                 return WORK_ERROR;
             break;
         }
@@ -869,7 +867,7 @@ WORK_STATE ossl_statem_client_post_work(SSL_CONNECTION *s, WORK_STATE wst)
         }
 
         if (!ssl->method->ssl3_enc->change_cipher_state(s,
-                                          SSL3_CHANGE_CIPHER_CLIENT_WRITE)) {
+                SSL3_CHANGE_CIPHER_CLIENT_WRITE)) {
             /* SSLfatal() already called */
             return WORK_ERROR;
         }
@@ -877,11 +875,11 @@ WORK_STATE ossl_statem_client_post_work(SSL_CONNECTION *s, WORK_STATE wst)
 #ifndef OPENSSL_NO_SCTP
         if (SSL_CONNECTION_IS_DTLS(s) && s->hit) {
             /*
-            * Change to new shared key of SCTP-Auth, will be ignored if
-            * no SCTP used.
-            */
+             * Change to new shared key of SCTP-Auth, will be ignored if
+             * no SCTP used.
+             */
             BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
-                     0, NULL);
+                0, NULL);
         }
 #endif
         break;
@@ -894,7 +892,7 @@ WORK_STATE ossl_statem_client_post_work(SSL_CONNECTION *s, WORK_STATE wst)
              * no SCTP used.
              */
             BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
-                     0, NULL);
+                0, NULL);
         }
 #endif
         if (statem_flush(s) != 1)
@@ -917,8 +915,8 @@ WORK_STATE ossl_statem_client_post_work(SSL_CONNECTION *s, WORK_STATE wst)
                  * keys.
                  */
                 if (SSL_IS_QUIC_HANDSHAKE(s)
-                        && !ssl->method->ssl3_enc->change_cipher_state(s,
-                            SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_CLIENT_READ)) {
+                    && !ssl->method->ssl3_enc->change_cipher_state(s,
+                        SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_CLIENT_READ)) {
                     /* SSLfatal() already called */
                     return WORK_ERROR;
                 }
@@ -948,7 +946,7 @@ WORK_STATE ossl_statem_client_post_work(SSL_CONNECTION *s, WORK_STATE wst)
  *   0: Error
  */
 int ossl_statem_client_construct_message(SSL_CONNECTION *s,
-                                         confunc_f *confunc, int *mt)
+    confunc_f *confunc, int *mt)
 {
     OSSL_STATEM *st = &s->statem;
 
@@ -1090,7 +1088,7 @@ size_t ossl_statem_client_max_message_size(SSL_CONNECTION *s)
  * Process a message that the client has received from the server.
  */
 MSG_PROCESS_RETURN ossl_statem_client_process_message(SSL_CONNECTION *s,
-                                                      PACKET *pkt)
+    PACKET *pkt)
 {
     OSSL_STATEM *st = &s->statem;
 
@@ -1154,7 +1152,7 @@ MSG_PROCESS_RETURN ossl_statem_client_process_message(SSL_CONNECTION *s,
  * from the server
  */
 WORK_STATE ossl_statem_client_post_process_message(SSL_CONNECTION *s,
-                                                   WORK_STATE wst)
+    WORK_STATE wst)
 {
     OSSL_STATEM *st = &s->statem;
 
@@ -1194,10 +1192,10 @@ CON_FUNC_RETURN tls_construct_client_hello(SSL_CONNECTION *s, WPACKET *pkt)
     }
 
     if (sess == NULL
-            || !ssl_version_supported(s, sess->ssl_version, NULL)
-            || !SSL_SESSION_is_resumable(sess)) {
+        || !ssl_version_supported(s, sess->ssl_version, NULL)
+        || !SSL_SESSION_is_resumable(sess)) {
         if (s->hello_retry_request == SSL_HRR_NONE
-                && !ssl_get_new_session(s, 0)) {
+            && !ssl_get_new_session(s, 0)) {
             /* SSLfatal() already called */
             return CON_FUNC_ERROR;
         }
@@ -1223,8 +1221,7 @@ CON_FUNC_RETURN tls_construct_client_hello(SSL_CONNECTION *s, WPACKET *pkt)
         i = (s->hello_retry_request == SSL_HRR_NONE);
     }
 
-    if (i && ssl_fill_hello_random(s, 0, p, sizeof(s->s3.client_random),
-                                   DOWNGRADE_NONE) <= 0) {
+    if (i && ssl_fill_hello_random(s, 0, p, sizeof(s->s3.client_random), DOWNGRADE_NONE) <= 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return CON_FUNC_ERROR;
     }
@@ -1263,7 +1260,7 @@ CON_FUNC_RETURN tls_construct_client_hello(SSL_CONNECTION *s, WPACKET *pkt)
      * supported_versions extension for the real supported versions.
      */
     if (!WPACKET_put_bytes_u16(pkt, s->client_version)
-            || !WPACKET_memcpy(pkt, s->s3.client_random, SSL3_RANDOM_SIZE)) {
+        || !WPACKET_memcpy(pkt, s->s3.client_random, SSL3_RANDOM_SIZE)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return CON_FUNC_ERROR;
     }
@@ -1272,13 +1269,14 @@ CON_FUNC_RETURN tls_construct_client_hello(SSL_CONNECTION *s, WPACKET *pkt)
     session_id = s->session->session_id;
     if (s->new_session || s->session->ssl_version == TLS1_3_VERSION) {
         if (s->version == TLS1_3_VERSION
-                && (s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0) {
+            && (s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0) {
             sess_id_len = sizeof(s->tmp_session_id);
             s->tmp_session_id_len = sess_id_len;
             session_id = s->tmp_session_id;
             if (s->hello_retry_request == SSL_HRR_NONE
-                    && RAND_bytes_ex(sctx->libctx, s->tmp_session_id,
-                                     sess_id_len, 0) <= 0) {
+                && RAND_bytes_ex(sctx->libctx, s->tmp_session_id,
+                       sess_id_len, 0)
+                    <= 0) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 return CON_FUNC_ERROR;
             }
@@ -1294,9 +1292,8 @@ CON_FUNC_RETURN tls_construct_client_hello(SSL_CONNECTION *s, WPACKET *pkt)
         }
     }
     if (!WPACKET_start_sub_packet_u8(pkt)
-            || (sess_id_len != 0 && !WPACKET_memcpy(pkt, session_id,
-                                                    sess_id_len))
-            || !WPACKET_close(pkt)) {
+        || (sess_id_len != 0 && !WPACKET_memcpy(pkt, session_id, sess_id_len))
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return CON_FUNC_ERROR;
     }
@@ -1304,8 +1301,8 @@ CON_FUNC_RETURN tls_construct_client_hello(SSL_CONNECTION *s, WPACKET *pkt)
     /* cookie stuff for DTLS */
     if (SSL_CONNECTION_IS_DTLS(s)) {
         if (s->d1->cookie_len > sizeof(s->d1->cookie)
-                || !WPACKET_sub_memcpy_u8(pkt, s->d1->cookie,
-                                          s->d1->cookie_len)) {
+            || !WPACKET_sub_memcpy_u8(pkt, s->d1->cookie,
+                s->d1->cookie_len)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return CON_FUNC_ERROR;
         }
@@ -1318,7 +1315,7 @@ CON_FUNC_RETURN tls_construct_client_hello(SSL_CONNECTION *s, WPACKET *pkt)
     }
 
     if (!ssl_cipher_list_to_bytes(s, SSL_get_ciphers(SSL_CONNECTION_GET_SSL(s)),
-                                  pkt)) {
+            pkt)) {
         /* SSLfatal() already called */
         return CON_FUNC_ERROR;
     }
@@ -1334,9 +1331,9 @@ CON_FUNC_RETURN tls_construct_client_hello(SSL_CONNECTION *s, WPACKET *pkt)
     }
 #ifndef OPENSSL_NO_COMP
     if (ssl_allow_compression(s)
-            && sctx->comp_methods
-            && (SSL_CONNECTION_IS_DTLS(s)
-                || s->s3.tmp.max_ver < TLS1_3_VERSION)) {
+        && sctx->comp_methods
+        && (SSL_CONNECTION_IS_DTLS(s)
+            || s->s3.tmp.max_ver < TLS1_3_VERSION)) {
         int compnum = sk_SSL_COMP_num(sctx->comp_methods);
         for (i = 0; i < compnum; i++) {
             comp = sk_SSL_COMP_value(sctx->comp_methods, i);
@@ -1389,7 +1386,7 @@ MSG_PROCESS_RETURN dtls_process_hello_verify(SSL_CONNECTION *s, PACKET *pkt)
 }
 
 static int set_client_ciphersuite(SSL_CONNECTION *s,
-                                  const unsigned char *cipherchars)
+    const unsigned char *cipherchars)
 {
     STACK_OF(SSL_CIPHER) *sk;
     const SSL_CIPHER *c;
@@ -1420,7 +1417,7 @@ static int set_client_ciphersuite(SSL_CONNECTION *s,
     }
 
     if (SSL_CONNECTION_IS_TLS13(s) && s->s3.tmp.new_cipher != NULL
-            && s->s3.tmp.new_cipher->id != c->id) {
+        && s->s3.tmp.new_cipher->id != c->id) {
         /* ServerHello selected a different ciphersuite to that in the HRR */
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CIPHER_RETURNED);
         return 0;
@@ -1446,9 +1443,9 @@ static int set_client_ciphersuite(SSL_CONNECTION *s,
              * ciphersuite as long as the hash is the same.
              */
             if (md == NULL
-                    || md != ssl_md(sctx, s->session->cipher->algorithm2)) {
+                || md != ssl_md(sctx, s->session->cipher->algorithm2)) {
                 SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                         SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED);
+                    SSL_R_CIPHERSUITE_DIGEST_HAS_CHANGED);
                 return 0;
             }
         } else {
@@ -1457,7 +1454,7 @@ static int set_client_ciphersuite(SSL_CONNECTION *s,
              * ciphersuite.
              */
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                     SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED);
+                SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED);
             return 0;
         }
     }
@@ -1489,9 +1486,9 @@ MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
 
     /* load the server random */
     if (s->version == TLS1_3_VERSION
-            && sversion == TLS1_2_VERSION
-            && PACKET_remaining(pkt) >= SSL3_RANDOM_SIZE
-            && memcmp(hrrrandom, PACKET_data(pkt), SSL3_RANDOM_SIZE) == 0) {
+        && sversion == TLS1_2_VERSION
+        && PACKET_remaining(pkt) >= SSL3_RANDOM_SIZE
+        && memcmp(hrrrandom, PACKET_data(pkt), SSL3_RANDOM_SIZE) == 0) {
         if (s->hello_retry_request != SSL_HRR_NONE) {
             SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE);
             goto err;
@@ -1540,16 +1537,16 @@ MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
     if (PACKET_remaining(pkt) == 0 && !hrr) {
         PACKET_null_init(&extpkt);
     } else if (!PACKET_as_length_prefixed_2(pkt, &extpkt)
-               || PACKET_remaining(pkt) != 0) {
+        || PACKET_remaining(pkt) != 0) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_LENGTH);
         goto err;
     }
 
     if (!hrr) {
         if (!tls_collect_extensions(s, &extpkt,
-                                    SSL_EXT_TLS1_2_SERVER_HELLO
-                                    | SSL_EXT_TLS1_3_SERVER_HELLO,
-                                    &extensions, NULL, 1)) {
+                SSL_EXT_TLS1_2_SERVER_HELLO
+                    | SSL_EXT_TLS1_3_SERVER_HELLO,
+                &extensions, NULL, 1)) {
             /* SSLfatal() already called */
             goto err;
         }
@@ -1563,13 +1560,14 @@ MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
     if (SSL_CONNECTION_IS_TLS13(s) || hrr) {
         if (compression != 0) {
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                     SSL_R_INVALID_COMPRESSION_ALGORITHM);
+                SSL_R_INVALID_COMPRESSION_ALGORITHM);
             goto err;
         }
 
         if (session_id_len != s->tmp_session_id_len
-                || memcmp(PACKET_data(&session_id), s->tmp_session_id,
-                          session_id_len) != 0) {
+            || memcmp(PACKET_data(&session_id), s->tmp_session_id,
+                   session_id_len)
+                != 0) {
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_INVALID_SESSION_ID);
             goto err;
         }
@@ -1604,14 +1602,14 @@ MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
          */
         if (RECORD_LAYER_processed_read_pending(&s->rlayer)) {
             SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
-                     SSL_R_NOT_ON_RECORD_BOUNDARY);
+                SSL_R_NOT_ON_RECORD_BOUNDARY);
             goto err;
         }
 
         /* This will set s->hit if we are resuming */
         if (!tls_parse_extension(s, TLSEXT_IDX_psk,
-                                 SSL_EXT_TLS1_3_SERVER_HELLO,
-                                 extensions, NULL, 0)) {
+                SSL_EXT_TLS1_3_SERVER_HELLO,
+                extensions, NULL, 0)) {
             /* SSLfatal() already called */
             goto err;
         }
@@ -1629,7 +1627,7 @@ MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
          * message to see if the server wants to resume.
          */
         if (s->version >= TLS1_VERSION
-                && s->ext.session_secret_cb != NULL && s->session->ext.tick) {
+            && s->ext.session_secret_cb != NULL && s->session->ext.tick) {
             const SSL_CIPHER *pref_cipher = NULL;
             /*
              * s->session->master_key_length is a size_t, but this is an int for
@@ -1639,13 +1637,12 @@ MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
 
             master_key_length = sizeof(s->session->master_key);
             if (s->ext.session_secret_cb(ussl, s->session->master_key,
-                                         &master_key_length,
-                                         NULL, &pref_cipher,
-                                         s->ext.session_secret_cb_arg)
-                     && master_key_length > 0) {
+                    &master_key_length,
+                    NULL, &pref_cipher,
+                    s->ext.session_secret_cb_arg)
+                && master_key_length > 0) {
                 s->session->master_key_length = master_key_length;
-                s->session->cipher = pref_cipher ?
-                    pref_cipher : ssl_get_cipher_by_char(s, cipherchars, 0);
+                s->session->cipher = pref_cipher ? pref_cipher : ssl_get_cipher_by_char(s, cipherchars, 0);
             } else {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 goto err;
@@ -1653,18 +1650,19 @@ MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
         }
 
         if (session_id_len != 0
-                && session_id_len == s->session->session_id_length
-                && memcmp(PACKET_data(&session_id), s->session->session_id,
-                          session_id_len) == 0)
+            && session_id_len == s->session->session_id_length
+            && memcmp(PACKET_data(&session_id), s->session->session_id,
+                   session_id_len)
+                == 0)
             s->hit = 1;
     }
 
     if (s->hit) {
         if (s->sid_ctx_length != s->session->sid_ctx_length
-                || memcmp(s->session->sid_ctx, s->sid_ctx, s->sid_ctx_length)) {
+            || memcmp(s->session->sid_ctx, s->sid_ctx, s->sid_ctx_length)) {
             /* actually a client application bug */
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                     SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT);
+                SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT);
             goto err;
         }
     } else {
@@ -1695,14 +1693,14 @@ MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
             /* session_id_len could be 0 */
             if (session_id_len > 0)
                 memcpy(s->session->session_id, PACKET_data(&session_id),
-                       session_id_len);
+                    session_id_len);
         }
     }
 
     /* Session version and negotiated protocol version should match */
     if (s->version != s->session->ssl_version) {
         SSLfatal(s, SSL_AD_PROTOCOL_VERSION,
-                 SSL_R_SSL_SESSION_VERSION_MISMATCH);
+            SSL_R_SSL_SESSION_VERSION_MISMATCH);
         goto err;
     }
     /*
@@ -1720,7 +1718,7 @@ MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
 #ifdef OPENSSL_NO_COMP
     if (compression != 0) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                 SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM);
+            SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM);
         goto err;
     }
     /*
@@ -1734,7 +1732,7 @@ MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
 #else
     if (s->hit && compression != s->session->compress_meth) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                 SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED);
+            SSL_R_OLD_SESSION_COMPRESSION_ALGORITHM_NOT_RETURNED);
         goto err;
     }
     if (compression == 0)
@@ -1744,12 +1742,12 @@ MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
         goto err;
     } else {
         comp = ssl3_comp_find(SSL_CONNECTION_GET_CTX(s)->comp_methods,
-                              compression);
+            compression);
     }
 
     if (compression != 0 && comp == NULL) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                 SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM);
+            SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM);
         goto err;
     } else {
         s->s3.tmp.new_compression = comp;
@@ -1772,7 +1770,7 @@ MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
          * no SCTP used.
          */
         memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL,
-               sizeof(DTLS1_SCTP_AUTH_LABEL));
+            sizeof(DTLS1_SCTP_AUTH_LABEL));
 
         /* Don't include the terminating zero. */
         labellen = sizeof(labelbuffer) - 1;
@@ -1780,16 +1778,17 @@ MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
             labellen += 1;
 
         if (SSL_export_keying_material(ssl, sctpauthkey,
-                                       sizeof(sctpauthkey),
-                                       labelbuffer,
-                                       labellen, NULL, 0, 0) <= 0) {
+                sizeof(sctpauthkey),
+                labelbuffer,
+                labellen, NULL, 0, 0)
+            <= 0) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             goto err;
         }
 
         BIO_ctrl(SSL_get_wbio(ssl),
-                 BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
-                 sizeof(sctpauthkey), sctpauthkey);
+            BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
+            sizeof(sctpauthkey), sctpauthkey);
     }
 #endif
 
@@ -1799,7 +1798,7 @@ MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
      */
     if (SSL_CONNECTION_IS_TLS13(s)) {
         if (!ssl->method->ssl3_enc->setup_key_block(s)
-                || !tls13_store_handshake_traffic_hash(s)) {
+            || !tls13_store_handshake_traffic_hash(s)) {
             /* SSLfatal() already called */
             goto err;
         }
@@ -1813,16 +1812,16 @@ MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
          * compat this doesn't cause a problem.
          */
         if (SSL_IS_QUIC_HANDSHAKE(s)
-                || (s->early_data_state == SSL_EARLY_DATA_NONE
-                    && (s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) == 0)) {
+            || (s->early_data_state == SSL_EARLY_DATA_NONE
+                && (s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) == 0)) {
             if (!ssl->method->ssl3_enc->change_cipher_state(s,
                     SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE)) {
                 /* SSLfatal() already called */
                 goto err;
-                    }
+            }
         }
         if (!ssl->method->ssl3_enc->change_cipher_state(s,
-                    SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_READ)) {
+                SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_READ)) {
             /* SSLfatal() already called */
             goto err;
         }
@@ -1830,13 +1829,13 @@ MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s, PACKET *pkt)
 
     OPENSSL_free(extensions);
     return MSG_PROCESS_CONTINUE_READING;
- err:
+err:
     OPENSSL_free(extensions);
     return MSG_PROCESS_ERROR;
 }
 
 static MSG_PROCESS_RETURN tls_process_as_hello_retry_request(SSL_CONNECTION *s,
-                                                             PACKET *extpkt)
+    PACKET *extpkt)
 {
     RAW_EXTENSION *extensions = NULL;
 
@@ -1845,12 +1844,12 @@ static MSG_PROCESS_RETURN tls_process_as_hello_retry_request(SSL_CONNECTION *s,
      * the old wrlmethod.
      */
     if (s->early_data_state == SSL_EARLY_DATA_FINISHED_WRITING
-            && !ssl_set_new_record_layer(s,
-                                         TLS_ANY_VERSION,
-                                         OSSL_RECORD_DIRECTION_WRITE,
-                                         OSSL_RECORD_PROTECTION_LEVEL_NONE,
-                                         NULL, 0, NULL, 0, NULL, 0, NULL,  0,
-                                         NULL, 0, NID_undef, NULL, NULL, NULL)) {
+        && !ssl_set_new_record_layer(s,
+            TLS_ANY_VERSION,
+            OSSL_RECORD_DIRECTION_WRITE,
+            OSSL_RECORD_PROTECTION_LEVEL_NONE,
+            NULL, 0, NULL, 0, NULL, 0, NULL, 0,
+            NULL, 0, NID_undef, NULL, NULL, NULL)) {
         /* SSLfatal already called */
         goto err;
     }
@@ -1858,9 +1857,9 @@ static MSG_PROCESS_RETURN tls_process_as_hello_retry_request(SSL_CONNECTION *s,
     s->rlayer.wrlmethod->set_protocol_version(s->rlayer.wrl, TLS1_3_VERSION);
 
     if (!tls_collect_extensions(s, extpkt, SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST,
-                                &extensions, NULL, 1)
-            || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST,
-                                         extensions, NULL, 0, 1)) {
+            &extensions, NULL, 1)
+        || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST,
+            extensions, NULL, 0, 1)) {
         /* SSLfatal() already called */
         goto err;
     }
@@ -1893,13 +1892,13 @@ static MSG_PROCESS_RETURN tls_process_as_hello_retry_request(SSL_CONNECTION *s,
      * for HRR messages.
      */
     if (!ssl3_finish_mac(s, (unsigned char *)s->init_buf->data,
-                                s->init_num + SSL3_HM_HEADER_LENGTH)) {
+            s->init_num + SSL3_HM_HEADER_LENGTH)) {
         /* SSLfatal() already called */
         goto err;
     }
 
     return MSG_PROCESS_FINISHED_READING;
- err:
+err:
     OPENSSL_free(extensions);
     return MSG_PROCESS_ERROR;
 }
@@ -1925,7 +1924,7 @@ MSG_PROCESS_RETURN tls_process_server_rpk(SSL_CONNECTION *sc, PACKET *pkt)
 }
 
 static WORK_STATE tls_post_process_server_rpk(SSL_CONNECTION *sc,
-                                              WORK_STATE wst)
+    WORK_STATE wst)
 {
     size_t certidx;
     const SSL_CERT_LOOKUP *clu;
@@ -1933,7 +1932,7 @@ static WORK_STATE tls_post_process_server_rpk(SSL_CONNECTION *sc,
 
     if (sc->session->peer_rpk == NULL) {
         SSLfatal(sc, SSL_AD_ILLEGAL_PARAMETER,
-                 SSL_R_INVALID_RAW_PUBLIC_KEY);
+            SSL_R_INVALID_RAW_PUBLIC_KEY);
         return WORK_ERROR;
     }
 
@@ -1945,16 +1944,17 @@ static WORK_STATE tls_post_process_server_rpk(SSL_CONNECTION *sc,
     if (v_ok <= 0 && sc->verify_mode != SSL_VERIFY_NONE) {
         ERR_clear_last_mark();
         SSLfatal(sc, ssl_x509err2alert(sc->verify_result),
-                 SSL_R_CERTIFICATE_VERIFY_FAILED);
+            SSL_R_CERTIFICATE_VERIFY_FAILED);
         return WORK_ERROR;
     }
-    ERR_pop_to_mark();      /* but we keep s->verify_result */
+    ERR_pop_to_mark(); /* but we keep s->verify_result */
     if (v_ok > 0 && sc->rwstate == SSL_RETRY_VERIFY) {
         return WORK_MORE_A;
     }
 
     if ((clu = ssl_cert_lookup_by_pkey(sc->session->peer_rpk, &certidx,
-                                       SSL_CONNECTION_GET_CTX(sc))) == NULL) {
+             SSL_CONNECTION_GET_CTX(sc)))
+        == NULL) {
         SSLfatal(sc, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_CERTIFICATE_TYPE);
         return WORK_ERROR;
     }
@@ -1980,9 +1980,9 @@ static WORK_STATE tls_post_process_server_rpk(SSL_CONNECTION *sc,
 
     /* Save the current hash state for when we receive the CertificateVerify */
     if (SSL_CONNECTION_IS_TLS13(sc)
-            && !ssl_handshake_hash(sc, sc->cert_verify_hash,
-                                   sizeof(sc->cert_verify_hash),
-                                   &sc->cert_verify_hash_len)) {
+        && !ssl_handshake_hash(sc, sc->cert_verify_hash,
+            sizeof(sc->cert_verify_hash),
+            &sc->cert_verify_hash_len)) {
         /* SSLfatal() already called */
         return WORK_ERROR;
     }
@@ -1992,7 +1992,7 @@ static WORK_STATE tls_post_process_server_rpk(SSL_CONNECTION *sc,
 
 /* prepare server cert verification by setting s->session->peer_chain from pkt */
 MSG_PROCESS_RETURN tls_process_server_certificate(SSL_CONNECTION *s,
-                                                  PACKET *pkt)
+    PACKET *pkt)
 {
     unsigned long cert_list_len, cert_len;
     X509 *x = NULL;
@@ -2005,7 +2005,7 @@ MSG_PROCESS_RETURN tls_process_server_certificate(SSL_CONNECTION *s,
         return tls_process_server_rpk(s, pkt);
     if (s->ext.server_cert_type != TLSEXT_cert_type_x509) {
         SSLfatal(s, SSL_AD_UNSUPPORTED_CERTIFICATE,
-                 SSL_R_UNKNOWN_CERTIFICATE_TYPE);
+            SSL_R_UNKNOWN_CERTIFICATE_TYPE);
         goto err;
     }
 
@@ -2015,10 +2015,10 @@ MSG_PROCESS_RETURN tls_process_server_certificate(SSL_CONNECTION *s,
     }
 
     if ((SSL_CONNECTION_IS_TLS13(s) && !PACKET_get_1(pkt, &context))
-            || context != 0
-            || !PACKET_get_net_3(pkt, &cert_list_len)
-            || PACKET_remaining(pkt) != cert_list_len
-            || PACKET_remaining(pkt) == 0) {
+        || context != 0
+        || !PACKET_get_net_3(pkt, &cert_list_len)
+        || PACKET_remaining(pkt) != cert_list_len
+        || PACKET_remaining(pkt) == 0) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
         goto err;
     }
@@ -2036,7 +2036,8 @@ MSG_PROCESS_RETURN tls_process_server_certificate(SSL_CONNECTION *s,
             goto err;
         }
         if (d2i_X509(&x, (const unsigned char **)&certbytes,
-                     cert_len) == NULL) {
+                cert_len)
+            == NULL) {
             SSLfatal(s, SSL_AD_BAD_CERTIFICATE, ERR_R_ASN1_LIB);
             goto err;
         }
@@ -2055,11 +2056,11 @@ MSG_PROCESS_RETURN tls_process_server_certificate(SSL_CONNECTION *s,
                 goto err;
             }
             if (!tls_collect_extensions(s, &extensions,
-                                        SSL_EXT_TLS1_3_CERTIFICATE, &rawexts,
-                                        NULL, chainidx == 0)
+                    SSL_EXT_TLS1_3_CERTIFICATE, &rawexts,
+                    NULL, chainidx == 0)
                 || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_CERTIFICATE,
-                                             rawexts, x, chainidx,
-                                             PACKET_remaining(pkt) == 0)) {
+                    rawexts, x, chainidx,
+                    PACKET_remaining(pkt) == 0)) {
                 OPENSSL_free(rawexts);
                 /* SSLfatal already called */
                 goto err;
@@ -2075,7 +2076,7 @@ MSG_PROCESS_RETURN tls_process_server_certificate(SSL_CONNECTION *s,
     }
     return MSG_PROCESS_CONTINUE_PROCESSING;
 
- err:
+err:
     X509_free(x);
     OSSL_STACK_OF_X509_free(s->session->peer_chain);
     s->session->peer_chain = NULL;
@@ -2088,7 +2089,7 @@ MSG_PROCESS_RETURN tls_process_server_certificate(SSL_CONNECTION *s,
  * Else the peer certificate verification callback may request retry.
  */
 WORK_STATE tls_post_process_server_certificate(SSL_CONNECTION *s,
-                                               WORK_STATE wst)
+    WORK_STATE wst)
 {
     X509 *x;
     EVP_PKEY *pkey = NULL;
@@ -2121,10 +2122,10 @@ WORK_STATE tls_post_process_server_certificate(SSL_CONNECTION *s,
     if (i <= 0 && s->verify_mode != SSL_VERIFY_NONE) {
         ERR_clear_last_mark();
         SSLfatal(s, ssl_x509err2alert(s->verify_result),
-                 SSL_R_CERTIFICATE_VERIFY_FAILED);
+            SSL_R_CERTIFICATE_VERIFY_FAILED);
         return WORK_ERROR;
     }
-    ERR_pop_to_mark();      /* but we keep s->verify_result */
+    ERR_pop_to_mark(); /* but we keep s->verify_result */
     if (i > 0 && s->rwstate == SSL_RETRY_VERIFY)
         return WORK_MORE_A;
 
@@ -2138,12 +2139,13 @@ WORK_STATE tls_post_process_server_certificate(SSL_CONNECTION *s,
 
     if (pkey == NULL || EVP_PKEY_missing_parameters(pkey)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                 SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS);
+            SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS);
         return WORK_ERROR;
     }
 
     if ((clu = ssl_cert_lookup_by_pkey(pkey, &certidx,
-				       SSL_CONNECTION_GET_CTX(s))) == NULL) {
+             SSL_CONNECTION_GET_CTX(s)))
+        == NULL) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_CERTIFICATE_TYPE);
         return WORK_ERROR;
     }
@@ -2173,9 +2175,9 @@ WORK_STATE tls_post_process_server_certificate(SSL_CONNECTION *s,
 
     /* Save the current hash state for when we receive the CertificateVerify */
     if (SSL_CONNECTION_IS_TLS13(s)
-            && !ssl_handshake_hash(s, s->cert_verify_hash,
-                                   sizeof(s->cert_verify_hash),
-                                   &s->cert_verify_hash_len)) {
+        && !ssl_handshake_hash(s, s->cert_verify_hash,
+            sizeof(s->cert_verify_hash),
+            &s->cert_verify_hash_len)) {
         /* SSLfatal() already called */;
         return WORK_ERROR;
     }
@@ -2224,7 +2226,7 @@ static int tls_process_ske_psk_preamble(SSL_CONNECTION *s, PACKET *pkt)
         OPENSSL_free(s->session->psk_identity_hint);
         s->session->psk_identity_hint = NULL;
     } else if (!PACKET_strndup(&psk_identity_hint,
-                               &s->session->psk_identity_hint)) {
+                   &s->session->psk_identity_hint)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
@@ -2249,18 +2251,18 @@ static int tls_process_ske_srp(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey)
         return 0;
     }
 
-    if ((s->srp_ctx.N =
-         BN_bin2bn(PACKET_data(&prime),
-                   (int)PACKET_remaining(&prime), NULL)) == NULL
-        || (s->srp_ctx.g =
-            BN_bin2bn(PACKET_data(&generator),
-                      (int)PACKET_remaining(&generator), NULL)) == NULL
-        || (s->srp_ctx.s =
-            BN_bin2bn(PACKET_data(&salt),
-                      (int)PACKET_remaining(&salt), NULL)) == NULL
-        || (s->srp_ctx.B =
-            BN_bin2bn(PACKET_data(&server_pub),
-                      (int)PACKET_remaining(&server_pub), NULL)) == NULL) {
+    if ((s->srp_ctx.N = BN_bin2bn(PACKET_data(&prime),
+             (int)PACKET_remaining(&prime), NULL))
+            == NULL
+        || (s->srp_ctx.g = BN_bin2bn(PACKET_data(&generator),
+                (int)PACKET_remaining(&generator), NULL))
+            == NULL
+        || (s->srp_ctx.s = BN_bin2bn(PACKET_data(&salt),
+                (int)PACKET_remaining(&salt), NULL))
+            == NULL
+        || (s->srp_ctx.B = BN_bin2bn(PACKET_data(&server_pub),
+                (int)PACKET_remaining(&server_pub), NULL))
+            == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BN_LIB);
         return 0;
     }
@@ -2301,9 +2303,9 @@ static int tls_process_ske_dhe(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey)
 
     p = BN_bin2bn(PACKET_data(&prime), (int)PACKET_remaining(&prime), NULL);
     g = BN_bin2bn(PACKET_data(&generator), (int)PACKET_remaining(&generator),
-                  NULL);
+        NULL);
     bnpub_key = BN_bin2bn(PACKET_data(&pub_key),
-                          (int)PACKET_remaining(&pub_key), NULL);
+        (int)PACKET_remaining(&pub_key), NULL);
     if (p == NULL || g == NULL || bnpub_key == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_BN_LIB);
         goto err;
@@ -2311,11 +2313,11 @@ static int tls_process_ske_dhe(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey)
 
     tmpl = OSSL_PARAM_BLD_new();
     if (tmpl == NULL
-            || !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_FFC_P, p)
-            || !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_FFC_G, g)
-            || !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_PUB_KEY,
-                                       bnpub_key)
-            || (params = OSSL_PARAM_BLD_to_param(tmpl)) == NULL) {
+        || !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_FFC_P, p)
+        || !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_FFC_G, g)
+        || !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_PUB_KEY,
+            bnpub_key)
+        || (params = OSSL_PARAM_BLD_to_param(tmpl)) == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
@@ -2326,7 +2328,7 @@ static int tls_process_ske_dhe(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey)
         goto err;
     }
     if (EVP_PKEY_fromdata_init(pctx) <= 0
-            || EVP_PKEY_fromdata(pctx, &peer_tmp, EVP_PKEY_KEYPAIR, params) <= 0) {
+        || EVP_PKEY_fromdata(pctx, &peer_tmp, EVP_PKEY_KEYPAIR, params) <= 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_DH_VALUE);
         goto err;
     }
@@ -2334,21 +2336,21 @@ static int tls_process_ske_dhe(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey)
     EVP_PKEY_CTX_free(pctx);
     pctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx, peer_tmp, sctx->propq);
     if (pctx == NULL
-            /*
-             * EVP_PKEY_param_check() will verify that the DH params are using
-             * a safe prime. In this context, because we're using ephemeral DH,
-             * we're ok with it not being a safe prime.
-             * EVP_PKEY_param_check_quick() skips the safe prime check.
-             */
-            || EVP_PKEY_param_check_quick(pctx) != 1
-            || EVP_PKEY_public_check(pctx) != 1) {
+        /*
+         * EVP_PKEY_param_check() will verify that the DH params are using
+         * a safe prime. In this context, because we're using ephemeral DH,
+         * we're ok with it not being a safe prime.
+         * EVP_PKEY_param_check_quick() skips the safe prime check.
+         */
+        || EVP_PKEY_param_check_quick(pctx) != 1
+        || EVP_PKEY_public_check(pctx) != 1) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_DH_VALUE);
         goto err;
     }
 
     if (!ssl_security(s, SSL_SECOP_TMP_DH,
-                      EVP_PKEY_get_security_bits(peer_tmp),
-                      0, peer_tmp)) {
+            EVP_PKEY_get_security_bits(peer_tmp),
+            0, peer_tmp)) {
         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_DH_KEY_TOO_SMALL);
         goto err;
     }
@@ -2366,7 +2368,7 @@ static int tls_process_ske_dhe(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey)
 
     ret = 1;
 
- err:
+err:
     OSSL_PARAM_BLD_free(tmpl);
     OSSL_PARAM_free(params);
     EVP_PKEY_free(peer_tmp);
@@ -2397,14 +2399,14 @@ static int tls_process_ske_ecdhe(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey
      * server has sent an invalid curve.
      */
     if (curve_type != NAMED_CURVE_TYPE
-            || !tls1_check_group_id(s, curve_id, 1)) {
+        || !tls1_check_group_id(s, curve_id, 1)) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_CURVE);
         return 0;
     }
 
     if ((s->s3.peer_tmp = ssl_generate_param_group(s, curve_id)) == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                 SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
+            SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
         return 0;
     }
 
@@ -2414,8 +2416,9 @@ static int tls_process_ske_ecdhe(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **pkey
     }
 
     if (EVP_PKEY_set1_encoded_public_key(s->s3.peer_tmp,
-                                         PACKET_data(&encoded_pt),
-                                         PACKET_remaining(&encoded_pt)) <= 0) {
+            PACKET_data(&encoded_pt),
+            PACKET_remaining(&encoded_pt))
+        <= 0) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_ECPOINT);
         return 0;
     }
@@ -2494,8 +2497,7 @@ MSG_PROCESS_RETURN tls_process_key_exchange(SSL_CONNECTION *s, PACKET *pkt)
          * equals the length of the parameters.
          */
         if (!PACKET_get_sub_packet(&save_param_start, &params,
-                                   PACKET_remaining(&save_param_start) -
-                                   PACKET_remaining(pkt))) {
+                PACKET_remaining(&save_param_start) - PACKET_remaining(pkt))) {
             SSLfatal(s, SSL_AD_DECODE_ERROR, ERR_R_INTERNAL_ERROR);
             goto err;
         }
@@ -2507,24 +2509,24 @@ MSG_PROCESS_RETURN tls_process_key_exchange(SSL_CONNECTION *s, PACKET *pkt)
                 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_TOO_SHORT);
                 goto err;
             }
-            if (tls12_check_peer_sigalg(s, sigalg, pkey) <=0) {
+            if (tls12_check_peer_sigalg(s, sigalg, pkey) <= 0) {
                 /* SSLfatal() already called */
                 goto err;
             }
         } else if (!tls1_set_peer_legacy_sigalg(s, pkey)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                     SSL_R_LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED);
+                SSL_R_LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED);
             goto err;
         }
 
         if (!tls1_lookup_md(sctx, s->s3.tmp.peer_sigalg, &md)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                     SSL_R_NO_SUITABLE_DIGEST_ALGORITHM);
+                SSL_R_NO_SUITABLE_DIGEST_ALGORITHM);
             goto err;
         }
         if (SSL_USE_SIGALGS(s))
             OSSL_TRACE1(TLS, "USING TLSv1.2 HASH %s\n",
-                        md == NULL ? "n/a" : EVP_MD_get0_name(md));
+                md == NULL ? "n/a" : EVP_MD_get0_name(md));
 
         if (!PACKET_get_length_prefixed_2(pkt, &signature)
             || PACKET_remaining(pkt) != 0) {
@@ -2539,29 +2541,31 @@ MSG_PROCESS_RETURN tls_process_key_exchange(SSL_CONNECTION *s, PACKET *pkt)
         }
 
         if (EVP_DigestVerifyInit_ex(md_ctx, &pctx,
-                                    md == NULL ? NULL : EVP_MD_get0_name(md),
-                                    sctx->libctx, sctx->propq, pkey,
-                                    NULL) <= 0) {
+                md == NULL ? NULL : EVP_MD_get0_name(md),
+                sctx->libctx, sctx->propq, pkey,
+                NULL)
+            <= 0) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
             goto err;
         }
         if (SSL_USE_PSS(s)) {
             if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0
                 || EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx,
-                                                RSA_PSS_SALTLEN_DIGEST) <= 0) {
+                       RSA_PSS_SALTLEN_DIGEST)
+                    <= 0) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
                 goto err;
             }
         }
         tbslen = construct_key_exchange_tbs(s, &tbs, PACKET_data(&params),
-                                            PACKET_remaining(&params));
+            PACKET_remaining(&params));
         if (tbslen == 0) {
             /* SSLfatal() already called */
             goto err;
         }
 
         rv = EVP_DigestVerify(md_ctx, PACKET_data(&signature),
-                              PACKET_remaining(&signature), tbs, tbslen);
+            PACKET_remaining(&signature), tbs, tbslen);
         OPENSSL_free(tbs);
         if (rv <= 0) {
             SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_BAD_SIGNATURE);
@@ -2588,13 +2592,13 @@ MSG_PROCESS_RETURN tls_process_key_exchange(SSL_CONNECTION *s, PACKET *pkt)
     }
 
     return MSG_PROCESS_CONTINUE_READING;
- err:
+err:
     EVP_MD_CTX_free(md_ctx);
     return MSG_PROCESS_ERROR;
 }
 
 MSG_PROCESS_RETURN tls_process_certificate_request(SSL_CONNECTION *s,
-                                                   PACKET *pkt)
+    PACKET *pkt)
 {
     /* Clear certificate validity flags */
     if (s->s3.tmp.valid_flags != NULL)
@@ -2627,8 +2631,7 @@ MSG_PROCESS_RETURN tls_process_certificate_request(SSL_CONNECTION *s,
         s->pha_context = NULL;
         s->pha_context_len = 0;
 
-        if (!PACKET_get_length_prefixed_1(pkt, &reqctx) ||
-            !PACKET_memdup(&reqctx, &s->pha_context, &s->pha_context_len)) {
+        if (!PACKET_get_length_prefixed_1(pkt, &reqctx) || !PACKET_memdup(&reqctx, &s->pha_context, &s->pha_context_len)) {
             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
             return MSG_PROCESS_ERROR;
         }
@@ -2638,10 +2641,10 @@ MSG_PROCESS_RETURN tls_process_certificate_request(SSL_CONNECTION *s,
             return MSG_PROCESS_ERROR;
         }
         if (!tls_collect_extensions(s, &extensions,
-                                    SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
-                                    &rawexts, NULL, 1)
+                SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
+                &rawexts, NULL, 1)
             || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
-                                         rawexts, NULL, 0, 1)) {
+                rawexts, NULL, 0, 1)) {
             /* SSLfatal() already called */
             OPENSSL_free(rawexts);
             return MSG_PROCESS_ERROR;
@@ -2679,7 +2682,7 @@ MSG_PROCESS_RETURN tls_process_certificate_request(SSL_CONNECTION *s,
              */
             if (!tls1_save_sigalgs(s, &sigalgs, 0)) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                         SSL_R_SIGNATURE_ALGORITHMS_ERROR);
+                    SSL_R_SIGNATURE_ALGORITHMS_ERROR);
                 return MSG_PROCESS_ERROR;
             }
             if (!tls1_process_sigalgs(s)) {
@@ -2719,7 +2722,7 @@ MSG_PROCESS_RETURN tls_process_certificate_request(SSL_CONNECTION *s,
 }
 
 MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL_CONNECTION *s,
-                                                  PACKET *pkt)
+    PACKET *pkt)
 {
     unsigned int ticklen;
     unsigned long ticket_lifetime_hint, age_add = 0;
@@ -2737,7 +2740,7 @@ MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL_CONNECTION *s,
                 || !PACKET_get_length_prefixed_1(pkt, &nonce)))
         || !PACKET_get_net_2(pkt, &ticklen)
         || (SSL_CONNECTION_IS_TLS13(s) ? (ticklen == 0
-                                          || PACKET_remaining(pkt) < ticklen)
+                                             || PACKET_remaining(pkt) < ticklen)
                                        : PACKET_remaining(pkt) != ticklen)) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
         goto err;
@@ -2772,7 +2775,7 @@ MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL_CONNECTION *s,
         }
 
         if ((s->session_ctx->session_cache_mode & SSL_SESS_CACHE_CLIENT) != 0
-                && !SSL_CONNECTION_IS_TLS13(s)) {
+            && !SSL_CONNECTION_IS_TLS13(s)) {
             /*
              * In TLSv1.2 and below the arrival of a new tickets signals that
              * any old ticket we were using is now out of date, so we remove the
@@ -2810,17 +2813,17 @@ MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL_CONNECTION *s,
         PACKET extpkt;
 
         if (!PACKET_as_length_prefixed_2(pkt, &extpkt)
-                || PACKET_remaining(pkt) != 0) {
+            || PACKET_remaining(pkt) != 0) {
             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
             goto err;
         }
 
         if (!tls_collect_extensions(s, &extpkt,
-                                    SSL_EXT_TLS1_3_NEW_SESSION_TICKET, &exts,
-                                    NULL, 1)
-                || !tls_parse_all_extensions(s,
-                                             SSL_EXT_TLS1_3_NEW_SESSION_TICKET,
-                                             exts, NULL, 0, 1)) {
+                SSL_EXT_TLS1_3_NEW_SESSION_TICKET, &exts,
+                NULL, 1)
+            || !tls_parse_all_extensions(s,
+                SSL_EXT_TLS1_3_NEW_SESSION_TICKET,
+                exts, NULL, 0, 1)) {
             /* SSLfatal() already called */
             goto err;
         }
@@ -2848,8 +2851,8 @@ MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL_CONNECTION *s,
      * but s->session->session_id_length is a size_t
      */
     if (!EVP_Digest(s->session->ext.tick, ticklen,
-                    s->session->session_id, &sess_len,
-                    sha256, NULL)) {
+            s->session->session_id, &sess_len,
+            sha256, NULL)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
         goto err;
     }
@@ -2863,7 +2866,9 @@ MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL_CONNECTION *s,
         const EVP_MD *md = ssl_handshake_md(s);
         int hashleni = EVP_MD_get_size(md);
         size_t hashlen;
-        static const unsigned char nonce_label[] = "resumption";
+        /* ASCII: "resumption", in hex for EBCDIC compatibility */
+        static const unsigned char nonce_label[] = { 0x72, 0x65, 0x73, 0x75, 0x6D,
+            0x70, 0x74, 0x69, 0x6F, 0x6E };
 
         /* Ensure cast to size_t is safe */
         if (!ossl_assert(hashleni > 0)) {
@@ -2873,12 +2878,12 @@ MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL_CONNECTION *s,
         hashlen = (size_t)hashleni;
 
         if (!tls13_hkdf_expand(s, md, s->resumption_master_secret,
-                               nonce_label,
-                               sizeof(nonce_label) - 1,
-                               PACKET_data(&nonce),
-                               PACKET_remaining(&nonce),
-                               s->session->master_key,
-                               hashlen, 1)) {
+                nonce_label,
+                sizeof(nonce_label),
+                PACKET_data(&nonce),
+                PACKET_remaining(&nonce),
+                s->session->master_key,
+                hashlen, 1)) {
             /* SSLfatal() already called */
             goto err;
         }
@@ -2890,7 +2895,7 @@ MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL_CONNECTION *s,
     }
 
     return MSG_PROCESS_CONTINUE_READING;
- err:
+err:
     EVP_MD_free(sha256);
     OPENSSL_free(exts);
     return MSG_PROCESS_ERROR;
@@ -2930,7 +2935,6 @@ int tls_process_cert_status_body(SSL_CONNECTION *s, PACKET *pkt)
     return 1;
 }
 
-
 MSG_PROCESS_RETURN tls_process_cert_status(SSL_CONNECTION *s, PACKET *pkt)
 {
     if (!tls_process_cert_status_body(s, pkt)) {
@@ -2966,18 +2970,18 @@ int tls_process_initial_server_flight(SSL_CONNECTION *s)
      * message, or NULL and -1 otherwise
      */
     if (s->ext.status_type != TLSEXT_STATUSTYPE_nothing
-            && sctx->ext.status_cb != NULL) {
+        && sctx->ext.status_cb != NULL) {
         int ret = sctx->ext.status_cb(SSL_CONNECTION_GET_USER_SSL(s),
-                                      sctx->ext.status_arg);
+            sctx->ext.status_arg);
 
         if (ret == 0) {
             SSLfatal(s, SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE,
-                     SSL_R_INVALID_STATUS_RESPONSE);
+                SSL_R_INVALID_STATUS_RESPONSE);
             return 0;
         }
         if (ret < 0) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                     SSL_R_OCSP_CALLBACK_FAILURE);
+                SSL_R_OCSP_CALLBACK_FAILURE);
             return 0;
         }
     }
@@ -3042,13 +3046,13 @@ static int tls_construct_cke_psk_preamble(SSL_CONNECTION *s, WPACKET *pkt)
     memset(identity, 0, sizeof(identity));
 
     psklen = s->psk_client_callback(SSL_CONNECTION_GET_USER_SSL(s),
-                                    s->session->psk_identity_hint,
-                                    identity, sizeof(identity) - 1,
-                                    psk, sizeof(psk));
+        s->session->psk_identity_hint,
+        identity, sizeof(identity) - 1,
+        psk, sizeof(psk));
 
     if (psklen > PSK_MAX_PSK_LEN) {
         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, ERR_R_INTERNAL_ERROR);
-        psklen = PSK_MAX_PSK_LEN;   /* Avoid overrunning the array on cleanse */
+        psklen = PSK_MAX_PSK_LEN; /* Avoid overrunning the array on cleanse */
         goto err;
     } else if (psklen == 0) {
         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_PSK_IDENTITY_NOT_FOUND);
@@ -3076,14 +3080,14 @@ static int tls_construct_cke_psk_preamble(SSL_CONNECTION *s, WPACKET *pkt)
     s->session->psk_identity = tmpidentity;
     tmpidentity = NULL;
 
-    if (!WPACKET_sub_memcpy_u16(pkt, identity, identitylen))  {
+    if (!WPACKET_sub_memcpy_u16(pkt, identity, identitylen)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
 
     ret = 1;
 
- err:
+err:
     OPENSSL_cleanse(psk, psklen);
     OPENSSL_cleanse(identity, sizeof(identity));
     OPENSSL_clear_free(tmppsk, psklen);
@@ -3151,7 +3155,7 @@ static int tls_construct_cke_rsa(SSL_CONNECTION *s, WPACKET *pkt)
         goto err;
     }
     if (!WPACKET_allocate_bytes(pkt, enclen, &encdata)
-            || EVP_PKEY_encrypt(pctx, encdata, &enclen, pms, pmslen) <= 0) {
+        || EVP_PKEY_encrypt(pctx, encdata, &enclen, pms, pmslen) <= 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_RSA_ENCRYPT);
         goto err;
     }
@@ -3174,7 +3178,7 @@ static int tls_construct_cke_rsa(SSL_CONNECTION *s, WPACKET *pkt)
     s->s3.tmp.pmslen = pmslen;
 
     return 1;
- err:
+err:
     OPENSSL_clear_free(pms, pmslen);
     EVP_PKEY_CTX_free(pctx);
 
@@ -3238,7 +3242,7 @@ static int tls_construct_cke_dhe(SSL_CONNECTION *s, WPACKET *pkt)
     }
 
     ret = 1;
- err:
+err:
     OPENSSL_free(encoded_pub);
     EVP_PKEY_free(ckey);
     return ret;
@@ -3282,7 +3286,7 @@ static int tls_construct_cke_ecdhe(SSL_CONNECTION *s, WPACKET *pkt)
     }
 
     ret = 1;
- err:
+err:
     OPENSSL_free(encodedPoint);
     EVP_PKEY_free(ckey);
     return ret;
@@ -3311,13 +3315,13 @@ static int tls_construct_cke_gost(SSL_CONNECTION *s, WPACKET *pkt)
      */
     if ((pkey = tls_get_peer_pkey(s)) == NULL) {
         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                 SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER);
+            SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER);
         return 0;
     }
 
     pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx,
-                                          pkey,
-                                          sctx->propq);
+        pkey,
+        sctx->propq);
     if (pkey_ctx == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
         return 0;
@@ -3351,9 +3355,11 @@ static int tls_construct_cke_gost(SSL_CONNECTION *s, WPACKET *pkt)
     if (ukm_hash == NULL
         || EVP_DigestInit(ukm_hash, EVP_get_digestbynid(dgst_nid)) <= 0
         || EVP_DigestUpdate(ukm_hash, s->s3.client_random,
-                            SSL3_RANDOM_SIZE) <= 0
+               SSL3_RANDOM_SIZE)
+            <= 0
         || EVP_DigestUpdate(ukm_hash, s->s3.server_random,
-                            SSL3_RANDOM_SIZE) <= 0
+               SSL3_RANDOM_SIZE)
+            <= 0
         || EVP_DigestFinal_ex(ukm_hash, shared_ukm, &md_len) <= 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
@@ -3361,7 +3367,8 @@ static int tls_construct_cke_gost(SSL_CONNECTION *s, WPACKET *pkt)
     EVP_MD_CTX_free(ukm_hash);
     ukm_hash = NULL;
     if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT,
-                          EVP_PKEY_CTRL_SET_IV, 8, shared_ukm) <= 0) {
+            EVP_PKEY_CTRL_SET_IV, 8, shared_ukm)
+        <= 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG);
         goto err;
     }
@@ -3376,8 +3383,8 @@ static int tls_construct_cke_gost(SSL_CONNECTION *s, WPACKET *pkt)
     }
 
     if (!WPACKET_put_bytes_u8(pkt, V_ASN1_SEQUENCE | V_ASN1_CONSTRUCTED)
-            || (msglen >= 0x80 && !WPACKET_put_bytes_u8(pkt, 0x81))
-            || !WPACKET_sub_memcpy_u8(pkt, tmp, msglen)) {
+        || (msglen >= 0x80 && !WPACKET_put_bytes_u8(pkt, 0x81))
+        || !WPACKET_sub_memcpy_u8(pkt, tmp, msglen)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
@@ -3387,7 +3394,7 @@ static int tls_construct_cke_gost(SSL_CONNECTION *s, WPACKET *pkt)
     s->s3.tmp.pmslen = pmslen;
 
     return 1;
- err:
+err:
     EVP_PKEY_CTX_free(pkey_ctx);
     OPENSSL_clear_free(pms, pmslen);
     EVP_MD_CTX_free(ukm_hash);
@@ -3415,7 +3422,7 @@ int ossl_gost_ukm(const SSL_CONNECTION *s, unsigned char *dgst_buf)
     unsigned int md_len;
     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
     const EVP_MD *md = ssl_evp_md_fetch(sctx->libctx, NID_id_GostR3411_2012_256,
-                                        sctx->propq);
+        sctx->propq);
 
     if (md == NULL)
         return 0;
@@ -3473,16 +3480,16 @@ static int tls_construct_cke_gost18(SSL_CONNECTION *s, WPACKET *pkt)
         goto err;
     }
 
-     /* Get server certificate PKEY and create ctx from it */
+    /* Get server certificate PKEY and create ctx from it */
     if ((pkey = tls_get_peer_pkey(s)) == NULL) {
         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                 SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER);
+            SSL_R_NO_GOST_CERTIFICATE_SENT_BY_PEER);
         goto err;
     }
 
     pkey_ctx = EVP_PKEY_CTX_new_from_pkey(sctx->libctx,
-                                          pkey,
-                                          sctx->propq);
+        pkey,
+        sctx->propq);
     if (pkey_ctx == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
         goto err;
@@ -3495,13 +3502,15 @@ static int tls_construct_cke_gost18(SSL_CONNECTION *s, WPACKET *pkt)
 
     /* Reuse EVP_PKEY_CTRL_SET_IV, make choice in engine code */
     if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT,
-                          EVP_PKEY_CTRL_SET_IV, 32, rnd_dgst) <= 0) {
+            EVP_PKEY_CTRL_SET_IV, 32, rnd_dgst)
+        <= 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG);
         goto err;
     }
 
     if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_ENCRYPT,
-                          EVP_PKEY_CTRL_CIPHER, cipher_nid, NULL) <= 0) {
+            EVP_PKEY_CTRL_CIPHER, cipher_nid, NULL)
+        <= 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG);
         goto err;
     }
@@ -3512,7 +3521,7 @@ static int tls_construct_cke_gost18(SSL_CONNECTION *s, WPACKET *pkt)
     }
 
     if (!WPACKET_allocate_bytes(pkt, msglen, &encdata)
-            || EVP_PKEY_encrypt(pkey_ctx, encdata, &msglen, pms, pmslen) <= 0) {
+        || EVP_PKEY_encrypt(pkey_ctx, encdata, &msglen, pms, pmslen) <= 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
         goto err;
     }
@@ -3523,7 +3532,7 @@ static int tls_construct_cke_gost18(SSL_CONNECTION *s, WPACKET *pkt)
     s->s3.tmp.pmslen = pmslen;
 
     return 1;
- err:
+err:
     EVP_PKEY_CTX_free(pkey_ctx);
     OPENSSL_clear_free(pms, pmslen);
     return 0;
@@ -3539,8 +3548,8 @@ static int tls_construct_cke_srp(SSL_CONNECTION *s, WPACKET *pkt)
     unsigned char *abytes = NULL;
 
     if (s->srp_ctx.A == NULL
-            || !WPACKET_sub_allocate_bytes_u16(pkt, BN_num_bytes(s->srp_ctx.A),
-                                               &abytes)) {
+        || !WPACKET_sub_allocate_bytes_u16(pkt, BN_num_bytes(s->srp_ctx.A),
+            &abytes)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
@@ -3561,7 +3570,7 @@ static int tls_construct_cke_srp(SSL_CONNECTION *s, WPACKET *pkt)
 }
 
 CON_FUNC_RETURN tls_construct_client_key_exchange(SSL_CONNECTION *s,
-                                                  WPACKET *pkt)
+    WPACKET *pkt)
 {
     unsigned long alg_k;
 
@@ -3599,7 +3608,7 @@ CON_FUNC_RETURN tls_construct_client_key_exchange(SSL_CONNECTION *s,
     }
 
     return CON_FUNC_SUCCESS;
- err:
+err:
     OPENSSL_clear_free(s->s3.tmp.pms, s->s3.tmp.pmslen);
     s->s3.tmp.pms = NULL;
     s->s3.tmp.pmslen = 0;
@@ -3656,7 +3665,7 @@ int tls_client_key_exchange_post_work(SSL_CONNECTION *s)
          * used.
          */
         memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL,
-               sizeof(DTLS1_SCTP_AUTH_LABEL));
+            sizeof(DTLS1_SCTP_AUTH_LABEL));
 
         /* Don't include the terminating zero. */
         labellen = sizeof(labelbuffer) - 1;
@@ -3664,19 +3673,20 @@ int tls_client_key_exchange_post_work(SSL_CONNECTION *s)
             labellen += 1;
 
         if (SSL_export_keying_material(ssl, sctpauthkey,
-                                       sizeof(sctpauthkey), labelbuffer,
-                                       labellen, NULL, 0, 0) <= 0) {
+                sizeof(sctpauthkey), labelbuffer,
+                labellen, NULL, 0, 0)
+            <= 0) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             goto err;
         }
 
         BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
-                 sizeof(sctpauthkey), sctpauthkey);
+            sizeof(sctpauthkey), sctpauthkey);
     }
 #endif
 
     return 1;
- err:
+err:
     OPENSSL_clear_free(pms, pmslen);
     s->s3.tmp.pms = NULL;
     s->s3.tmp.pmslen = 0;
@@ -3697,8 +3707,7 @@ static int ssl3_check_client_certificate(SSL_CONNECTION *s)
      * If strict mode check suitability of chain before using it. This also
      * adjusts suite B digest if necessary.
      */
-    if (s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT &&
-        !tls1_check_chain(s, NULL, NULL, NULL, -2))
+    if (s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT && !tls1_check_chain(s, NULL, NULL, NULL, -2))
         return 0;
     return 1;
 }
@@ -3776,7 +3785,7 @@ WORK_STATE tls_prepare_client_certificate(SSL_CONNECTION *s, WORK_STATE wst)
         }
 
         if (!SSL_CONNECTION_IS_TLS13(s)
-                || (s->options & SSL_OP_NO_TX_CERTIFICATE_COMPRESSION) != 0)
+            || (s->options & SSL_OP_NO_TX_CERTIFICATE_COMPRESSION) != 0)
             s->ext.compress_certificate_from_peer[0] = TLSEXT_comp_cert_none;
 
         if (s->post_handshake_auth == SSL_PHA_REQUESTED)
@@ -3790,7 +3799,7 @@ WORK_STATE tls_prepare_client_certificate(SSL_CONNECTION *s, WORK_STATE wst)
 }
 
 CON_FUNC_RETURN tls_construct_client_certificate(SSL_CONNECTION *s,
-                                                 WPACKET *pkt)
+    WPACKET *pkt)
 {
     CERT_PKEY *cpk = NULL;
     SSL *ssl = SSL_CONNECTION_GET_SSL(s);
@@ -3833,12 +3842,12 @@ CON_FUNC_RETURN tls_construct_client_certificate(SSL_CONNECTION *s,
      * moment. We need to do it now.
      */
     if (SSL_CONNECTION_IS_TLS13(s)
-            && !SSL_IS_QUIC_HANDSHAKE(s)
-            && SSL_IS_FIRST_HANDSHAKE(s)
-            && (s->early_data_state != SSL_EARLY_DATA_NONE
-                || (s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0)
-            && (!ssl->method->ssl3_enc->change_cipher_state(s,
-                    SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {
+        && !SSL_IS_QUIC_HANDSHAKE(s)
+        && SSL_IS_FIRST_HANDSHAKE(s)
+        && (s->early_data_state != SSL_EARLY_DATA_NONE
+            || (s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0)
+        && (!ssl->method->ssl3_enc->change_cipher_state(s,
+            SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {
         /*
          * This is a fatal error, which leaves enc_write_ctx in an inconsistent
          * state and thus ssl3_send_alert may crash.
@@ -3852,7 +3861,7 @@ CON_FUNC_RETURN tls_construct_client_certificate(SSL_CONNECTION *s,
 
 #ifndef OPENSSL_NO_COMP_ALG
 CON_FUNC_RETURN tls_construct_client_compressed_certificate(SSL_CONNECTION *sc,
-                                                            WPACKET *pkt)
+    WPACKET *pkt)
 {
     SSL *ssl = SSL_CONNECTION_GET_SSL(sc);
     WPACKET tmppkt;
@@ -3885,8 +3894,8 @@ CON_FUNC_RETURN tls_construct_client_compressed_certificate(SSL_CONNECTION *sc,
 
     /* continue with the real |pkt| */
     if (!WPACKET_put_bytes_u16(pkt, alg)
-            || !WPACKET_get_total_written(&tmppkt, &length)
-            || !WPACKET_put_bytes_u24(pkt, length))
+        || !WPACKET_get_total_written(&tmppkt, &length)
+        || !WPACKET_put_bytes_u24(pkt, length))
         goto err;
 
     switch (alg) {
@@ -3905,17 +3914,17 @@ CON_FUNC_RETURN tls_construct_client_compressed_certificate(SSL_CONNECTION *sc,
     max_length = ossl_calculate_comp_expansion(alg, length);
 
     if ((comp = COMP_CTX_new(method)) == NULL
-            || !WPACKET_start_sub_packet_u24(pkt)
-            || !WPACKET_reserve_bytes(pkt, max_length, NULL))
+        || !WPACKET_start_sub_packet_u24(pkt)
+        || !WPACKET_reserve_bytes(pkt, max_length, NULL))
         goto err;
 
     comp_len = COMP_compress_block(comp, WPACKET_get_curr(pkt), max_length,
-                                   (unsigned char *)buf->data, length);
+        (unsigned char *)buf->data, length);
     if (comp_len <= 0)
         goto err;
 
     if (!WPACKET_allocate_bytes(pkt, comp_len, NULL)
-            || !WPACKET_close(pkt))
+        || !WPACKET_close(pkt))
         goto err;
 
     /*
@@ -3924,11 +3933,11 @@ CON_FUNC_RETURN tls_construct_client_compressed_certificate(SSL_CONNECTION *sc,
      * moment. We need to do it now.
      */
     if (SSL_IS_FIRST_HANDSHAKE(sc)
-            && !SSL_IS_QUIC_HANDSHAKE(sc)
-            && (sc->early_data_state != SSL_EARLY_DATA_NONE
-                || (sc->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0)
-            && (!ssl->method->ssl3_enc->change_cipher_state(sc,
-                    SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {
+        && !SSL_IS_QUIC_HANDSHAKE(sc)
+        && (sc->early_data_state != SSL_EARLY_DATA_NONE
+            || (sc->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0)
+        && (!ssl->method->ssl3_enc->change_cipher_state(sc,
+            SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {
         /*
          * This is a fatal error, which leaves sc->enc_write_ctx in an
          * inconsistent state and thus ssl3_send_alert may crash.
@@ -3939,9 +3948,9 @@ CON_FUNC_RETURN tls_construct_client_compressed_certificate(SSL_CONNECTION *sc,
     ret = 1;
     goto out;
 
- err:
+err:
     SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
- out:
+out:
     if (buf != NULL) {
         /* If |buf| is NULL, then |tmppkt| could not have been initialized */
         WPACKET_cleanup(&tmppkt);
@@ -3978,7 +3987,7 @@ int ssl3_check_cert_and_algorithm(SSL_CONNECTION *s)
 
     if (alg_k & (SSL_kRSA | SSL_kRSAPSK) && idx != SSL_PKEY_RSA) {
         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                 SSL_R_MISSING_RSA_ENCRYPTING_CERT);
+            SSL_R_MISSING_RSA_ENCRYPTING_CERT);
         return 0;
     }
 
@@ -4011,7 +4020,7 @@ CON_FUNC_RETURN tls_construct_next_proto(SSL_CONNECTION *s, WPACKET *pkt)
     padding_len = 32 - ((len + 2) % 32);
 
     if (!WPACKET_sub_memcpy_u8(pkt, s->ext.npn, len)
-            || !WPACKET_sub_allocate_bytes_u8(pkt, padding_len, &padding)) {
+        || !WPACKET_sub_allocate_bytes_u8(pkt, padding_len, &padding)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return CON_FUNC_ERROR;
     }
@@ -4053,22 +4062,22 @@ MSG_PROCESS_RETURN tls_process_hello_req(SSL_CONNECTION *s, PACKET *pkt)
 }
 
 static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL_CONNECTION *s,
-                                                           PACKET *pkt)
+    PACKET *pkt)
 {
     PACKET extensions;
     RAW_EXTENSION *rawexts = NULL;
 
     if (!PACKET_as_length_prefixed_2(pkt, &extensions)
-            || PACKET_remaining(pkt) != 0) {
+        || PACKET_remaining(pkt) != 0) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
         goto err;
     }
 
     if (!tls_collect_extensions(s, &extensions,
-                                SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, &rawexts,
-                                NULL, 1)
-            || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
-                                         rawexts, NULL, 0, 1)) {
+            SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS, &rawexts,
+            NULL, 1)
+        || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
+            rawexts, NULL, 0, 1)) {
         /* SSLfatal() already called */
         goto err;
     }
@@ -4076,7 +4085,7 @@ static MSG_PROCESS_RETURN tls_process_encrypted_extensions(SSL_CONNECTION *s,
     OPENSSL_free(rawexts);
     return MSG_PROCESS_CONTINUE_READING;
 
- err:
+err:
     OPENSSL_free(rawexts);
     return MSG_PROCESS_ERROR;
 }
@@ -4099,14 +4108,14 @@ int ssl_do_client_cert_cb(SSL_CONNECTION *s, X509 **px509, EVP_PKEY **ppkey)
 }
 
 int ssl_cipher_list_to_bytes(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *sk,
-                             WPACKET *pkt)
+    WPACKET *pkt)
 {
     int i;
     size_t totlen = 0, len, maxlen, maxverok = 0;
     int empty_reneg_info_scsv = !s->renegotiate
-                                && !SSL_CONNECTION_IS_DTLS(s)
-                                && ssl_security(s, SSL_SECOP_VERSION, 0, TLS1_VERSION, NULL)
-                                && s->min_proto_version <= TLS1_VERSION;
+        && !SSL_CONNECTION_IS_DTLS(s)
+        && ssl_security(s, SSL_SECOP_VERSION, 0, TLS1_VERSION, NULL)
+        && s->min_proto_version <= TLS1_VERSION;
     SSL *ssl = SSL_CONNECTION_GET_SSL(s);
 
     /* Set disabled masks for this session */
@@ -4121,9 +4130,9 @@ int ssl_cipher_list_to_bytes(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *sk,
     }
 
 #ifdef OPENSSL_MAX_TLS1_2_CIPHER_LENGTH
-# if OPENSSL_MAX_TLS1_2_CIPHER_LENGTH < 6
-#  error Max cipher length too short
-# endif
+#if OPENSSL_MAX_TLS1_2_CIPHER_LENGTH < 6
+#error Max cipher length too short
+#endif
     /*
      * Some servers hang if client hello > 256 bytes as hack workaround
      * chop number of supported ciphers to keep it well below this if we
@@ -4160,7 +4169,7 @@ int ssl_cipher_list_to_bytes(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *sk,
             int maxproto = SSL_CONNECTION_IS_DTLS(s) ? c->max_dtls : c->max_tls;
 
             if (ssl_version_cmp(s, maxproto, s->s3.tmp.max_ver) >= 0
-                    && ssl_version_cmp(s, minproto, s->s3.tmp.max_ver) <= 0)
+                && ssl_version_cmp(s, minproto, s->s3.tmp.max_ver) <= 0)
                 maxverok = 1;
         }
 
@@ -4168,13 +4177,12 @@ int ssl_cipher_list_to_bytes(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *sk,
     }
 
     if (totlen == 0 || !maxverok) {
-        const char *maxvertext =
-            !maxverok
+        const char *maxvertext = !maxverok
             ? "No ciphers enabled for max supported SSL/TLS version"
             : NULL;
 
         SSLfatal_data(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_CIPHERS_AVAILABLE,
-                      maxvertext);
+            maxvertext);
         return 0;
     }
 
@@ -4205,7 +4213,7 @@ int ssl_cipher_list_to_bytes(SSL_CONNECTION *s, STACK_OF(SSL_CIPHER) *sk,
 CON_FUNC_RETURN tls_construct_end_of_early_data(SSL_CONNECTION *s, WPACKET *pkt)
 {
     if (s->early_data_state != SSL_EARLY_DATA_WRITE_RETRY
-            && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING) {
+        && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
         return CON_FUNC_ERROR;
     }
diff --git a/crypto/openssl/ssl/statem/statem_dtls.c b/crypto/openssl/ssl/statem/statem_dtls.c
index 78baeed90319..f62b757721fc 100644
--- a/crypto/openssl/ssl/statem/statem_dtls.c
+++ b/crypto/openssl/ssl/statem/statem_dtls.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2005-2025 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2005-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy
@@ -19,23 +19,34 @@
 
 #define RSMBLY_BITMASK_SIZE(msg_len) (((msg_len) + 7) / 8)
 
-#define RSMBLY_BITMASK_MARK(bitmask, start, end) { \
-                        if ((end) - (start) <= 8) { \
-                                long ii; \
-                                for (ii = (start); ii < (end); ii++) bitmask[((ii) >> 3)] |= (1 << ((ii) & 7)); \
-                        } else { \
-                                long ii; \
-                                bitmask[((start) >> 3)] |= bitmask_start_values[((start) & 7)]; \
-                                for (ii = (((start) >> 3) + 1); ii < ((((end) - 1)) >> 3); ii++) bitmask[ii] = 0xff; \
-                                bitmask[(((end) - 1) >> 3)] |= bitmask_end_values[((end) & 7)]; \
-                        } }
+#define RSMBLY_BITMASK_MARK(bitmask, start, end)                             \
+    {                                                                        \
+        if ((end) - (start) <= 8) {                                          \
+            long ii;                                                         \
+            for (ii = (start); ii < (end); ii++)                             \
+                bitmask[((ii) >> 3)] |= (1 << ((ii) & 7));                   \
+        } else {                                                             \
+            long ii;                                                         \
+            bitmask[((start) >> 3)] |= bitmask_start_values[((start) & 7)];  \
+            for (ii = (((start) >> 3) + 1); ii < ((((end) - 1)) >> 3); ii++) \
+                bitmask[ii] = 0xff;                                          \
+            bitmask[(((end) - 1) >> 3)] |= bitmask_end_values[((end) & 7)];  \
+        }                                                                    \
+    }
 
-#define RSMBLY_BITMASK_IS_COMPLETE(bitmask, msg_len, is_complete) { \
-                        long ii; \
-                        is_complete = 1; \
-                        if (bitmask[(((msg_len) - 1) >> 3)] != bitmask_end_values[((msg_len) & 7)]) is_complete = 0; \
-                        if (is_complete) for (ii = (((msg_len) - 1) >> 3) - 1; ii >= 0 ; ii--) \
-                                if (bitmask[ii] != 0xff) { is_complete = 0; break; } }
+#define RSMBLY_BITMASK_IS_COMPLETE(bitmask, msg_len, is_complete)                   \
+    {                                                                               \
+        long ii;                                                                    \
+        is_complete = 1;                                                            \
+        if (bitmask[(((msg_len) - 1) >> 3)] != bitmask_end_values[((msg_len) & 7)]) \
+            is_complete = 0;                                                        \
+        if (is_complete)                                                            \
+            for (ii = (((msg_len) - 1) >> 3) - 1; ii >= 0; ii--)                    \
+                if (bitmask[ii] != 0xff) {                                          \
+                    is_complete = 0;                                                \
+                    break;                                                          \
+                }                                                                   \
+    }
 
 static const unsigned char bitmask_start_values[] = {
     0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80
@@ -45,16 +56,16 @@ static const unsigned char bitmask_end_values[] = {
 };
 
 static void dtls1_fix_message_header(SSL_CONNECTION *s, size_t frag_off,
-                                     size_t frag_len);
+    size_t frag_len);
 static unsigned char *dtls1_write_message_header(SSL_CONNECTION *s,
-                                                 unsigned char *p);
+    unsigned char *p);
 static void dtls1_set_message_header_int(SSL_CONNECTION *s, unsigned char mt,
-                                         size_t len,
-                                         unsigned short seq_num,
-                                         size_t frag_off,
-                                         size_t frag_len);
+    size_t len,
+    unsigned short seq_num,
+    size_t frag_off,
+    size_t frag_len);
 static int dtls_get_reassembled_message(SSL_CONNECTION *s, int *errtype,
-                                        size_t *len);
+    size_t *len);
 
 static hm_fragment *dtls1_hm_fragment_new(size_t frag_len, int reassembly)
 {
@@ -123,8 +134,7 @@ int dtls1_do_write(SSL_CONNECTION *s, uint8_t type)
         return -1;
 
     if (s->init_off == 0 && type == SSL3_RT_HANDSHAKE) {
-        if (!ossl_assert(s->init_num ==
-                         s->d1->w_msg_hdr.msg_len + DTLS1_HM_HEADER_LENGTH))
+        if (!ossl_assert(s->init_num == s->d1->w_msg_hdr.msg_len + DTLS1_HM_HEADER_LENGTH))
             return -1;
     }
 
@@ -223,19 +233,18 @@ int dtls1_do_write(SSL_CONNECTION *s, uint8_t type)
              */
             if (s->msg_callback && s->init_off != 0)
                 memcpy(saved_payload, &s->init_buf->data[s->init_off],
-                       sizeof(saved_payload));
+                    sizeof(saved_payload));
 
             dtls1_write_message_header(s,
-                                       (unsigned char *)&s->init_buf->
-                                       data[s->init_off]);
+                (unsigned char *)&s->init_buf->data[s->init_off]);
         }
 
         ret = dtls1_write_bytes(s, type, &s->init_buf->data[s->init_off], len,
-                                &written);
+            &written);
 
         if (type == SSL3_RT_HANDSHAKE && s->msg_callback && s->init_off != 0)
             memcpy(&s->init_buf->data[s->init_off], saved_payload,
-                   sizeof(saved_payload));
+                sizeof(saved_payload));
 
         if (ret <= 0) {
             /*
@@ -244,8 +253,7 @@ int dtls1_do_write(SSL_CONNECTION *s, uint8_t type)
              * retransmit anything.  continue as if everything is fine and
              * wait for an alert to handle the retransmit
              */
-            if (retry && BIO_ctrl(SSL_get_wbio(ssl),
-                                  BIO_CTRL_DGRAM_MTU_EXCEEDED, 0, NULL) > 0) {
+            if (retry && BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_MTU_EXCEEDED, 0, NULL) > 0) {
                 if (!(SSL_get_options(ssl) & SSL_OP_NO_QUERY_MTU)) {
                     if (!dtls1_query_mtu(s))
                         return -1;
@@ -273,15 +281,14 @@ int dtls1_do_write(SSL_CONNECTION *s, uint8_t type)
              * then the best thing to do is probably carry on regardless.
              */
             assert(s->s3.tmp.new_compression != NULL
-                   || BIO_wpending(s->wbio) <= (int)s->d1->mtu);
+                || BIO_wpending(s->wbio) <= (int)s->d1->mtu);
 
             if (type == SSL3_RT_HANDSHAKE && !s->d1->retransmitting) {
                 /*
                  * should not be done for 'Hello Request's, but in that case
                  * we'll ignore the result anyway
                  */
-                unsigned char *p =
-                    (unsigned char *)&s->init_buf->data[s->init_off];
+                unsigned char *p = (unsigned char *)&s->init_buf->data[s->init_off];
                 const struct hm_header_st *msg_hdr = &s->d1->w_msg_hdr;
                 size_t xlen;
 
@@ -309,8 +316,8 @@ int dtls1_do_write(SSL_CONNECTION *s, uint8_t type)
             if (written == s->init_num) {
                 if (s->msg_callback)
                     s->msg_callback(1, s->version, type, s->init_buf->data,
-                                    s->init_off + s->init_num, ussl,
-                                    s->msg_callback_arg);
+                        s->init_off + s->init_num, ussl,
+                        s->msg_callback_arg);
 
                 s->init_off = 0; /* done writing this message */
                 s->init_num = 0;
@@ -345,10 +352,10 @@ int dtls_get_message(SSL_CONNECTION *s, int *mt)
     msg_hdr = &s->d1->r_msg_hdr;
     memset(msg_hdr, 0, sizeof(*msg_hdr));
 
- again:
+again:
     if (!dtls_get_reassembled_message(s, &errtype, &tmplen)) {
         if (errtype == DTLS1_HM_BAD_FRAGMENT
-                || errtype == DTLS1_HM_FRAGMENT_RETRY) {
+            || errtype == DTLS1_HM_FRAGMENT_RETRY) {
             /* bad fragment received */
             goto again;
         }
@@ -362,8 +369,8 @@ int dtls_get_message(SSL_CONNECTION *s, int *mt)
     if (*mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
         if (s->msg_callback) {
             s->msg_callback(0, s->version, SSL3_RT_CHANGE_CIPHER_SPEC,
-                            p, 1, SSL_CONNECTION_GET_USER_SSL(s),
-                            s->msg_callback_arg);
+                p, 1, SSL_CONNECTION_GET_USER_SSL(s),
+                s->msg_callback_arg);
         }
         /*
          * This isn't a real handshake message so skip the processing below.
@@ -422,10 +429,10 @@ int dtls_get_message_body(SSL_CONNECTION *s, size_t *len)
 
     if (s->msg_callback)
         s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE,
-                        s->init_buf->data, s->init_num + DTLS1_HM_HEADER_LENGTH,
-                        SSL_CONNECTION_GET_USER_SSL(s), s->msg_callback_arg);
+            s->init_buf->data, s->init_num + DTLS1_HM_HEADER_LENGTH,
+            SSL_CONNECTION_GET_USER_SSL(s), s->msg_callback_arg);
 
- end:
+end:
     *len = s->init_num;
     return 1;
 }
@@ -444,7 +451,7 @@ static size_t dtls1_max_handshake_message_len(const SSL_CONNECTION *s)
 }
 
 static int dtls1_preprocess_fragment(SSL_CONNECTION *s,
-                                     struct hm_header_st *msg_hdr)
+    struct hm_header_st *msg_hdr)
 {
     size_t frag_off, frag_len, msg_len;
 
@@ -454,7 +461,7 @@ static int dtls1_preprocess_fragment(SSL_CONNECTION *s,
 
     /* sanity checking */
     if ((frag_off + frag_len) > msg_len
-            || msg_len > dtls1_max_handshake_message_len(s)) {
+        || msg_len > dtls1_max_handshake_message_len(s)) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_EXCESSIVE_MESSAGE_SIZE);
         return 0;
     }
@@ -517,9 +524,9 @@ static int dtls1_retrieve_buffered_fragment(SSL_CONNECTION *s, size_t *len)
             hm_fragment *nextfrag;
 
             if (!s->server
-                    || frag->msg_header.seq != 0
-                    || s->d1->handshake_read_seq != 1
-                    || s->statem.hand_state != DTLS_ST_SW_HELLO_VERIFY_REQUEST) {
+                || frag->msg_header.seq != 0
+                || s->d1->handshake_read_seq != 1
+                || s->statem.hand_state != DTLS_ST_SW_HELLO_VERIFY_REQUEST) {
                 /*
                  * This is a stale message that has been buffered so clear it.
                  * It is safe to pop this message from the queue even though
@@ -542,9 +549,9 @@ static int dtls1_retrieve_buffered_fragment(SSL_CONNECTION *s, size_t *len)
                     nextfrag = (hm_fragment *)next->data;
                     if (nextfrag->msg_header.seq == s->d1->handshake_read_seq) {
                         /*
-                        * We have fragments for both a ClientHello without
-                        * cookie and one with. Ditch the one without.
-                        */
+                         * We have fragments for both a ClientHello without
+                         * cookie and one with. Ditch the one without.
+                         */
                         pqueue_pop(s->d1->buffered_messages);
                         dtls1_hm_fragment_free(frag);
                         pitem_free(item);
@@ -572,10 +579,9 @@ static int dtls1_retrieve_buffered_fragment(SSL_CONNECTION *s, size_t *len)
         ret = dtls1_preprocess_fragment(s, &frag->msg_header);
 
         if (ret && frag->msg_header.frag_len > 0) {
-            unsigned char *p =
-                (unsigned char *)s->init_buf->data + DTLS1_HM_HEADER_LENGTH;
+            unsigned char *p = (unsigned char *)s->init_buf->data + DTLS1_HM_HEADER_LENGTH;
             memcpy(&p[frag->msg_header.frag_off], frag->fragment,
-                   frag->msg_header.frag_len);
+                frag->msg_header.frag_len);
         }
 
         dtls1_hm_fragment_free(frag);
@@ -605,7 +611,7 @@ static int dtls1_retrieve_buffered_fragment(SSL_CONNECTION *s, size_t *len)
 }
 
 static int dtls1_reassemble_fragment(SSL_CONNECTION *s,
-                                     const struct hm_header_st *msg_hdr)
+    const struct hm_header_st *msg_hdr)
 {
     hm_fragment *frag = NULL;
     pitem *item = NULL;
@@ -615,8 +621,7 @@ static int dtls1_reassemble_fragment(SSL_CONNECTION *s,
     size_t readbytes;
     SSL *ssl = SSL_CONNECTION_GET_SSL(s);
 
-    if ((msg_hdr->frag_off + frag_len) > msg_hdr->msg_len ||
-        msg_hdr->msg_len > dtls1_max_handshake_message_len(s))
+    if ((msg_hdr->frag_off + frag_len) > msg_hdr->msg_len || msg_hdr->msg_len > dtls1_max_handshake_message_len(s))
         goto err;
 
     if (frag_len == 0) {
@@ -655,10 +660,8 @@ static int dtls1_reassemble_fragment(SSL_CONNECTION *s,
 
         while (frag_len) {
             i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL,
-                                            devnull,
-                                            frag_len >
-                                            sizeof(devnull) ? sizeof(devnull) :
-                                            frag_len, 0, &readbytes);
+                devnull,
+                frag_len > sizeof(devnull) ? sizeof(devnull) : frag_len, 0, &readbytes);
             if (i <= 0)
                 goto err;
             frag_len -= readbytes;
@@ -668,20 +671,20 @@ static int dtls1_reassemble_fragment(SSL_CONNECTION *s,
 
     /* read the body of the fragment (header has already been read */
     i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL,
-                                    frag->fragment + msg_hdr->frag_off,
-                                    frag_len, 0, &readbytes);
+        frag->fragment + msg_hdr->frag_off,
+        frag_len, 0, &readbytes);
     if (i <= 0 || readbytes != frag_len)
         i = -1;
     if (i <= 0)
         goto err;
 
     RSMBLY_BITMASK_MARK(frag->reassembly, (long)msg_hdr->frag_off,
-                        (long)(msg_hdr->frag_off + frag_len));
+        (long)(msg_hdr->frag_off + frag_len));
 
     if (!ossl_assert(msg_hdr->msg_len > 0))
         goto err;
     RSMBLY_BITMASK_IS_COMPLETE(frag->reassembly, (long)msg_hdr->msg_len,
-                               is_complete);
+        is_complete);
 
     if (is_complete) {
         OPENSSL_free(frag->reassembly);
@@ -708,14 +711,14 @@ static int dtls1_reassemble_fragment(SSL_CONNECTION *s,
 
     return DTLS1_HM_FRAGMENT_RETRY;
 
- err:
+err:
     if (item == NULL)
         dtls1_hm_fragment_free(frag);
     return -1;
 }
 
 static int dtls1_process_out_of_seq_message(SSL_CONNECTION *s,
-                                            const struct hm_header_st *msg_hdr)
+    const struct hm_header_st *msg_hdr)
 {
     int i = -1;
     hm_fragment *frag = NULL;
@@ -746,17 +749,13 @@ static int dtls1_process_out_of_seq_message(SSL_CONNECTION *s,
      * in the future, already in the queue or if we received a FINISHED
      * before the SERVER_HELLO, which then must be a stale retransmit.
      */
-    if (msg_hdr->seq <= s->d1->handshake_read_seq ||
-        msg_hdr->seq > s->d1->handshake_read_seq + 10 || item != NULL ||
-        (s->d1->handshake_read_seq == 0 && msg_hdr->type == SSL3_MT_FINISHED)) {
+    if (msg_hdr->seq <= s->d1->handshake_read_seq || msg_hdr->seq > s->d1->handshake_read_seq + 10 || item != NULL || (s->d1->handshake_read_seq == 0 && msg_hdr->type == SSL3_MT_FINISHED)) {
         unsigned char devnull[256];
 
         while (frag_len) {
             i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL,
-                                            devnull,
-                                            frag_len >
-                                            sizeof(devnull) ? sizeof(devnull) :
-                                            frag_len, 0, &readbytes);
+                devnull,
+                frag_len > sizeof(devnull) ? sizeof(devnull) : frag_len, 0, &readbytes);
             if (i <= 0)
                 goto err;
             frag_len -= readbytes;
@@ -780,9 +779,9 @@ static int dtls1_process_out_of_seq_message(SSL_CONNECTION *s,
              * read the body of the fragment (header has already been read
              */
             i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL,
-                                            frag->fragment, frag_len, 0,
-                                            &readbytes);
-            if (i<=0 || readbytes != frag_len)
+                frag->fragment, frag_len, 0,
+                &readbytes);
+            if (i <= 0 || readbytes != frag_len)
                 i = -1;
             if (i <= 0)
                 goto err;
@@ -807,14 +806,14 @@ static int dtls1_process_out_of_seq_message(SSL_CONNECTION *s,
 
     return DTLS1_HM_FRAGMENT_RETRY;
 
- err:
+err:
     if (item == NULL)
         dtls1_hm_fragment_free(frag);
     return 0;
 }
 
 static int dtls_get_reassembled_message(SSL_CONNECTION *s, int *errtype,
-                                        size_t *len)
+    size_t *len)
 {
     size_t mlen, frag_off, frag_len;
     int i, ret;
@@ -830,7 +829,7 @@ static int dtls_get_reassembled_message(SSL_CONNECTION *s, int *errtype,
 
     p = (unsigned char *)s->init_buf->data;
 
- redo:
+redo:
     /* see if we have the required fragment already */
     ret = dtls1_retrieve_buffered_fragment(s, &frag_len);
     if (ret < 0) {
@@ -845,8 +844,8 @@ static int dtls_get_reassembled_message(SSL_CONNECTION *s, int *errtype,
 
     /* read handshake message header */
     i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, &recvd_type, p,
-                                    DTLS1_HM_HEADER_LENGTH, 0, &readbytes);
-    if (i <= 0) {               /* nbio, or an error */
+        DTLS1_HM_HEADER_LENGTH, 0, &readbytes);
+    if (i <= 0) { /* nbio, or an error */
         s->rwstate = SSL_READING;
         *len = 0;
         return 0;
@@ -854,7 +853,7 @@ static int dtls_get_reassembled_message(SSL_CONNECTION *s, int *errtype,
     if (recvd_type == SSL3_RT_CHANGE_CIPHER_SPEC) {
         if (p[0] != SSL3_MT_CCS) {
             SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
-                     SSL_R_BAD_CHANGE_CIPHER_SPEC);
+                SSL_R_BAD_CHANGE_CIPHER_SPEC);
             goto f_err;
         }
 
@@ -896,10 +895,10 @@ static int dtls_get_reassembled_message(SSL_CONNECTION *s, int *errtype,
      */
     if (msg_hdr.seq != s->d1->handshake_read_seq) {
         if (!s->server
-                || msg_hdr.seq != 0
-                || s->d1->handshake_read_seq != 1
-                || p[0] != SSL3_MT_CLIENT_HELLO
-                || s->statem.hand_state != DTLS_ST_SW_HELLO_VERIFY_REQUEST) {
+            || msg_hdr.seq != 0
+            || s->d1->handshake_read_seq != 1
+            || p[0] != SSL3_MT_CLIENT_HELLO
+            || s->statem.hand_state != DTLS_ST_SW_HELLO_VERIFY_REQUEST) {
             *errtype = dtls1_process_out_of_seq_message(s, &msg_hdr);
             return 0;
         }
@@ -917,9 +916,9 @@ static int dtls_get_reassembled_message(SSL_CONNECTION *s, int *errtype,
     }
 
     if (!s->server
-            && s->d1->r_msg_hdr.frag_off == 0
-            && s->statem.hand_state != TLS_ST_OK
-            && p[0] == SSL3_MT_HELLO_REQUEST) {
+        && s->d1->r_msg_hdr.frag_off == 0
+        && s->statem.hand_state != TLS_ST_OK
+        && p[0] == SSL3_MT_HELLO_REQUEST) {
         /*
          * The server may always send 'Hello Request' messages -- we are
          * doing a handshake anyway now, so ignore them if their format is
@@ -928,12 +927,12 @@ static int dtls_get_reassembled_message(SSL_CONNECTION *s, int *errtype,
         if (p[1] == 0 && p[2] == 0 && p[3] == 0) {
             if (s->msg_callback)
                 s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE,
-                                p, DTLS1_HM_HEADER_LENGTH, ussl,
-                                s->msg_callback_arg);
+                    p, DTLS1_HM_HEADER_LENGTH, ussl,
+                    s->msg_callback_arg);
 
             s->init_num = 0;
             goto redo;
-        } else {                /* Incorrectly formatted Hello request */
+        } else { /* Incorrectly formatted Hello request */
 
             SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE);
             goto f_err;
@@ -946,10 +945,11 @@ static int dtls_get_reassembled_message(SSL_CONNECTION *s, int *errtype,
     }
 
     if (frag_len > 0) {
-        p += DTLS1_HM_HEADER_LENGTH;
+        /* dtls1_preprocess_fragment() above could reallocate init_buf */
+        p = (unsigned char *)s->init_buf->data + DTLS1_HM_HEADER_LENGTH;
 
         i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL,
-                                        &p[frag_off], frag_len, 0, &readbytes);
+            &p[frag_off], frag_len, 0, &readbytes);
 
         /*
          * This shouldn't ever fail due to NBIO because we already checked
@@ -993,7 +993,7 @@ static int dtls_get_reassembled_message(SSL_CONNECTION *s, int *errtype,
     *len = s->init_num = frag_len;
     return 1;
 
- f_err:
+f_err:
     s->init_num = 0;
     *len = 0;
     return 0;
@@ -1006,7 +1006,7 @@ static int dtls_get_reassembled_message(SSL_CONNECTION *s, int *errtype,
  * ssl->session->read_hash              assign
  */
 CON_FUNC_RETURN dtls_construct_change_cipher_spec(SSL_CONNECTION *s,
-                                                  WPACKET *pkt)
+    WPACKET *pkt)
 {
     if (s->version == DTLS1_BAD_VER) {
         s->d1->next_handshake_write_seq++;
@@ -1113,10 +1113,7 @@ int dtls1_retransmit_buffered_messages(SSL_CONNECTION *s)
 
     for (item = pqueue_next(&iter); item != NULL; item = pqueue_next(&iter)) {
         frag = (hm_fragment *)item->data;
-        if (dtls1_retransmit_message(s, (unsigned short)
-                                     dtls1_get_queue_priority
-                                     (frag->msg_header.seq,
-                                      frag->msg_header.is_ccs), &found) <= 0)
+        if (dtls1_retransmit_message(s, (unsigned short)dtls1_get_queue_priority(frag->msg_header.seq, frag->msg_header.is_ccs), &found) <= 0)
             return -1;
     }
 
@@ -1144,16 +1141,13 @@ int dtls1_buffer_message(SSL_CONNECTION *s, int is_ccs)
 
     if (is_ccs) {
         /* For DTLS1_BAD_VER the header length is non-standard */
-        if (!ossl_assert(s->d1->w_msg_hdr.msg_len +
-                         ((s->version ==
-                           DTLS1_BAD_VER) ? 3 : DTLS1_CCS_HEADER_LENGTH)
-                         == (unsigned int)s->init_num)) {
+        if (!ossl_assert(s->d1->w_msg_hdr.msg_len + ((s->version == DTLS1_BAD_VER) ? 3 : DTLS1_CCS_HEADER_LENGTH)
+                == (unsigned int)s->init_num)) {
             dtls1_hm_fragment_free(frag);
             return 0;
         }
     } else {
-        if (!ossl_assert(s->d1->w_msg_hdr.msg_len +
-                         DTLS1_HM_HEADER_LENGTH == (unsigned int)s->init_num)) {
+        if (!ossl_assert(s->d1->w_msg_hdr.msg_len + DTLS1_HM_HEADER_LENGTH == (unsigned int)s->init_num)) {
             dtls1_hm_fragment_free(frag);
             return 0;
         }
@@ -1170,16 +1164,12 @@ int dtls1_buffer_message(SSL_CONNECTION *s, int is_ccs)
     frag->msg_header.saved_retransmit_state.wrlmethod = s->rlayer.wrlmethod;
     frag->msg_header.saved_retransmit_state.wrl = s->rlayer.wrl;
 
-
     memset(seq64be, 0, sizeof(seq64be));
-    seq64be[6] =
-        (unsigned
-         char)(dtls1_get_queue_priority(frag->msg_header.seq,
-                                        frag->msg_header.is_ccs) >> 8);
-    seq64be[7] =
-        (unsigned
-         char)(dtls1_get_queue_priority(frag->msg_header.seq,
-                                        frag->msg_header.is_ccs));
+    seq64be[6] = (unsigned char)(dtls1_get_queue_priority(frag->msg_header.seq,
+                                     frag->msg_header.is_ccs)
+        >> 8);
+    seq64be[7] = (unsigned char)(dtls1_get_queue_priority(frag->msg_header.seq,
+        frag->msg_header.is_ccs));
 
     item = pitem_new(seq64be, frag);
     if (item == NULL) {
@@ -1187,7 +1177,11 @@ int dtls1_buffer_message(SSL_CONNECTION *s, int is_ccs)
         return 0;
     }
 
-    pqueue_insert(s->d1->sent_messages, item);
+    if (pqueue_insert(s->d1->sent_messages, item) == NULL) {
+        dtls1_hm_fragment_free(frag);
+        pitem_free(item);
+        return 0;
+    }
     return 1;
 }
 
@@ -1222,13 +1216,13 @@ int dtls1_retransmit_message(SSL_CONNECTION *s, unsigned short seq, int *found)
         header_length = DTLS1_HM_HEADER_LENGTH;
 
     memcpy(s->init_buf->data, frag->fragment,
-           frag->msg_header.msg_len + header_length);
+        frag->msg_header.msg_len + header_length);
     s->init_num = frag->msg_header.msg_len + header_length;
 
     dtls1_set_message_header_int(s, frag->msg_header.type,
-                                 frag->msg_header.msg_len,
-                                 frag->msg_header.seq, 0,
-                                 frag->msg_header.frag_len);
+        frag->msg_header.msg_len,
+        frag->msg_header.seq, 0,
+        frag->msg_header.frag_len);
 
     /* save current state */
     saved_state.wrlmethod = s->rlayer.wrlmethod;
@@ -1246,8 +1240,7 @@ int dtls1_retransmit_message(SSL_CONNECTION *s, unsigned short seq, int *found)
      */
     s->rlayer.wrlmethod->set1_bio(s->rlayer.wrl, s->wbio);
 
-    ret = dtls1_do_write(s, frag->msg_header.is_ccs ?
-                         SSL3_RT_CHANGE_CIPHER_SPEC : SSL3_RT_HANDSHAKE);
+    ret = dtls1_do_write(s, frag->msg_header.is_ccs ? SSL3_RT_CHANGE_CIPHER_SPEC : SSL3_RT_HANDSHAKE);
 
     /* restore current state */
     s->rlayer.wrlmethod = saved_state.wrlmethod;
@@ -1260,8 +1253,8 @@ int dtls1_retransmit_message(SSL_CONNECTION *s, unsigned short seq, int *found)
 }
 
 void dtls1_set_message_header(SSL_CONNECTION *s,
-                              unsigned char mt, size_t len,
-                              size_t frag_off, size_t frag_len)
+    unsigned char mt, size_t len,
+    size_t frag_off, size_t frag_len)
 {
     if (frag_off == 0) {
         s->d1->handshake_write_seq = s->d1->next_handshake_write_seq;
@@ -1269,14 +1262,14 @@ void dtls1_set_message_header(SSL_CONNECTION *s,
     }
 
     dtls1_set_message_header_int(s, mt, len, s->d1->handshake_write_seq,
-                                 frag_off, frag_len);
+        frag_off, frag_len);
 }
 
 /* don't actually do the writing, wait till the MTU has been retrieved */
 static void
 dtls1_set_message_header_int(SSL_CONNECTION *s, unsigned char mt,
-                             size_t len, unsigned short seq_num,
-                             size_t frag_off, size_t frag_len)
+    size_t len, unsigned short seq_num,
+    size_t frag_off, size_t frag_len)
 {
     struct hm_header_st *msg_hdr = &s->d1->w_msg_hdr;
 
@@ -1297,7 +1290,7 @@ dtls1_fix_message_header(SSL_CONNECTION *s, size_t frag_off, size_t frag_len)
 }
 
 static unsigned char *dtls1_write_message_header(SSL_CONNECTION *s,
-                                                 unsigned char *p)
+    unsigned char *p)
 {
     struct hm_header_st *msg_hdr = &s->d1->w_msg_hdr;
 
@@ -1311,8 +1304,7 @@ static unsigned char *dtls1_write_message_header(SSL_CONNECTION *s,
     return p;
 }
 
-void dtls1_get_message_header(const unsigned char *data, struct
-                              hm_header_st *msg_hdr)
+void dtls1_get_message_header(const unsigned char *data, struct hm_header_st *msg_hdr)
 {
     memset(msg_hdr, 0, sizeof(*msg_hdr));
     msg_hdr->type = *(data++);
@@ -1330,7 +1322,7 @@ int dtls1_set_handshake_header(SSL_CONNECTION *s, WPACKET *pkt, int htype)
     if (htype == SSL3_MT_CHANGE_CIPHER_SPEC) {
         s->d1->handshake_write_seq = s->d1->next_handshake_write_seq;
         dtls1_set_message_header_int(s, SSL3_MT_CCS, 0,
-                                     s->d1->handshake_write_seq, 0, 0);
+            s->d1->handshake_write_seq, 0, 0);
         if (!WPACKET_put_bytes_u8(pkt, SSL3_MT_CCS))
             return 0;
     } else {
@@ -1340,7 +1332,7 @@ int dtls1_set_handshake_header(SSL_CONNECTION *s, WPACKET *pkt, int htype)
          * filled in later
          */
         if (!WPACKET_allocate_bytes(pkt, DTLS1_HM_HEADER_LENGTH, &header)
-                || !WPACKET_start_sub_packet(pkt))
+            || !WPACKET_start_sub_packet(pkt))
             return 0;
     }
 
@@ -1352,8 +1344,8 @@ int dtls1_close_construct_packet(SSL_CONNECTION *s, WPACKET *pkt, int htype)
     size_t msglen;
 
     if ((htype != SSL3_MT_CHANGE_CIPHER_SPEC && !WPACKET_close(pkt))
-            || !WPACKET_get_length(pkt, &msglen)
-            || msglen > INT_MAX)
+        || !WPACKET_get_length(pkt, &msglen)
+        || msglen > INT_MAX)
         return 0;
 
     if (htype != SSL3_MT_CHANGE_CIPHER_SPEC) {
@@ -1365,8 +1357,7 @@ int dtls1_close_construct_packet(SSL_CONNECTION *s, WPACKET *pkt, int htype)
 
     if (htype != DTLS1_MT_HELLO_VERIFY_REQUEST) {
         /* Buffer the message to handle re-xmits */
-        if (!dtls1_buffer_message(s, htype == SSL3_MT_CHANGE_CIPHER_SPEC
-                                     ? 1 : 0))
+        if (!dtls1_buffer_message(s, htype == SSL3_MT_CHANGE_CIPHER_SPEC ? 1 : 0))
             return 0;
     }
 
diff --git a/crypto/openssl/ssl/statem/statem_lib.c b/crypto/openssl/ssl/statem/statem_lib.c
index 13f1af7e9fd0..aa9d196780eb 100644
--- a/crypto/openssl/ssl/statem/statem_lib.c
+++ b/crypto/openssl/ssl/statem/statem_lib.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 1995-2025 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
  * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
@@ -39,9 +39,9 @@ const unsigned char hrrrandom[] = {
 };
 
 int ossl_statem_set_mutator(SSL *s,
-                            ossl_statem_mutate_handshake_cb mutate_handshake_cb,
-                            ossl_statem_finish_mutate_handshake_cb finish_mutate_handshake_cb,
-                            void *mutatearg)
+    ossl_statem_mutate_handshake_cb mutate_handshake_cb,
+    ossl_statem_finish_mutate_handshake_cb finish_mutate_handshake_cb,
+    void *mutatearg)
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 
@@ -71,19 +71,19 @@ int ssl3_do_write(SSL_CONNECTION *s, uint8_t type)
      * we've been asked to write. Does not happen in normal operation.
      */
     if (s->statem.mutate_handshake_cb != NULL
-            && !s->statem.write_in_progress
-            && type == SSL3_RT_HANDSHAKE
-            && s->init_num >= SSL3_HM_HEADER_LENGTH) {
+        && !s->statem.write_in_progress
+        && type == SSL3_RT_HANDSHAKE
+        && s->init_num >= SSL3_HM_HEADER_LENGTH) {
         unsigned char *msg;
         size_t msglen;
 
         if (!s->statem.mutate_handshake_cb((unsigned char *)s->init_buf->data,
-                                           s->init_num,
-                                           &msg, &msglen,
-                                           s->statem.mutatearg))
+                s->init_num,
+                &msg, &msglen,
+                s->statem.mutatearg))
             return -1;
         if (msglen < SSL3_HM_HEADER_LENGTH
-                || !BUF_MEM_grow(s->init_buf, msglen))
+            || !BUF_MEM_grow(s->init_buf, msglen))
             return -1;
         memcpy(s->init_buf->data, msg, msglen);
         s->init_num = msglen;
@@ -93,7 +93,7 @@ int ssl3_do_write(SSL_CONNECTION *s, uint8_t type)
     }
 
     ret = ssl3_write_bytes(ssl, type, &s->init_buf->data[s->init_off],
-                           s->init_num, &written);
+        s->init_num, &written);
     if (ret <= 0)
         return -1;
     if (type == SSL3_RT_HANDSHAKE)
@@ -104,18 +104,18 @@ int ssl3_do_write(SSL_CONNECTION *s, uint8_t type)
          */
         if (!SSL_CONNECTION_IS_TLS13(s)
             || (s->statem.hand_state != TLS_ST_SW_SESSION_TICKET
-                                 && s->statem.hand_state != TLS_ST_CW_KEY_UPDATE
-                                 && s->statem.hand_state != TLS_ST_SW_KEY_UPDATE))
+                && s->statem.hand_state != TLS_ST_CW_KEY_UPDATE
+                && s->statem.hand_state != TLS_ST_SW_KEY_UPDATE))
             if (!ssl3_finish_mac(s,
-                                 (unsigned char *)&s->init_buf->data[s->init_off],
-                                 written))
+                    (unsigned char *)&s->init_buf->data[s->init_off],
+                    written))
                 return -1;
     if (written == s->init_num) {
         s->statem.write_in_progress = 0;
         if (s->msg_callback)
             s->msg_callback(1, s->version, type, s->init_buf->data,
-                            (size_t)(s->init_off + s->init_num), ussl,
-                            s->msg_callback_arg);
+                (size_t)(s->init_off + s->init_num), ussl,
+                s->msg_callback_arg);
         return 1;
     }
     s->init_off += written;
@@ -128,8 +128,8 @@ int tls_close_construct_packet(SSL_CONNECTION *s, WPACKET *pkt, int htype)
     size_t msglen;
 
     if ((htype != SSL3_MT_CHANGE_CIPHER_SPEC && !WPACKET_close(pkt))
-            || !WPACKET_get_length(pkt, &msglen)
-            || msglen > INT_MAX)
+        || !WPACKET_get_length(pkt, &msglen)
+        || msglen > INT_MAX)
         return 0;
     s->init_num = (int)msglen;
     s->init_off = 0;
@@ -160,26 +160,26 @@ int tls_setup_handshake(SSL_CONNECTION *s)
     if (sctx->ssl_digest_methods[SSL_MD_MD5_SHA1_IDX] == NULL) {
         int negotiated_minversion;
         int md5sha1_needed_maxversion = SSL_CONNECTION_IS_DTLS(s)
-                                        ? DTLS1_VERSION : TLS1_1_VERSION;
+            ? DTLS1_VERSION
+            : TLS1_1_VERSION;
 
         /* We don't have MD5-SHA1 - do we need it? */
         if (ssl_version_cmp(s, ver_max, md5sha1_needed_maxversion) <= 0) {
             SSLfatal_data(s, SSL_AD_HANDSHAKE_FAILURE,
-                          SSL_R_NO_SUITABLE_DIGEST_ALGORITHM,
-                          "The max supported SSL/TLS version needs the"
-                          " MD5-SHA1 digest but it is not available"
-                          " in the loaded providers. Use (D)TLSv1.2 or"
-                          " above, or load different providers");
+                SSL_R_NO_SUITABLE_DIGEST_ALGORITHM,
+                "The max supported SSL/TLS version needs the"
+                " MD5-SHA1 digest but it is not available"
+                " in the loaded providers. Use (D)TLSv1.2 or"
+                " above, or load different providers");
             return 0;
         }
 
         ok = 1;
 
         /* Don't allow TLSv1.1 or below to be negotiated */
-        negotiated_minversion = SSL_CONNECTION_IS_DTLS(s) ?
-                                DTLS1_2_VERSION : TLS1_2_VERSION;
+        negotiated_minversion = SSL_CONNECTION_IS_DTLS(s) ? DTLS1_2_VERSION : TLS1_2_VERSION;
         if (ssl_version_cmp(s, ver_min, negotiated_minversion) < 0)
-                ok = SSL_set_min_proto_version(ssl, negotiated_minversion);
+            ok = SSL_set_min_proto_version(ssl, negotiated_minversion);
         if (!ok) {
             /* Shouldn't happen */
             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, ERR_R_INTERNAL_ERROR);
@@ -200,21 +200,23 @@ int tls_setup_handshake(SSL_CONNECTION *s)
         for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
             const SSL_CIPHER *c = sk_SSL_CIPHER_value(ciphers, i);
             int cipher_minprotover = SSL_CONNECTION_IS_DTLS(s)
-                                     ? c->min_dtls : c->min_tls;
+                ? c->min_dtls
+                : c->min_tls;
             int cipher_maxprotover = SSL_CONNECTION_IS_DTLS(s)
-                                     ? c->max_dtls : c->max_tls;
+                ? c->max_dtls
+                : c->max_tls;
 
             if (ssl_version_cmp(s, ver_max, cipher_minprotover) >= 0
-                    && ssl_version_cmp(s, ver_max, cipher_maxprotover) <= 0) {
+                && ssl_version_cmp(s, ver_max, cipher_maxprotover) <= 0) {
                 ok = 1;
                 break;
             }
         }
         if (!ok) {
             SSLfatal_data(s, SSL_AD_HANDSHAKE_FAILURE,
-                          SSL_R_NO_CIPHERS_AVAILABLE,
-                          "No ciphers enabled for max supported "
-                          "SSL/TLS version");
+                SSL_R_NO_CIPHERS_AVAILABLE,
+                "No ciphers enabled for max supported "
+                "SSL/TLS version");
             return 0;
         }
         if (SSL_IS_FIRST_HANDSHAKE(s)) {
@@ -231,7 +233,7 @@ int tls_setup_handshake(SSL_CONNECTION *s)
             ssl_tsan_counter(s->session_ctx, &s->session_ctx->stats.sess_connect);
         else
             ssl_tsan_counter(s->session_ctx,
-                         &s->session_ctx->stats.sess_connect_renegotiate);
+                &s->session_ctx->stats.sess_connect_renegotiate);
 
         /* mark client_random uninitialized */
         memset(s->s3.client_random, 0, sizeof(s->s3.client_random));
@@ -250,18 +252,18 @@ int tls_setup_handshake(SSL_CONNECTION *s)
  * Size of the to-be-signed TLS13 data, without the hash size itself:
  * 64 bytes of value 32, 33 context bytes, 1 byte separator
  */
-#define TLS13_TBS_START_SIZE            64
-#define TLS13_TBS_PREAMBLE_SIZE         (TLS13_TBS_START_SIZE + 33 + 1)
+#define TLS13_TBS_START_SIZE 64
+#define TLS13_TBS_PREAMBLE_SIZE (TLS13_TBS_START_SIZE + 33 + 1)
 
 static int get_cert_verify_tbs_data(SSL_CONNECTION *s, unsigned char *tls13tbs,
-                                    void **hdata, size_t *hdatalen)
+    void **hdata, size_t *hdatalen)
 {
     /* ASCII: "TLS 1.3, server CertificateVerify", in hex for EBCDIC compatibility */
     static const char servercontext[] = "\x54\x4c\x53\x20\x31\x2e\x33\x2c\x20\x73\x65\x72"
-        "\x76\x65\x72\x20\x43\x65\x72\x74\x69\x66\x69\x63\x61\x74\x65\x56\x65\x72\x69\x66\x79";
+                                        "\x76\x65\x72\x20\x43\x65\x72\x74\x69\x66\x69\x63\x61\x74\x65\x56\x65\x72\x69\x66\x79";
     /* ASCII: "TLS 1.3, client CertificateVerify", in hex for EBCDIC compatibility */
     static const char clientcontext[] = "\x54\x4c\x53\x20\x31\x2e\x33\x2c\x20\x63\x6c\x69"
-        "\x65\x6e\x74\x20\x43\x65\x72\x74\x69\x66\x69\x63\x61\x74\x65\x56\x65\x72\x69\x66\x79";
+                                        "\x65\x6e\x74\x20\x43\x65\x72\x74\x69\x66\x69\x63\x61\x74\x65\x56\x65\x72\x69\x66\x79";
 
     if (SSL_CONNECTION_IS_TLS13(s)) {
         size_t hashlen;
@@ -270,7 +272,7 @@ static int get_cert_verify_tbs_data(SSL_CONNECTION *s, unsigned char *tls13tbs,
         memset(tls13tbs, 32, TLS13_TBS_START_SIZE);
         /* This copies the 33 bytes of context plus the 0 separator byte */
         if (s->statem.hand_state == TLS_ST_CR_CERT_VRFY
-                 || s->statem.hand_state == TLS_ST_SW_CERT_VRFY)
+            || s->statem.hand_state == TLS_ST_SW_CERT_VRFY)
             strcpy((char *)tls13tbs + TLS13_TBS_START_SIZE, servercontext);
         else
             strcpy((char *)tls13tbs + TLS13_TBS_START_SIZE, clientcontext);
@@ -281,12 +283,12 @@ static int get_cert_verify_tbs_data(SSL_CONNECTION *s, unsigned char *tls13tbs,
          * that includes the CertVerify itself.
          */
         if (s->statem.hand_state == TLS_ST_CR_CERT_VRFY
-                || s->statem.hand_state == TLS_ST_SR_CERT_VRFY) {
+            || s->statem.hand_state == TLS_ST_SR_CERT_VRFY) {
             memcpy(tls13tbs + TLS13_TBS_PREAMBLE_SIZE, s->cert_verify_hash,
-                   s->cert_verify_hash_len);
+                s->cert_verify_hash_len);
             hashlen = s->cert_verify_hash_len;
         } else if (!ssl_handshake_hash(s, tls13tbs + TLS13_TBS_PREAMBLE_SIZE,
-                                       EVP_MAX_MD_SIZE, &hashlen)) {
+                       EVP_MAX_MD_SIZE, &hashlen)) {
             /* SSLfatal() already called */
             return 0;
         }
@@ -350,9 +352,10 @@ CON_FUNC_RETURN tls_construct_cert_verify(SSL_CONNECTION *s, WPACKET *pkt)
     }
 
     if (EVP_DigestSignInit_ex(mctx, &pctx,
-                              md == NULL ? NULL : EVP_MD_get0_name(md),
-                              sctx->libctx, sctx->propq, pkey,
-                              NULL) <= 0) {
+            md == NULL ? NULL : EVP_MD_get0_name(md),
+            sctx->libctx, sctx->propq, pkey,
+            NULL)
+        <= 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
         goto err;
     }
@@ -360,7 +363,8 @@ CON_FUNC_RETURN tls_construct_cert_verify(SSL_CONNECTION *s, WPACKET *pkt)
     if (lu->sig == EVP_PKEY_RSA_PSS) {
         if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0
             || EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx,
-                                                RSA_PSS_SALTLEN_DIGEST) <= 0) {
+                   RSA_PSS_SALTLEN_DIGEST)
+                <= 0) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
             goto err;
         }
@@ -372,8 +376,9 @@ CON_FUNC_RETURN tls_construct_cert_verify(SSL_CONNECTION *s, WPACKET *pkt)
          */
         if (EVP_DigestSignUpdate(mctx, hdata, hdatalen) <= 0
             || EVP_MD_CTX_ctrl(mctx, EVP_CTRL_SSL3_MASTER_SECRET,
-                               (int)s->session->master_key_length,
-                               s->session->master_key) <= 0
+                   (int)s->session->master_key_length,
+                   s->session->master_key)
+                <= 0
             || EVP_DigestSignFinal(mctx, NULL, &siglen) <= 0) {
 
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
@@ -381,7 +386,7 @@ CON_FUNC_RETURN tls_construct_cert_verify(SSL_CONNECTION *s, WPACKET *pkt)
         }
         sig = OPENSSL_malloc(siglen);
         if (sig == NULL
-                || EVP_DigestSignFinal(mctx, sig, &siglen) <= 0) {
+            || EVP_DigestSignFinal(mctx, sig, &siglen) <= 0) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
             goto err;
         }
@@ -396,7 +401,7 @@ CON_FUNC_RETURN tls_construct_cert_verify(SSL_CONNECTION *s, WPACKET *pkt)
         }
         sig = OPENSSL_malloc(siglen);
         if (sig == NULL
-                || EVP_DigestSign(mctx, sig, &siglen, hdata, hdatalen) <= 0) {
+            || EVP_DigestSign(mctx, sig, &siglen, hdata, hdatalen) <= 0) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
             goto err;
         }
@@ -427,7 +432,7 @@ CON_FUNC_RETURN tls_construct_cert_verify(SSL_CONNECTION *s, WPACKET *pkt)
     OPENSSL_free(sig);
     EVP_MD_CTX_free(mctx);
     return CON_FUNC_SUCCESS;
- err:
+err:
     OPENSSL_free(sig);
     EVP_MD_CTX_free(mctx);
     return CON_FUNC_ERROR;
@@ -464,7 +469,7 @@ MSG_PROCESS_RETURN tls_process_cert_verify(SSL_CONNECTION *s, PACKET *pkt)
 
     if (ssl_cert_lookup_by_pkey(pkey, NULL, sctx) == NULL) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                 SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE);
+            SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE);
         goto err;
     }
 
@@ -480,9 +485,9 @@ MSG_PROCESS_RETURN tls_process_cert_verify(SSL_CONNECTION *s, PACKET *pkt)
             goto err;
         }
     } else if (!tls1_set_peer_legacy_sigalg(s, pkey)) {
-            SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                     SSL_R_LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED);
-            goto err;
+        SSLfatal(s, SSL_AD_INTERNAL_ERROR,
+            SSL_R_LEGACY_SIGALG_DISALLOWED_OR_UNSUPPORTED);
+        goto err;
     }
 
     if (!tls1_lookup_md(sctx, s->s3.tmp.peer_sigalg, &md)) {
@@ -492,7 +497,7 @@ MSG_PROCESS_RETURN tls_process_cert_verify(SSL_CONNECTION *s, PACKET *pkt)
 
     if (SSL_USE_SIGALGS(s))
         OSSL_TRACE1(TLS, "USING TLSv1.2 HASH %s\n",
-                    md == NULL ? "n/a" : EVP_MD_get0_name(md));
+            md == NULL ? "n/a" : EVP_MD_get0_name(md));
 
     /* Check for broken implementations of GOST ciphersuites */
     /*
@@ -502,14 +507,14 @@ MSG_PROCESS_RETURN tls_process_cert_verify(SSL_CONNECTION *s, PACKET *pkt)
 #ifndef OPENSSL_NO_GOST
     if (!SSL_USE_SIGALGS(s)
         && ((PACKET_remaining(pkt) == 64
-             && (EVP_PKEY_get_id(pkey) == NID_id_GostR3410_2001
-                 || EVP_PKEY_get_id(pkey) == NID_id_GostR3410_2012_256))
+                && (EVP_PKEY_get_id(pkey) == NID_id_GostR3410_2001
+                    || EVP_PKEY_get_id(pkey) == NID_id_GostR3410_2012_256))
             || (PACKET_remaining(pkt) == 128
                 && EVP_PKEY_get_id(pkey) == NID_id_GostR3410_2012_512))) {
         len = PACKET_remaining(pkt);
     } else
 #endif
-    if (!PACKET_get_net_2(pkt, &len)) {
+        if (!PACKET_get_net_2(pkt, &len)) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
         goto err;
     }
@@ -529,12 +534,13 @@ MSG_PROCESS_RETURN tls_process_cert_verify(SSL_CONNECTION *s, PACKET *pkt)
     }
 
     OSSL_TRACE1(TLS, "Using client verify alg %s\n",
-                md == NULL ? "n/a" : EVP_MD_get0_name(md));
+        md == NULL ? "n/a" : EVP_MD_get0_name(md));
 
     if (EVP_DigestVerifyInit_ex(mctx, &pctx,
-                                md == NULL ? NULL : EVP_MD_get0_name(md),
-                                sctx->libctx, sctx->propq, pkey,
-                                NULL) <= 0) {
+            md == NULL ? NULL : EVP_MD_get0_name(md),
+            sctx->libctx, sctx->propq, pkey,
+            NULL)
+        <= 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
         goto err;
     }
@@ -555,16 +561,18 @@ MSG_PROCESS_RETURN tls_process_cert_verify(SSL_CONNECTION *s, PACKET *pkt)
     if (SSL_USE_PSS(s)) {
         if (EVP_PKEY_CTX_set_rsa_padding(pctx, RSA_PKCS1_PSS_PADDING) <= 0
             || EVP_PKEY_CTX_set_rsa_pss_saltlen(pctx,
-                                                RSA_PSS_SALTLEN_DIGEST) <= 0) {
+                   RSA_PSS_SALTLEN_DIGEST)
+                <= 0) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
             goto err;
         }
     }
     if (s->version == SSL3_VERSION) {
         if (EVP_DigestVerifyUpdate(mctx, hdata, hdatalen) <= 0
-                || EVP_MD_CTX_ctrl(mctx, EVP_CTRL_SSL3_MASTER_SECRET,
-                                   (int)s->session->master_key_length,
-                                    s->session->master_key) <= 0) {
+            || EVP_MD_CTX_ctrl(mctx, EVP_CTRL_SSL3_MASTER_SECRET,
+                   (int)s->session->master_key_length,
+                   s->session->master_key)
+                <= 0) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
             goto err;
         }
@@ -597,7 +605,7 @@ MSG_PROCESS_RETURN tls_process_cert_verify(SSL_CONNECTION *s, PACKET *pkt)
         ret = MSG_PROCESS_CONTINUE_PROCESSING;
     else
         ret = MSG_PROCESS_CONTINUE_READING;
- err:
+err:
     BIO_free(s->s3.handshake_buffer);
     s->s3.handshake_buffer = NULL;
     EVP_MD_CTX_free(mctx);
@@ -625,13 +633,14 @@ CON_FUNC_RETURN tls_construct_finished(SSL_CONNECTION *s, WPACKET *pkt)
      * then we need to do it now.
      */
     if (SSL_CONNECTION_IS_TLS13(s)
-            && !s->server
-            && !SSL_IS_QUIC_HANDSHAKE(s)
-            && (s->early_data_state != SSL_EARLY_DATA_NONE
-                || (s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0)
-            && s->s3.tmp.cert_req == 0
-            && (!ssl->method->ssl3_enc->change_cipher_state(s,
-                    SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {;
+        && !s->server
+        && !SSL_IS_QUIC_HANDSHAKE(s)
+        && (s->early_data_state != SSL_EARLY_DATA_NONE
+            || (s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0)
+        && s->s3.tmp.cert_req == 0
+        && (!ssl->method->ssl3_enc->change_cipher_state(s,
+            SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_CLIENT_WRITE))) {
+        ;
         /* SSLfatal() already called */
         return CON_FUNC_ERROR;
     }
@@ -645,8 +654,8 @@ CON_FUNC_RETURN tls_construct_finished(SSL_CONNECTION *s, WPACKET *pkt)
     }
 
     finish_md_len = ssl->method->ssl3_enc->final_finish_mac(s,
-                                                            sender, slen,
-                                                            s->s3.tmp.finish_md);
+        sender, slen,
+        s->s3.tmp.finish_md);
     if (finish_md_len == 0) {
         /* SSLfatal() already called */
         return CON_FUNC_ERROR;
@@ -665,7 +674,7 @@ CON_FUNC_RETURN tls_construct_finished(SSL_CONNECTION *s, WPACKET *pkt)
      */
     if (!SSL_CONNECTION_IS_TLS13(s)
         && !ssl_log_secret(s, MASTER_SECRET_LABEL, s->session->master_key,
-                           s->session->master_key_length)) {
+            s->session->master_key_length)) {
         /* SSLfatal() already called */
         return CON_FUNC_ERROR;
     }
@@ -679,11 +688,11 @@ CON_FUNC_RETURN tls_construct_finished(SSL_CONNECTION *s, WPACKET *pkt)
     }
     if (!s->server) {
         memcpy(s->s3.previous_client_finished, s->s3.tmp.finish_md,
-               finish_md_len);
+            finish_md_len);
         s->s3.previous_client_finished_len = finish_md_len;
     } else {
         memcpy(s->s3.previous_server_finished, s->s3.tmp.finish_md,
-               finish_md_len);
+            finish_md_len);
         s->s3.previous_server_finished_len = finish_md_len;
     }
 
@@ -715,7 +724,7 @@ MSG_PROCESS_RETURN tls_process_key_update(SSL_CONNECTION *s, PACKET *pkt)
     }
 
     if (!PACKET_get_1(pkt, &updatetype)
-            || PACKET_remaining(pkt) != 0) {
+        || PACKET_remaining(pkt) != 0) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_KEY_UPDATE);
         return MSG_PROCESS_ERROR;
     }
@@ -725,7 +734,7 @@ MSG_PROCESS_RETURN tls_process_key_update(SSL_CONNECTION *s, PACKET *pkt)
      * didn't recognise.
      */
     if (updatetype != SSL_KEY_UPDATE_NOT_REQUESTED
-            && updatetype != SSL_KEY_UPDATE_REQUESTED) {
+        && updatetype != SSL_KEY_UPDATE_REQUESTED) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_BAD_KEY_UPDATE);
         return MSG_PROCESS_ERROR;
     }
@@ -764,9 +773,8 @@ int ssl3_take_mac(SSL_CONNECTION *s)
         slen = ssl->method->ssl3_enc->client_finished_label_len;
     }
 
-    s->s3.tmp.peer_finish_md_len =
-        ssl->method->ssl3_enc->final_finish_mac(s, sender, slen,
-                                                s->s3.tmp.peer_finish_md);
+    s->s3.tmp.peer_finish_md_len = ssl->method->ssl3_enc->final_finish_mac(s, sender, slen,
+        s->s3.tmp.peer_finish_md);
 
     if (s->s3.tmp.peer_finish_md_len == 0) {
         /* SSLfatal() already called */
@@ -777,7 +785,7 @@ int ssl3_take_mac(SSL_CONNECTION *s)
 }
 
 MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL_CONNECTION *s,
-                                                  PACKET *pkt)
+    PACKET *pkt)
 {
     size_t remain;
 
@@ -789,7 +797,7 @@ MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL_CONNECTION *s,
      */
     if (SSL_CONNECTION_IS_DTLS(s)) {
         if ((s->version == DTLS1_BAD_VER
-             && remain != DTLS1_CCS_HEADER_LENGTH + 1)
+                && remain != DTLS1_CCS_HEADER_LENGTH + 1)
             || (s->version != DTLS1_BAD_VER
                 && remain != DTLS1_CCS_HEADER_LENGTH - 1)) {
             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_BAD_CHANGE_CIPHER_SPEC);
@@ -825,7 +833,7 @@ MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL_CONNECTION *s,
          * SCTP is used
          */
         BIO_ctrl(SSL_get_wbio(SSL_CONNECTION_GET_SSL(s)),
-                 BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD, 1, NULL);
+            BIO_CTRL_DGRAM_SCTP_AUTH_CCS_RCVD, 1, NULL);
 #endif
     }
 
@@ -839,22 +847,21 @@ MSG_PROCESS_RETURN tls_process_finished(SSL_CONNECTION *s, PACKET *pkt)
     int was_first = SSL_IS_FIRST_HANDSHAKE(s);
     int ok;
 
-
     /* This is a real handshake so make sure we clean it up at the end */
     if (s->server) {
         /*
-        * To get this far we must have read encrypted data from the client. We
-        * no longer tolerate unencrypted alerts. This is ignored if less than
-        * TLSv1.3
-        */
+         * To get this far we must have read encrypted data from the client. We
+         * no longer tolerate unencrypted alerts. This is ignored if less than
+         * TLSv1.3
+         */
         if (s->rlayer.rrlmethod->set_plain_alerts != NULL)
             s->rlayer.rrlmethod->set_plain_alerts(s->rlayer.rrl, 0);
         if (s->post_handshake_auth != SSL_PHA_REQUESTED)
             s->statem.cleanuphand = 1;
         if (SSL_CONNECTION_IS_TLS13(s)
             && !tls13_save_handshake_digest_for_pha(s)) {
-                /* SSLfatal() already called */
-                return MSG_PROCESS_ERROR;
+            /* SSLfatal() already called */
+            return MSG_PROCESS_ERROR;
         }
     }
 
@@ -883,7 +890,7 @@ MSG_PROCESS_RETURN tls_process_finished(SSL_CONNECTION *s, PACKET *pkt)
     }
 
     ok = CRYPTO_memcmp(PACKET_data(pkt), s->s3.tmp.peer_finish_md,
-                       md_len);
+        md_len);
 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
     if (ok != 0) {
         if ((PACKET_data(pkt)[0] ^ s->s3.tmp.peer_finish_md[0]) != 0xFF) {
@@ -905,11 +912,11 @@ MSG_PROCESS_RETURN tls_process_finished(SSL_CONNECTION *s, PACKET *pkt)
     }
     if (s->server) {
         memcpy(s->s3.previous_client_finished, s->s3.tmp.peer_finish_md,
-               md_len);
+            md_len);
         s->s3.previous_client_finished_len = md_len;
     } else {
         memcpy(s->s3.previous_server_finished, s->s3.tmp.peer_finish_md,
-               md_len);
+            md_len);
         s->s3.previous_server_finished_len = md_len;
     }
 
@@ -919,9 +926,7 @@ MSG_PROCESS_RETURN tls_process_finished(SSL_CONNECTION *s, PACKET *pkt)
      */
     if (SSL_CONNECTION_IS_TLS13(s)) {
         if (s->server) {
-            if (s->post_handshake_auth != SSL_PHA_REQUESTED &&
-                    !ssl->method->ssl3_enc->change_cipher_state(s,
-                        SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_SERVER_READ)) {
+            if (s->post_handshake_auth != SSL_PHA_REQUESTED && !ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_SERVER_READ)) {
                 /* SSLfatal() already called */
                 return MSG_PROCESS_ERROR;
             }
@@ -948,8 +953,8 @@ MSG_PROCESS_RETURN tls_process_finished(SSL_CONNECTION *s, PACKET *pkt)
              * a message we have the correct keys in place to ack it)
              */
             if (!SSL_IS_QUIC_HANDSHAKE(s)
-                    && !ssl->method->ssl3_enc->change_cipher_state(s,
-                        SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_CLIENT_READ)) {
+                && !ssl->method->ssl3_enc->change_cipher_state(s,
+                    SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_CLIENT_READ)) {
                 /* SSLfatal() already called */
                 return MSG_PROCESS_ERROR;
             }
@@ -961,8 +966,8 @@ MSG_PROCESS_RETURN tls_process_finished(SSL_CONNECTION *s, PACKET *pkt)
     }
 
     if (was_first
-            && !SSL_IS_FIRST_HANDSHAKE(s)
-            && s->rlayer.rrlmethod->set_first_handshake != NULL)
+        && !SSL_IS_FIRST_HANDSHAKE(s)
+        && s->rlayer.rrlmethod->set_first_handshake != NULL)
         s->rlayer.rrlmethod->set_first_handshake(s->rlayer.rrl, 0);
 
     return MSG_PROCESS_FINISHED_READING;
@@ -980,7 +985,7 @@ CON_FUNC_RETURN tls_construct_change_cipher_spec(SSL_CONNECTION *s, WPACKET *pkt
 
 /* Add a certificate to the WPACKET */
 static int ssl_add_cert_to_wpacket(SSL_CONNECTION *s, WPACKET *pkt,
-                                   X509 *x, int chain, int for_comp)
+    X509 *x, int chain, int for_comp)
 {
     int len;
     unsigned char *outbytes;
@@ -996,14 +1001,14 @@ static int ssl_add_cert_to_wpacket(SSL_CONNECTION *s, WPACKET *pkt,
         return 0;
     }
     if (!WPACKET_sub_allocate_bytes_u24(pkt, len, &outbytes)
-            || i2d_X509(x, &outbytes) != len) {
+        || i2d_X509(x, &outbytes) != len) {
         if (!for_comp)
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
 
     if ((SSL_CONNECTION_IS_TLS13(s) || for_comp)
-            && !tls_construct_extensions(s, pkt, context, x, chain)) {
+        && !tls_construct_extensions(s, pkt, context, x, chain)) {
         /* SSLfatal() already called */
         return 0;
     }
@@ -1043,7 +1048,7 @@ static int ssl_add_cert_chain(SSL_CONNECTION *s, WPACKET *pkt, CERT_PKEY *cpk, i
 
     if (chain_store != NULL) {
         X509_STORE_CTX *xs_ctx = X509_STORE_CTX_new_ex(sctx->libctx,
-                                                       sctx->propq);
+            sctx->propq);
 
         if (xs_ctx == NULL) {
             if (!for_comp)
@@ -1112,7 +1117,7 @@ static int ssl_add_cert_chain(SSL_CONNECTION *s, WPACKET *pkt, CERT_PKEY *cpk, i
     return 1;
 }
 
-EVP_PKEY* tls_get_peer_pkey(const SSL_CONNECTION *sc)
+EVP_PKEY *tls_get_peer_pkey(const SSL_CONNECTION *sc)
 {
     if (sc->session->peer_rpk != NULL)
         return sc->session->peer_rpk;
@@ -1274,13 +1279,13 @@ int tls_process_rpk(SSL_CONNECTION *sc, PACKET *pkt, EVP_PKEY **peer_rpk)
     }
     spkistart = spki;
     if ((pkey = d2i_PUBKEY_ex(NULL, &spki, spki_len, sctx->libctx, sctx->propq)) == NULL
-            || spki != (spkistart + spki_len)) {
+        || spki != (spkistart + spki_len)) {
         SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
         goto err;
     }
     if (EVP_PKEY_missing_parameters(pkey)) {
         SSLfatal(sc, SSL_AD_INTERNAL_ERROR,
-                 SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS);
+            SSL_R_UNABLE_TO_FIND_PUBLIC_KEY_PARAMETERS);
         goto err;
     }
 
@@ -1291,18 +1296,18 @@ int tls_process_rpk(SSL_CONNECTION *sc, PACKET *pkt, EVP_PKEY **peer_rpk)
             goto err;
         }
         if (!PACKET_as_length_prefixed_2(pkt, &extensions)
-                || PACKET_remaining(pkt) != 0) {
+            || PACKET_remaining(pkt) != 0) {
             SSLfatal(sc, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
             goto err;
         }
         if (!tls_collect_extensions(sc, &extensions, SSL_EXT_TLS1_3_RAW_PUBLIC_KEY,
-                                    &rawexts, NULL, 1)) {
+                &rawexts, NULL, 1)) {
             /* SSLfatal already called */
             goto err;
         }
         /* chain index is always zero and fin always 1 for RPK */
         if (!tls_parse_all_extensions(sc, SSL_EXT_TLS1_3_RAW_PUBLIC_KEY,
-                                      rawexts, NULL, 0, 1)) {
+                rawexts, NULL, 0, 1)) {
             /* SSLfatal already called */
             goto err;
         }
@@ -1313,7 +1318,7 @@ int tls_process_rpk(SSL_CONNECTION *sc, PACKET *pkt, EVP_PKEY **peer_rpk)
         pkey = NULL;
     }
 
- err:
+err:
     OPENSSL_free(rawexts);
     EVP_PKEY_free(pkey);
     return ret;
@@ -1381,7 +1386,7 @@ unsigned long tls_output_rpk(SSL_CONNECTION *sc, WPACKET *pkt, CERT_PKEY *cpk)
          * |x509| may be NULL, which raw public-key extensions need to handle.
          */
         if (!tls_construct_extensions(sc, pkt, SSL_EXT_TLS1_3_RAW_PUBLIC_KEY,
-                                      x509, 0)) {
+                x509, 0)) {
             /* SSLfatal() already called */
             goto err;
         }
@@ -1392,13 +1397,13 @@ unsigned long tls_output_rpk(SSL_CONNECTION *sc, WPACKET *pkt, CERT_PKEY *cpk)
     }
 
     ret = 1;
- err:
+err:
     OPENSSL_free(pdata);
     return ret;
 }
 
 unsigned long ssl3_output_cert_chain(SSL_CONNECTION *s, WPACKET *pkt,
-                                     CERT_PKEY *cpk, int for_comp)
+    CERT_PKEY *cpk, int for_comp)
 {
     if (!WPACKET_start_sub_packet_u24(pkt)) {
         if (!for_comp)
@@ -1424,9 +1429,9 @@ unsigned long ssl3_output_cert_chain(SSL_CONNECTION *s, WPACKET *pkt,
  * freed up as well.
  */
 WORK_STATE tls_finish_handshake(SSL_CONNECTION *s, ossl_unused WORK_STATE wst,
-                                int clearbufs, int stop)
+    int clearbufs, int stop)
 {
-    void (*cb) (const SSL *ssl, int type, int val) = NULL;
+    void (*cb)(const SSL *ssl, int type, int val) = NULL;
     int cleanuphand = s->statem.cleanuphand;
     SSL *ssl = SSL_CONNECTION_GET_USER_SSL(s);
     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
@@ -1442,7 +1447,7 @@ WORK_STATE tls_finish_handshake(SSL_CONNECTION *s, ossl_unused WORK_STATE wst,
              */
             || BIO_dgram_is_sctp(SSL_get_wbio(SSL_CONNECTION_GET_SSL(s)))
 #endif
-            ) {
+        ) {
             /*
              * We don't do this in DTLS over UDP because we may still need the init_buf
              * in case there are any unexpected retransmits
@@ -1459,7 +1464,7 @@ WORK_STATE tls_finish_handshake(SSL_CONNECTION *s, ossl_unused WORK_STATE wst,
     }
 
     if (SSL_CONNECTION_IS_TLS13(s) && !s->server
-            && s->post_handshake_auth == SSL_PHA_REQUESTED)
+        && s->post_handshake_auth == SSL_PHA_REQUESTED)
         s->post_handshake_auth = SSL_PHA_EXT_SENT;
 
     /*
@@ -1493,7 +1498,8 @@ WORK_STATE tls_finish_handshake(SSL_CONNECTION *s, ossl_unused WORK_STATE wst,
                  * so we remove this one from the cache.
                  */
                 if ((s->session_ctx->session_cache_mode
-                     & SSL_SESS_CACHE_CLIENT) != 0)
+                        & SSL_SESS_CACHE_CLIENT)
+                    != 0)
                     SSL_CTX_remove_session(s->session_ctx, s->session);
             } else {
                 /*
@@ -1504,11 +1510,11 @@ WORK_STATE tls_finish_handshake(SSL_CONNECTION *s, ossl_unused WORK_STATE wst,
             }
             if (s->hit)
                 ssl_tsan_counter(s->session_ctx,
-                                 &s->session_ctx->stats.sess_hit);
+                    &s->session_ctx->stats.sess_hit);
 
             s->handshake_func = ossl_statem_connect;
             ssl_tsan_counter(s->session_ctx,
-                             &s->session_ctx->stats.sess_connect_good);
+                &s->session_ctx->stats.sess_connect_good);
         }
 
         if (SSL_CONNECTION_IS_DTLS(s)) {
@@ -1530,8 +1536,8 @@ WORK_STATE tls_finish_handshake(SSL_CONNECTION *s, ossl_unused WORK_STATE wst,
 
     if (cb != NULL) {
         if (cleanuphand
-                || !SSL_CONNECTION_IS_TLS13(s)
-                || SSL_IS_FIRST_HANDSHAKE(s))
+            || !SSL_CONNECTION_IS_TLS13(s)
+            || SSL_IS_FIRST_HANDSHAKE(s))
             cb(ssl, SSL_CB_HANDSHAKE_DONE, 1);
     }
 
@@ -1559,9 +1565,9 @@ int tls_get_message_header(SSL_CONNECTION *s, int *mt)
     do {
         while (s->init_num < SSL3_HM_HEADER_LENGTH) {
             i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, &recvd_type,
-                                            &p[s->init_num],
-                                            SSL3_HM_HEADER_LENGTH - s->init_num,
-                                            0, &readbytes);
+                &p[s->init_num],
+                SSL3_HM_HEADER_LENGTH - s->init_num,
+                0, &readbytes);
             if (i <= 0) {
                 s->rwstate = SSL_READING;
                 return 0;
@@ -1573,11 +1579,11 @@ int tls_get_message_header(SSL_CONNECTION *s, int *mt)
                  */
                 if (s->init_num != 0 || readbytes != 1 || p[0] != SSL3_MT_CCS) {
                     SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
-                             SSL_R_BAD_CHANGE_CIPHER_SPEC);
+                        SSL_R_BAD_CHANGE_CIPHER_SPEC);
                     return 0;
                 }
                 if (s->statem.hand_state == TLS_ST_BEFORE
-                        && (s->s3.flags & TLS1_FLAGS_STATELESS) != 0) {
+                    && (s->s3.flags & TLS1_FLAGS_STATELESS) != 0) {
                     /*
                      * We are stateless and we received a CCS. Probably this is
                      * from a client between the first and second ClientHellos.
@@ -1594,7 +1600,7 @@ int tls_get_message_header(SSL_CONNECTION *s, int *mt)
                 return 1;
             } else if (recvd_type != SSL3_RT_HANDSHAKE) {
                 SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
-                         SSL_R_CCS_RECEIVED_EARLY);
+                    SSL_R_CCS_RECEIVED_EARLY);
                 return 0;
             }
             s->init_num += readbytes;
@@ -1603,7 +1609,7 @@ int tls_get_message_header(SSL_CONNECTION *s, int *mt)
         skip_message = 0;
         if (!s->server)
             if (s->statem.hand_state != TLS_ST_OK
-                    && p[0] == SSL3_MT_HELLO_REQUEST)
+                && p[0] == SSL3_MT_HELLO_REQUEST)
                 /*
                  * The server may always send 'Hello Request' messages --
                  * we are doing a handshake anyway now, so ignore them if
@@ -1616,8 +1622,8 @@ int tls_get_message_header(SSL_CONNECTION *s, int *mt)
 
                     if (s->msg_callback)
                         s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE,
-                                        p, SSL3_HM_HEADER_LENGTH, ussl,
-                                        s->msg_callback_arg);
+                            p, SSL3_HM_HEADER_LENGTH, ussl,
+                            s->msg_callback_arg);
                 }
     } while (skip_message);
     /* s->init_num == SSL3_HM_HEADER_LENGTH */
@@ -1643,7 +1649,7 @@ int tls_get_message_header(SSL_CONNECTION *s, int *mt)
         /* BUF_MEM_grow takes an 'int' parameter */
         if (l > (INT_MAX - SSL3_HM_HEADER_LENGTH)) {
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                     SSL_R_EXCESSIVE_MESSAGE_SIZE);
+                SSL_R_EXCESSIVE_MESSAGE_SIZE);
             return 0;
         }
         s->s3.tmp.message_size = l;
@@ -1673,7 +1679,7 @@ int tls_get_message_body(SSL_CONNECTION *s, size_t *len)
     n = s->s3.tmp.message_size - s->init_num;
     while (n > 0) {
         i = ssl->method->ssl_read_bytes(ssl, SSL3_RT_HANDSHAKE, NULL,
-                                        &p[s->init_num], n, 0, &readbytes);
+            &p[s->init_num], n, 0, &readbytes);
         if (i <= 0) {
             s->rwstate = SSL_READING;
             *len = 0;
@@ -1696,14 +1702,14 @@ int tls_get_message_body(SSL_CONNECTION *s, size_t *len)
     /* Feed this message into MAC computation. */
     if (RECORD_LAYER_is_sslv2_record(&s->rlayer)) {
         if (!ssl3_finish_mac(s, (unsigned char *)s->init_buf->data,
-                             s->init_num)) {
+                s->init_num)) {
             /* SSLfatal() already called */
             *len = 0;
             return 0;
         }
         if (s->msg_callback)
             s->msg_callback(0, SSL2_VERSION, 0, s->init_buf->data,
-                            (size_t)s->init_num, ussl, s->msg_callback_arg);
+                (size_t)s->init_num, ussl, s->msg_callback_arg);
     } else {
         /*
          * We defer feeding in the HRR until later. We'll do it as part of
@@ -1711,18 +1717,19 @@ int tls_get_message_body(SSL_CONNECTION *s, size_t *len)
          * The TLsv1.3 handshake transcript stops at the ClientFinished
          * message.
          */
-#define SERVER_HELLO_RANDOM_OFFSET  (SSL3_HM_HEADER_LENGTH + 2)
+#define SERVER_HELLO_RANDOM_OFFSET (SSL3_HM_HEADER_LENGTH + 2)
         /* KeyUpdate and NewSessionTicket do not need to be added */
         if (!SSL_CONNECTION_IS_TLS13(s)
             || (s->s3.tmp.message_type != SSL3_MT_NEWSESSION_TICKET
-                         && s->s3.tmp.message_type != SSL3_MT_KEY_UPDATE)) {
+                && s->s3.tmp.message_type != SSL3_MT_KEY_UPDATE)) {
             if (s->s3.tmp.message_type != SSL3_MT_SERVER_HELLO
-                    || s->init_num < SERVER_HELLO_RANDOM_OFFSET + SSL3_RANDOM_SIZE
-                    || memcmp(hrrrandom,
-                              s->init_buf->data + SERVER_HELLO_RANDOM_OFFSET,
-                              SSL3_RANDOM_SIZE) != 0) {
+                || s->init_num < SERVER_HELLO_RANDOM_OFFSET + SSL3_RANDOM_SIZE
+                || memcmp(hrrrandom,
+                       s->init_buf->data + SERVER_HELLO_RANDOM_OFFSET,
+                       SSL3_RANDOM_SIZE)
+                    != 0) {
                 if (!ssl3_finish_mac(s, (unsigned char *)s->init_buf->data,
-                                     s->init_num + SSL3_HM_HEADER_LENGTH)) {
+                        s->init_num + SSL3_HM_HEADER_LENGTH)) {
                     /* SSLfatal() already called */
                     *len = 0;
                     return 0;
@@ -1731,8 +1738,8 @@ int tls_get_message_body(SSL_CONNECTION *s, size_t *len)
         }
         if (s->msg_callback)
             s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, s->init_buf->data,
-                            (size_t)s->init_num + SSL3_HM_HEADER_LENGTH, ussl,
-                            s->msg_callback_arg);
+                (size_t)s->init_num + SSL3_HM_HEADER_LENGTH, ussl,
+                s->msg_callback_arg);
     }
 
     *len = s->init_num;
@@ -1740,49 +1747,49 @@ int tls_get_message_body(SSL_CONNECTION *s, size_t *len)
 }
 
 static const X509ERR2ALERT x509table[] = {
-    {X509_V_ERR_APPLICATION_VERIFICATION, SSL_AD_HANDSHAKE_FAILURE},
-    {X509_V_ERR_CA_KEY_TOO_SMALL, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_EC_KEY_EXPLICIT_PARAMS, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_CA_MD_TOO_WEAK, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_CERT_CHAIN_TOO_LONG, SSL_AD_UNKNOWN_CA},
-    {X509_V_ERR_CERT_HAS_EXPIRED, SSL_AD_CERTIFICATE_EXPIRED},
-    {X509_V_ERR_CERT_NOT_YET_VALID, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_CERT_REJECTED, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_CERT_REVOKED, SSL_AD_CERTIFICATE_REVOKED},
-    {X509_V_ERR_CERT_SIGNATURE_FAILURE, SSL_AD_DECRYPT_ERROR},
-    {X509_V_ERR_CERT_UNTRUSTED, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_CRL_HAS_EXPIRED, SSL_AD_CERTIFICATE_EXPIRED},
-    {X509_V_ERR_CRL_NOT_YET_VALID, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_CRL_SIGNATURE_FAILURE, SSL_AD_DECRYPT_ERROR},
-    {X509_V_ERR_DANE_NO_MATCH, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT, SSL_AD_UNKNOWN_CA},
-    {X509_V_ERR_EE_KEY_TOO_SMALL, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_EMAIL_MISMATCH, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_HOSTNAME_MISMATCH, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_INVALID_CA, SSL_AD_UNKNOWN_CA},
-    {X509_V_ERR_INVALID_CALL, SSL_AD_INTERNAL_ERROR},
-    {X509_V_ERR_INVALID_PURPOSE, SSL_AD_UNSUPPORTED_CERTIFICATE},
-    {X509_V_ERR_IP_ADDRESS_MISMATCH, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_OUT_OF_MEM, SSL_AD_INTERNAL_ERROR},
-    {X509_V_ERR_PATH_LENGTH_EXCEEDED, SSL_AD_UNKNOWN_CA},
-    {X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN, SSL_AD_UNKNOWN_CA},
-    {X509_V_ERR_STORE_LOOKUP, SSL_AD_INTERNAL_ERROR},
-    {X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE, SSL_AD_BAD_CERTIFICATE},
-    {X509_V_ERR_UNABLE_TO_GET_CRL, SSL_AD_UNKNOWN_CA},
-    {X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER, SSL_AD_UNKNOWN_CA},
-    {X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT, SSL_AD_UNKNOWN_CA},
-    {X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY, SSL_AD_UNKNOWN_CA},
-    {X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE, SSL_AD_UNKNOWN_CA},
-    {X509_V_ERR_UNSPECIFIED, SSL_AD_INTERNAL_ERROR},
+    { X509_V_ERR_APPLICATION_VERIFICATION, SSL_AD_HANDSHAKE_FAILURE },
+    { X509_V_ERR_CA_KEY_TOO_SMALL, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_EC_KEY_EXPLICIT_PARAMS, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_CA_MD_TOO_WEAK, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_CERT_CHAIN_TOO_LONG, SSL_AD_UNKNOWN_CA },
+    { X509_V_ERR_CERT_HAS_EXPIRED, SSL_AD_CERTIFICATE_EXPIRED },
+    { X509_V_ERR_CERT_NOT_YET_VALID, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_CERT_REJECTED, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_CERT_REVOKED, SSL_AD_CERTIFICATE_REVOKED },
+    { X509_V_ERR_CERT_SIGNATURE_FAILURE, SSL_AD_DECRYPT_ERROR },
+    { X509_V_ERR_CERT_UNTRUSTED, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_CRL_HAS_EXPIRED, SSL_AD_CERTIFICATE_EXPIRED },
+    { X509_V_ERR_CRL_NOT_YET_VALID, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_CRL_SIGNATURE_FAILURE, SSL_AD_DECRYPT_ERROR },
+    { X509_V_ERR_DANE_NO_MATCH, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT, SSL_AD_UNKNOWN_CA },
+    { X509_V_ERR_EE_KEY_TOO_SMALL, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_EMAIL_MISMATCH, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_HOSTNAME_MISMATCH, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_INVALID_CA, SSL_AD_UNKNOWN_CA },
+    { X509_V_ERR_INVALID_CALL, SSL_AD_INTERNAL_ERROR },
+    { X509_V_ERR_INVALID_PURPOSE, SSL_AD_UNSUPPORTED_CERTIFICATE },
+    { X509_V_ERR_IP_ADDRESS_MISMATCH, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_OUT_OF_MEM, SSL_AD_INTERNAL_ERROR },
+    { X509_V_ERR_PATH_LENGTH_EXCEEDED, SSL_AD_UNKNOWN_CA },
+    { X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN, SSL_AD_UNKNOWN_CA },
+    { X509_V_ERR_STORE_LOOKUP, SSL_AD_INTERNAL_ERROR },
+    { X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE, SSL_AD_BAD_CERTIFICATE },
+    { X509_V_ERR_UNABLE_TO_GET_CRL, SSL_AD_UNKNOWN_CA },
+    { X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER, SSL_AD_UNKNOWN_CA },
+    { X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT, SSL_AD_UNKNOWN_CA },
+    { X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY, SSL_AD_UNKNOWN_CA },
+    { X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE, SSL_AD_UNKNOWN_CA },
+    { X509_V_ERR_UNSPECIFIED, SSL_AD_INTERNAL_ERROR },
 
     /* Last entry; return this if we don't find the value above. */
-    {X509_V_OK, SSL_AD_CERTIFICATE_UNKNOWN}
+    { X509_V_OK, SSL_AD_CERTIFICATE_UNKNOWN }
 };
 
 int ssl_x509err2alert(int x509err)
@@ -1823,63 +1830,63 @@ int ssl_version_cmp(const SSL_CONNECTION *s, int versiona, int versionb)
 
 typedef struct {
     int version;
-    const SSL_METHOD *(*cmeth) (void);
-    const SSL_METHOD *(*smeth) (void);
+    const SSL_METHOD *(*cmeth)(void);
+    const SSL_METHOD *(*smeth)(void);
 } version_info;
 
 #if TLS_MAX_VERSION_INTERNAL != TLS1_3_VERSION
-# error Code needs update for TLS_method() support beyond TLS1_3_VERSION.
+#error Code needs update for TLS_method() support beyond TLS1_3_VERSION.
 #endif
 
 /* Must be in order high to low */
 static const version_info tls_version_table[] = {
 #ifndef OPENSSL_NO_TLS1_3
-    {TLS1_3_VERSION, tlsv1_3_client_method, tlsv1_3_server_method},
+    { TLS1_3_VERSION, tlsv1_3_client_method, tlsv1_3_server_method },
 #else
-    {TLS1_3_VERSION, NULL, NULL},
+    { TLS1_3_VERSION, NULL, NULL },
 #endif
 #ifndef OPENSSL_NO_TLS1_2
-    {TLS1_2_VERSION, tlsv1_2_client_method, tlsv1_2_server_method},
+    { TLS1_2_VERSION, tlsv1_2_client_method, tlsv1_2_server_method },
 #else
-    {TLS1_2_VERSION, NULL, NULL},
+    { TLS1_2_VERSION, NULL, NULL },
 #endif
 #ifndef OPENSSL_NO_TLS1_1
-    {TLS1_1_VERSION, tlsv1_1_client_method, tlsv1_1_server_method},
+    { TLS1_1_VERSION, tlsv1_1_client_method, tlsv1_1_server_method },
 #else
-    {TLS1_1_VERSION, NULL, NULL},
+    { TLS1_1_VERSION, NULL, NULL },
 #endif
 #ifndef OPENSSL_NO_TLS1
-    {TLS1_VERSION, tlsv1_client_method, tlsv1_server_method},
+    { TLS1_VERSION, tlsv1_client_method, tlsv1_server_method },
 #else
-    {TLS1_VERSION, NULL, NULL},
+    { TLS1_VERSION, NULL, NULL },
 #endif
 #ifndef OPENSSL_NO_SSL3
-    {SSL3_VERSION, sslv3_client_method, sslv3_server_method},
+    { SSL3_VERSION, sslv3_client_method, sslv3_server_method },
 #else
-    {SSL3_VERSION, NULL, NULL},
+    { SSL3_VERSION, NULL, NULL },
 #endif
-    {0, NULL, NULL},
+    { 0, NULL, NULL },
 };
 
 #if DTLS_MAX_VERSION_INTERNAL != DTLS1_2_VERSION
-# error Code needs update for DTLS_method() support beyond DTLS1_2_VERSION.
+#error Code needs update for DTLS_method() support beyond DTLS1_2_VERSION.
 #endif
 
 /* Must be in order high to low */
 static const version_info dtls_version_table[] = {
 #ifndef OPENSSL_NO_DTLS1_2
-    {DTLS1_2_VERSION, dtlsv1_2_client_method, dtlsv1_2_server_method},
+    { DTLS1_2_VERSION, dtlsv1_2_client_method, dtlsv1_2_server_method },
 #else
-    {DTLS1_2_VERSION, NULL, NULL},
+    { DTLS1_2_VERSION, NULL, NULL },
 #endif
 #ifndef OPENSSL_NO_DTLS1
-    {DTLS1_VERSION, dtlsv1_client_method, dtlsv1_server_method},
-    {DTLS1_BAD_VER, dtls_bad_ver_client_method, NULL},
+    { DTLS1_VERSION, dtlsv1_client_method, dtlsv1_server_method },
+    { DTLS1_BAD_VER, dtls_bad_ver_client_method, NULL },
 #else
-    {DTLS1_VERSION, NULL, NULL},
-    {DTLS1_BAD_VER, NULL, NULL},
+    { DTLS1_VERSION, NULL, NULL },
+    { DTLS1_BAD_VER, NULL, NULL },
 #endif
-    {0, NULL, NULL},
+    { 0, NULL, NULL },
 };
 
 /*
@@ -1894,13 +1901,10 @@ static int ssl_method_error(const SSL_CONNECTION *s, const SSL_METHOD *method)
 {
     int version = method->version;
 
-    if ((s->min_proto_version != 0 &&
-        ssl_version_cmp(s, version, s->min_proto_version) < 0) ||
-        ssl_security(s, SSL_SECOP_VERSION, 0, version, NULL) == 0)
+    if ((s->min_proto_version != 0 && ssl_version_cmp(s, version, s->min_proto_version) < 0) || ssl_security(s, SSL_SECOP_VERSION, 0, version, NULL) == 0)
         return SSL_R_VERSION_TOO_LOW;
 
-    if (s->max_proto_version != 0 &&
-        ssl_version_cmp(s, version, s->max_proto_version) > 0)
+    if (s->max_proto_version != 0 && ssl_version_cmp(s, version, s->max_proto_version) > 0)
         return SSL_R_VERSION_TOO_HIGH;
 
     if ((s->options & method->mask) != 0)
@@ -1930,7 +1934,7 @@ static int is_tls13_capable(const SSL_CONNECTION *s)
      * cb is set then we just assume TLSv1.3 will be ok
      */
     if (sctx->ext.servername_cb != NULL
-            || s->session_ctx->ext.servername_cb != NULL)
+        || s->session_ctx->ext.servername_cb != NULL)
         return 1;
 
 #ifndef OPENSSL_NO_PSK
@@ -1980,7 +1984,7 @@ static int is_tls13_capable(const SSL_CONNECTION *s)
  * Returns 1 when supported, otherwise 0
  */
 int ssl_version_supported(const SSL_CONNECTION *s, int version,
-                          const SSL_METHOD **meth)
+    const SSL_METHOD **meth)
 {
     const version_info *vent;
     const version_info *table;
@@ -1998,17 +2002,17 @@ int ssl_version_supported(const SSL_CONNECTION *s, int version,
     }
 
     for (vent = table;
-         vent->version != 0 && ssl_version_cmp(s, version, vent->version) <= 0;
-         ++vent) {
+        vent->version != 0 && ssl_version_cmp(s, version, vent->version) <= 0;
+        ++vent) {
         const SSL_METHOD *(*thismeth)(void) = s->server ? vent->smeth
                                                         : vent->cmeth;
 
         if (thismeth != NULL
-                && ssl_version_cmp(s, version, vent->version) == 0
-                && ssl_method_error(s, thismeth()) == 0
-                && (!s->server
-                    || version != TLS1_3_VERSION
-                    || is_tls13_capable(s))) {
+            && ssl_version_cmp(s, version, vent->version) == 0
+            && ssl_method_error(s, thismeth()) == 0
+            && (!s->server
+                || version != TLS1_3_VERSION
+                || is_tls13_capable(s))) {
             if (meth != NULL)
                 *meth = thismeth();
             return 1;
@@ -2126,18 +2130,18 @@ int ssl_set_version_bound(int method_version, int version, int *bound)
 static void check_for_downgrade(SSL_CONNECTION *s, int vers, DOWNGRADE *dgrd)
 {
     if (vers == TLS1_2_VERSION
-            && ssl_version_supported(s, TLS1_3_VERSION, NULL)) {
+        && ssl_version_supported(s, TLS1_3_VERSION, NULL)) {
         *dgrd = DOWNGRADE_TO_1_2;
     } else if (!SSL_CONNECTION_IS_DTLS(s)
-            && vers < TLS1_2_VERSION
-               /*
-                * We need to ensure that a server that disables TLSv1.2
-                * (creating a hole between TLSv1.3 and TLSv1.1) can still
-                * complete handshakes with clients that support TLSv1.2 and
-                * below. Therefore we do not enable the sentinel if TLSv1.3 is
-                * enabled and TLSv1.2 is not.
-                */
-            && ssl_version_supported(s, TLS1_2_VERSION, NULL)) {
+        && vers < TLS1_2_VERSION
+        /*
+         * We need to ensure that a server that disables TLSv1.2
+         * (creating a hole between TLSv1.3 and TLSv1.1) can still
+         * complete handshakes with clients that support TLSv1.2 and
+         * below. Therefore we do not enable the sentinel if TLSv1.3 is
+         * enabled and TLSv1.2 is not.
+         */
+        && ssl_version_supported(s, TLS1_2_VERSION, NULL)) {
         *dgrd = DOWNGRADE_TO_1_1;
     } else {
         *dgrd = DOWNGRADE_NONE;
@@ -2154,7 +2158,7 @@ static void check_for_downgrade(SSL_CONNECTION *s, int vers, DOWNGRADE *dgrd)
  * Returns 0 on success or an SSL error reason number on failure.
  */
 int ssl_choose_server_version(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello,
-                              DOWNGRADE *dgrd)
+    DOWNGRADE *dgrd)
 {
     /*-
      * With version-flexible methods we have an initial state with:
@@ -2280,8 +2284,7 @@ int ssl_choose_server_version(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello,
     for (vent = table; vent->version != 0; ++vent) {
         const SSL_METHOD *method;
 
-        if (vent->smeth == NULL ||
-            ssl_version_cmp(s, client_version, vent->version) < 0)
+        if (vent->smeth == NULL || ssl_version_cmp(s, client_version, vent->version) < 0)
             continue;
         method = vent->smeth();
         if (ssl_method_error(s, method) == 0) {
@@ -2310,7 +2313,7 @@ int ssl_choose_server_version(SSL_CONNECTION *s, CLIENTHELLO_MSG *hello,
  * Returns 1 on success or 0 on error.
  */
 int ssl_choose_client_version(SSL_CONNECTION *s, int version,
-                              RAW_EXTENSION *extensions)
+    RAW_EXTENSION *extensions)
 {
     const version_info *vent;
     const version_info *table;
@@ -2322,15 +2325,16 @@ int ssl_choose_client_version(SSL_CONNECTION *s, int version,
 
     /* This will overwrite s->version if the extension is present */
     if (!tls_parse_extension(s, TLSEXT_IDX_supported_versions,
-                             SSL_EXT_TLS1_2_SERVER_HELLO
-                             | SSL_EXT_TLS1_3_SERVER_HELLO, extensions,
-                             NULL, 0)) {
+            SSL_EXT_TLS1_2_SERVER_HELLO
+                | SSL_EXT_TLS1_3_SERVER_HELLO,
+            extensions,
+            NULL, 0)) {
         s->version = origv;
         return 0;
     }
 
     if (s->hello_retry_request != SSL_HRR_NONE
-            && s->version != TLS1_3_VERSION) {
+        && s->version != TLS1_3_VERSION) {
         s->version = origv;
         SSLfatal(s, SSL_AD_PROTOCOL_VERSION, SSL_R_WRONG_SSL_VERSION);
         return 0;
@@ -2384,23 +2388,25 @@ int ssl_choose_client_version(SSL_CONNECTION *s, int version,
     if (!SSL_CONNECTION_IS_DTLS(s) && real_max > s->version) {
         /* Signal applies to all versions */
         if (memcmp(tls11downgrade,
-                   s->s3.server_random + SSL3_RANDOM_SIZE
-                   - sizeof(tls11downgrade),
-                   sizeof(tls11downgrade)) == 0) {
+                s->s3.server_random + SSL3_RANDOM_SIZE
+                    - sizeof(tls11downgrade),
+                sizeof(tls11downgrade))
+            == 0) {
             s->version = origv;
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                     SSL_R_INAPPROPRIATE_FALLBACK);
+                SSL_R_INAPPROPRIATE_FALLBACK);
             return 0;
         }
         /* Only when accepting TLS1.3 */
         if (real_max == TLS1_3_VERSION
             && memcmp(tls12downgrade,
-                      s->s3.server_random + SSL3_RANDOM_SIZE
-                      - sizeof(tls12downgrade),
-                      sizeof(tls12downgrade)) == 0) {
+                   s->s3.server_random + SSL3_RANDOM_SIZE
+                       - sizeof(tls12downgrade),
+                   sizeof(tls12downgrade))
+                == 0) {
             s->version = origv;
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                     SSL_R_INAPPROPRIATE_FALLBACK);
+                SSL_R_INAPPROPRIATE_FALLBACK);
             return 0;
         }
     }
@@ -2445,7 +2451,7 @@ int ssl_choose_client_version(SSL_CONNECTION *s, int version,
  * min_version and max_version will also be set to 0.
  */
 int ssl_get_min_max_version(const SSL_CONNECTION *s, int *min_version,
-                            int *max_version, int *real_max)
+    int *max_version, int *real_max)
 {
     int version, tmp_real_max;
     int hole;
@@ -2596,7 +2602,7 @@ int ssl_set_client_hello_version(SSL_CONNECTION *s)
  * where the group was found.
  */
 int check_in_list(SSL_CONNECTION *s, uint16_t group_id, const uint16_t *groups,
-                  size_t num_groups, int checkallow, size_t *pos)
+    size_t num_groups, int checkallow, size_t *pos)
 {
     size_t i;
 
@@ -2607,8 +2613,8 @@ int check_in_list(SSL_CONNECTION *s, uint16_t group_id, const uint16_t *groups,
         uint16_t group = groups[i];
 
         if (group_id == group
-                && (!checkallow
-                    || tls_group_allowed(s, group, SSL_SECOP_CURVE_CHECK))) {
+            && (!checkallow
+                || tls_group_allowed(s, group, SSL_SECOP_CURVE_CHECK))) {
             if (pos != NULL)
                 *pos = i;
             return 1;
@@ -2620,9 +2626,9 @@ int check_in_list(SSL_CONNECTION *s, uint16_t group_id, const uint16_t *groups,
 
 /* Replace ClientHello1 in the transcript hash with a synthetic message */
 int create_synthetic_message_hash(SSL_CONNECTION *s,
-                                  const unsigned char *hashval,
-                                  size_t hashlen, const unsigned char *hrr,
-                                  size_t hrrlen)
+    const unsigned char *hashval,
+    size_t hashlen, const unsigned char *hrr,
+    size_t hrrlen)
 {
     unsigned char hashvaltmp[EVP_MAX_MD_SIZE];
     unsigned char msghdr[SSL3_HM_HEADER_LENGTH];
@@ -2634,8 +2640,8 @@ int create_synthetic_message_hash(SSL_CONNECTION *s,
         hashlen = 0;
         /* Get the hash of the initial ClientHello */
         if (!ssl3_digest_cached_records(s, 0)
-                || !ssl_handshake_hash(s, hashvaltmp, sizeof(hashvaltmp),
-                                       &hashlen)) {
+            || !ssl_handshake_hash(s, hashvaltmp, sizeof(hashvaltmp),
+                &hashlen)) {
             /* SSLfatal() already called */
             return 0;
         }
@@ -2651,7 +2657,7 @@ int create_synthetic_message_hash(SSL_CONNECTION *s,
     msghdr[0] = SSL3_MT_MESSAGE_HASH;
     msghdr[SSL3_HM_HEADER_LENGTH - 1] = (unsigned char)hashlen;
     if (!ssl3_finish_mac(s, msghdr, SSL3_HM_HEADER_LENGTH)
-            || !ssl3_finish_mac(s, hashval, hashlen)) {
+        || !ssl3_finish_mac(s, hashval, hashlen)) {
         /* SSLfatal() already called */
         return 0;
     }
@@ -2662,10 +2668,10 @@ int create_synthetic_message_hash(SSL_CONNECTION *s,
      * receiving a ClientHello2 with a cookie.
      */
     if (hrr != NULL
-            && (!ssl3_finish_mac(s, hrr, hrrlen)
-                || !ssl3_finish_mac(s, (unsigned char *)s->init_buf->data,
-                                    s->s3.tmp.message_size
-                                    + SSL3_HM_HEADER_LENGTH))) {
+        && (!ssl3_finish_mac(s, hrr, hrrlen)
+            || !ssl3_finish_mac(s, (unsigned char *)s->init_buf->data,
+                s->s3.tmp.message_size
+                    + SSL3_HM_HEADER_LENGTH))) {
         /* SSLfatal() already called */
         return 0;
     }
@@ -2726,7 +2732,7 @@ int parse_ca_names(SSL_CONNECTION *s, PACKET *pkt)
 
     return 1;
 
- err:
+err:
     sk_X509_NAME_pop_free(ca_sk, X509_NAME_free);
     X509_NAME_free(xn);
     return 0;
@@ -2750,7 +2756,7 @@ const STACK_OF(X509_NAME) *get_ca_names(SSL_CONNECTION *s)
 }
 
 int construct_ca_names(SSL_CONNECTION *s, const STACK_OF(X509_NAME) *ca_sk,
-                       WPACKET *pkt)
+    WPACKET *pkt)
 {
     /* Start sub-packet for client CA list */
     if (!WPACKET_start_sub_packet_u16(pkt)) {
@@ -2767,10 +2773,10 @@ int construct_ca_names(SSL_CONNECTION *s, const STACK_OF(X509_NAME) *ca_sk,
             int namelen;
 
             if (name == NULL
-                    || (namelen = i2d_X509_NAME(name, NULL)) < 0
-                    || !WPACKET_sub_allocate_bytes_u16(pkt, namelen,
-                                                       &namebytes)
-                    || i2d_X509_NAME(name, &namebytes) != namelen) {
+                || (namelen = i2d_X509_NAME(name, NULL)) < 0
+                || !WPACKET_sub_allocate_bytes_u16(pkt, namelen,
+                    &namebytes)
+                || i2d_X509_NAME(name, &namebytes) != namelen) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 return 0;
             }
@@ -2787,7 +2793,7 @@ int construct_ca_names(SSL_CONNECTION *s, const STACK_OF(X509_NAME) *ca_sk,
 
 /* Create a buffer containing data to be signed for server key exchange */
 size_t construct_key_exchange_tbs(SSL_CONNECTION *s, unsigned char **ptbs,
-                                  const void *param, size_t paramlen)
+    const void *param, size_t paramlen)
 {
     size_t tbslen = 2 * SSL3_RANDOM_SIZE + paramlen;
     unsigned char *tbs = OPENSSL_malloc(tbslen);
@@ -2822,7 +2828,7 @@ int tls13_save_handshake_digest_for_pha(SSL_CONNECTION *s)
             return 0;
         }
         if (!EVP_MD_CTX_copy_ex(s->pha_dgst,
-                                s->s3.handshake_dgst)) {
+                s->s3.handshake_dgst)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             EVP_MD_CTX_free(s->pha_dgst);
             s->pha_dgst = NULL;
@@ -2843,7 +2849,7 @@ int tls13_restore_handshake_digest_for_pha(SSL_CONNECTION *s)
         return 0;
     }
     if (!EVP_MD_CTX_copy_ex(s->s3.handshake_dgst,
-                            s->pha_dgst)) {
+            s->pha_dgst)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
@@ -2852,9 +2858,9 @@ int tls13_restore_handshake_digest_for_pha(SSL_CONNECTION *s)
 
 #ifndef OPENSSL_NO_COMP_ALG
 MSG_PROCESS_RETURN tls13_process_compressed_certificate(SSL_CONNECTION *sc,
-                                                        PACKET *pkt,
-                                                        PACKET *tmppkt,
-                                                        BUF_MEM *buf)
+    PACKET *pkt,
+    PACKET *tmppkt,
+    BUF_MEM *buf)
 {
     MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR;
     int comp_alg;
@@ -2869,7 +2875,7 @@ MSG_PROCESS_RETURN tls13_process_compressed_certificate(SSL_CONNECTION *sc,
         SSLfatal(sc, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
-    if (!PACKET_get_net_2(pkt, (unsigned int*)&comp_alg)) {
+    if (!PACKET_get_net_2(pkt, (unsigned int *)&comp_alg)) {
         SSLfatal(sc, SSL_AD_BAD_CERTIFICATE, ERR_R_INTERNAL_ERROR);
         goto err;
     }
@@ -2914,7 +2920,7 @@ MSG_PROCESS_RETURN tls13_process_compressed_certificate(SSL_CONNECTION *sc,
 
     /* Prevent excessive pre-decompression allocation */
     if (expected_length > sc->max_cert_list) {
-        SSLfatal(sc, SSL_AD_ILLEGAL_PARAMETER, SSL_R_EXCESSIVE_MESSAGE_SIZE);
+        SSLfatal(sc, SSL_AD_BAD_CERTIFICATE, SSL_R_EXCESSIVE_MESSAGE_SIZE);
         goto err;
     }
 
@@ -2926,12 +2932,13 @@ MSG_PROCESS_RETURN tls13_process_compressed_certificate(SSL_CONNECTION *sc,
     if (!BUF_MEM_grow(buf, expected_length)
         || !PACKET_buf_init(tmppkt, (unsigned char *)buf->data, expected_length)
         || COMP_expand_block(comp, (unsigned char *)buf->data, expected_length,
-                             (unsigned char*)PACKET_data(pkt), comp_length) != (int)expected_length) {
+               (unsigned char *)PACKET_data(pkt), comp_length)
+            != (int)expected_length) {
         SSLfatal(sc, SSL_AD_BAD_CERTIFICATE, SSL_R_BAD_DECOMPRESSION);
         goto err;
     }
     ret = MSG_PROCESS_CONTINUE_PROCESSING;
- err:
+err:
     COMP_CTX_free(comp);
     return ret;
 }
diff --git a/crypto/openssl/ssl/statem/statem_local.h b/crypto/openssl/ssl/statem/statem_local.h
index 352f9b8cec7a..e1d57eb8c646 100644
--- a/crypto/openssl/ssl/statem/statem_local.h
+++ b/crypto/openssl/ssl/statem/statem_local.h
@@ -18,31 +18,31 @@
 
 /* The spec allows for a longer length than this, but we limit it */
 #define HELLO_VERIFY_REQUEST_MAX_LENGTH 258
-#define END_OF_EARLY_DATA_MAX_LENGTH    0
-#define HELLO_RETRY_REQUEST_MAX_LENGTH  20000
+#define END_OF_EARLY_DATA_MAX_LENGTH 0
+#define HELLO_RETRY_REQUEST_MAX_LENGTH 20000
 #define ENCRYPTED_EXTENSIONS_MAX_LENGTH 20000
 #define SESSION_TICKET_MAX_LENGTH_TLS13 131338
 #define SESSION_TICKET_MAX_LENGTH_TLS12 65541
-#define SERVER_KEY_EXCH_MAX_LENGTH      102400
-#define SERVER_HELLO_DONE_MAX_LENGTH    0
-#define KEY_UPDATE_MAX_LENGTH           1
-#define CCS_MAX_LENGTH                  1
+#define SERVER_KEY_EXCH_MAX_LENGTH 102400
+#define SERVER_HELLO_DONE_MAX_LENGTH 0
+#define KEY_UPDATE_MAX_LENGTH 1
+#define CCS_MAX_LENGTH 1
 
 /* Max ServerHello size permitted by RFC 8446 */
-#define SERVER_HELLO_MAX_LENGTH         65607
+#define SERVER_HELLO_MAX_LENGTH 65607
 
 /* Max CertificateVerify size permitted by RFC 8446 */
-#define CERTIFICATE_VERIFY_MAX_LENGTH   65539
+#define CERTIFICATE_VERIFY_MAX_LENGTH 65539
 
 /* Max should actually be 36 but we are generous */
-#define FINISHED_MAX_LENGTH             64
+#define FINISHED_MAX_LENGTH 64
 
 /* Dummy message type */
-#define SSL3_MT_DUMMY   -1
+#define SSL3_MT_DUMMY -1
 
 /* Invalid extension ID for non-supported extensions */
-#define TLSEXT_TYPE_invalid            0x10000
-#define TLSEXT_TYPE_out_of_range       0x10001
+#define TLSEXT_TYPE_invalid 0x10000
+#define TLSEXT_TYPE_out_of_range 0x10001
 unsigned int ossl_get_extension_type(size_t idx);
 
 extern const unsigned char hrrrandom[];
@@ -62,21 +62,21 @@ typedef enum {
     MSG_PROCESS_CONTINUE_READING
 } MSG_PROCESS_RETURN;
 
-typedef CON_FUNC_RETURN (*confunc_f) (SSL_CONNECTION *s, WPACKET *pkt);
+typedef CON_FUNC_RETURN (*confunc_f)(SSL_CONNECTION *s, WPACKET *pkt);
 
 int ssl3_take_mac(SSL_CONNECTION *s);
 int check_in_list(SSL_CONNECTION *s, uint16_t group_id, const uint16_t *groups,
-                  size_t num_groups, int checkallow, size_t *pos);
+    size_t num_groups, int checkallow, size_t *pos);
 int create_synthetic_message_hash(SSL_CONNECTION *s,
-                                  const unsigned char *hashval,
-                                  size_t hashlen, const unsigned char *hrr,
-                                  size_t hrrlen);
+    const unsigned char *hashval,
+    size_t hashlen, const unsigned char *hrr,
+    size_t hrrlen);
 int parse_ca_names(SSL_CONNECTION *s, PACKET *pkt);
 const STACK_OF(X509_NAME) *get_ca_names(SSL_CONNECTION *s);
 int construct_ca_names(SSL_CONNECTION *s, const STACK_OF(X509_NAME) *ca_sk,
-                       WPACKET *pkt);
+    WPACKET *pkt);
 size_t construct_key_exchange_tbs(SSL_CONNECTION *s, unsigned char **ptbs,
-                                  const void *param, size_t paramlen);
+    const void *param, size_t paramlen);
 
 /*
  * TLS/DTLS client state machine functions
@@ -86,12 +86,12 @@ WRITE_TRAN ossl_statem_client_write_transition(SSL_CONNECTION *s);
 WORK_STATE ossl_statem_client_pre_work(SSL_CONNECTION *s, WORK_STATE wst);
 WORK_STATE ossl_statem_client_post_work(SSL_CONNECTION *s, WORK_STATE wst);
 int ossl_statem_client_construct_message(SSL_CONNECTION *s,
-                                         confunc_f *confunc, int *mt);
+    confunc_f *confunc, int *mt);
 size_t ossl_statem_client_max_message_size(SSL_CONNECTION *s);
 MSG_PROCESS_RETURN ossl_statem_client_process_message(SSL_CONNECTION *s,
-                                                      PACKET *pkt);
+    PACKET *pkt);
 WORK_STATE ossl_statem_client_post_process_message(SSL_CONNECTION *s,
-                                                   WORK_STATE wst);
+    WORK_STATE wst);
 
 /*
  * TLS/DTLS server state machine functions
@@ -101,12 +101,12 @@ WRITE_TRAN ossl_statem_server_write_transition(SSL_CONNECTION *s);
 WORK_STATE ossl_statem_server_pre_work(SSL_CONNECTION *s, WORK_STATE wst);
 WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION *s, WORK_STATE wst);
 int ossl_statem_server_construct_message(SSL_CONNECTION *s,
-                                         confunc_f *confunc,int *mt);
+    confunc_f *confunc, int *mt);
 size_t ossl_statem_server_max_message_size(SSL_CONNECTION *s);
 MSG_PROCESS_RETURN ossl_statem_server_process_message(SSL_CONNECTION *s,
-                                                      PACKET *pkt);
+    PACKET *pkt);
 WORK_STATE ossl_statem_server_post_process_message(SSL_CONNECTION *s,
-                                                   WORK_STATE wst);
+    WORK_STATE wst);
 
 /* Functions for getting new message data */
 __owur int tls_get_message_header(SSL_CONNECTION *s, int *mt);
@@ -117,76 +117,76 @@ __owur int dtls_get_message_body(SSL_CONNECTION *s, size_t *len);
 /* Message construction and processing functions */
 __owur int tls_process_initial_server_flight(SSL_CONNECTION *s);
 __owur MSG_PROCESS_RETURN tls_process_change_cipher_spec(SSL_CONNECTION *s,
-                                                         PACKET *pkt);
+    PACKET *pkt);
 __owur MSG_PROCESS_RETURN tls_process_finished(SSL_CONNECTION *s, PACKET *pkt);
-__owur CON_FUNC_RETURN  tls_construct_change_cipher_spec(SSL_CONNECTION *s,
-                                                         WPACKET *pkt);
+__owur CON_FUNC_RETURN tls_construct_change_cipher_spec(SSL_CONNECTION *s,
+    WPACKET *pkt);
 __owur CON_FUNC_RETURN dtls_construct_change_cipher_spec(SSL_CONNECTION *s,
-                                                         WPACKET *pkt);
+    WPACKET *pkt);
 
 __owur CON_FUNC_RETURN tls_construct_finished(SSL_CONNECTION *s, WPACKET *pkt);
 __owur CON_FUNC_RETURN tls_construct_key_update(SSL_CONNECTION *s, WPACKET *pkt);
 __owur MSG_PROCESS_RETURN tls_process_key_update(SSL_CONNECTION *s,
-                                                 PACKET *pkt);
+    PACKET *pkt);
 __owur WORK_STATE tls_finish_handshake(SSL_CONNECTION *s, WORK_STATE wst,
-                                       int clearbufs, int stop);
+    int clearbufs, int stop);
 __owur WORK_STATE dtls_wait_for_dry(SSL_CONNECTION *s);
 
 #ifndef OPENSSL_NO_COMP_ALG
 __owur MSG_PROCESS_RETURN tls13_process_compressed_certificate(SSL_CONNECTION *sc,
-                                                               PACKET *pkt,
-                                                               PACKET *tmppkt,
-                                                               BUF_MEM *buf);
+    PACKET *pkt,
+    PACKET *tmppkt,
+    BUF_MEM *buf);
 #endif
 
 /* some client-only functions */
 __owur CON_FUNC_RETURN tls_construct_client_hello(SSL_CONNECTION *s,
-                                                  WPACKET *pkt);
+    WPACKET *pkt);
 __owur MSG_PROCESS_RETURN tls_process_server_hello(SSL_CONNECTION *s,
-                                                   PACKET *pkt);
+    PACKET *pkt);
 __owur MSG_PROCESS_RETURN tls_process_certificate_request(SSL_CONNECTION *s,
-                                                          PACKET *pkt);
+    PACKET *pkt);
 __owur MSG_PROCESS_RETURN tls_process_new_session_ticket(SSL_CONNECTION *s,
-                                                         PACKET *pkt);
+    PACKET *pkt);
 __owur int tls_process_cert_status_body(SSL_CONNECTION *s, PACKET *pkt);
 __owur MSG_PROCESS_RETURN tls_process_cert_status(SSL_CONNECTION *s,
-                                                  PACKET *pkt);
+    PACKET *pkt);
 __owur MSG_PROCESS_RETURN tls_process_server_done(SSL_CONNECTION *s,
-                                                  PACKET *pkt);
+    PACKET *pkt);
 __owur CON_FUNC_RETURN tls_construct_cert_verify(SSL_CONNECTION *s,
-                                                 WPACKET *pkt);
+    WPACKET *pkt);
 __owur WORK_STATE tls_prepare_client_certificate(SSL_CONNECTION *s,
-                                                 WORK_STATE wst);
+    WORK_STATE wst);
 __owur CON_FUNC_RETURN tls_construct_client_certificate(SSL_CONNECTION *s,
-                                                        WPACKET *pkt);
+    WPACKET *pkt);
 #ifndef OPENSSL_NO_COMP_ALG
 __owur CON_FUNC_RETURN tls_construct_client_compressed_certificate(SSL_CONNECTION *sc,
-                                                                   WPACKET *pkt);
+    WPACKET *pkt);
 #endif
 __owur int ssl_do_client_cert_cb(SSL_CONNECTION *s, X509 **px509,
-                                 EVP_PKEY **ppkey);
+    EVP_PKEY **ppkey);
 __owur CON_FUNC_RETURN tls_construct_client_key_exchange(SSL_CONNECTION *s,
-                                                         WPACKET *pkt);
+    WPACKET *pkt);
 __owur int tls_client_key_exchange_post_work(SSL_CONNECTION *s);
 __owur int tls_construct_cert_status_body(SSL_CONNECTION *s, WPACKET *pkt);
 __owur CON_FUNC_RETURN tls_construct_cert_status(SSL_CONNECTION *s,
-                                                 WPACKET *pkt);
+    WPACKET *pkt);
 __owur MSG_PROCESS_RETURN tls_process_key_exchange(SSL_CONNECTION *s,
-                                                   PACKET *pkt);
+    PACKET *pkt);
 __owur MSG_PROCESS_RETURN tls_process_server_rpk(SSL_CONNECTION *sc,
-                                                 PACKET *pkt);
+    PACKET *pkt);
 __owur MSG_PROCESS_RETURN tls_process_client_rpk(SSL_CONNECTION *sc,
-                                                 PACKET *pkt);
+    PACKET *pkt);
 __owur unsigned long tls_output_rpk(SSL_CONNECTION *sc, WPACKET *pkt,
-                                    CERT_PKEY *cpk);
+    CERT_PKEY *cpk);
 __owur int tls_process_rpk(SSL_CONNECTION *s, PACKET *pkt, EVP_PKEY **peer_rpk);
 __owur MSG_PROCESS_RETURN tls_process_server_certificate(SSL_CONNECTION *s,
-                                                         PACKET *pkt);
+    PACKET *pkt);
 __owur WORK_STATE tls_post_process_server_certificate(SSL_CONNECTION *s,
-                                                      WORK_STATE wst);
+    WORK_STATE wst);
 #ifndef OPENSSL_NO_COMP_ALG
 __owur MSG_PROCESS_RETURN tls_process_server_compressed_certificate(SSL_CONNECTION *sc,
-                                                                    PACKET *pkt);
+    PACKET *pkt);
 #endif
 __owur int ssl3_check_cert_and_algorithm(SSL_CONNECTION *s);
 #ifndef OPENSSL_NO_NEXTPROTONEG
@@ -195,49 +195,49 @@ __owur CON_FUNC_RETURN tls_construct_next_proto(SSL_CONNECTION *s, WPACKET *pkt)
 __owur MSG_PROCESS_RETURN tls_process_hello_req(SSL_CONNECTION *s, PACKET *pkt);
 __owur MSG_PROCESS_RETURN dtls_process_hello_verify(SSL_CONNECTION *s, PACKET *pkt);
 __owur CON_FUNC_RETURN tls_construct_end_of_early_data(SSL_CONNECTION *s,
-                                                       WPACKET *pkt);
+    WPACKET *pkt);
 
 /* some server-only functions */
 __owur MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION *s,
-                                                   PACKET *pkt);
+    PACKET *pkt);
 __owur WORK_STATE tls_post_process_client_hello(SSL_CONNECTION *s,
-                                                WORK_STATE wst);
+    WORK_STATE wst);
 __owur CON_FUNC_RETURN tls_construct_server_hello(SSL_CONNECTION *s,
-                                                  WPACKET *pkt);
+    WPACKET *pkt);
 __owur CON_FUNC_RETURN dtls_construct_hello_verify_request(SSL_CONNECTION *s,
-                                                           WPACKET *pkt);
+    WPACKET *pkt);
 __owur CON_FUNC_RETURN tls_construct_server_certificate(SSL_CONNECTION *s,
-                                                        WPACKET *pkt);
+    WPACKET *pkt);
 #ifndef OPENSSL_NO_COMP_ALG
 __owur CON_FUNC_RETURN tls_construct_server_compressed_certificate(SSL_CONNECTION *sc,
-                                                                   WPACKET *pkt);
+    WPACKET *pkt);
 #endif
 __owur CON_FUNC_RETURN tls_construct_server_key_exchange(SSL_CONNECTION *s,
-                                                         WPACKET *pkt);
+    WPACKET *pkt);
 __owur CON_FUNC_RETURN tls_construct_certificate_request(SSL_CONNECTION *s,
-                                                         WPACKET *pkt);
+    WPACKET *pkt);
 __owur CON_FUNC_RETURN tls_construct_server_done(SSL_CONNECTION *s,
-                                                 WPACKET *pkt);
+    WPACKET *pkt);
 __owur MSG_PROCESS_RETURN tls_process_client_certificate(SSL_CONNECTION *s,
-                                                         PACKET *pkt);
+    PACKET *pkt);
 #ifndef OPENSSL_NO_COMP_ALG
 __owur MSG_PROCESS_RETURN tls_process_client_compressed_certificate(SSL_CONNECTION *sc,
-                                                                    PACKET *pkt);
+    PACKET *pkt);
 #endif
 __owur MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL_CONNECTION *s,
-                                                          PACKET *pkt);
+    PACKET *pkt);
 __owur WORK_STATE tls_post_process_client_key_exchange(SSL_CONNECTION *s,
-                                                       WORK_STATE wst);
+    WORK_STATE wst);
 __owur MSG_PROCESS_RETURN tls_process_cert_verify(SSL_CONNECTION *s,
-                                                  PACKET *pkt);
+    PACKET *pkt);
 #ifndef OPENSSL_NO_NEXTPROTONEG
 __owur MSG_PROCESS_RETURN tls_process_next_proto(SSL_CONNECTION *s,
-                                                 PACKET *pkt);
+    PACKET *pkt);
 #endif
 __owur CON_FUNC_RETURN tls_construct_new_session_ticket(SSL_CONNECTION *s,
-                                                        WPACKET *pkt);
+    WPACKET *pkt);
 MSG_PROCESS_RETURN tls_process_end_of_early_data(SSL_CONNECTION *s,
-                                                 PACKET *pkt);
+    PACKET *pkt);
 
 #ifndef OPENSSL_NO_GOST
 /* These functions are used in GOST18 CKE, both for client and server */
@@ -254,319 +254,319 @@ typedef enum ext_return_en {
 } EXT_RETURN;
 
 __owur int tls_validate_all_contexts(SSL_CONNECTION *s, unsigned int thisctx,
-                                     RAW_EXTENSION *exts);
+    RAW_EXTENSION *exts);
 __owur int extension_is_relevant(SSL_CONNECTION *s, unsigned int extctx,
-                                 unsigned int thisctx);
+    unsigned int thisctx);
 __owur int tls_collect_extensions(SSL_CONNECTION *s, PACKET *packet,
-                                  unsigned int context,
-                                  RAW_EXTENSION **res, size_t *len, int init);
+    unsigned int context,
+    RAW_EXTENSION **res, size_t *len, int init);
 __owur int tls_parse_extension(SSL_CONNECTION *s, TLSEXT_INDEX idx, int context,
-                               RAW_EXTENSION *exts,  X509 *x, size_t chainidx);
+    RAW_EXTENSION *exts, X509 *x, size_t chainidx);
 __owur int tls_parse_all_extensions(SSL_CONNECTION *s, int context,
-                                    RAW_EXTENSION *exts,
-                                    X509 *x, size_t chainidx, int fin);
+    RAW_EXTENSION *exts,
+    X509 *x, size_t chainidx, int fin);
 __owur int should_add_extension(SSL_CONNECTION *s, unsigned int extctx,
-                                unsigned int thisctx, int max_version);
+    unsigned int thisctx, int max_version);
 __owur int tls_construct_extensions(SSL_CONNECTION *s, WPACKET *pkt,
-                                    unsigned int context,
-                                    X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 
 __owur int tls_psk_do_binder(SSL_CONNECTION *s, const EVP_MD *md,
-                             const unsigned char *msgstart,
-                             size_t binderoffset, const unsigned char *binderin,
-                             unsigned char *binderout,
-                             SSL_SESSION *sess, int sign, int external);
+    const unsigned char *msgstart,
+    size_t binderoffset, const unsigned char *binderin,
+    unsigned char *binderout,
+    SSL_SESSION *sess, int sign, int external);
 
 /* Server Extension processing */
 int tls_parse_ctos_renegotiate(SSL_CONNECTION *s, PACKET *pkt,
-                               unsigned int context,
-                               X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_ctos_server_name(SSL_CONNECTION *s, PACKET *pkt,
-                               unsigned int context,
-                               X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_ctos_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 #ifndef OPENSSL_NO_SRP
 int tls_parse_ctos_srp(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx);
+    X509 *x, size_t chainidx);
 #endif
 int tls_parse_ctos_early_data(SSL_CONNECTION *s, PACKET *pkt,
-                              unsigned int context,
-                              X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_ctos_ec_pt_formats(SSL_CONNECTION *s, PACKET *pkt,
-                                 unsigned int context,
-                                 X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_ctos_supported_groups(SSL_CONNECTION *s, PACKET *pkt,
-                                    unsigned int context,
-                                    X509 *x, size_t chainidxl);
+    unsigned int context,
+    X509 *x, size_t chainidxl);
 int tls_parse_ctos_session_ticket(SSL_CONNECTION *s, PACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_ctos_sig_algs_cert(SSL_CONNECTION *s, PACKET *pkt,
-                                 unsigned int context,
-                                 X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_ctos_sig_algs(SSL_CONNECTION *s, PACKET *pkt,
-                            unsigned int context, X509 *x, size_t chainidx);
+    unsigned int context, X509 *x, size_t chainidx);
 #ifndef OPENSSL_NO_OCSP
 int tls_parse_ctos_status_request(SSL_CONNECTION *s, PACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 #endif
 #ifndef OPENSSL_NO_NEXTPROTONEG
 int tls_parse_ctos_npn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx);
+    X509 *x, size_t chainidx);
 #endif
 int tls_parse_ctos_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                        X509 *x, size_t chainidx);
+    X509 *x, size_t chainidx);
 #ifndef OPENSSL_NO_SRTP
 int tls_parse_ctos_use_srtp(SSL_CONNECTION *s, PACKET *pkt,
-                            unsigned int context, X509 *x, size_t chainidx);
+    unsigned int context, X509 *x, size_t chainidx);
 #endif
 int tls_parse_ctos_etm(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx);
+    X509 *x, size_t chainidx);
 int tls_parse_ctos_key_share(SSL_CONNECTION *s, PACKET *pkt,
-                             unsigned int context, X509 *x, size_t chainidx);
+    unsigned int context, X509 *x, size_t chainidx);
 int tls_parse_ctos_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                          X509 *x, size_t chainidx);
+    X509 *x, size_t chainidx);
 int tls_parse_ctos_ems(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx);
+    X509 *x, size_t chainidx);
 int tls_parse_ctos_psk_kex_modes(SSL_CONNECTION *s, PACKET *pkt,
-                                 unsigned int context,
-                                 X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_ctos_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx);
+    X509 *x, size_t chainidx);
 int tls_parse_ctos_post_handshake_auth(SSL_CONNECTION *, PACKET *pkt,
-                                       unsigned int context,
-                                       X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 
 EXT_RETURN tls_construct_stoc_renegotiate(SSL_CONNECTION *s, WPACKET *pkt,
-                                          unsigned int context, X509 *x,
-                                          size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 EXT_RETURN tls_construct_stoc_server_name(SSL_CONNECTION *s, WPACKET *pkt,
-                                          unsigned int context, X509 *x,
-                                          size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 EXT_RETURN tls_construct_stoc_early_data(SSL_CONNECTION *s, WPACKET *pkt,
-                                         unsigned int context, X509 *x,
-                                         size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 EXT_RETURN tls_construct_stoc_maxfragmentlen(SSL_CONNECTION *s, WPACKET *pkt,
-                                             unsigned int context, X509 *x,
-                                             size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 EXT_RETURN tls_construct_stoc_ec_pt_formats(SSL_CONNECTION *s, WPACKET *pkt,
-                                            unsigned int context, X509 *x,
-                                            size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 EXT_RETURN tls_construct_stoc_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
-                                               unsigned int context, X509 *x,
-                                               size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 EXT_RETURN tls_construct_stoc_session_ticket(SSL_CONNECTION *s, WPACKET *pkt,
-                                             unsigned int context, X509 *x,
-                                             size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 #ifndef OPENSSL_NO_OCSP
 EXT_RETURN tls_construct_stoc_status_request(SSL_CONNECTION *s, WPACKET *pkt,
-                                             unsigned int context, X509 *x,
-                                             size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 #endif
 #ifndef OPENSSL_NO_NEXTPROTONEG
 EXT_RETURN tls_construct_stoc_next_proto_neg(SSL_CONNECTION *s, WPACKET *pkt,
-                                             unsigned int context, X509 *x,
-                                             size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 #endif
 EXT_RETURN tls_construct_stoc_alpn(SSL_CONNECTION *s, WPACKET *pkt,
-                                   unsigned int context,
-                                   X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 #ifndef OPENSSL_NO_SRTP
 EXT_RETURN tls_construct_stoc_use_srtp(SSL_CONNECTION *s, WPACKET *pkt,
-                                       unsigned int context,
-                                       X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 #endif
 EXT_RETURN tls_construct_stoc_etm(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 EXT_RETURN tls_construct_stoc_ems(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 EXT_RETURN tls_construct_stoc_supported_versions(SSL_CONNECTION *s, WPACKET *pkt,
-                                                 unsigned int context, X509 *x,
-                                                 size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 EXT_RETURN tls_construct_stoc_key_share(SSL_CONNECTION *s, WPACKET *pkt,
-                                        unsigned int context, X509 *x,
-                                        size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 EXT_RETURN tls_construct_stoc_cookie(SSL_CONNECTION *s, WPACKET *pkt,
-                                     unsigned int context,
-                                     X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 /*
  * Not in public headers as this is not an official extension. Only used when
  * SSL_OP_CRYPTOPRO_TLSEXT_BUG is set.
  */
-#define TLSEXT_TYPE_cryptopro_bug      0xfde8
+#define TLSEXT_TYPE_cryptopro_bug 0xfde8
 EXT_RETURN tls_construct_stoc_cryptopro_bug(SSL_CONNECTION *s, WPACKET *pkt,
-                                            unsigned int context, X509 *x,
-                                            size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 EXT_RETURN tls_construct_stoc_psk(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 
 /* Client Extension processing */
 EXT_RETURN tls_construct_ctos_renegotiate(SSL_CONNECTION *s, WPACKET *pkt,
-                                          unsigned int context,
-                                          X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 EXT_RETURN tls_construct_ctos_server_name(SSL_CONNECTION *s, WPACKET *pkt,
-                                          unsigned int context,
-                                          X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 EXT_RETURN tls_construct_ctos_maxfragmentlen(SSL_CONNECTION *s, WPACKET *pkt,
-                                             unsigned int context,
-                                             X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 #ifndef OPENSSL_NO_SRP
 EXT_RETURN tls_construct_ctos_srp(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context, X509 *x,
-                                  size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 #endif
 EXT_RETURN tls_construct_ctos_ec_pt_formats(SSL_CONNECTION *s, WPACKET *pkt,
-                                            unsigned int context, X509 *x,
-                                            size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 EXT_RETURN tls_construct_ctos_supported_groups(SSL_CONNECTION *s, WPACKET *pkt,
-                                               unsigned int context, X509 *x,
-                                               size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 
 EXT_RETURN tls_construct_ctos_early_data(SSL_CONNECTION *s, WPACKET *pkt,
-                                         unsigned int context, X509 *x,
-                                         size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 EXT_RETURN tls_construct_ctos_session_ticket(SSL_CONNECTION *s, WPACKET *pkt,
-                                             unsigned int context, X509 *x,
-                                             size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 EXT_RETURN tls_construct_ctos_sig_algs(SSL_CONNECTION *s, WPACKET *pkt,
-                                       unsigned int context, X509 *x,
-                                       size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 #ifndef OPENSSL_NO_OCSP
 EXT_RETURN tls_construct_ctos_status_request(SSL_CONNECTION *s, WPACKET *pkt,
-                                             unsigned int context, X509 *x,
-                                             size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 #endif
 #ifndef OPENSSL_NO_NEXTPROTONEG
 EXT_RETURN tls_construct_ctos_npn(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 #endif
 EXT_RETURN tls_construct_ctos_alpn(SSL_CONNECTION *s, WPACKET *pkt,
-                                   unsigned int context,
-                                   X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 #ifndef OPENSSL_NO_SRTP
 EXT_RETURN tls_construct_ctos_use_srtp(SSL_CONNECTION *s, WPACKET *pkt,
-                                       unsigned int context,
-                                       X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 #endif
 EXT_RETURN tls_construct_ctos_etm(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 #ifndef OPENSSL_NO_CT
 EXT_RETURN tls_construct_ctos_sct(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 #endif
 EXT_RETURN tls_construct_ctos_ems(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 EXT_RETURN tls_construct_ctos_supported_versions(SSL_CONNECTION *s, WPACKET *pkt,
-                                                 unsigned int context, X509 *x,
-                                                 size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 EXT_RETURN tls_construct_ctos_key_share(SSL_CONNECTION *s, WPACKET *pkt,
-                                        unsigned int context, X509 *x,
-                                        size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 EXT_RETURN tls_construct_ctos_psk_kex_modes(SSL_CONNECTION *s, WPACKET *pkt,
-                                            unsigned int context, X509 *x,
-                                            size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 EXT_RETURN tls_construct_ctos_cookie(SSL_CONNECTION *s, WPACKET *pkt,
-                                     unsigned int context,
-                                     X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 EXT_RETURN tls_construct_ctos_padding(SSL_CONNECTION *s, WPACKET *pkt,
-                                      unsigned int context, X509 *x,
-                                      size_t chainidx);
+    unsigned int context, X509 *x,
+    size_t chainidx);
 EXT_RETURN tls_construct_ctos_psk(SSL_CONNECTION *s, WPACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 EXT_RETURN tls_construct_ctos_post_handshake_auth(SSL_CONNECTION *s, WPACKET *pkt,
-                                                  unsigned int context,
-                                                  X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 
 int tls_parse_stoc_renegotiate(SSL_CONNECTION *s, PACKET *pkt,
-                               unsigned int context,
-                               X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_stoc_server_name(SSL_CONNECTION *s, PACKET *pkt,
-                               unsigned int context,
-                               X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_stoc_early_data(SSL_CONNECTION *s, PACKET *pkt,
-                              unsigned int context,
-                              X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_stoc_maxfragmentlen(SSL_CONNECTION *s, PACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_stoc_ec_pt_formats(SSL_CONNECTION *s, PACKET *pkt,
-                                 unsigned int context,
-                                 X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_stoc_session_ticket(SSL_CONNECTION *s, PACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 #ifndef OPENSSL_NO_OCSP
 int tls_parse_stoc_status_request(SSL_CONNECTION *s, PACKET *pkt,
-                                  unsigned int context,
-                                  X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 #endif
 #ifndef OPENSSL_NO_CT
 int tls_parse_stoc_sct(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx);
+    X509 *x, size_t chainidx);
 #endif
 #ifndef OPENSSL_NO_NEXTPROTONEG
 int tls_parse_stoc_npn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx);
+    X509 *x, size_t chainidx);
 #endif
 int tls_parse_stoc_alpn(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                        X509 *x, size_t chainidx);
+    X509 *x, size_t chainidx);
 #ifndef OPENSSL_NO_SRTP
 int tls_parse_stoc_use_srtp(SSL_CONNECTION *s, PACKET *pkt,
-                            unsigned int context, X509 *x, size_t chainidx);
+    unsigned int context, X509 *x, size_t chainidx);
 #endif
 int tls_parse_stoc_etm(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx);
+    X509 *x, size_t chainidx);
 int tls_parse_stoc_ems(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx);
+    X509 *x, size_t chainidx);
 int tls_parse_stoc_supported_versions(SSL_CONNECTION *s, PACKET *pkt,
-                                      unsigned int context,
-                                      X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_stoc_key_share(SSL_CONNECTION *s, PACKET *pkt,
-                             unsigned int context, X509 *x, size_t chainidx);
+    unsigned int context, X509 *x, size_t chainidx);
 int tls_parse_stoc_cookie(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                          X509 *x, size_t chainidx);
+    X509 *x, size_t chainidx);
 int tls_parse_stoc_psk(SSL_CONNECTION *s, PACKET *pkt, unsigned int context,
-                       X509 *x, size_t chainidx);
+    X509 *x, size_t chainidx);
 
 int tls_handle_alpn(SSL_CONNECTION *s);
 
 int tls13_save_handshake_digest_for_pha(SSL_CONNECTION *s);
 int tls13_restore_handshake_digest_for_pha(SSL_CONNECTION *s);
 
-__owur EVP_PKEY* tls_get_peer_pkey(const SSL_CONNECTION *sc);
+__owur EVP_PKEY *tls_get_peer_pkey(const SSL_CONNECTION *sc);
 /* RFC7250 */
 EXT_RETURN tls_construct_ctos_client_cert_type(SSL_CONNECTION *sc, WPACKET *pkt,
-                                               unsigned int context,
-                                               X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 EXT_RETURN tls_construct_stoc_client_cert_type(SSL_CONNECTION *sc, WPACKET *pkt,
-                                               unsigned int context,
-                                               X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_ctos_client_cert_type(SSL_CONNECTION *sc, PACKET *pkt,
-                                    unsigned int context,
-                                    X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_stoc_client_cert_type(SSL_CONNECTION *sc, PACKET *pkt,
-                                    unsigned int context,
-                               X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 EXT_RETURN tls_construct_ctos_server_cert_type(SSL_CONNECTION *sc, WPACKET *pkt,
-                                               unsigned int context,
-                                               X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 EXT_RETURN tls_construct_stoc_server_cert_type(SSL_CONNECTION *sc, WPACKET *pkt,
-                                               unsigned int context,
-                                               X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_ctos_server_cert_type(SSL_CONNECTION *sc, PACKET *pkt,
-                                    unsigned int context,
-                                    X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
 int tls_parse_stoc_server_cert_type(SSL_CONNECTION *s, PACKET *pkt,
-                                    unsigned int context,
-                                    X509 *x, size_t chainidx);
+    unsigned int context,
+    X509 *x, size_t chainidx);
diff --git a/crypto/openssl/ssl/statem/statem_srvr.c b/crypto/openssl/ssl/statem/statem_srvr.c
index 43986121efd3..6079176f9988 100644
--- a/crypto/openssl/ssl/statem/statem_srvr.c
+++ b/crypto/openssl/ssl/statem/statem_srvr.c
@@ -32,24 +32,24 @@
 #include <openssl/comp.h>
 #include "internal/comp.h"
 
-#define TICKET_NONCE_SIZE       8
+#define TICKET_NONCE_SIZE 8
 
 typedef struct {
-  ASN1_TYPE *kxBlob;
-  ASN1_TYPE *opaqueBlob;
+    ASN1_TYPE *kxBlob;
+    ASN1_TYPE *opaqueBlob;
 } GOST_KX_MESSAGE;
 
 DECLARE_ASN1_FUNCTIONS(GOST_KX_MESSAGE)
 
 ASN1_SEQUENCE(GOST_KX_MESSAGE) = {
-  ASN1_SIMPLE(GOST_KX_MESSAGE,  kxBlob, ASN1_ANY),
-  ASN1_OPT(GOST_KX_MESSAGE, opaqueBlob, ASN1_ANY),
+    ASN1_SIMPLE(GOST_KX_MESSAGE, kxBlob, ASN1_ANY),
+    ASN1_OPT(GOST_KX_MESSAGE, opaqueBlob, ASN1_ANY),
 } ASN1_SEQUENCE_END(GOST_KX_MESSAGE)
 
 IMPLEMENT_ASN1_FUNCTIONS(GOST_KX_MESSAGE)
 
 static CON_FUNC_RETURN tls_construct_encrypted_extensions(SSL_CONNECTION *s,
-                                                          WPACKET *pkt);
+    WPACKET *pkt);
 
 static ossl_inline int received_client_cert(const SSL_CONNECTION *sc)
 {
@@ -86,7 +86,7 @@ static int ossl_statem_server13_read_transition(SSL_CONNECTION *s, int mt)
             }
             break;
         } else if (s->ext.early_data == SSL_EARLY_DATA_ACCEPTED
-                   && !SSL_NO_EOED(s)) {
+            && !SSL_NO_EOED(s)) {
             if (mt == SSL3_MT_END_OF_EARLY_DATA) {
                 st->hand_state = TLS_ST_SR_END_OF_EARLY_DATA;
                 return 1;
@@ -104,7 +104,7 @@ static int ossl_statem_server13_read_transition(SSL_CONNECTION *s, int mt)
             }
 #ifndef OPENSSL_NO_COMP_ALG
             if (mt == SSL3_MT_COMPRESSED_CERTIFICATE
-                    && s->ext.compress_certificate_sent) {
+                && s->ext.compress_certificate_sent) {
                 st->hand_state = TLS_ST_SR_COMP_CERT;
                 return 1;
             }
@@ -154,7 +154,7 @@ static int ossl_statem_server13_read_transition(SSL_CONNECTION *s, int mt)
             }
 #ifndef OPENSSL_NO_COMP_ALG
             if (mt == SSL3_MT_COMPRESSED_CERTIFICATE
-                    && s->ext.compress_certificate_sent) {
+                && s->ext.compress_certificate_sent) {
                 st->hand_state = TLS_ST_SR_COMP_CERT;
                 return 1;
             }
@@ -226,7 +226,7 @@ int ossl_statem_server_read_transition(SSL_CONNECTION *s, int mt)
                          * cert.
                          */
                         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                                 SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
+                            SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
                         return 0;
                     }
                     st->hand_state = TLS_ST_SR_KEY_EXCH;
@@ -321,7 +321,7 @@ int ossl_statem_server_read_transition(SSL_CONNECTION *s, int mt)
         break;
     }
 
- err:
+err:
     /* No valid transition found */
     if (SSL_CONNECTION_IS_DTLS(s) && mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
         BIO *rbio;
@@ -361,10 +361,10 @@ static int send_server_key_exchange(SSL_CONNECTION *s)
      * key exchange.
      */
     if (alg_k & (SSL_kDHE | SSL_kECDHE)
-        /*
-         * PSK: send ServerKeyExchange if PSK identity hint if
-         * provided
-         */
+    /*
+     * PSK: send ServerKeyExchange if PSK identity hint if
+     * provided
+     */
 #ifndef OPENSSL_NO_PSK
         /* Only send SKE if we have identity hint for plain PSK */
         || ((alg_k & (SSL_kPSK | SSL_kRSAPSK))
@@ -376,7 +376,7 @@ static int send_server_key_exchange(SSL_CONNECTION *s)
         /* SRP: send ServerKeyExchange */
         || (alg_k & SSL_kSRP)
 #endif
-        ) {
+    ) {
         return 1;
     }
 
@@ -414,40 +414,39 @@ static int get_compressed_certificate_alg(SSL_CONNECTION *sc)
 int send_certificate_request(SSL_CONNECTION *s)
 {
     if (
-           /* don't request cert unless asked for it: */
-           s->verify_mode & SSL_VERIFY_PEER
-           /*
-            * don't request if post-handshake-only unless doing
-            * post-handshake in TLSv1.3:
-            */
-           && (!SSL_CONNECTION_IS_TLS13(s)
-               || !(s->verify_mode & SSL_VERIFY_POST_HANDSHAKE)
-               || s->post_handshake_auth == SSL_PHA_REQUEST_PENDING)
-           /*
-            * if SSL_VERIFY_CLIENT_ONCE is set, don't request cert
-            * a second time:
-            */
-           && (s->certreqs_sent < 1 ||
-               !(s->verify_mode & SSL_VERIFY_CLIENT_ONCE))
-           /*
-            * never request cert in anonymous ciphersuites (see
-            * section "Certificate request" in SSL 3 drafts and in
-            * RFC 2246):
-            */
-           && (!(s->s3.tmp.new_cipher->algorithm_auth & SSL_aNULL)
-               /*
-                * ... except when the application insists on
-                * verification (against the specs, but statem_clnt.c accepts
-                * this for SSL 3)
-                */
-               || (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT))
-           /* don't request certificate for SRP auth */
-           && !(s->s3.tmp.new_cipher->algorithm_auth & SSL_aSRP)
-           /*
-            * With normal PSK Certificates and Certificate Requests
-            * are omitted
-            */
-           && !(s->s3.tmp.new_cipher->algorithm_auth & SSL_aPSK)) {
+        /* don't request cert unless asked for it: */
+        s->verify_mode & SSL_VERIFY_PEER
+        /*
+         * don't request if post-handshake-only unless doing
+         * post-handshake in TLSv1.3:
+         */
+        && (!SSL_CONNECTION_IS_TLS13(s)
+            || !(s->verify_mode & SSL_VERIFY_POST_HANDSHAKE)
+            || s->post_handshake_auth == SSL_PHA_REQUEST_PENDING)
+        /*
+         * if SSL_VERIFY_CLIENT_ONCE is set, don't request cert
+         * a second time:
+         */
+        && (s->certreqs_sent < 1 || !(s->verify_mode & SSL_VERIFY_CLIENT_ONCE))
+        /*
+         * never request cert in anonymous ciphersuites (see
+         * section "Certificate request" in SSL 3 drafts and in
+         * RFC 2246):
+         */
+        && (!(s->s3.tmp.new_cipher->algorithm_auth & SSL_aNULL)
+            /*
+             * ... except when the application insists on
+             * verification (against the specs, but statem_clnt.c accepts
+             * this for SSL 3)
+             */
+            || (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT))
+        /* don't request certificate for SRP auth */
+        && !(s->s3.tmp.new_cipher->algorithm_auth & SSL_aSRP)
+        /*
+         * With normal PSK Certificates and Certificate Requests
+         * are omitted
+         */
+        && !(s->s3.tmp.new_cipher->algorithm_auth & SSL_aPSK)) {
         return 1;
     }
 
@@ -503,7 +502,7 @@ static WRITE_TRAN ossl_statem_server13_write_transition(SSL_CONNECTION *s)
 
     case TLS_ST_SW_SRVR_HELLO:
         if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0
-                && s->hello_retry_request != SSL_HRR_COMPLETE)
+            && s->hello_retry_request != SSL_HRR_COMPLETE)
             st->hand_state = TLS_ST_SW_CHANGE;
         else if (s->hello_retry_request == SSL_HRR_PENDING)
             st->hand_state = TLS_ST_EARLY_DATA;
@@ -670,8 +669,7 @@ WRITE_TRAN ossl_statem_server_write_transition(SSL_CONNECTION *s)
         } else {
             /* Check if it is anon DH or anon ECDH, */
             /* normal PSK or SRP */
-            if (!(s->s3.tmp.new_cipher->algorithm_auth &
-                  (SSL_aNULL | SSL_aSRP | SSL_aPSK))) {
+            if (!(s->s3.tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP | SSL_aPSK))) {
                 st->hand_state = TLS_ST_SW_CERT;
             } else if (send_server_key_exchange(s)) {
                 st->hand_state = TLS_ST_SW_KEY_EXCH;
@@ -791,7 +789,7 @@ WORK_STATE ossl_statem_server_pre_work(SSL_CONNECTION *s, WORK_STATE wst)
 
     case TLS_ST_SW_SESSION_TICKET:
         if (SSL_CONNECTION_IS_TLS13(s) && s->sent_tickets == 0
-                && s->ext.extra_tickets_expected == 0) {
+            && s->ext.extra_tickets_expected == 0) {
             /*
              * Actually this is the end of the handshake, but we're going
              * straight into writing the session ticket out. So we finish off
@@ -837,7 +835,7 @@ WORK_STATE ossl_statem_server_pre_work(SSL_CONNECTION *s, WORK_STATE wst)
 
     case TLS_ST_EARLY_DATA:
         if (s->early_data_state != SSL_EARLY_DATA_ACCEPTING
-                && (s->s3.flags & TLS1_FLAGS_STATELESS) == 0)
+            && (s->s3.flags & TLS1_FLAGS_STATELESS) == 0)
             return WORK_FINISHED_CONTINUE;
 
         /*
@@ -847,8 +845,7 @@ WORK_STATE ossl_statem_server_pre_work(SSL_CONNECTION *s, WORK_STATE wst)
         if (SSL_NO_EOED(s) && s->ext.early_data == SSL_EARLY_DATA_ACCEPTED
             && s->early_data_state != SSL_EARLY_DATA_FINISHED_READING) {
             s->early_data_state = SSL_EARLY_DATA_FINISHED_READING;
-            if (!ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_HANDSHAKE
-                                                               | SSL3_CHANGE_CIPHER_SERVER_READ)) {
+            if (!ssl->method->ssl3_enc->change_cipher_state(s, SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_SERVER_READ)) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 return WORK_ERROR;
             }
@@ -928,7 +925,7 @@ WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION *s, WORK_STATE wst)
         if (SSL_CONNECTION_IS_TLS13(s)
             && s->hello_retry_request == SSL_HRR_PENDING) {
             if ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) == 0
-                    && statem_flush(s) != 1)
+                && statem_flush(s) != 1)
                 return WORK_MORE_A;
             break;
         }
@@ -943,7 +940,7 @@ WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION *s, WORK_STATE wst)
              * SCTP used.
              */
             memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL,
-                   sizeof(DTLS1_SCTP_AUTH_LABEL));
+                sizeof(DTLS1_SCTP_AUTH_LABEL));
 
             /* Don't include the terminating zero. */
             labellen = sizeof(labelbuffer) - 1;
@@ -951,20 +948,21 @@ WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION *s, WORK_STATE wst)
                 labellen += 1;
 
             if (SSL_export_keying_material(ssl, sctpauthkey,
-                                           sizeof(sctpauthkey), labelbuffer,
-                                           labellen, NULL, 0,
-                                           0) <= 0) {
+                    sizeof(sctpauthkey), labelbuffer,
+                    labellen, NULL, 0,
+                    0)
+                <= 0) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 return WORK_ERROR;
             }
 
             BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
-                     sizeof(sctpauthkey), sctpauthkey);
+                sizeof(sctpauthkey), sctpauthkey);
         }
 #endif
         if (!SSL_CONNECTION_IS_TLS13(s)
-                || ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0
-                    && s->hello_retry_request != SSL_HRR_COMPLETE))
+            || ((s->options & SSL_OP_ENABLE_MIDDLEBOX_COMPAT) != 0
+                && s->hello_retry_request != SSL_HRR_COMPLETE))
             break;
         /* Fall through */
 
@@ -979,14 +977,14 @@ WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION *s, WORK_STATE wst)
             if (!ssl->method->ssl3_enc->setup_key_block(s)
                 || !tls13_store_handshake_traffic_hash(s)
                 || !ssl->method->ssl3_enc->change_cipher_state(s,
-                        SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_SERVER_WRITE)) {
+                    SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_SERVER_WRITE)) {
                 /* SSLfatal() already called */
                 return WORK_ERROR;
             }
 
             if (s->ext.early_data != SSL_EARLY_DATA_ACCEPTED
                 && !ssl->method->ssl3_enc->change_cipher_state(s,
-                        SSL3_CC_HANDSHAKE |SSL3_CHANGE_CIPHER_SERVER_READ)) {
+                    SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_SERVER_READ)) {
                 /* SSLfatal() already called */
                 return WORK_ERROR;
             }
@@ -1007,11 +1005,11 @@ WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION *s, WORK_STATE wst)
              * no SCTP used.
              */
             BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
-                     0, NULL);
+                0, NULL);
         }
 #endif
         if (!ssl->method->ssl3_enc->change_cipher_state(s,
-                                SSL3_CHANGE_CIPHER_SERVER_WRITE)) {
+                SSL3_CHANGE_CIPHER_SERVER_WRITE)) {
             /* SSLfatal() already called */
             return WORK_ERROR;
         }
@@ -1032,20 +1030,20 @@ WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION *s, WORK_STATE wst)
              * no SCTP used.
              */
             BIO_ctrl(SSL_get_wbio(ssl), BIO_CTRL_DGRAM_SCTP_NEXT_AUTH_KEY,
-                     0, NULL);
+                0, NULL);
         }
 #endif
         if (SSL_CONNECTION_IS_TLS13(s)) {
             /* TLS 1.3 gets the secret size from the handshake md */
             size_t dummy;
             if (!ssl->method->ssl3_enc->generate_master_secret(s,
-                        s->master_secret, s->handshake_secret, 0,
-                        &dummy)
+                    s->master_secret, s->handshake_secret, 0,
+                    &dummy)
                 || !tls13_store_server_finished_hash(s)
                 || !ssl->method->ssl3_enc->change_cipher_state(s,
-                        SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_SERVER_WRITE))
-            /* SSLfatal() already called */
-            return WORK_ERROR;
+                    SSL3_CC_APPLICATION | SSL3_CHANGE_CIPHER_SERVER_WRITE))
+                /* SSLfatal() already called */
+                return WORK_ERROR;
         }
         break;
 
@@ -1055,7 +1053,7 @@ WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION *s, WORK_STATE wst)
                 return WORK_MORE_A;
         } else {
             if (!SSL_CONNECTION_IS_TLS13(s)
-                    || (s->options & SSL_OP_NO_TX_CERTIFICATE_COMPRESSION) != 0)
+                || (s->options & SSL_OP_NO_TX_CERTIFICATE_COMPRESSION) != 0)
                 s->ext.compress_certificate_from_peer[0] = TLSEXT_comp_cert_none;
         }
         break;
@@ -1063,7 +1061,7 @@ WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION *s, WORK_STATE wst)
     case TLS_ST_SW_ENCRYPTED_EXTENSIONS:
         if (!s->hit && !send_certificate_request(s)) {
             if (!SSL_CONNECTION_IS_TLS13(s)
-                    || (s->options & SSL_OP_NO_TX_CERTIFICATE_COMPRESSION) != 0)
+                || (s->options & SSL_OP_NO_TX_CERTIFICATE_COMPRESSION) != 0)
                 s->ext.compress_certificate_from_peer[0] = TLSEXT_comp_cert_none;
         }
         break;
@@ -1081,7 +1079,7 @@ WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION *s, WORK_STATE wst)
         clear_sys_error();
         if (SSL_CONNECTION_IS_TLS13(s) && statem_flush(s) != 1) {
             if (SSL_get_error(ssl, 0) == SSL_ERROR_SYSCALL
-                    && conn_is_closed()) {
+                && conn_is_closed()) {
                 /*
                  * We ignore connection closed errors in TLSv1.3 when sending a
                  * NewSessionTicket and behave as if we were successful. This is
@@ -1110,7 +1108,7 @@ WORK_STATE ossl_statem_server_post_work(SSL_CONNECTION *s, WORK_STATE wst)
  *   0: Error
  */
 int ossl_statem_server_construct_message(SSL_CONNECTION *s,
-                                         confunc_f *confunc, int *mt)
+    confunc_f *confunc, int *mt)
 {
     OSSL_STATEM *st = &s->statem;
 
@@ -1161,7 +1159,6 @@ int ossl_statem_server_construct_message(SSL_CONNECTION *s,
         *mt = SSL3_MT_CERTIFICATE_VERIFY;
         break;
 
-
     case TLS_ST_SW_KEY_EXCH:
         *confunc = tls_construct_server_key_exchange;
         *mt = SSL3_MT_SERVER_KEY_EXCHANGE;
@@ -1226,10 +1223,10 @@ int ossl_statem_server_construct_message(SSL_CONNECTION *s,
  *  2 + # length of extensions
  *  2^16-1 # maximum length of extensions
  */
-#define CLIENT_HELLO_MAX_LENGTH         131396
+#define CLIENT_HELLO_MAX_LENGTH 131396
 
-#define CLIENT_KEY_EXCH_MAX_LENGTH      2048
-#define NEXT_PROTO_MAX_LENGTH           514
+#define CLIENT_KEY_EXCH_MAX_LENGTH 2048
+#define NEXT_PROTO_MAX_LENGTH 514
 
 /*
  * Returns the maximum allowed length for the current message that we are
@@ -1280,7 +1277,7 @@ size_t ossl_statem_server_max_message_size(SSL_CONNECTION *s)
  * Process a message that the server has received from the client.
  */
 MSG_PROCESS_RETURN ossl_statem_server_process_message(SSL_CONNECTION *s,
-                                                      PACKET *pkt)
+    PACKET *pkt)
 {
     OSSL_STATEM *st = &s->statem;
 
@@ -1323,7 +1320,6 @@ MSG_PROCESS_RETURN ossl_statem_server_process_message(SSL_CONNECTION *s,
 
     case TLS_ST_SR_KEY_UPDATE:
         return tls_process_key_update(s, pkt);
-
     }
 }
 
@@ -1332,7 +1328,7 @@ MSG_PROCESS_RETURN ossl_statem_server_process_message(SSL_CONNECTION *s,
  * from the client
  */
 WORK_STATE ossl_statem_server_post_process_message(SSL_CONNECTION *s,
-                                                   WORK_STATE wst)
+    WORK_STATE wst)
 {
     OSSL_STATEM *st = &s->statem;
 
@@ -1357,15 +1353,14 @@ static int ssl_check_srp_ext_ClientHello(SSL_CONNECTION *s)
     int ret;
     int al = SSL_AD_UNRECOGNIZED_NAME;
 
-    if ((s->s3.tmp.new_cipher->algorithm_mkey & SSL_kSRP) &&
-        (s->srp_ctx.TLS_ext_srp_username_callback != NULL)) {
+    if ((s->s3.tmp.new_cipher->algorithm_mkey & SSL_kSRP) && (s->srp_ctx.TLS_ext_srp_username_callback != NULL)) {
         if (s->srp_ctx.login == NULL) {
             /*
              * RFC 5054 says SHOULD reject, we do so if There is no srp
              * login name
              */
             SSLfatal(s, SSL_AD_UNKNOWN_PSK_IDENTITY,
-                     SSL_R_PSK_IDENTITY_NOT_FOUND);
+                SSL_R_PSK_IDENTITY_NOT_FOUND);
             return -1;
         } else {
             ret = ssl_srp_server_param_with_username_intern(s, &al);
@@ -1373,9 +1368,9 @@ static int ssl_check_srp_ext_ClientHello(SSL_CONNECTION *s)
                 return 0;
             if (ret == SSL3_AL_FATAL) {
                 SSLfatal(s, al,
-                         al == SSL_AD_UNKNOWN_PSK_IDENTITY
-                         ? SSL_R_PSK_IDENTITY_NOT_FOUND
-                         : SSL_R_CLIENTHELLO_TLSEXT);
+                    al == SSL_AD_UNKNOWN_PSK_IDENTITY
+                        ? SSL_R_PSK_IDENTITY_NOT_FOUND
+                        : SSL_R_CLIENTHELLO_TLSEXT);
                 return -1;
             }
         }
@@ -1385,25 +1380,26 @@ static int ssl_check_srp_ext_ClientHello(SSL_CONNECTION *s)
 #endif
 
 int dtls_raw_hello_verify_request(WPACKET *pkt, unsigned char *cookie,
-                                  size_t cookie_len)
+    size_t cookie_len)
 {
     /* Always use DTLS 1.0 version: see RFC 6347 */
     if (!WPACKET_put_bytes_u16(pkt, DTLS1_VERSION)
-            || !WPACKET_sub_memcpy_u8(pkt, cookie, cookie_len))
+        || !WPACKET_sub_memcpy_u8(pkt, cookie, cookie_len))
         return 0;
 
     return 1;
 }
 
 CON_FUNC_RETURN dtls_construct_hello_verify_request(SSL_CONNECTION *s,
-                                                    WPACKET *pkt)
+    WPACKET *pkt)
 {
     unsigned int cookie_leni;
     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
 
     if (sctx->app_gen_cookie_cb == NULL
         || sctx->app_gen_cookie_cb(SSL_CONNECTION_GET_USER_SSL(s), s->d1->cookie,
-                                   &cookie_leni) == 0
+               &cookie_leni)
+            == 0
         || cookie_leni > DTLS1_COOKIE_LENGTH) {
         SSLfatal(s, SSL_AD_NO_ALERT, SSL_R_COOKIE_GEN_CALLBACK_FAILURE);
         return CON_FUNC_ERROR;
@@ -1411,7 +1407,7 @@ CON_FUNC_RETURN dtls_construct_hello_verify_request(SSL_CONNECTION *s,
     s->d1->cookie_len = cookie_leni;
 
     if (!dtls_raw_hello_verify_request(pkt, s->d1->cookie,
-                                       s->d1->cookie_len)) {
+            s->d1->cookie_len)) {
         SSLfatal(s, SSL_AD_NO_ALERT, ERR_R_INTERNAL_ERROR);
         return CON_FUNC_ERROR;
     }
@@ -1434,29 +1430,45 @@ CON_FUNC_RETURN dtls_construct_hello_verify_request(SSL_CONNECTION *s,
  * 10.8..10.8.3 (which don't work).
  */
 static void ssl_check_for_safari(SSL_CONNECTION *s,
-                                 const CLIENTHELLO_MSG *hello)
+    const CLIENTHELLO_MSG *hello)
 {
     static const unsigned char kSafariExtensionsBlock[] = {
-        0x00, 0x0a,             /* elliptic_curves extension */
-        0x00, 0x08,             /* 8 bytes */
-        0x00, 0x06,             /* 6 bytes of curve ids */
-        0x00, 0x17,             /* P-256 */
-        0x00, 0x18,             /* P-384 */
-        0x00, 0x19,             /* P-521 */
+        0x00,
+        0x0a, /* elliptic_curves extension */
+        0x00,
+        0x08, /* 8 bytes */
+        0x00,
+        0x06, /* 6 bytes of curve ids */
+        0x00,
+        0x17, /* P-256 */
+        0x00,
+        0x18, /* P-384 */
+        0x00,
+        0x19, /* P-521 */
 
-        0x00, 0x0b,             /* ec_point_formats */
-        0x00, 0x02,             /* 2 bytes */
-        0x01,                   /* 1 point format */
-        0x00,                   /* uncompressed */
+        0x00,
+        0x0b, /* ec_point_formats */
+        0x00,
+        0x02, /* 2 bytes */
+        0x01, /* 1 point format */
+        0x00, /* uncompressed */
         /* The following is only present in TLS 1.2 */
-        0x00, 0x0d,             /* signature_algorithms */
-        0x00, 0x0c,             /* 12 bytes */
-        0x00, 0x0a,             /* 10 bytes */
-        0x05, 0x01,             /* SHA-384/RSA */
-        0x04, 0x01,             /* SHA-256/RSA */
-        0x02, 0x01,             /* SHA-1/RSA */
-        0x04, 0x03,             /* SHA-256/ECDSA */
-        0x02, 0x03,             /* SHA-1/ECDSA */
+        0x00,
+        0x0d, /* signature_algorithms */
+        0x00,
+        0x0c, /* 12 bytes */
+        0x00,
+        0x0a, /* 10 bytes */
+        0x05,
+        0x01, /* SHA-384/RSA */
+        0x04,
+        0x01, /* SHA-256/RSA */
+        0x02,
+        0x01, /* SHA-1/RSA */
+        0x04,
+        0x03, /* SHA-256/ECDSA */
+        0x02,
+        0x03, /* SHA-1/ECDSA */
     };
     /* Length of the common prefix (first two extensions). */
     static const size_t kSafariCommonExtensionsLength = 18;
@@ -1476,16 +1488,18 @@ static void ssl_check_for_safari(SSL_CONNECTION *s,
         return;
 
     ext_len = TLS1_get_client_version(
-        SSL_CONNECTION_GET_SSL(s)) >= TLS1_2_VERSION ?
-                      sizeof(kSafariExtensionsBlock) : kSafariCommonExtensionsLength;
+                  SSL_CONNECTION_GET_SSL(s))
+            >= TLS1_2_VERSION
+        ? sizeof(kSafariExtensionsBlock)
+        : kSafariCommonExtensionsLength;
 
     s->s3.is_probably_safari = PACKET_equal(&tmppkt, kSafariExtensionsBlock,
-                                             ext_len);
+        ext_len);
 }
 
-#define RENEG_OPTIONS_OK(options) \
+#define RENEG_OPTIONS_OK(options)             \
     ((options & SSL_OP_NO_RENEGOTIATION) == 0 \
-     && (options & SSL_OP_ALLOW_CLIENT_RENEGOTIATION) != 0)
+        && (options & SSL_OP_ALLOW_CLIENT_RENEGOTIATION) != 0)
 
 MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION *s, PACKET *pkt)
 {
@@ -1501,9 +1515,10 @@ MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION *s, PACKET *pkt)
             goto err;
         }
         if (!RENEG_OPTIONS_OK(s->options)
-                || (!s->s3.send_connection_binding
-                    && (s->options
-                        & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION) == 0)) {
+            || (!s->s3.send_connection_binding
+                && (s->options
+                       & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
+                    == 0)) {
             ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_RENEGOTIATION);
             return MSG_PROCESS_FINISHED_READING;
         }
@@ -1527,7 +1542,7 @@ MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION *s, PACKET *pkt)
         unsigned int mt;
 
         if (!SSL_IS_FIRST_HANDSHAKE(s)
-                || s->hello_retry_request != SSL_HRR_NONE) {
+            || s->hello_retry_request != SSL_HRR_NONE) {
             SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE);
             goto err;
         }
@@ -1587,7 +1602,7 @@ MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION *s, PACKET *pkt)
         }
 
         if (!PACKET_get_sub_packet(pkt, &clienthello->ciphersuites,
-                                   ciphersuite_len)
+                ciphersuite_len)
             || !PACKET_copy_bytes(pkt, clienthello->session_id, session_id_len)
             || !PACKET_get_sub_packet(pkt, &challenge, challenge_len)
             /* No extensions. */
@@ -1603,11 +1618,11 @@ MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION *s, PACKET *pkt)
          * sizeof(clienthello->random) does.
          */
         challenge_len = challenge_len > SSL3_RANDOM_SIZE
-                        ? SSL3_RANDOM_SIZE : challenge_len;
+            ? SSL3_RANDOM_SIZE
+            : challenge_len;
         memset(clienthello->random, 0, SSL3_RANDOM_SIZE);
         if (!PACKET_copy_bytes(&challenge,
-                               clienthello->random + SSL3_RANDOM_SIZE -
-                               challenge_len, challenge_len)
+                clienthello->random + SSL3_RANDOM_SIZE - challenge_len, challenge_len)
             /* Advertise only null compression. */
             || !PACKET_buf_init(&compression, &null_compression, 1)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
@@ -1620,8 +1635,8 @@ MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION *s, PACKET *pkt)
         if (!PACKET_copy_bytes(pkt, clienthello->random, SSL3_RANDOM_SIZE)
             || !PACKET_get_length_prefixed_1(pkt, &session_id)
             || !PACKET_copy_all(&session_id, clienthello->session_id,
-                    SSL_MAX_SSL_SESSION_ID_LENGTH,
-                    &clienthello->session_id_len)) {
+                SSL_MAX_SSL_SESSION_ID_LENGTH,
+                &clienthello->session_id_len)) {
             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
             goto err;
         }
@@ -1632,8 +1647,8 @@ MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION *s, PACKET *pkt)
                 goto err;
             }
             if (!PACKET_copy_all(&cookie, clienthello->dtls_cookie,
-                                 DTLS1_COOKIE_LENGTH,
-                                 &clienthello->dtls_cookie_len)) {
+                    DTLS1_COOKIE_LENGTH,
+                    &clienthello->dtls_cookie_len)) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 goto err;
             }
@@ -1665,7 +1680,7 @@ MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION *s, PACKET *pkt)
             PACKET_null_init(&clienthello->extensions);
         } else {
             if (!PACKET_get_length_prefixed_2(pkt, &clienthello->extensions)
-                    || PACKET_remaining(pkt) != 0) {
+                || PACKET_remaining(pkt) != 0) {
                 SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
                 goto err;
             }
@@ -1673,8 +1688,8 @@ MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION *s, PACKET *pkt)
     }
 
     if (!PACKET_copy_all(&compression, clienthello->compressions,
-                         MAX_COMPRESSIONS_SIZE,
-                         &clienthello->compressions_len)) {
+            MAX_COMPRESSIONS_SIZE,
+            &clienthello->compressions_len)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
@@ -1682,8 +1697,8 @@ MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION *s, PACKET *pkt)
     /* Preserve the raw extensions PACKET for later use */
     extensions = clienthello->extensions;
     if (!tls_collect_extensions(s, &extensions, SSL_EXT_CLIENT_HELLO,
-                                &clienthello->pre_proc_exts,
-                                &clienthello->pre_proc_exts_len, 1)) {
+            &clienthello->pre_proc_exts,
+            &clienthello->pre_proc_exts_len, 1)) {
         /* SSLfatal already been called */
         goto err;
     }
@@ -1691,7 +1706,7 @@ MSG_PROCESS_RETURN tls_process_client_hello(SSL_CONNECTION *s, PACKET *pkt)
 
     return MSG_PROCESS_CONTINUE_PROCESSING;
 
- err:
+err:
     if (clienthello != NULL)
         OPENSSL_free(clienthello->pre_proc_exts);
     OPENSSL_free(clienthello);
@@ -1741,8 +1756,8 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
 
     if (clienthello->isv2) {
         if (clienthello->legacy_version == SSL2_VERSION
-                || (clienthello->legacy_version & 0xff00)
-                   != (SSL3_VERSION_MAJOR << 8)) {
+            || (clienthello->legacy_version & 0xff00)
+                != (SSL3_VERSION_MAJOR << 8)) {
             /*
              * This is real SSLv2 or something completely unknown. We don't
              * support it.
@@ -1778,16 +1793,18 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
         if (SSL_get_options(ssl) & SSL_OP_COOKIE_EXCHANGE) {
             if (sctx->app_verify_cookie_cb != NULL) {
                 if (sctx->app_verify_cookie_cb(ussl, clienthello->dtls_cookie,
-                                               clienthello->dtls_cookie_len) == 0) {
+                        clienthello->dtls_cookie_len)
+                    == 0) {
                     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                             SSL_R_COOKIE_MISMATCH);
+                        SSL_R_COOKIE_MISMATCH);
                     goto err;
                     /* else cookie verification succeeded */
                 }
                 /* default verification */
             } else if (s->d1->cookie_len != clienthello->dtls_cookie_len
-                    || memcmp(clienthello->dtls_cookie, s->d1->cookie,
-                              s->d1->cookie_len) != 0) {
+                || memcmp(clienthello->dtls_cookie, s->d1->cookie,
+                       s->d1->cookie_len)
+                    != 0) {
                 SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_COOKIE_MISMATCH);
                 goto err;
             }
@@ -1798,9 +1815,9 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
     s->hit = 0;
 
     if (!ssl_cache_cipherlist(s, &clienthello->ciphersuites,
-                              clienthello->isv2) ||
-        !ossl_bytes_to_cipher_list(s, &clienthello->ciphersuites, &ciphers,
-                                   &scsvs, clienthello->isv2, 1)) {
+            clienthello->isv2)
+        || !ossl_bytes_to_cipher_list(s, &clienthello->ciphersuites, &ciphers,
+            &scsvs, clienthello->isv2, 1)) {
         /* SSLfatal() already called */
         goto err;
     }
@@ -1814,12 +1831,11 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
                 if (s->renegotiate) {
                     /* SCSV is fatal if renegotiating */
                     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                             SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING);
+                        SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING);
                     goto err;
                 }
                 s->s3.send_connection_binding = 1;
-            } else if (SSL_CIPHER_get_id(c) == SSL3_CK_FALLBACK_SCSV &&
-                       !ssl_check_version_downgrade(s)) {
+            } else if (SSL_CIPHER_get_id(c) == SSL3_CK_FALLBACK_SCSV && !ssl_check_version_downgrade(s)) {
                 /*
                  * This SCSV indicates that the client previously tried
                  * a higher version.  We should fail if the current version
@@ -1828,7 +1844,7 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
                  * an insecure downgrade.
                  */
                 SSLfatal(s, SSL_AD_INAPPROPRIATE_FALLBACK,
-                         SSL_R_INAPPROPRIATE_FALLBACK);
+                    SSL_R_INAPPROPRIATE_FALLBACK);
                 goto err;
             }
         }
@@ -1836,16 +1852,15 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
 
     /* For TLSv1.3 we must select the ciphersuite *before* session resumption */
     if (SSL_CONNECTION_IS_TLS13(s)) {
-        const SSL_CIPHER *cipher =
-            ssl3_choose_cipher(s, ciphers, SSL_get_ciphers(ssl));
+        const SSL_CIPHER *cipher = ssl3_choose_cipher(s, ciphers, SSL_get_ciphers(ssl));
 
         if (cipher == NULL) {
             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SHARED_CIPHER);
             goto err;
         }
         if (s->hello_retry_request == SSL_HRR_PENDING
-                && (s->s3.tmp.new_cipher == NULL
-                    || s->s3.tmp.new_cipher->id != cipher->id)) {
+            && (s->s3.tmp.new_cipher == NULL
+                || s->s3.tmp.new_cipher->id != cipher->id)) {
             /*
              * A previous HRR picked a different ciphersuite to the one we
              * just selected. Something must have changed.
@@ -1858,8 +1873,8 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
 
     /* We need to do this before getting the session */
     if (!tls_parse_extension(s, TLSEXT_IDX_extended_master_secret,
-                             SSL_EXT_CLIENT_HELLO,
-                             clienthello->pre_proc_exts, NULL, 0)) {
+            SSL_EXT_CLIENT_HELLO,
+            clienthello->pre_proc_exts, NULL, 0)) {
         /* SSLfatal() already called */
         goto err;
     }
@@ -1880,9 +1895,7 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
      * SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION setting will be
      * ignored.
      */
-    if (clienthello->isv2 ||
-        (s->new_session &&
-         (s->options & SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION))) {
+    if (clienthello->isv2 || (s->new_session && (s->options & SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION))) {
         if (!ssl_get_new_session(s, 1)) {
             /* SSLfatal() already called */
             goto err;
@@ -1906,7 +1919,7 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
 
     if (SSL_CONNECTION_IS_TLS13(s)) {
         memcpy(s->tmp_session_id, s->clienthello->session_id,
-               s->clienthello->session_id_len);
+            s->clienthello->session_id_len);
         s->tmp_session_id_len = s->clienthello->session_id_len;
     }
 
@@ -1918,15 +1931,16 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
         j = 0;
         id = s->session->cipher->id;
 
-        OSSL_TRACE_BEGIN(TLS_CIPHER) {
+        OSSL_TRACE_BEGIN(TLS_CIPHER)
+        {
             BIO_printf(trc_out, "client sent %d ciphers\n",
-                       sk_SSL_CIPHER_num(ciphers));
+                sk_SSL_CIPHER_num(ciphers));
         }
         for (i = 0; i < sk_SSL_CIPHER_num(ciphers); i++) {
             c = sk_SSL_CIPHER_value(ciphers, i);
             if (trc_out != NULL)
                 BIO_printf(trc_out, "client [%2d of %2d]:%s\n", i,
-                           sk_SSL_CIPHER_num(ciphers), SSL_CIPHER_get_name(c));
+                    sk_SSL_CIPHER_num(ciphers), SSL_CIPHER_get_name(c));
             if (c->id == id) {
                 j = 1;
                 break;
@@ -1938,7 +1952,7 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
              * to reuse it
              */
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                     SSL_R_REQUIRED_CIPHER_MISSING);
+                SSL_R_REQUIRED_CIPHER_MISSING);
             OSSL_TRACE_CANCEL(TLS_CIPHER);
             goto err;
         }
@@ -1952,9 +1966,10 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
     }
     /* Make sure at least the null compression is supported. */
     if (memchr(clienthello->compressions, 0,
-               clienthello->compressions_len) == NULL) {
+            clienthello->compressions_len)
+        == NULL) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                 SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING);
+            SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING);
         goto err;
     }
 
@@ -1963,7 +1978,7 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
 
     /* TLS extensions */
     if (!tls_parse_all_extensions(s, SSL_EXT_CLIENT_HELLO,
-                                  clienthello->pre_proc_exts, NULL, 0, 1)) {
+            clienthello->pre_proc_exts, NULL, 0, 1)) {
         /* SSLfatal() already called */
         goto err;
     }
@@ -1989,10 +2004,10 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
     }
 
     if (!s->hit
-            && s->version >= TLS1_VERSION
-            && !SSL_CONNECTION_IS_TLS13(s)
-            && !SSL_CONNECTION_IS_DTLS(s)
-            && s->ext.session_secret_cb != NULL) {
+        && s->version >= TLS1_VERSION
+        && !SSL_CONNECTION_IS_TLS13(s)
+        && !SSL_CONNECTION_IS_DTLS(s)
+        && s->ext.session_secret_cb != NULL) {
         const SSL_CIPHER *pref_cipher = NULL;
         /*
          * s->session->master_key_length is a size_t, but this is an int for
@@ -2002,10 +2017,10 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
 
         master_key_length = sizeof(s->session->master_key);
         if (s->ext.session_secret_cb(ussl, s->session->master_key,
-                                     &master_key_length, ciphers,
-                                     &pref_cipher,
-                                     s->ext.session_secret_cb_arg)
-                && master_key_length > 0) {
+                &master_key_length, ciphers,
+                &pref_cipher,
+                s->ext.session_secret_cb_arg)
+            && master_key_length > 0) {
             s->session->master_key_length = master_key_length;
             s->hit = 1;
             s->peer_ciphers = ciphers;
@@ -2016,7 +2031,7 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
             /* check if some cipher was preferred by call back */
             if (pref_cipher == NULL)
                 pref_cipher = ssl3_choose_cipher(s, s->peer_ciphers,
-                                                 SSL_get_ciphers(ssl));
+                    SSL_get_ciphers(ssl));
             if (pref_cipher == NULL) {
                 SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_SHARED_CIPHER);
                 goto err;
@@ -2044,7 +2059,7 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
          */
         if (clienthello->compressions_len != 1) {
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                     SSL_R_INVALID_COMPRESSION_ALGORITHM);
+                SSL_R_INVALID_COMPRESSION_ALGORITHM);
             goto err;
         }
     }
@@ -2057,7 +2072,7 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
         /* Can't disable compression */
         if (!ssl_allow_compression(s)) {
             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                     SSL_R_INCONSISTENT_COMPRESSION);
+                SSL_R_INCONSISTENT_COMPRESSION);
             goto err;
         }
         /* Look for resumed compression method */
@@ -2070,7 +2085,7 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
         }
         if (s->s3.tmp.new_compression == NULL) {
             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                     SSL_R_INVALID_COMPRESSION_ALGORITHM);
+                SSL_R_INVALID_COMPRESSION_ALGORITHM);
             goto err;
         }
         /* Look for resumed method in compression list */
@@ -2080,7 +2095,7 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
         }
         if (k >= clienthello->compressions_len) {
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                     SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING);
+                SSL_R_REQUIRED_COMPRESSION_ALGORITHM_MISSING);
             goto err;
         }
     } else if (s->hit) {
@@ -2147,7 +2162,7 @@ static int tls_early_post_process_client_hello(SSL_CONNECTION *s)
     OPENSSL_free(s->clienthello);
     s->clienthello = NULL;
     return 1;
- err:
+err:
     sk_SSL_CIPHER_free(ciphers);
     sk_SSL_CIPHER_free(scsvs);
     OPENSSL_free(clienthello->pre_proc_exts);
@@ -2174,7 +2189,7 @@ static int tls_handle_status_request(SSL_CONNECTION *s)
      * influence which certificate is sent
      */
     if (s->ext.status_type != TLSEXT_STATUSTYPE_nothing && sctx != NULL
-            && sctx->ext.status_cb != NULL) {
+        && sctx->ext.status_cb != NULL) {
         int ret;
 
         /* If no certificate can't return certificate status */
@@ -2185,7 +2200,7 @@ static int tls_handle_status_request(SSL_CONNECTION *s)
              */
             s->cert->key = s->s3.tmp.cert;
             ret = sctx->ext.status_cb(SSL_CONNECTION_GET_USER_SSL(s),
-                                      sctx->ext.status_arg);
+                sctx->ext.status_arg);
             switch (ret) {
                 /* We don't want to send a status request response */
             case SSL_TLSEXT_ERR_NOACK:
@@ -2220,10 +2235,10 @@ int tls_handle_alpn(SSL_CONNECTION *s)
 
     if (sctx->ext.alpn_select_cb != NULL && s->s3.alpn_proposed != NULL) {
         int r = sctx->ext.alpn_select_cb(SSL_CONNECTION_GET_USER_SSL(s),
-                                         &selected, &selected_len,
-                                         s->s3.alpn_proposed,
-                                         (unsigned int)s->s3.alpn_proposed_len,
-                                         sctx->ext.alpn_select_cb_arg);
+            &selected, &selected_len,
+            s->s3.alpn_proposed,
+            (unsigned int)s->s3.alpn_proposed_len,
+            sctx->ext.alpn_select_cb_arg);
 
         if (r == SSL_TLSEXT_ERR_OK) {
             OPENSSL_free(s->s3.alpn_selected);
@@ -2241,9 +2256,10 @@ int tls_handle_alpn(SSL_CONNECTION *s)
 
             /* Check ALPN is consistent with session */
             if (s->session->ext.alpn_selected == NULL
-                        || selected_len != s->session->ext.alpn_selected_len
-                        || memcmp(selected, s->session->ext.alpn_selected,
-                                  selected_len) != 0) {
+                || selected_len != s->session->ext.alpn_selected_len
+                || memcmp(selected, s->session->ext.alpn_selected,
+                       selected_len)
+                    != 0) {
                 /* Not consistent so can't be used for early_data */
                 s->ext.early_data_ok = 0;
 
@@ -2255,14 +2271,14 @@ int tls_handle_alpn(SSL_CONNECTION *s)
                      */
                     if (!ossl_assert(s->session->ext.alpn_selected == NULL)) {
                         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                                 ERR_R_INTERNAL_ERROR);
+                            ERR_R_INTERNAL_ERROR);
                         return 0;
                     }
                     s->session->ext.alpn_selected = OPENSSL_memdup(selected,
-                                                                   selected_len);
+                        selected_len);
                     if (s->session->ext.alpn_selected == NULL) {
                         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                                 ERR_R_INTERNAL_ERROR);
+                            ERR_R_INTERNAL_ERROR);
                         return 0;
                     }
                     s->session->ext.alpn_selected_len = selected_len;
@@ -2272,7 +2288,7 @@ int tls_handle_alpn(SSL_CONNECTION *s)
             return 1;
         } else if (r != SSL_TLSEXT_ERR_NOACK) {
             SSLfatal(s, SSL_AD_NO_APPLICATION_PROTOCOL,
-                     SSL_R_NO_APPLICATION_PROTOCOL);
+                SSL_R_NO_APPLICATION_PROTOCOL);
             return 0;
         }
         /*
@@ -2325,13 +2341,12 @@ WORK_STATE tls_post_process_client_hello(SSL_CONNECTION *s, WORK_STATE wst)
 
             /* In TLSv1.3 we selected the ciphersuite before resumption */
             if (!SSL_CONNECTION_IS_TLS13(s)) {
-                cipher =
-                    ssl3_choose_cipher(s, s->peer_ciphers,
-                                       SSL_get_ciphers(ssl));
+                cipher = ssl3_choose_cipher(s, s->peer_ciphers,
+                    SSL_get_ciphers(ssl));
 
                 if (cipher == NULL) {
                     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                             SSL_R_NO_SHARED_CIPHER);
+                        SSL_R_NO_SHARED_CIPHER);
                     goto err;
                 }
                 s->s3.tmp.new_cipher = cipher;
@@ -2343,10 +2358,10 @@ WORK_STATE tls_post_process_client_hello(SSL_CONNECTION *s, WORK_STATE wst)
                 }
                 /* check whether we should disable session resumption */
                 if (s->not_resumable_session_cb != NULL)
-                    s->session->not_resumable =
-                        s->not_resumable_session_cb(ussl,
-                            ((s->s3.tmp.new_cipher->algorithm_mkey
-                              & (SSL_kDHE | SSL_kECDHE)) != 0));
+                    s->session->not_resumable = s->not_resumable_session_cb(ussl,
+                        ((s->s3.tmp.new_cipher->algorithm_mkey
+                             & (SSL_kDHE | SSL_kECDHE))
+                            != 0));
                 if (s->session->not_resumable)
                     /* do not send a session ticket */
                     s->ext.ticket_expected = 0;
@@ -2407,7 +2422,7 @@ WORK_STATE tls_post_process_client_hello(SSL_CONNECTION *s, WORK_STATE wst)
 #endif
 
     return WORK_FINISHED_STOP;
- err:
+err:
     return WORK_ERROR;
 }
 
@@ -2418,18 +2433,19 @@ CON_FUNC_RETURN tls_construct_server_hello(SSL_CONNECTION *s, WPACKET *pkt)
     int version;
     unsigned char *session_id;
     int usetls13 = SSL_CONNECTION_IS_TLS13(s)
-                   || s->hello_retry_request == SSL_HRR_PENDING;
+        || s->hello_retry_request == SSL_HRR_PENDING;
 
     version = usetls13 ? TLS1_2_VERSION : s->version;
     if (!WPACKET_put_bytes_u16(pkt, version)
-               /*
-                * Random stuff. Filling of the server_random takes place in
-                * tls_process_client_hello()
-                */
-            || !WPACKET_memcpy(pkt,
-                               s->hello_retry_request == SSL_HRR_PENDING
-                                   ? hrrrandom : s->s3.server_random,
-                               SSL3_RANDOM_SIZE)) {
+        /*
+         * Random stuff. Filling of the server_random takes place in
+         * tls_process_client_hello()
+         */
+        || !WPACKET_memcpy(pkt,
+            s->hello_retry_request == SSL_HRR_PENDING
+                ? hrrrandom
+                : s->s3.server_random,
+            SSL3_RANDOM_SIZE)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return CON_FUNC_ERROR;
     }
@@ -2453,7 +2469,7 @@ CON_FUNC_RETURN tls_construct_server_hello(SSL_CONNECTION *s, WPACKET *pkt)
      * to send back.
      */
     if (!(SSL_CONNECTION_GET_CTX(s)->session_cache_mode & SSL_SESS_CACHE_SERVER)
-            && !s->hit)
+        && !s->hit)
         s->session->session_id_length = 0;
 
     if (usetls13) {
@@ -2480,20 +2496,20 @@ CON_FUNC_RETURN tls_construct_server_hello(SSL_CONNECTION *s, WPACKET *pkt)
 #endif
 
     if (!WPACKET_sub_memcpy_u8(pkt, session_id, sl)
-            || !SSL_CONNECTION_GET_SSL(s)->method->put_cipher_by_char(s->s3.tmp.new_cipher,
-                                                                      pkt, &len)
-            || !WPACKET_put_bytes_u8(pkt, compm)) {
+        || !SSL_CONNECTION_GET_SSL(s)->method->put_cipher_by_char(s->s3.tmp.new_cipher,
+            pkt, &len)
+        || !WPACKET_put_bytes_u8(pkt, compm)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return CON_FUNC_ERROR;
     }
 
     if (!tls_construct_extensions(s, pkt,
-                                  s->hello_retry_request == SSL_HRR_PENDING
-                                      ? SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST
-                                      : (SSL_CONNECTION_IS_TLS13(s)
-                                          ? SSL_EXT_TLS1_3_SERVER_HELLO
-                                          : SSL_EXT_TLS1_2_SERVER_HELLO),
-                                  NULL, 0)) {
+            s->hello_retry_request == SSL_HRR_PENDING
+                ? SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST
+                : (SSL_CONNECTION_IS_TLS13(s)
+                          ? SSL_EXT_TLS1_3_SERVER_HELLO
+                          : SSL_EXT_TLS1_2_SERVER_HELLO),
+            NULL, 0)) {
         /* SSLfatal() already called */
         return CON_FUNC_ERROR;
     }
@@ -2513,7 +2529,7 @@ CON_FUNC_RETURN tls_construct_server_hello(SSL_CONNECTION *s, WPACKET *pkt)
             return CON_FUNC_ERROR;
         }
     } else if (!(s->verify_mode & SSL_VERIFY_PEER)
-                && !ssl3_digest_cached_records(s, 0)) {
+        && !ssl3_digest_cached_records(s, 0)) {
         /* SSLfatal() already called */;
         return CON_FUNC_ERROR;
     }
@@ -2533,7 +2549,7 @@ CON_FUNC_RETURN tls_construct_server_done(SSL_CONNECTION *s, WPACKET *pkt)
 }
 
 CON_FUNC_RETURN tls_construct_server_key_exchange(SSL_CONNECTION *s,
-                                                  WPACKET *pkt)
+    WPACKET *pkt)
 {
     EVP_PKEY *pkdh = NULL;
     unsigned char *encodedPoint = NULL;
@@ -2567,124 +2583,122 @@ CON_FUNC_RETURN tls_construct_server_key_exchange(SSL_CONNECTION *s,
     /* Plain PSK or RSAPSK nothing to do */
     if (type & (SSL_kPSK | SSL_kRSAPSK)) {
     } else
-#endif                          /* !OPENSSL_NO_PSK */
-    if (type & (SSL_kDHE | SSL_kDHEPSK)) {
-        CERT *cert = s->cert;
-        EVP_PKEY *pkdhp = NULL;
+#endif /* !OPENSSL_NO_PSK */
+        if (type & (SSL_kDHE | SSL_kDHEPSK)) {
+            CERT *cert = s->cert;
+            EVP_PKEY *pkdhp = NULL;
 
-        if (s->cert->dh_tmp_auto) {
-            pkdh = ssl_get_auto_dh(s);
-            if (pkdh == NULL) {
-                SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
-                goto err;
+            if (s->cert->dh_tmp_auto) {
+                pkdh = ssl_get_auto_dh(s);
+                if (pkdh == NULL) {
+                    SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
+                    goto err;
+                }
+                pkdhp = pkdh;
+            } else {
+                pkdhp = cert->dh_tmp;
             }
-            pkdhp = pkdh;
-        } else {
-            pkdhp = cert->dh_tmp;
-        }
 #if !defined(OPENSSL_NO_DEPRECATED_3_0)
-        if ((pkdhp == NULL) && (s->cert->dh_tmp_cb != NULL)) {
-            pkdh = ssl_dh_to_pkey(s->cert->dh_tmp_cb(SSL_CONNECTION_GET_USER_SSL(s),
-                                                     0, 1024));
-            if (pkdh == NULL) {
+            if ((pkdhp == NULL) && (s->cert->dh_tmp_cb != NULL)) {
+                pkdh = ssl_dh_to_pkey(s->cert->dh_tmp_cb(SSL_CONNECTION_GET_USER_SSL(s),
+                    0, 1024));
+                if (pkdh == NULL) {
+                    SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
+                    goto err;
+                }
+                pkdhp = pkdh;
+            }
+#endif
+            if (pkdhp == NULL) {
+                SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_TMP_DH_KEY);
+                goto err;
+            }
+            if (!ssl_security(s, SSL_SECOP_TMP_DH,
+                    EVP_PKEY_get_security_bits(pkdhp), 0, pkdhp)) {
+                SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_DH_KEY_TOO_SMALL);
+                goto err;
+            }
+            if (s->s3.tmp.pkey != NULL) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 goto err;
             }
-            pkdhp = pkdh;
-        }
-#endif
-        if (pkdhp == NULL) {
-            SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_TMP_DH_KEY);
-            goto err;
-        }
-        if (!ssl_security(s, SSL_SECOP_TMP_DH,
-                          EVP_PKEY_get_security_bits(pkdhp), 0, pkdhp)) {
-            SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_DH_KEY_TOO_SMALL);
-            goto err;
-        }
-        if (s->s3.tmp.pkey != NULL) {
-            SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
-            goto err;
-        }
 
-        s->s3.tmp.pkey = ssl_generate_pkey(s, pkdhp);
-        if (s->s3.tmp.pkey == NULL) {
-            SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
-            goto err;
-        }
+            s->s3.tmp.pkey = ssl_generate_pkey(s, pkdhp);
+            if (s->s3.tmp.pkey == NULL) {
+                SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
+                goto err;
+            }
 
-        EVP_PKEY_free(pkdh);
-        pkdh = NULL;
+            EVP_PKEY_free(pkdh);
+            pkdh = NULL;
 
-        /* These BIGNUMs need to be freed when we're finished */
-        freer = 1;
-        if (!EVP_PKEY_get_bn_param(s->s3.tmp.pkey, OSSL_PKEY_PARAM_FFC_P,
-                                   &r[0])
+            /* These BIGNUMs need to be freed when we're finished */
+            freer = 1;
+            if (!EVP_PKEY_get_bn_param(s->s3.tmp.pkey, OSSL_PKEY_PARAM_FFC_P,
+                    &r[0])
                 || !EVP_PKEY_get_bn_param(s->s3.tmp.pkey, OSSL_PKEY_PARAM_FFC_G,
-                                          &r[1])
+                    &r[1])
                 || !EVP_PKEY_get_bn_param(s->s3.tmp.pkey,
-                                          OSSL_PKEY_PARAM_PUB_KEY, &r[2])) {
-            SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
-            goto err;
-        }
-    } else if (type & (SSL_kECDHE | SSL_kECDHEPSK)) {
+                    OSSL_PKEY_PARAM_PUB_KEY, &r[2])) {
+                SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
+                goto err;
+            }
+        } else if (type & (SSL_kECDHE | SSL_kECDHEPSK)) {
 
-        if (s->s3.tmp.pkey != NULL) {
-            SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
-            goto err;
-        }
+            if (s->s3.tmp.pkey != NULL) {
+                SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
+                goto err;
+            }
 
-        /* Get NID of appropriate shared curve */
-        curve_id = tls1_shared_group(s, -2);
-        if (curve_id == 0) {
-            SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                     SSL_R_UNSUPPORTED_ELLIPTIC_CURVE);
-            goto err;
-        }
-        /* Cache the group used in the SSL_SESSION */
-        s->session->kex_group = curve_id;
-        /* Generate a new key for this curve */
-        s->s3.tmp.pkey = ssl_generate_pkey_group(s, curve_id);
-        if (s->s3.tmp.pkey == NULL) {
-            /* SSLfatal() already called */
-            goto err;
-        }
+            /* Get NID of appropriate shared curve */
+            curve_id = tls1_shared_group(s, -2);
+            if (curve_id == 0) {
+                SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
+                    SSL_R_UNSUPPORTED_ELLIPTIC_CURVE);
+                goto err;
+            }
+            /* Cache the group used in the SSL_SESSION */
+            s->session->kex_group = curve_id;
+            /* Generate a new key for this curve */
+            s->s3.tmp.pkey = ssl_generate_pkey_group(s, curve_id);
+            if (s->s3.tmp.pkey == NULL) {
+                /* SSLfatal() already called */
+                goto err;
+            }
 
-        /* Encode the public key. */
-        encodedlen = EVP_PKEY_get1_encoded_public_key(s->s3.tmp.pkey,
-                                                      &encodedPoint);
-        if (encodedlen == 0) {
-            SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EC_LIB);
-            goto err;
-        }
+            /* Encode the public key. */
+            encodedlen = EVP_PKEY_get1_encoded_public_key(s->s3.tmp.pkey,
+                &encodedPoint);
+            if (encodedlen == 0) {
+                SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_EC_LIB);
+                goto err;
+            }
 
-        /*
-         * We'll generate the serverKeyExchange message explicitly so we
-         * can set these to NULLs
-         */
-        r[0] = NULL;
-        r[1] = NULL;
-        r[2] = NULL;
-        r[3] = NULL;
-    } else
+            /*
+             * We'll generate the serverKeyExchange message explicitly so we
+             * can set these to NULLs
+             */
+            r[0] = NULL;
+            r[1] = NULL;
+            r[2] = NULL;
+            r[3] = NULL;
+        } else
 #ifndef OPENSSL_NO_SRP
-    if (type & SSL_kSRP) {
-        if ((s->srp_ctx.N == NULL) ||
-            (s->srp_ctx.g == NULL) ||
-            (s->srp_ctx.s == NULL) || (s->srp_ctx.B == NULL)) {
-            SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_SRP_PARAM);
+            if (type & SSL_kSRP) {
+            if ((s->srp_ctx.N == NULL) || (s->srp_ctx.g == NULL) || (s->srp_ctx.s == NULL) || (s->srp_ctx.B == NULL)) {
+                SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_MISSING_SRP_PARAM);
+                goto err;
+            }
+            r[0] = s->srp_ctx.N;
+            r[1] = s->srp_ctx.g;
+            r[2] = s->srp_ctx.s;
+            r[3] = s->srp_ctx.B;
+        } else
+#endif
+        {
+            SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE);
             goto err;
         }
-        r[0] = s->srp_ctx.N;
-        r[1] = s->srp_ctx.g;
-        r[2] = s->srp_ctx.s;
-        r[3] = s->srp_ctx.B;
-    } else
-#endif
-    {
-        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE);
-        goto err;
-    }
 
     if (((s->s3.tmp.new_cipher->algorithm_auth & (SSL_aNULL | SSL_aSRP)) != 0)
         || ((s->s3.tmp.new_cipher->algorithm_mkey & SSL_PSK)) != 0) {
@@ -2697,15 +2711,16 @@ CON_FUNC_RETURN tls_construct_server_key_exchange(SSL_CONNECTION *s,
 #ifndef OPENSSL_NO_PSK
     if (type & SSL_PSK) {
         size_t len = (s->cert->psk_identity_hint == NULL)
-                        ? 0 : strlen(s->cert->psk_identity_hint);
+            ? 0
+            : strlen(s->cert->psk_identity_hint);
 
         /*
          * It should not happen that len > PSK_MAX_IDENTITY_LEN - we already
          * checked this when we set the identity hint - but just in case
          */
         if (len > PSK_MAX_IDENTITY_LEN
-                || !WPACKET_sub_memcpy_u16(pkt, s->cert->psk_identity_hint,
-                                           len)) {
+            || !WPACKET_sub_memcpy_u16(pkt, s->cert->psk_identity_hint,
+                len)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             goto err;
         }
@@ -2746,7 +2761,7 @@ CON_FUNC_RETURN tls_construct_server_key_exchange(SSL_CONNECTION *s,
         }
 
         if (!WPACKET_allocate_bytes(pkt, BN_num_bytes(r[i]), &binval)
-                || !WPACKET_close(pkt)) {
+            || !WPACKET_close(pkt)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             goto err;
         }
@@ -2762,9 +2777,9 @@ CON_FUNC_RETURN tls_construct_server_key_exchange(SSL_CONNECTION *s,
          * point itself
          */
         if (!WPACKET_put_bytes_u8(pkt, NAMED_CURVE_TYPE)
-                || !WPACKET_put_bytes_u8(pkt, 0)
-                || !WPACKET_put_bytes_u8(pkt, curve_id)
-                || !WPACKET_sub_memcpy_u8(pkt, encodedPoint, encodedlen)) {
+            || !WPACKET_put_bytes_u8(pkt, 0)
+            || !WPACKET_put_bytes_u8(pkt, curve_id)
+            || !WPACKET_sub_memcpy_u8(pkt, encodedPoint, encodedlen)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             goto err;
         }
@@ -2796,9 +2811,10 @@ CON_FUNC_RETURN tls_construct_server_key_exchange(SSL_CONNECTION *s,
         }
 
         if (EVP_DigestSignInit_ex(md_ctx, &pctx,
-                                  md == NULL ? NULL : EVP_MD_get0_name(md),
-                                  sctx->libctx, sctx->propq, pkey,
-                                  NULL) <= 0) {
+                md == NULL ? NULL : EVP_MD_get0_name(md),
+                sctx->libctx, sctx->propq, pkey,
+                NULL)
+            <= 0) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             goto err;
         }
@@ -2810,18 +2826,18 @@ CON_FUNC_RETURN tls_construct_server_key_exchange(SSL_CONNECTION *s,
             }
         }
         tbslen = construct_key_exchange_tbs(s, &tbs,
-                                            s->init_buf->data + paramoffset,
-                                            paramlen);
+            s->init_buf->data + paramoffset,
+            paramlen);
         if (tbslen == 0) {
             /* SSLfatal() already called */
             goto err;
         }
 
-        if (EVP_DigestSign(md_ctx, NULL, &siglen, tbs, tbslen) <=0
-                || !WPACKET_sub_reserve_bytes_u16(pkt, siglen, &sigbytes1)
-                || EVP_DigestSign(md_ctx, sigbytes1, &siglen, tbs, tbslen) <= 0
-                || !WPACKET_sub_allocate_bytes_u16(pkt, siglen, &sigbytes2)
-                || sigbytes1 != sigbytes2) {
+        if (EVP_DigestSign(md_ctx, NULL, &siglen, tbs, tbslen) <= 0
+            || !WPACKET_sub_reserve_bytes_u16(pkt, siglen, &sigbytes1)
+            || EVP_DigestSign(md_ctx, sigbytes1, &siglen, tbs, tbslen) <= 0
+            || !WPACKET_sub_allocate_bytes_u16(pkt, siglen, &sigbytes2)
+            || sigbytes1 != sigbytes2) {
             OPENSSL_free(tbs);
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             goto err;
@@ -2830,7 +2846,7 @@ CON_FUNC_RETURN tls_construct_server_key_exchange(SSL_CONNECTION *s,
     }
 
     ret = CON_FUNC_SUCCESS;
- err:
+err:
     EVP_PKEY_free(pkdh);
     OPENSSL_free(encodedPoint);
     EVP_MD_CTX_free(md_ctx);
@@ -2844,7 +2860,7 @@ CON_FUNC_RETURN tls_construct_server_key_exchange(SSL_CONNECTION *s,
 }
 
 CON_FUNC_RETURN tls_construct_certificate_request(SSL_CONNECTION *s,
-                                                  WPACKET *pkt)
+    WPACKET *pkt)
 {
     if (SSL_CONNECTION_IS_TLS13(s)) {
         /* Send random context when doing post-handshake auth */
@@ -2857,9 +2873,10 @@ CON_FUNC_RETURN tls_construct_certificate_request(SSL_CONNECTION *s,
                 return CON_FUNC_ERROR;
             }
             if (RAND_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx,
-                              s->pha_context, s->pha_context_len, 0) <= 0
-                    || !WPACKET_sub_memcpy_u8(pkt, s->pha_context,
-                                              s->pha_context_len)) {
+                    s->pha_context, s->pha_context_len, 0)
+                    <= 0
+                || !WPACKET_sub_memcpy_u8(pkt, s->pha_context,
+                    s->pha_context_len)) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 return CON_FUNC_ERROR;
             }
@@ -2876,8 +2893,8 @@ CON_FUNC_RETURN tls_construct_certificate_request(SSL_CONNECTION *s,
         }
 
         if (!tls_construct_extensions(s, pkt,
-                                      SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, NULL,
-                                      0)) {
+                SSL_EXT_TLS1_3_CERTIFICATE_REQUEST, NULL,
+                0)) {
             /* SSLfatal() already called */
             return CON_FUNC_ERROR;
         }
@@ -2896,9 +2913,9 @@ CON_FUNC_RETURN tls_construct_certificate_request(SSL_CONNECTION *s,
         size_t nl = tls12_get_psigalgs(s, 1, &psigs);
 
         if (!WPACKET_start_sub_packet_u16(pkt)
-                || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
-                || !tls12_copy_sigalgs(s, pkt, psigs, nl)
-                || !WPACKET_close(pkt)) {
+            || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
+            || !tls12_copy_sigalgs(s, pkt, psigs, nl)
+            || !WPACKET_close(pkt)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return CON_FUNC_ERROR;
         }
@@ -2909,7 +2926,7 @@ CON_FUNC_RETURN tls_construct_certificate_request(SSL_CONNECTION *s,
         return CON_FUNC_ERROR;
     }
 
- done:
+done:
     s->certreqs_sent++;
     s->s3.tmp.cert_request = 1;
     return CON_FUNC_SUCCESS;
@@ -2941,8 +2958,8 @@ static int tls_process_cke_psk_preamble(SSL_CONNECTION *s, PACKET *pkt)
     }
 
     psklen = s->psk_server_callback(SSL_CONNECTION_GET_USER_SSL(s),
-                                    s->session->psk_identity,
-                                    psk, sizeof(psk));
+        s->session->psk_identity,
+        psk, sizeof(psk));
 
     if (psklen > PSK_MAX_PSK_LEN) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
@@ -3028,23 +3045,24 @@ static int tls_process_cke_rsa(SSL_CONNECTION *s, PACKET *pkt)
      * See https://tools.ietf.org/html/rfc5246#section-7.4.7.1
      */
     if (EVP_PKEY_decrypt_init(ctx) <= 0
-            || EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_WITH_TLS_PADDING) <= 0) {
+        || EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_WITH_TLS_PADDING) <= 0) {
         SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_DECRYPTION_FAILED);
         goto err;
     }
 
     *p++ = OSSL_PARAM_construct_uint(OSSL_ASYM_CIPHER_PARAM_TLS_CLIENT_VERSION,
-                                     (unsigned int *)&s->client_version);
-   if ((s->options & SSL_OP_TLS_ROLLBACK_BUG) != 0)
+        (unsigned int *)&s->client_version);
+    if ((s->options & SSL_OP_TLS_ROLLBACK_BUG) != 0)
         *p++ = OSSL_PARAM_construct_uint(
             OSSL_ASYM_CIPHER_PARAM_TLS_NEGOTIATED_VERSION,
             (unsigned int *)&s->version);
     *p++ = OSSL_PARAM_construct_end();
 
     if (!EVP_PKEY_CTX_set_params(ctx, params)
-            || EVP_PKEY_decrypt(ctx, rsa_decrypt, &outlen,
-                                PACKET_data(&enc_premaster),
-                                PACKET_remaining(&enc_premaster)) <= 0) {
+        || EVP_PKEY_decrypt(ctx, rsa_decrypt, &outlen,
+               PACKET_data(&enc_premaster),
+               PACKET_remaining(&enc_premaster))
+            <= 0) {
         SSLfatal(s, SSL_AD_DECRYPT_ERROR, SSL_R_DECRYPTION_FAILED);
         goto err;
     }
@@ -3066,7 +3084,7 @@ static int tls_process_cke_rsa(SSL_CONNECTION *s, PACKET *pkt)
     }
 
     ret = 1;
- err:
+err:
     OPENSSL_free(rsa_decrypt);
     EVP_PKEY_CTX_free(ctx);
     return ret;
@@ -3118,7 +3136,7 @@ static int tls_process_cke_dhe(SSL_CONNECTION *s, PACKET *pkt)
     ret = 1;
     EVP_PKEY_free(s->s3.tmp.pkey);
     s->s3.tmp.pkey = NULL;
- err:
+err:
     EVP_PKEY_free(ckey);
     return ret;
 }
@@ -3173,7 +3191,7 @@ static int tls_process_cke_ecdhe(SSL_CONNECTION *s, PACKET *pkt)
     ret = 1;
     EVP_PKEY_free(s->s3.tmp.pkey);
     s->s3.tmp.pkey = NULL;
- err:
+err:
     EVP_PKEY_free(ckey);
 
     return ret;
@@ -3275,10 +3293,10 @@ static int tls_process_cke_gost(SSL_CONNECTION *s, PACKET *pkt)
      * We have nothing to do with this blob so we just skip it */
     pKX = d2i_GOST_KX_MESSAGE(NULL, &ptr, PACKET_remaining(pkt));
     if (pKX == NULL
-       || pKX->kxBlob == NULL
-       || ASN1_TYPE_get(pKX->kxBlob) != V_ASN1_SEQUENCE) {
-         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_DECRYPTION_FAILED);
-         goto err;
+        || pKX->kxBlob == NULL
+        || ASN1_TYPE_get(pKX->kxBlob) != V_ASN1_SEQUENCE) {
+        SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_DECRYPTION_FAILED);
+        goto err;
     }
 
     if (!PACKET_forward(pkt, ptr - PACKET_data(pkt))) {
@@ -3295,7 +3313,8 @@ static int tls_process_cke_gost(SSL_CONNECTION *s, PACKET *pkt)
     start = pKX->kxBlob->value.sequence->data;
 
     if (EVP_PKEY_decrypt(pkey_ctx, premaster_secret, &outlen, start,
-                         inlen) <= 0) {
+            inlen)
+        <= 0) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_DECRYPTION_FAILED);
         goto err;
     }
@@ -3306,11 +3325,12 @@ static int tls_process_cke_gost(SSL_CONNECTION *s, PACKET *pkt)
     }
     /* Check if pubkey from client certificate was used */
     if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, -1, EVP_PKEY_CTRL_PEER_KEY, 2,
-                          NULL) > 0)
+            NULL)
+        > 0)
         s->statem.no_cert_verify = 1;
 
     ret = 1;
- err:
+err:
     EVP_PKEY_CTX_free(pkey_ctx);
     GOST_KX_MESSAGE_free(pKX);
     return ret;
@@ -3345,9 +3365,7 @@ static int tls_process_cke_gost18(SSL_CONNECTION *s, PACKET *pkt)
     }
 
     /* Get our certificate private key */
-    pk = s->cert->pkeys[SSL_PKEY_GOST12_512].privatekey != NULL ?
-         s->cert->pkeys[SSL_PKEY_GOST12_512].privatekey :
-         s->cert->pkeys[SSL_PKEY_GOST12_256].privatekey;
+    pk = s->cert->pkeys[SSL_PKEY_GOST12_512].privatekey != NULL ? s->cert->pkeys[SSL_PKEY_GOST12_512].privatekey : s->cert->pkeys[SSL_PKEY_GOST12_256].privatekey;
     if (pk == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_HANDSHAKE_STATE);
         goto err;
@@ -3365,13 +3383,15 @@ static int tls_process_cke_gost18(SSL_CONNECTION *s, PACKET *pkt)
 
     /* Reuse EVP_PKEY_CTRL_SET_IV, make choice in engine code depending on size */
     if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_DECRYPT,
-                          EVP_PKEY_CTRL_SET_IV, 32, rnd_dgst) <= 0) {
+            EVP_PKEY_CTRL_SET_IV, 32, rnd_dgst)
+        <= 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG);
         goto err;
     }
 
     if (EVP_PKEY_CTX_ctrl(pkey_ctx, -1, EVP_PKEY_OP_DECRYPT,
-                          EVP_PKEY_CTRL_CIPHER, cipher_nid, NULL) <= 0) {
+            EVP_PKEY_CTRL_CIPHER, cipher_nid, NULL)
+        <= 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG);
         goto err;
     }
@@ -3384,12 +3404,12 @@ static int tls_process_cke_gost18(SSL_CONNECTION *s, PACKET *pkt)
     }
     /* Generate master secret */
     if (!ssl_generate_master_secret(s, premaster_secret, outlen, 0)) {
-         /* SSLfatal() already called */
-         goto err;
+        /* SSLfatal() already called */
+        goto err;
     }
     ret = 1;
 
- err:
+err:
     EVP_PKEY_CTX_free(pkey_ctx);
     return ret;
 #else
@@ -3400,7 +3420,7 @@ static int tls_process_cke_gost18(SSL_CONNECTION *s, PACKET *pkt)
 }
 
 MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL_CONNECTION *s,
-                                                   PACKET *pkt)
+    PACKET *pkt)
 {
     unsigned long alg_k;
 
@@ -3459,7 +3479,7 @@ MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL_CONNECTION *s,
     }
 
     return MSG_PROCESS_CONTINUE_PROCESSING;
- err:
+err:
 #ifndef OPENSSL_NO_PSK
     OPENSSL_clear_free(s->s3.tmp.psk, s->s3.tmp.psklen);
     s->s3.tmp.psk = NULL;
@@ -3469,7 +3489,7 @@ MSG_PROCESS_RETURN tls_process_client_key_exchange(SSL_CONNECTION *s,
 }
 
 WORK_STATE tls_post_process_client_key_exchange(SSL_CONNECTION *s,
-                                                WORK_STATE wst)
+    WORK_STATE wst)
 {
 #ifndef OPENSSL_NO_SCTP
     if (wst == WORK_MORE_A) {
@@ -3482,7 +3502,7 @@ WORK_STATE tls_post_process_client_key_exchange(SSL_CONNECTION *s,
              * used.
              */
             memcpy(labelbuffer, DTLS1_SCTP_AUTH_LABEL,
-                   sizeof(DTLS1_SCTP_AUTH_LABEL));
+                sizeof(DTLS1_SCTP_AUTH_LABEL));
 
             /* Don't include the terminating zero. */
             labellen = sizeof(labelbuffer) - 1;
@@ -3490,16 +3510,17 @@ WORK_STATE tls_post_process_client_key_exchange(SSL_CONNECTION *s,
                 labellen += 1;
 
             if (SSL_export_keying_material(SSL_CONNECTION_GET_SSL(s),
-                                           sctpauthkey,
-                                           sizeof(sctpauthkey), labelbuffer,
-                                           labellen, NULL, 0,
-                                           0) <= 0) {
+                    sctpauthkey,
+                    sizeof(sctpauthkey), labelbuffer,
+                    labellen, NULL, 0,
+                    0)
+                <= 0) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 return WORK_ERROR;
             }
 
             BIO_ctrl(s->wbio, BIO_CTRL_DGRAM_SCTP_ADD_AUTH_KEY,
-                     sizeof(sctpauthkey), sctpauthkey);
+                sizeof(sctpauthkey), sctpauthkey);
         }
     }
 #endif
@@ -3545,15 +3566,15 @@ MSG_PROCESS_RETURN tls_process_client_rpk(SSL_CONNECTION *sc, PACKET *pkt)
 
     if (peer_rpk == NULL) {
         if ((sc->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)
-                && (sc->verify_mode & SSL_VERIFY_PEER)) {
+            && (sc->verify_mode & SSL_VERIFY_PEER)) {
             SSLfatal(sc, SSL_AD_CERTIFICATE_REQUIRED,
-                     SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
+                SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
             goto err;
         }
     } else {
         if (ssl_verify_rpk(sc, peer_rpk) <= 0) {
             SSLfatal(sc, ssl_x509err2alert(sc->verify_result),
-                     SSL_R_CERTIFICATE_VERIFY_FAILED);
+                SSL_R_CERTIFICATE_VERIFY_FAILED);
             goto err;
         }
     }
@@ -3600,8 +3621,8 @@ MSG_PROCESS_RETURN tls_process_client_rpk(SSL_CONNECTION *sc, PACKET *pkt)
 
         /* Save the current hash state for when we receive the CertificateVerify */
         if (!ssl_handshake_hash(sc, sc->cert_verify_hash,
-                                sizeof(sc->cert_verify_hash),
-                                &sc->cert_verify_hash_len)) {
+                sizeof(sc->cert_verify_hash),
+                &sc->cert_verify_hash_len)) {
             /* SSLfatal() already called */;
             goto err;
         }
@@ -3612,13 +3633,13 @@ MSG_PROCESS_RETURN tls_process_client_rpk(SSL_CONNECTION *sc, PACKET *pkt)
 
     ret = MSG_PROCESS_CONTINUE_READING;
 
- err:
+err:
     EVP_PKEY_free(peer_rpk);
     return ret;
 }
 
 MSG_PROCESS_RETURN tls_process_client_certificate(SSL_CONNECTION *s,
-                                                  PACKET *pkt)
+    PACKET *pkt)
 {
     int i;
     MSG_PROCESS_RETURN ret = MSG_PROCESS_ERROR;
@@ -3643,7 +3664,7 @@ MSG_PROCESS_RETURN tls_process_client_certificate(SSL_CONNECTION *s,
 
     if (s->ext.client_cert_type != TLSEXT_cert_type_x509) {
         SSLfatal(s, SSL_AD_UNSUPPORTED_CERTIFICATE,
-                 SSL_R_UNKNOWN_CERTIFICATE_TYPE);
+            SSL_R_UNKNOWN_CERTIFICATE_TYPE);
         goto err;
     }
 
@@ -3654,16 +3675,16 @@ MSG_PROCESS_RETURN tls_process_client_certificate(SSL_CONNECTION *s,
 
     if (SSL_CONNECTION_IS_TLS13(s)
         && (!PACKET_get_length_prefixed_1(pkt, &context)
-                || (s->pha_context == NULL && PACKET_remaining(&context) != 0)
-                || (s->pha_context != NULL
-                    && !PACKET_equal(&context, s->pha_context,
-                                     s->pha_context_len)))) {
+            || (s->pha_context == NULL && PACKET_remaining(&context) != 0)
+            || (s->pha_context != NULL
+                && !PACKET_equal(&context, s->pha_context,
+                    s->pha_context_len)))) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_INVALID_CONTEXT);
         goto err;
     }
 
     if (!PACKET_get_length_prefixed_3(pkt, &spkt)
-            || PACKET_remaining(pkt) != 0) {
+        || PACKET_remaining(pkt) != 0) {
         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_MISMATCH);
         goto err;
     }
@@ -3700,11 +3721,11 @@ MSG_PROCESS_RETURN tls_process_client_certificate(SSL_CONNECTION *s,
                 goto err;
             }
             if (!tls_collect_extensions(s, &extensions,
-                                        SSL_EXT_TLS1_3_CERTIFICATE, &rawexts,
-                                        NULL, chainidx == 0)
+                    SSL_EXT_TLS1_3_CERTIFICATE, &rawexts,
+                    NULL, chainidx == 0)
                 || !tls_parse_all_extensions(s, SSL_EXT_TLS1_3_CERTIFICATE,
-                                             rawexts, x, chainidx,
-                                             PACKET_remaining(&spkt) == 0)) {
+                    rawexts, x, chainidx,
+                    PACKET_remaining(&spkt) == 0)) {
                 OPENSSL_free(rawexts);
                 goto err;
             }
@@ -3722,14 +3743,13 @@ MSG_PROCESS_RETURN tls_process_client_certificate(SSL_CONNECTION *s,
         /* TLS does not mind 0 certs returned */
         if (s->version == SSL3_VERSION) {
             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                     SSL_R_NO_CERTIFICATES_RETURNED);
+                SSL_R_NO_CERTIFICATES_RETURNED);
             goto err;
         }
         /* Fail for TLS only if we required a certificate */
-        else if ((s->verify_mode & SSL_VERIFY_PEER) &&
-                 (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) {
+        else if ((s->verify_mode & SSL_VERIFY_PEER) && (s->verify_mode & SSL_VERIFY_FAIL_IF_NO_PEER_CERT)) {
             SSLfatal(s, SSL_AD_CERTIFICATE_REQUIRED,
-                     SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
+                SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE);
             goto err;
         }
         /* No client certificate so digest cached records */
@@ -3742,13 +3762,13 @@ MSG_PROCESS_RETURN tls_process_client_certificate(SSL_CONNECTION *s,
         i = ssl_verify_cert_chain(s, sk);
         if (i <= 0) {
             SSLfatal(s, ssl_x509err2alert(s->verify_result),
-                     SSL_R_CERTIFICATE_VERIFY_FAILED);
+                SSL_R_CERTIFICATE_VERIFY_FAILED);
             goto err;
         }
         pkey = X509_get0_pubkey(sk_X509_value(sk, 0));
         if (pkey == NULL) {
             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                     SSL_R_UNKNOWN_CERTIFICATE_TYPE);
+                SSL_R_UNKNOWN_CERTIFICATE_TYPE);
             goto err;
         }
     }
@@ -3799,8 +3819,8 @@ MSG_PROCESS_RETURN tls_process_client_certificate(SSL_CONNECTION *s,
     /* Save the current hash state for when we receive the CertificateVerify */
     if (SSL_CONNECTION_IS_TLS13(s)) {
         if (!ssl_handshake_hash(s, s->cert_verify_hash,
-                                sizeof(s->cert_verify_hash),
-                                &s->cert_verify_hash_len)) {
+                sizeof(s->cert_verify_hash),
+                &s->cert_verify_hash_len)) {
             /* SSLfatal() already called */
             goto err;
         }
@@ -3811,7 +3831,7 @@ MSG_PROCESS_RETURN tls_process_client_certificate(SSL_CONNECTION *s,
 
     ret = MSG_PROCESS_CONTINUE_READING;
 
- err:
+err:
     X509_free(x);
     OSSL_STACK_OF_X509_free(sk);
     return ret;
@@ -3885,10 +3905,10 @@ CON_FUNC_RETURN tls_construct_server_compressed_certificate(SSL_CONNECTION *sc,
      * Use pre-compressed certificate
      */
     if (!WPACKET_put_bytes_u16(pkt, alg)
-            || !WPACKET_put_bytes_u24(pkt, cc->orig_len)
-            || !WPACKET_start_sub_packet_u24(pkt)
-            || !WPACKET_memcpy(pkt, cc->data, cc->len)
-            || !WPACKET_close(pkt))
+        || !WPACKET_put_bytes_u24(pkt, cc->orig_len)
+        || !WPACKET_start_sub_packet_u24(pkt)
+        || !WPACKET_memcpy(pkt, cc->data, cc->len)
+        || !WPACKET_close(pkt))
         return 0;
 
     sc->s3.tmp.cert->cert_comp_used++;
@@ -3897,7 +3917,7 @@ CON_FUNC_RETURN tls_construct_server_compressed_certificate(SSL_CONNECTION *sc,
 #endif
 
 static int create_ticket_prequel(SSL_CONNECTION *s, WPACKET *pkt,
-                                 uint32_t age_add, unsigned char *tick_nonce)
+    uint32_t age_add, unsigned char *tick_nonce)
 {
     uint32_t timeout = (uint32_t)ossl_time2seconds(s->session->timeout);
 
@@ -3912,7 +3932,8 @@ static int create_ticket_prequel(SSL_CONNECTION *s, WPACKET *pkt,
 
     if (SSL_CONNECTION_IS_TLS13(s)) {
         if (ossl_time_compare(s->session->timeout,
-                              ossl_seconds2time(ONE_WEEK_SEC)) > 0)
+                ossl_seconds2time(ONE_WEEK_SEC))
+            > 0)
             timeout = ONE_WEEK_SEC;
     } else if (s->hit)
         timeout = 0;
@@ -3924,7 +3945,7 @@ static int create_ticket_prequel(SSL_CONNECTION *s, WPACKET *pkt,
 
     if (SSL_CONNECTION_IS_TLS13(s)) {
         if (!WPACKET_put_bytes_u32(pkt, age_add)
-                || !WPACKET_sub_memcpy_u8(pkt, tick_nonce, TICKET_NONCE_SIZE)) {
+            || !WPACKET_sub_memcpy_u8(pkt, tick_nonce, TICKET_NONCE_SIZE)) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             return 0;
         }
@@ -3940,9 +3961,9 @@ static int create_ticket_prequel(SSL_CONNECTION *s, WPACKET *pkt,
 }
 
 static CON_FUNC_RETURN construct_stateless_ticket(SSL_CONNECTION *s,
-                                                  WPACKET *pkt,
-                                                  uint32_t age_add,
-                                                  unsigned char *tick_nonce)
+    WPACKET *pkt,
+    uint32_t age_add,
+    unsigned char *tick_nonce)
 {
     unsigned char *senc = NULL;
     EVP_CIPHER_CTX *ctx = NULL;
@@ -3999,7 +4020,7 @@ static CON_FUNC_RETURN construct_stateless_ticket(SSL_CONNECTION *s,
      */
     const_p = senc;
     sess = d2i_SSL_SESSION_ex(NULL, &const_p, slen_full, sctx->libctx,
-                              sctx->propq);
+        sctx->propq);
     if (sess == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
@@ -4034,13 +4055,13 @@ static CON_FUNC_RETURN construct_stateless_ticket(SSL_CONNECTION *s,
 
         if (tctx->ext.ticket_key_evp_cb != NULL)
             ret = tctx->ext.ticket_key_evp_cb(ssl, key_name, iv, ctx,
-                                              ssl_hmac_get0_EVP_MAC_CTX(hctx),
-                                              1);
+                ssl_hmac_get0_EVP_MAC_CTX(hctx),
+                1);
 #ifndef OPENSSL_NO_DEPRECATED_3_0
         else if (tctx->ext.ticket_key_cb != NULL)
             /* if 0 is returned, write an empty ticket */
             ret = tctx->ext.ticket_key_cb(ssl, key_name, iv, ctx,
-                                          ssl_hmac_get0_HMAC_CTX(hctx), 1);
+                ssl_hmac_get0_HMAC_CTX(hctx), 1);
 #endif
 
         if (ret == 0) {
@@ -4055,7 +4076,7 @@ static CON_FUNC_RETURN construct_stateless_ticket(SSL_CONNECTION *s,
             }
             /* Put timeout and length */
             if (!WPACKET_put_bytes_u32(pkt, 0)
-                    || !WPACKET_put_bytes_u16(pkt, 0)) {
+                || !WPACKET_put_bytes_u16(pkt, 0)) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 goto err;
             }
@@ -4075,7 +4096,7 @@ static CON_FUNC_RETURN construct_stateless_ticket(SSL_CONNECTION *s,
         }
     } else {
         EVP_CIPHER *cipher = EVP_CIPHER_fetch(sctx->libctx, "AES-256-CBC",
-                                              sctx->propq);
+            sctx->propq);
 
         if (cipher == NULL) {
             /* Error is already recorded */
@@ -4085,19 +4106,19 @@ static CON_FUNC_RETURN construct_stateless_ticket(SSL_CONNECTION *s,
 
         iv_len = EVP_CIPHER_get_iv_length(cipher);
         if (iv_len < 0
-                || RAND_bytes_ex(sctx->libctx, iv, iv_len, 0) <= 0
-                || !EVP_EncryptInit_ex(ctx, cipher, NULL,
-                                       tctx->ext.secure->tick_aes_key, iv)
-                || !ssl_hmac_init(hctx, tctx->ext.secure->tick_hmac_key,
-                                  sizeof(tctx->ext.secure->tick_hmac_key),
-                                  "SHA256")) {
+            || RAND_bytes_ex(sctx->libctx, iv, iv_len, 0) <= 0
+            || !EVP_EncryptInit_ex(ctx, cipher, NULL,
+                tctx->ext.secure->tick_aes_key, iv)
+            || !ssl_hmac_init(hctx, tctx->ext.secure->tick_hmac_key,
+                sizeof(tctx->ext.secure->tick_hmac_key),
+                "SHA256")) {
             EVP_CIPHER_free(cipher);
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             goto err;
         }
         EVP_CIPHER_free(cipher);
         memcpy(key_name, tctx->ext.tick_key_name,
-               sizeof(tctx->ext.tick_key_name));
+            sizeof(tctx->ext.tick_key_name));
     }
 
     if (!create_ticket_prequel(s, pkt, age_add, tick_nonce)) {
@@ -4106,29 +4127,29 @@ static CON_FUNC_RETURN construct_stateless_ticket(SSL_CONNECTION *s,
     }
 
     if (!WPACKET_get_total_written(pkt, &macoffset)
-               /* Output key name */
-            || !WPACKET_memcpy(pkt, key_name, sizeof(key_name))
-               /* output IV */
-            || !WPACKET_memcpy(pkt, iv, iv_len)
-            || !WPACKET_reserve_bytes(pkt, slen + EVP_MAX_BLOCK_LENGTH,
-                                      &encdata1)
-               /* Encrypt session data */
-            || !EVP_EncryptUpdate(ctx, encdata1, &len, senc, slen)
-            || !WPACKET_allocate_bytes(pkt, len, &encdata2)
-            || encdata1 != encdata2
-            || !EVP_EncryptFinal(ctx, encdata1 + len, &lenfinal)
-            || !WPACKET_allocate_bytes(pkt, lenfinal, &encdata2)
-            || encdata1 + len != encdata2
-            || len + lenfinal > slen + EVP_MAX_BLOCK_LENGTH
-            || !WPACKET_get_total_written(pkt, &macendoffset)
-            || !ssl_hmac_update(hctx,
-                                (unsigned char *)s->init_buf->data + macoffset,
-                                macendoffset - macoffset)
-            || !WPACKET_reserve_bytes(pkt, EVP_MAX_MD_SIZE, &macdata1)
-            || !ssl_hmac_final(hctx, macdata1, &hlen, EVP_MAX_MD_SIZE)
-            || hlen > EVP_MAX_MD_SIZE
-            || !WPACKET_allocate_bytes(pkt, hlen, &macdata2)
-            || macdata1 != macdata2) {
+        /* Output key name */
+        || !WPACKET_memcpy(pkt, key_name, sizeof(key_name))
+        /* output IV */
+        || !WPACKET_memcpy(pkt, iv, iv_len)
+        || !WPACKET_reserve_bytes(pkt, slen + EVP_MAX_BLOCK_LENGTH,
+            &encdata1)
+        /* Encrypt session data */
+        || !EVP_EncryptUpdate(ctx, encdata1, &len, senc, slen)
+        || !WPACKET_allocate_bytes(pkt, len, &encdata2)
+        || encdata1 != encdata2
+        || !EVP_EncryptFinal(ctx, encdata1 + len, &lenfinal)
+        || !WPACKET_allocate_bytes(pkt, lenfinal, &encdata2)
+        || encdata1 + len != encdata2
+        || len + lenfinal > slen + EVP_MAX_BLOCK_LENGTH
+        || !WPACKET_get_total_written(pkt, &macendoffset)
+        || !ssl_hmac_update(hctx,
+            (unsigned char *)s->init_buf->data + macoffset,
+            macendoffset - macoffset)
+        || !WPACKET_reserve_bytes(pkt, EVP_MAX_MD_SIZE, &macdata1)
+        || !ssl_hmac_final(hctx, macdata1, &hlen, EVP_MAX_MD_SIZE)
+        || hlen > EVP_MAX_MD_SIZE
+        || !WPACKET_allocate_bytes(pkt, hlen, &macdata2)
+        || macdata1 != macdata2) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
@@ -4140,7 +4161,7 @@ static CON_FUNC_RETURN construct_stateless_ticket(SSL_CONNECTION *s,
     }
 
     ok = CON_FUNC_SUCCESS;
- err:
+err:
     OPENSSL_free(senc);
     EVP_CIPHER_CTX_free(ctx);
     ssl_hmac_free(hctx);
@@ -4148,8 +4169,8 @@ static CON_FUNC_RETURN construct_stateless_ticket(SSL_CONNECTION *s,
 }
 
 static int construct_stateful_ticket(SSL_CONNECTION *s, WPACKET *pkt,
-                                     uint32_t age_add,
-                                     unsigned char *tick_nonce)
+    uint32_t age_add,
+    unsigned char *tick_nonce)
 {
     if (!create_ticket_prequel(s, pkt, age_add, tick_nonce)) {
         /* SSLfatal() already called */
@@ -4157,8 +4178,8 @@ static int construct_stateful_ticket(SSL_CONNECTION *s, WPACKET *pkt,
     }
 
     if (!WPACKET_memcpy(pkt, s->session->session_id,
-                        s->session->session_id_length)
-            || !WPACKET_close(pkt)) {
+            s->session->session_id_length)
+        || !WPACKET_close(pkt)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
@@ -4195,7 +4216,9 @@ CON_FUNC_RETURN tls_construct_new_session_ticket(SSL_CONNECTION *s, WPACKET *pkt
     if (SSL_CONNECTION_IS_TLS13(s)) {
         size_t i, hashlen;
         uint64_t nonce;
-        static const unsigned char nonce_label[] = "resumption";
+        /* ASCII: "resumption", in hex for EBCDIC compatibility */
+        static const unsigned char nonce_label[] = { 0x72, 0x65, 0x73, 0x75, 0x6D,
+            0x70, 0x74, 0x69, 0x6F, 0x6E };
         const EVP_MD *md = ssl_handshake_md(s);
         int hashleni = EVP_MD_get_size(md);
 
@@ -4228,7 +4251,8 @@ CON_FUNC_RETURN tls_construct_new_session_ticket(SSL_CONNECTION *s, WPACKET *pkt
             goto err;
         }
         if (RAND_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx,
-                          age_add_u.age_add_c, sizeof(age_add_u), 0) <= 0) {
+                age_add_u.age_add_c, sizeof(age_add_u), 0)
+            <= 0) {
             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
             goto err;
         }
@@ -4241,12 +4265,12 @@ CON_FUNC_RETURN tls_construct_new_session_ticket(SSL_CONNECTION *s, WPACKET *pkt
         }
 
         if (!tls13_hkdf_expand(s, md, s->resumption_master_secret,
-                               nonce_label,
-                               sizeof(nonce_label) - 1,
-                               tick_nonce,
-                               TICKET_NONCE_SIZE,
-                               s->session->master_key,
-                               hashlen, 1)) {
+                nonce_label,
+                sizeof(nonce_label),
+                tick_nonce,
+                TICKET_NONCE_SIZE,
+                s->session->master_key,
+                hashlen, 1)) {
             /* SSLfatal() already called */
             goto err;
         }
@@ -4256,8 +4280,7 @@ CON_FUNC_RETURN tls_construct_new_session_ticket(SSL_CONNECTION *s, WPACKET *pkt
         ssl_session_calculate_timeout(s->session);
         if (s->s3.alpn_selected != NULL) {
             OPENSSL_free(s->session->ext.alpn_selected);
-            s->session->ext.alpn_selected =
-                OPENSSL_memdup(s->s3.alpn_selected, s->s3.alpn_selected_len);
+            s->session->ext.alpn_selected = OPENSSL_memdup(s->s3.alpn_selected, s->s3.alpn_selected_len);
             if (s->session->ext.alpn_selected == NULL) {
                 s->session->ext.alpn_selected_len = 0;
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_CRYPTO_LIB);
@@ -4268,9 +4291,7 @@ CON_FUNC_RETURN tls_construct_new_session_ticket(SSL_CONNECTION *s, WPACKET *pkt
         s->session->ext.max_early_data = s->max_early_data;
     }
 
-    if (tctx->generate_ticket_cb != NULL &&
-        tctx->generate_ticket_cb(SSL_CONNECTION_GET_USER_SSL(s),
-                                 tctx->ticket_cb_data) == 0) {
+    if (tctx->generate_ticket_cb != NULL && tctx->generate_ticket_cb(SSL_CONNECTION_GET_USER_SSL(s), tctx->ticket_cb_data) == 0) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
@@ -4280,9 +4301,9 @@ CON_FUNC_RETURN tls_construct_new_session_ticket(SSL_CONNECTION *s, WPACKET *pkt
      * is no point in using full stateless tickets.
      */
     if (SSL_CONNECTION_IS_TLS13(s)
-            && ((s->options & SSL_OP_NO_TICKET) != 0
-                || (s->max_early_data > 0
-                    && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0))) {
+        && ((s->options & SSL_OP_NO_TICKET) != 0
+            || (s->max_early_data > 0
+                && (s->options & SSL_OP_NO_ANTI_REPLAY) == 0))) {
         if (!construct_stateful_ticket(s, pkt, age_add_u.age_add, tick_nonce)) {
             /* SSLfatal() already called */
             goto err;
@@ -4291,7 +4312,7 @@ CON_FUNC_RETURN tls_construct_new_session_ticket(SSL_CONNECTION *s, WPACKET *pkt
         CON_FUNC_RETURN tmpret;
 
         tmpret = construct_stateless_ticket(s, pkt, age_add_u.age_add,
-                                            tick_nonce);
+            tick_nonce);
         if (tmpret != CON_FUNC_SUCCESS) {
             if (tmpret == CON_FUNC_DONT_SEND) {
                 /* Non-fatal. Abort construction but continue */
@@ -4306,8 +4327,8 @@ CON_FUNC_RETURN tls_construct_new_session_ticket(SSL_CONNECTION *s, WPACKET *pkt
 
     if (SSL_CONNECTION_IS_TLS13(s)) {
         if (!tls_construct_extensions(s, pkt,
-                                      SSL_EXT_TLS1_3_NEW_SESSION_TICKET,
-                                      NULL, 0)) {
+                SSL_EXT_TLS1_3_NEW_SESSION_TICKET,
+                NULL, 0)) {
             /* SSLfatal() already called */
             goto err;
         }
@@ -4316,7 +4337,7 @@ CON_FUNC_RETURN tls_construct_new_session_ticket(SSL_CONNECTION *s, WPACKET *pkt
     }
 
     ret = CON_FUNC_SUCCESS;
- err:
+err:
     return ret;
 }
 
@@ -4327,8 +4348,8 @@ CON_FUNC_RETURN tls_construct_new_session_ticket(SSL_CONNECTION *s, WPACKET *pkt
 int tls_construct_cert_status_body(SSL_CONNECTION *s, WPACKET *pkt)
 {
     if (!WPACKET_put_bytes_u8(pkt, s->ext.status_type)
-            || !WPACKET_sub_memcpy_u24(pkt, s->ext.ocsp.resp,
-                                       s->ext.ocsp.resp_len)) {
+        || !WPACKET_sub_memcpy_u24(pkt, s->ext.ocsp.resp,
+            s->ext.ocsp.resp_len)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return 0;
     }
@@ -4383,10 +4404,10 @@ MSG_PROCESS_RETURN tls_process_next_proto(SSL_CONNECTION *s, PACKET *pkt)
 #endif
 
 static CON_FUNC_RETURN tls_construct_encrypted_extensions(SSL_CONNECTION *s,
-                                                          WPACKET *pkt)
+    WPACKET *pkt)
 {
     if (!tls_construct_extensions(s, pkt, SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
-                                  NULL, 0)) {
+            NULL, 0)) {
         /* SSLfatal() already called */
         return CON_FUNC_ERROR;
     }
@@ -4402,7 +4423,7 @@ MSG_PROCESS_RETURN tls_process_end_of_early_data(SSL_CONNECTION *s, PACKET *pkt)
     }
 
     if (s->early_data_state != SSL_EARLY_DATA_READING
-            && s->early_data_state != SSL_EARLY_DATA_READ_RETRY) {
+        && s->early_data_state != SSL_EARLY_DATA_READ_RETRY) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         return MSG_PROCESS_ERROR;
     }
@@ -4418,7 +4439,7 @@ MSG_PROCESS_RETURN tls_process_end_of_early_data(SSL_CONNECTION *s, PACKET *pkt)
 
     s->early_data_state = SSL_EARLY_DATA_FINISHED_READING;
     if (!SSL_CONNECTION_GET_SSL(s)->method->ssl3_enc->change_cipher_state(s,
-                SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_SERVER_READ)) {
+            SSL3_CC_HANDSHAKE | SSL3_CHANGE_CIPHER_SERVER_READ)) {
         /* SSLfatal() already called */
         return MSG_PROCESS_ERROR;
     }
diff --git a/crypto/openssl/ssl/t1_enc.c b/crypto/openssl/ssl/t1_enc.c
index 474ea7bf5b66..8978e0c630e6 100644
--- a/crypto/openssl/ssl/t1_enc.c
+++ b/crypto/openssl/ssl/t1_enc.c
@@ -24,13 +24,13 @@
 
 /* seed1 through seed5 are concatenated */
 static int tls1_PRF(SSL_CONNECTION *s,
-                    const void *seed1, size_t seed1_len,
-                    const void *seed2, size_t seed2_len,
-                    const void *seed3, size_t seed3_len,
-                    const void *seed4, size_t seed4_len,
-                    const void *seed5, size_t seed5_len,
-                    const unsigned char *sec, size_t slen,
-                    unsigned char *out, size_t olen, int fatal)
+    const void *seed1, size_t seed1_len,
+    const void *seed2, size_t seed2_len,
+    const void *seed3, size_t seed3_len,
+    const void *seed4, size_t seed4_len,
+    const void *seed5, size_t seed5_len,
+    const unsigned char *sec, size_t slen,
+    unsigned char *out, size_t olen, int fatal)
 {
     const EVP_MD *md = ssl_prf_md(s);
     EVP_KDF *kdf;
@@ -47,8 +47,8 @@ static int tls1_PRF(SSL_CONNECTION *s,
         return 0;
     }
     kdf = EVP_KDF_fetch(SSL_CONNECTION_GET_CTX(s)->libctx,
-                        OSSL_KDF_NAME_TLS1_PRF,
-                        SSL_CONNECTION_GET_CTX(s)->propq);
+        OSSL_KDF_NAME_TLS1_PRF,
+        SSL_CONNECTION_GET_CTX(s)->propq);
     if (kdf == NULL)
         goto err;
     kctx = EVP_KDF_CTX_new(kdf);
@@ -57,27 +57,27 @@ static int tls1_PRF(SSL_CONNECTION *s,
         goto err;
     mdname = EVP_MD_get0_name(md);
     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST,
-                                            (char *)mdname, 0);
+        (char *)mdname, 0);
     *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SECRET,
-                                             (unsigned char *)sec,
-                                             (size_t)slen);
+        (unsigned char *)sec,
+        (size_t)slen);
     *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED,
-                                             (void *)seed1, (size_t)seed1_len);
+        (void *)seed1, (size_t)seed1_len);
     *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED,
-                                             (void *)seed2, (size_t)seed2_len);
+        (void *)seed2, (size_t)seed2_len);
     *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED,
-                                             (void *)seed3, (size_t)seed3_len);
+        (void *)seed3, (size_t)seed3_len);
     *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED,
-                                             (void *)seed4, (size_t)seed4_len);
+        (void *)seed4, (size_t)seed4_len);
     *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SEED,
-                                             (void *)seed5, (size_t)seed5_len);
+        (void *)seed5, (size_t)seed5_len);
     *p = OSSL_PARAM_construct_end();
     if (EVP_KDF_derive(kctx, out, olen, params)) {
         EVP_KDF_CTX_free(kctx);
         return 1;
     }
 
- err:
+err:
     if (fatal)
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
     else
@@ -87,17 +87,17 @@ static int tls1_PRF(SSL_CONNECTION *s,
 }
 
 static int tls1_generate_key_block(SSL_CONNECTION *s, unsigned char *km,
-                                   size_t num)
+    size_t num)
 {
     int ret;
 
     /* Calls SSLfatal() as required */
     ret = tls1_PRF(s,
-                   TLS_MD_KEY_EXPANSION_CONST,
-                   TLS_MD_KEY_EXPANSION_CONST_SIZE, s->s3.server_random,
-                   SSL3_RANDOM_SIZE, s->s3.client_random, SSL3_RANDOM_SIZE,
-                   NULL, 0, NULL, 0, s->session->master_key,
-                   s->session->master_key_length, km, num, 1);
+        TLS_MD_KEY_EXPANSION_CONST,
+        TLS_MD_KEY_EXPANSION_CONST_SIZE, s->s3.server_random,
+        SSL3_RANDOM_SIZE, s->s3.client_random, SSL3_RANDOM_SIZE,
+        NULL, 0, NULL, 0, s->session->master_key,
+        s->session->master_key_length, km, num, 1);
 
     return ret;
 }
@@ -149,8 +149,7 @@ int tls1_change_cipher_state(SSL_CONNECTION *s, int which)
         goto err;
     }
     k = iivlen;
-    if ((which == SSL3_CHANGE_CIPHER_CLIENT_WRITE) ||
-        (which == SSL3_CHANGE_CIPHER_SERVER_READ)) {
+    if ((which == SSL3_CHANGE_CIPHER_CLIENT_WRITE) || (which == SSL3_CHANGE_CIPHER_SERVER_READ)) {
         mac_secret = &(p[0]);
         n = i + i;
         key = &(p[n]);
@@ -178,7 +177,8 @@ int tls1_change_cipher_state(SSL_CONNECTION *s, int which)
         break;
     case EVP_CIPH_CCM_MODE:
         if ((s->s3.tmp.new_cipher->algorithm_enc
-                & (SSL_AES128CCM8 | SSL_AES256CCM8)) != 0)
+                & (SSL_AES128CCM8 | SSL_AES256CCM8))
+            != 0)
             taglen = EVP_CCM8_TLS_TAG_LEN;
         else
             taglen = EVP_CCM_TLS_TAG_LEN;
@@ -233,23 +233,25 @@ int tls1_change_cipher_state(SSL_CONNECTION *s, int which)
         dtls1_increment_epoch(s, which);
 
     if (!ssl_set_new_record_layer(s, s->version, direction,
-                                    OSSL_RECORD_PROTECTION_LEVEL_APPLICATION,
-                                    NULL, 0, key, cl, iv, (size_t)k, mac_secret,
-                                    mac_secret_size, c, taglen, mac_type,
-                                    m, comp, NULL)) {
+            OSSL_RECORD_PROTECTION_LEVEL_APPLICATION,
+            NULL, 0, key, cl, iv, (size_t)k, mac_secret,
+            mac_secret_size, c, taglen, mac_type,
+            m, comp, NULL)) {
         /* SSLfatal already called */
         goto err;
     }
 
-    OSSL_TRACE_BEGIN(TLS) {
+    OSSL_TRACE_BEGIN(TLS)
+    {
         BIO_printf(trc_out, "which = %04X, key:\n", which);
         BIO_dump_indent(trc_out, key, EVP_CIPHER_get_key_length(c), 4);
         BIO_printf(trc_out, "iv:\n");
         BIO_dump_indent(trc_out, iv, k, 4);
-    } OSSL_TRACE_END(TLS);
+    }
+    OSSL_TRACE_END(TLS);
 
     return 1;
- err:
+err:
     return 0;
 }
 
@@ -268,8 +270,8 @@ int tls1_setup_key_block(SSL_CONNECTION *s)
         return 1;
 
     if (!ssl_cipher_get_evp(SSL_CONNECTION_GET_CTX(s), s->session, &c, &hash,
-                            &mac_type, &mac_secret_size, &comp,
-                            s->ext.use_etm)) {
+            &mac_type, &mac_secret_size, &comp,
+            s->ext.use_etm)) {
         /* Error is already recorded */
         SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR);
         return 0;
@@ -299,7 +301,8 @@ int tls1_setup_key_block(SSL_CONNECTION *s)
     s->s3.tmp.key_block_length = num;
     s->s3.tmp.key_block = p;
 
-    OSSL_TRACE_BEGIN(TLS) {
+    OSSL_TRACE_BEGIN(TLS)
+    {
         BIO_printf(trc_out, "key block length: %zu\n", num);
         BIO_printf(trc_out, "client random\n");
         BIO_dump_indent(trc_out, s->s3.client_random, SSL3_RANDOM_SIZE, 4);
@@ -307,27 +310,30 @@ int tls1_setup_key_block(SSL_CONNECTION *s)
         BIO_dump_indent(trc_out, s->s3.server_random, SSL3_RANDOM_SIZE, 4);
         BIO_printf(trc_out, "master key\n");
         BIO_dump_indent(trc_out,
-                        s->session->master_key,
-                        s->session->master_key_length, 4);
-    } OSSL_TRACE_END(TLS);
+            s->session->master_key,
+            s->session->master_key_length, 4);
+    }
+    OSSL_TRACE_END(TLS);
 
     if (!tls1_generate_key_block(s, p, num)) {
         /* SSLfatal() already called */
         goto err;
     }
 
-    OSSL_TRACE_BEGIN(TLS) {
+    OSSL_TRACE_BEGIN(TLS)
+    {
         BIO_printf(trc_out, "key block\n");
         BIO_dump_indent(trc_out, p, num, 4);
-    } OSSL_TRACE_END(TLS);
+    }
+    OSSL_TRACE_END(TLS);
 
     ret = 1;
- err:
+err:
     return ret;
 }
 
 size_t tls1_final_finish_mac(SSL_CONNECTION *s, const char *str,
-                             size_t slen, unsigned char *out)
+    size_t slen, unsigned char *out)
 {
     size_t hashlen;
     unsigned char hash[EVP_MAX_MD_SIZE];
@@ -347,8 +353,8 @@ size_t tls1_final_finish_mac(SSL_CONNECTION *s, const char *str,
     }
 
     if (!tls1_PRF(s, str, slen, hash, hashlen, NULL, 0, NULL, 0, NULL, 0,
-                  s->session->master_key, s->session->master_key_length,
-                  out, finished_size, 1)) {
+            s->session->master_key, s->session->master_key_length,
+            out, finished_size, 1)) {
         /* SSLfatal() already called */
         return 0;
     }
@@ -357,8 +363,8 @@ size_t tls1_final_finish_mac(SSL_CONNECTION *s, const char *str,
 }
 
 int tls1_generate_master_secret(SSL_CONNECTION *s, unsigned char *out,
-                                unsigned char *p, size_t len,
-                                size_t *secret_size)
+    unsigned char *p, size_t len,
+    size_t *secret_size)
 {
     if (s->session->flags & SSL_SESS_FLAG_EXTMS) {
         unsigned char hash[EVP_MAX_MD_SIZE * 2];
@@ -369,41 +375,44 @@ int tls1_generate_master_secret(SSL_CONNECTION *s, unsigned char *out,
          * point (after client key exchange and before certificate verify)
          */
         if (!ssl3_digest_cached_records(s, 1)
-                || !ssl_handshake_hash(s, hash, sizeof(hash), &hashlen)) {
+            || !ssl_handshake_hash(s, hash, sizeof(hash), &hashlen)) {
             /* SSLfatal() already called */
             return 0;
         }
-        OSSL_TRACE_BEGIN(TLS) {
+        OSSL_TRACE_BEGIN(TLS)
+        {
             BIO_printf(trc_out, "Handshake hashes:\n");
             BIO_dump(trc_out, (char *)hash, hashlen);
-        } OSSL_TRACE_END(TLS);
+        }
+        OSSL_TRACE_END(TLS);
         if (!tls1_PRF(s,
-                      TLS_MD_EXTENDED_MASTER_SECRET_CONST,
-                      TLS_MD_EXTENDED_MASTER_SECRET_CONST_SIZE,
-                      hash, hashlen,
-                      NULL, 0,
-                      NULL, 0,
-                      NULL, 0, p, len, out,
-                      SSL3_MASTER_SECRET_SIZE, 1)) {
+                TLS_MD_EXTENDED_MASTER_SECRET_CONST,
+                TLS_MD_EXTENDED_MASTER_SECRET_CONST_SIZE,
+                hash, hashlen,
+                NULL, 0,
+                NULL, 0,
+                NULL, 0, p, len, out,
+                SSL3_MASTER_SECRET_SIZE, 1)) {
             /* SSLfatal() already called */
             return 0;
         }
         OPENSSL_cleanse(hash, hashlen);
     } else {
         if (!tls1_PRF(s,
-                      TLS_MD_MASTER_SECRET_CONST,
-                      TLS_MD_MASTER_SECRET_CONST_SIZE,
-                      s->s3.client_random, SSL3_RANDOM_SIZE,
-                      NULL, 0,
-                      s->s3.server_random, SSL3_RANDOM_SIZE,
-                      NULL, 0, p, len, out,
-                      SSL3_MASTER_SECRET_SIZE, 1)) {
-           /* SSLfatal() already called */
+                TLS_MD_MASTER_SECRET_CONST,
+                TLS_MD_MASTER_SECRET_CONST_SIZE,
+                s->s3.client_random, SSL3_RANDOM_SIZE,
+                NULL, 0,
+                s->s3.server_random, SSL3_RANDOM_SIZE,
+                NULL, 0, p, len, out,
+                SSL3_MASTER_SECRET_SIZE, 1)) {
+            /* SSLfatal() already called */
             return 0;
         }
     }
 
-    OSSL_TRACE_BEGIN(TLS) {
+    OSSL_TRACE_BEGIN(TLS)
+    {
         BIO_printf(trc_out, "Premaster Secret:\n");
         BIO_dump_indent(trc_out, p, len, 4);
         BIO_printf(trc_out, "Client Random:\n");
@@ -412,18 +421,19 @@ int tls1_generate_master_secret(SSL_CONNECTION *s, unsigned char *out,
         BIO_dump_indent(trc_out, s->s3.server_random, SSL3_RANDOM_SIZE, 4);
         BIO_printf(trc_out, "Master Secret:\n");
         BIO_dump_indent(trc_out,
-                        s->session->master_key,
-                        SSL3_MASTER_SECRET_SIZE, 4);
-    } OSSL_TRACE_END(TLS);
+            s->session->master_key,
+            SSL3_MASTER_SECRET_SIZE, 4);
+    }
+    OSSL_TRACE_END(TLS);
 
     *secret_size = SSL3_MASTER_SECRET_SIZE;
     return 1;
 }
 
 int tls1_export_keying_material(SSL_CONNECTION *s, unsigned char *out,
-                                size_t olen, const char *label, size_t llen,
-                                const unsigned char *context,
-                                size_t contextlen, int use_context)
+    size_t olen, const char *label, size_t llen,
+    const unsigned char *context,
+    size_t contextlen, int use_context)
 {
     unsigned char *val = NULL;
     size_t vallen = 0, currentvalpos;
@@ -475,34 +485,39 @@ int tls1_export_keying_material(SSL_CONNECTION *s, unsigned char *out,
      * the comparisons won't have buffer overflow
      */
     if (memcmp(val, TLS_MD_CLIENT_FINISH_CONST,
-               TLS_MD_CLIENT_FINISH_CONST_SIZE) == 0)
+            TLS_MD_CLIENT_FINISH_CONST_SIZE)
+        == 0)
         goto err1;
     if (memcmp(val, TLS_MD_SERVER_FINISH_CONST,
-               TLS_MD_SERVER_FINISH_CONST_SIZE) == 0)
+            TLS_MD_SERVER_FINISH_CONST_SIZE)
+        == 0)
         goto err1;
     if (memcmp(val, TLS_MD_MASTER_SECRET_CONST,
-               TLS_MD_MASTER_SECRET_CONST_SIZE) == 0)
+            TLS_MD_MASTER_SECRET_CONST_SIZE)
+        == 0)
         goto err1;
     if (memcmp(val, TLS_MD_EXTENDED_MASTER_SECRET_CONST,
-               TLS_MD_EXTENDED_MASTER_SECRET_CONST_SIZE) == 0)
+            TLS_MD_EXTENDED_MASTER_SECRET_CONST_SIZE)
+        == 0)
         goto err1;
     if (memcmp(val, TLS_MD_KEY_EXPANSION_CONST,
-               TLS_MD_KEY_EXPANSION_CONST_SIZE) == 0)
+            TLS_MD_KEY_EXPANSION_CONST_SIZE)
+        == 0)
         goto err1;
 
     rv = tls1_PRF(s,
-                  val, vallen,
-                  NULL, 0,
-                  NULL, 0,
-                  NULL, 0,
-                  NULL, 0,
-                  s->session->master_key, s->session->master_key_length,
-                  out, olen, 0);
+        val, vallen,
+        NULL, 0,
+        NULL, 0,
+        NULL, 0,
+        NULL, 0,
+        s->session->master_key, s->session->master_key_length,
+        out, olen, 0);
 
     goto ret;
- err1:
+err1:
     ERR_raise(ERR_LIB_SSL, SSL_R_TLS_ILLEGAL_EXPORTER_LABEL);
- ret:
+ret:
     OPENSSL_clear_free(val, vallen);
     return rv;
 }
diff --git a/crypto/openssl/ssl/t1_lib.c b/crypto/openssl/ssl/t1_lib.c
index 2f71f954382d..ded6a1eadfb8 100644
--- a/crypto/openssl/ssl/t1_lib.c
+++ b/crypto/openssl/ssl/t1_lib.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 1995-2025 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the Apache License 2.0 (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy
@@ -146,51 +146,51 @@ static const struct {
     int nid;
     uint16_t group_id;
 } nid_to_group[] = {
-    {NID_sect163k1, OSSL_TLS_GROUP_ID_sect163k1},
-    {NID_sect163r1, OSSL_TLS_GROUP_ID_sect163r1},
-    {NID_sect163r2, OSSL_TLS_GROUP_ID_sect163r2},
-    {NID_sect193r1, OSSL_TLS_GROUP_ID_sect193r1},
-    {NID_sect193r2, OSSL_TLS_GROUP_ID_sect193r2},
-    {NID_sect233k1, OSSL_TLS_GROUP_ID_sect233k1},
-    {NID_sect233r1, OSSL_TLS_GROUP_ID_sect233r1},
-    {NID_sect239k1, OSSL_TLS_GROUP_ID_sect239k1},
-    {NID_sect283k1, OSSL_TLS_GROUP_ID_sect283k1},
-    {NID_sect283r1, OSSL_TLS_GROUP_ID_sect283r1},
-    {NID_sect409k1, OSSL_TLS_GROUP_ID_sect409k1},
-    {NID_sect409r1, OSSL_TLS_GROUP_ID_sect409r1},
-    {NID_sect571k1, OSSL_TLS_GROUP_ID_sect571k1},
-    {NID_sect571r1, OSSL_TLS_GROUP_ID_sect571r1},
-    {NID_secp160k1, OSSL_TLS_GROUP_ID_secp160k1},
-    {NID_secp160r1, OSSL_TLS_GROUP_ID_secp160r1},
-    {NID_secp160r2, OSSL_TLS_GROUP_ID_secp160r2},
-    {NID_secp192k1, OSSL_TLS_GROUP_ID_secp192k1},
-    {NID_X9_62_prime192v1, OSSL_TLS_GROUP_ID_secp192r1},
-    {NID_secp224k1, OSSL_TLS_GROUP_ID_secp224k1},
-    {NID_secp224r1, OSSL_TLS_GROUP_ID_secp224r1},
-    {NID_secp256k1, OSSL_TLS_GROUP_ID_secp256k1},
-    {NID_X9_62_prime256v1, OSSL_TLS_GROUP_ID_secp256r1},
-    {NID_secp384r1, OSSL_TLS_GROUP_ID_secp384r1},
-    {NID_secp521r1, OSSL_TLS_GROUP_ID_secp521r1},
-    {NID_brainpoolP256r1, OSSL_TLS_GROUP_ID_brainpoolP256r1},
-    {NID_brainpoolP384r1, OSSL_TLS_GROUP_ID_brainpoolP384r1},
-    {NID_brainpoolP512r1, OSSL_TLS_GROUP_ID_brainpoolP512r1},
-    {EVP_PKEY_X25519, OSSL_TLS_GROUP_ID_x25519},
-    {EVP_PKEY_X448, OSSL_TLS_GROUP_ID_x448},
-    {NID_brainpoolP256r1tls13, OSSL_TLS_GROUP_ID_brainpoolP256r1_tls13},
-    {NID_brainpoolP384r1tls13, OSSL_TLS_GROUP_ID_brainpoolP384r1_tls13},
-    {NID_brainpoolP512r1tls13, OSSL_TLS_GROUP_ID_brainpoolP512r1_tls13},
-    {NID_id_tc26_gost_3410_2012_256_paramSetA, OSSL_TLS_GROUP_ID_gc256A},
-    {NID_id_tc26_gost_3410_2012_256_paramSetB, OSSL_TLS_GROUP_ID_gc256B},
-    {NID_id_tc26_gost_3410_2012_256_paramSetC, OSSL_TLS_GROUP_ID_gc256C},
-    {NID_id_tc26_gost_3410_2012_256_paramSetD, OSSL_TLS_GROUP_ID_gc256D},
-    {NID_id_tc26_gost_3410_2012_512_paramSetA, OSSL_TLS_GROUP_ID_gc512A},
-    {NID_id_tc26_gost_3410_2012_512_paramSetB, OSSL_TLS_GROUP_ID_gc512B},
-    {NID_id_tc26_gost_3410_2012_512_paramSetC, OSSL_TLS_GROUP_ID_gc512C},
-    {NID_ffdhe2048, OSSL_TLS_GROUP_ID_ffdhe2048},
-    {NID_ffdhe3072, OSSL_TLS_GROUP_ID_ffdhe3072},
-    {NID_ffdhe4096, OSSL_TLS_GROUP_ID_ffdhe4096},
-    {NID_ffdhe6144, OSSL_TLS_GROUP_ID_ffdhe6144},
-    {NID_ffdhe8192, OSSL_TLS_GROUP_ID_ffdhe8192}
+    { NID_sect163k1, OSSL_TLS_GROUP_ID_sect163k1 },
+    { NID_sect163r1, OSSL_TLS_GROUP_ID_sect163r1 },
+    { NID_sect163r2, OSSL_TLS_GROUP_ID_sect163r2 },
+    { NID_sect193r1, OSSL_TLS_GROUP_ID_sect193r1 },
+    { NID_sect193r2, OSSL_TLS_GROUP_ID_sect193r2 },
+    { NID_sect233k1, OSSL_TLS_GROUP_ID_sect233k1 },
+    { NID_sect233r1, OSSL_TLS_GROUP_ID_sect233r1 },
+    { NID_sect239k1, OSSL_TLS_GROUP_ID_sect239k1 },
+    { NID_sect283k1, OSSL_TLS_GROUP_ID_sect283k1 },
+    { NID_sect283r1, OSSL_TLS_GROUP_ID_sect283r1 },
+    { NID_sect409k1, OSSL_TLS_GROUP_ID_sect409k1 },
+    { NID_sect409r1, OSSL_TLS_GROUP_ID_sect409r1 },
+    { NID_sect571k1, OSSL_TLS_GROUP_ID_sect571k1 },
+    { NID_sect571r1, OSSL_TLS_GROUP_ID_sect571r1 },
+    { NID_secp160k1, OSSL_TLS_GROUP_ID_secp160k1 },
+    { NID_secp160r1, OSSL_TLS_GROUP_ID_secp160r1 },
+    { NID_secp160r2, OSSL_TLS_GROUP_ID_secp160r2 },
+    { NID_secp192k1, OSSL_TLS_GROUP_ID_secp192k1 },
+    { NID_X9_62_prime192v1, OSSL_TLS_GROUP_ID_secp192r1 },
+    { NID_secp224k1, OSSL_TLS_GROUP_ID_secp224k1 },
+    { NID_secp224r1, OSSL_TLS_GROUP_ID_secp224r1 },
+    { NID_secp256k1, OSSL_TLS_GROUP_ID_secp256k1 },
+    { NID_X9_62_prime256v1, OSSL_TLS_GROUP_ID_secp256r1 },
+    { NID_secp384r1, OSSL_TLS_GROUP_ID_secp384r1 },
+    { NID_secp521r1, OSSL_TLS_GROUP_ID_secp521r1 },
+    { NID_brainpoolP256r1, OSSL_TLS_GROUP_ID_brainpoolP256r1 },
+    { NID_brainpoolP384r1, OSSL_TLS_GROUP_ID_brainpoolP384r1 },
+    { NID_brainpoolP512r1, OSSL_TLS_GROUP_ID_brainpoolP512r1 },
+    { EVP_PKEY_X25519, OSSL_TLS_GROUP_ID_x25519 },
+    { EVP_PKEY_X448, OSSL_TLS_GROUP_ID_x448 },
+    { NID_brainpoolP256r1tls13, OSSL_TLS_GROUP_ID_brainpoolP256r1_tls13 },
+    { NID_brainpoolP384r1tls13, OSSL_TLS_GROUP_ID_brainpoolP384r1_tls13 },
+    { NID_brainpoolP512r1tls13, OSSL_TLS_GROUP_ID_brainpoolP512r1_tls13 },
+    { NID_id_tc26_gost_3410_2012_256_paramSetA, OSSL_TLS_GROUP_ID_gc256A },
+    { NID_id_tc26_gost_3410_2012_256_paramSetB, OSSL_TLS_GROUP_ID_gc256B },
+    { NID_id_tc26_gost_3410_2012_256_paramSetC, OSSL_TLS_GROUP_ID_gc256C },
+    { NID_id_tc26_gost_3410_2012_256_paramSetD, OSSL_TLS_GROUP_ID_gc256D },
+    { NID_id_tc26_gost_3410_2012_512_paramSetA, OSSL_TLS_GROUP_ID_gc512A },
+    { NID_id_tc26_gost_3410_2012_512_paramSetB, OSSL_TLS_GROUP_ID_gc512B },
+    { NID_id_tc26_gost_3410_2012_512_paramSetC, OSSL_TLS_GROUP_ID_gc512C },
+    { NID_ffdhe2048, OSSL_TLS_GROUP_ID_ffdhe2048 },
+    { NID_ffdhe3072, OSSL_TLS_GROUP_ID_ffdhe3072 },
+    { NID_ffdhe4096, OSSL_TLS_GROUP_ID_ffdhe4096 },
+    { NID_ffdhe6144, OSSL_TLS_GROUP_ID_ffdhe6144 },
+    { NID_ffdhe8192, OSSL_TLS_GROUP_ID_ffdhe8192 }
 };
 
 static const unsigned char ecformats_default[] = {
@@ -211,14 +211,14 @@ static const uint16_t suiteb_curves[] = {
 
 /* Group list string of the built-in pseudo group DEFAULT_SUITE_B */
 #define SUITE_B_GROUP_NAME "DEFAULT_SUITE_B"
-#define SUITE_B_GROUP_LIST "secp256r1:secp384r1",
+#define SUITE_B_GROUP_LIST "?secp256r1:?secp384r1",
 
 struct provider_ctx_data_st {
     SSL_CTX *ctx;
     OSSL_PROVIDER *provider;
 };
 
-#define TLS_GROUP_LIST_MALLOC_BLOCK_SIZE        10
+#define TLS_GROUP_LIST_MALLOC_BLOCK_SIZE 10
 static OSSL_CALLBACK add_provider_groups;
 static int add_provider_groups(const OSSL_PARAM params[], void *data)
 {
@@ -236,18 +236,18 @@ static int add_provider_groups(const OSSL_PARAM params[], void *data)
 
         if (ctx->group_list_max_len == 0)
             tmp = OPENSSL_malloc(sizeof(TLS_GROUP_INFO)
-                                 * TLS_GROUP_LIST_MALLOC_BLOCK_SIZE);
+                * TLS_GROUP_LIST_MALLOC_BLOCK_SIZE);
         else
             tmp = OPENSSL_realloc(ctx->group_list,
-                                  (ctx->group_list_max_len
-                                   + TLS_GROUP_LIST_MALLOC_BLOCK_SIZE)
-                                  * sizeof(TLS_GROUP_INFO));
+                (ctx->group_list_max_len
+                    + TLS_GROUP_LIST_MALLOC_BLOCK_SIZE)
+                    * sizeof(TLS_GROUP_INFO));
         if (tmp == NULL)
             return 0;
         ctx->group_list = tmp;
         memset(tmp + ctx->group_list_max_len,
-               0,
-               sizeof(TLS_GROUP_INFO) * TLS_GROUP_LIST_MALLOC_BLOCK_SIZE);
+            0,
+            sizeof(TLS_GROUP_INFO) * TLS_GROUP_LIST_MALLOC_BLOCK_SIZE);
         ctx->group_list_max_len += TLS_GROUP_LIST_MALLOC_BLOCK_SIZE;
     }
 
@@ -339,7 +339,7 @@ static int add_provider_groups(const OSSL_PARAM params[], void *data)
         EVP_KEYMGMT_free(keymgmt);
     }
     ERR_pop_to_mark();
- err:
+err:
     if (ginf != NULL) {
         OPENSSL_free(ginf->tlsname);
         OPENSSL_free(ginf->realname);
@@ -356,7 +356,7 @@ static int discover_provider_groups(OSSL_PROVIDER *provider, void *vctx)
     pgd.ctx = vctx;
     pgd.provider = provider;
     return OSSL_PROVIDER_get_capabilities(provider, "TLS-GROUP",
-                                          add_provider_groups, &pgd);
+        add_provider_groups, &pgd);
 }
 
 int ssl_load_groups(SSL_CTX *ctx)
@@ -367,7 +367,16 @@ int ssl_load_groups(SSL_CTX *ctx)
     return SSL_CTX_set1_groups_list(ctx, TLS_DEFAULT_GROUP_LIST);
 }
 
-#define TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE        10
+static const char *inferred_keytype(const TLS_SIGALG_INFO *sinf)
+{
+    return (sinf->keytype != NULL
+            ? sinf->keytype
+            : (sinf->sig_name != NULL
+                      ? sinf->sig_name
+                      : sinf->sigalg_name));
+}
+
+#define TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE 10
 static OSSL_CALLBACK add_provider_sigalgs;
 static int add_provider_sigalgs(const OSSL_PARAM params[], void *data)
 {
@@ -386,17 +395,17 @@ static int add_provider_sigalgs(const OSSL_PARAM params[], void *data)
 
         if (ctx->sigalg_list_max_len == 0)
             tmp = OPENSSL_malloc(sizeof(TLS_SIGALG_INFO)
-                                 * TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE);
+                * TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE);
         else
             tmp = OPENSSL_realloc(ctx->sigalg_list,
-                                  (ctx->sigalg_list_max_len
-                                   + TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE)
-                                  * sizeof(TLS_SIGALG_INFO));
+                (ctx->sigalg_list_max_len
+                    + TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE)
+                    * sizeof(TLS_SIGALG_INFO));
         if (tmp == NULL)
             return 0;
         ctx->sigalg_list = tmp;
         memset(tmp + ctx->sigalg_list_max_len, 0,
-               sizeof(TLS_SIGALG_INFO) * TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE);
+            sizeof(TLS_SIGALG_INFO) * TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE);
         ctx->sigalg_list_max_len += TLS_SIGALG_LIST_MALLOC_BLOCK_SIZE;
     }
 
@@ -424,7 +433,7 @@ static int add_provider_sigalgs(const OSSL_PARAM params[], void *data)
         goto err;
 
     p = OSSL_PARAM_locate_const(params,
-                                OSSL_CAPABILITY_TLS_SIGALG_CODE_POINT);
+        OSSL_CAPABILITY_TLS_SIGALG_CODE_POINT);
     if (p == NULL
         || !OSSL_PARAM_get_uint(p, &code_point)
         || code_point > UINT16_MAX) {
@@ -434,7 +443,7 @@ static int add_provider_sigalgs(const OSSL_PARAM params[], void *data)
     sinf->code_point = (uint16_t)code_point;
 
     p = OSSL_PARAM_locate_const(params,
-                                OSSL_CAPABILITY_TLS_SIGALG_SECURITY_BITS);
+        OSSL_CAPABILITY_TLS_SIGALG_SECURITY_BITS);
     if (p == NULL || !OSSL_PARAM_get_uint(p, &sinf->secbits)) {
         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
         goto err;
@@ -538,8 +547,7 @@ static int add_provider_sigalgs(const OSSL_PARAM params[], void *data)
         goto err;
     }
     /* DTLS version numbers grow downward */
-    if ((sinf->maxdtls != 0) && (sinf->maxdtls != -1) &&
-        ((sinf->maxdtls > sinf->mindtls))) {
+    if ((sinf->maxdtls != 0) && (sinf->maxdtls != -1) && ((sinf->maxdtls > sinf->mindtls))) {
         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
         goto err;
     }
@@ -557,16 +565,13 @@ static int add_provider_sigalgs(const OSSL_PARAM params[], void *data)
         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
         goto err;
     }
-    if ((sinf->maxtls != 0) && (sinf->maxtls != -1) &&
-        ((sinf->maxtls < sinf->mintls))) {
+    if ((sinf->maxtls != 0) && (sinf->maxtls != -1) && ((sinf->maxtls < sinf->mintls))) {
         ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
         goto err;
     }
-    if ((sinf->mintls != 0) && (sinf->mintls != -1) &&
-        ((sinf->mintls > TLS1_3_VERSION)))
+    if ((sinf->mintls != 0) && (sinf->mintls != -1) && ((sinf->mintls > TLS1_3_VERSION)))
         sinf->mintls = sinf->maxtls = -1;
-    if ((sinf->maxtls != 0) && (sinf->maxtls != -1) &&
-        ((sinf->maxtls < TLS1_3_VERSION)))
+    if ((sinf->maxtls != 0) && (sinf->maxtls != -1) && ((sinf->maxtls < TLS1_3_VERSION)))
         sinf->mintls = sinf->maxtls = -1;
 
     /* Ignore unusable sigalgs */
@@ -583,11 +588,7 @@ static int add_provider_sigalgs(const OSSL_PARAM params[], void *data)
      */
     ret = 1;
     ERR_set_mark();
-    keytype = (sinf->keytype != NULL
-               ? sinf->keytype
-               : (sinf->sig_name != NULL
-                  ? sinf->sig_name
-                  : sinf->sigalg_name));
+    keytype = inferred_keytype(sinf);
     keymgmt = EVP_KEYMGMT_fetch(ctx->libctx, keytype, ctx->propq);
     if (keymgmt != NULL) {
         /*
@@ -612,10 +613,9 @@ static int add_provider_sigalgs(const OSSL_PARAM params[], void *data)
              */
             OBJ_create(sinf->sigalg_oid, sinf->sigalg_name, NULL);
             /* sanity check: Without successful registration don't use alg */
-            if ((OBJ_txt2nid(sinf->sigalg_name) == NID_undef) ||
-                (OBJ_nid2obj(OBJ_txt2nid(sinf->sigalg_name)) == NULL)) {
-                    ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
-                    goto err;
+            if ((OBJ_txt2nid(sinf->sigalg_name) == NID_undef) || (OBJ_nid2obj(OBJ_txt2nid(sinf->sigalg_name)) == NULL)) {
+                ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
+                goto err;
             }
             if (sinf->sig_name != NULL)
                 OBJ_create(sinf->sig_oid, sinf->sig_name, NULL);
@@ -624,17 +624,17 @@ static int add_provider_sigalgs(const OSSL_PARAM params[], void *data)
             if (sinf->hash_name != NULL)
                 OBJ_create(sinf->hash_oid, sinf->hash_name, NULL);
             OBJ_add_sigid(OBJ_txt2nid(sinf->sigalg_name),
-                          (sinf->hash_name != NULL
-                           ? OBJ_txt2nid(sinf->hash_name)
-                           : NID_undef),
-                          OBJ_txt2nid(keytype));
+                (sinf->hash_name != NULL
+                        ? OBJ_txt2nid(sinf->hash_name)
+                        : NID_undef),
+                OBJ_txt2nid(keytype));
             ctx->sigalg_list_len++;
             sinf = NULL;
         }
         EVP_KEYMGMT_free(keymgmt);
     }
     ERR_pop_to_mark();
- err:
+err:
     if (sinf != NULL) {
         OPENSSL_free(sinf->name);
         sinf->name = NULL;
@@ -665,7 +665,7 @@ static int discover_provider_sigalgs(OSSL_PROVIDER *provider, void *vctx)
     pgd.ctx = vctx;
     pgd.provider = provider;
     OSSL_PROVIDER_get_capabilities(provider, "TLS-SIGALG",
-                                   add_provider_sigalgs, &pgd);
+        add_provider_sigalgs, &pgd);
     /*
      * Always OK, even if provider doesn't support the capability:
      * Reconsider testing retval when legacy sigalgs are also loaded this way.
@@ -687,8 +687,9 @@ int ssl_load_sigalgs(SSL_CTX *ctx)
         ctx->ssl_cert_info = OPENSSL_zalloc(sizeof(lu) * ctx->sigalg_list_len);
         if (ctx->ssl_cert_info == NULL)
             return 0;
-        for(i = 0; i < ctx->sigalg_list_len; i++) {
-            ctx->ssl_cert_info[i].nid = OBJ_txt2nid(ctx->sigalg_list[i].sigalg_name);
+        for (i = 0; i < ctx->sigalg_list_len; i++) {
+            const char *keytype = inferred_keytype(&ctx->sigalg_list[i]);
+            ctx->ssl_cert_info[i].pkey_nid = OBJ_txt2nid(keytype);
             ctx->ssl_cert_info[i].amask = SSL_aANY;
         }
     }
@@ -707,7 +708,7 @@ static uint16_t tls1_group_name2id(SSL_CTX *ctx, const char *name)
 
     for (i = 0; i < ctx->group_list_len; i++) {
         if (OPENSSL_strcasecmp(ctx->group_list[i].tlsname, name) == 0
-                || OPENSSL_strcasecmp(ctx->group_list[i].realname, name) == 0)
+            || OPENSSL_strcasecmp(ctx->group_list[i].realname, name) == 0)
             return ctx->group_list[i].group_id;
     }
 
@@ -747,8 +748,7 @@ int tls1_group_id2nid(uint16_t group_id, int include_unknown)
      * Return well known Group NIDs - for backwards compatibility. This won't
      * work for groups we don't know about.
      */
-    for (i = 0; i < OSSL_NELEM(nid_to_group); i++)
-    {
+    for (i = 0; i < OSSL_NELEM(nid_to_group); i++) {
         if (nid_to_group[i].group_id == group_id)
             return nid_to_group[i].nid;
     }
@@ -765,8 +765,7 @@ uint16_t tls1_nid2group_id(int nid)
      * Return well known Group ids - for backwards compatibility. This won't
      * work for groups we don't know about.
      */
-    for (i = 0; i < OSSL_NELEM(nid_to_group); i++)
-    {
+    for (i = 0; i < OSSL_NELEM(nid_to_group); i++) {
         if (nid_to_group[i].nid == nid)
             return nid_to_group[i].group_id;
     }
@@ -779,7 +778,7 @@ uint16_t tls1_nid2group_id(int nid)
  * the number of groups supported.
  */
 void tls1_get_supported_groups(SSL_CONNECTION *s, const uint16_t **pgroups,
-                               size_t *pgroupslen)
+    size_t *pgroupslen)
 {
     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
 
@@ -826,7 +825,7 @@ void tls1_get_supported_groups(SSL_CONNECTION *s, const uint16_t **pgroups,
  * combination with setting add_only_one = 1 is applied.
  */
 void tls1_get_requested_keyshare_groups(SSL_CONNECTION *s, const uint16_t **pgroups,
-                                        size_t *pgroupslen)
+    size_t *pgroupslen)
 {
     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
 
@@ -840,7 +839,7 @@ void tls1_get_requested_keyshare_groups(SSL_CONNECTION *s, const uint16_t **pgro
 }
 
 void tls1_get_group_tuples(SSL_CONNECTION *s, const size_t **ptuples,
-                           size_t *ptupleslen)
+    size_t *ptupleslen)
 {
     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
 
@@ -854,11 +853,11 @@ void tls1_get_group_tuples(SSL_CONNECTION *s, const size_t **ptuples,
 }
 
 int tls_valid_group(SSL_CONNECTION *s, uint16_t group_id,
-                    int minversion, int maxversion,
-                    int isec, int *okfortls13)
+    int minversion, int maxversion,
+    int isec, int *okfortls13)
 {
     const TLS_GROUP_INFO *ginfo = tls1_group_id_lookup(SSL_CONNECTION_GET_CTX(s),
-                                                       group_id);
+        group_id);
     int ret;
     int group_minversion, group_maxversion;
 
@@ -883,12 +882,12 @@ int tls_valid_group(SSL_CONNECTION *s, uint16_t group_id,
     if (!SSL_CONNECTION_IS_DTLS(s)) {
         if (ret && okfortls13 != NULL && maxversion == TLS1_3_VERSION)
             *okfortls13 = (group_maxversion == 0)
-                          || (group_maxversion >= TLS1_3_VERSION);
+                || (group_maxversion >= TLS1_3_VERSION);
     }
     ret &= !isec
-           || strcmp(ginfo->algorithm, "EC") == 0
-           || strcmp(ginfo->algorithm, "X25519") == 0
-           || strcmp(ginfo->algorithm, "X448") == 0;
+        || strcmp(ginfo->algorithm, "EC") == 0
+        || strcmp(ginfo->algorithm, "X25519") == 0
+        || strcmp(ginfo->algorithm, "X448") == 0;
 
     return ret;
 }
@@ -897,7 +896,7 @@ int tls_valid_group(SSL_CONNECTION *s, uint16_t group_id,
 int tls_group_allowed(SSL_CONNECTION *s, uint16_t group, int op)
 {
     const TLS_GROUP_INFO *ginfo = tls1_group_id_lookup(SSL_CONNECTION_GET_CTX(s),
-                                                       group);
+        group);
     unsigned char gtmp[2];
 
     if (ginfo == NULL)
@@ -906,7 +905,7 @@ int tls_group_allowed(SSL_CONNECTION *s, uint16_t group, int op)
     gtmp[0] = group >> 8;
     gtmp[1] = group & 0xff;
     return ssl_security(s, op, ginfo->secbits,
-                        tls1_group_id2nid(ginfo->group_id, 0), (void *)gtmp);
+        tls1_group_id2nid(ginfo->group_id, 0), (void *)gtmp);
 }
 
 /* Return 1 if "id" is in "list" */
@@ -932,7 +931,7 @@ static void free_wrapper(TLS_GROUP_IX *a)
 }
 
 static int tls_group_ix_cmp(const TLS_GROUP_IX *const *a,
-                            const TLS_GROUP_IX *const *b)
+    const TLS_GROUP_IX *const *b)
 {
     int idcmpab = (*a)->grp->group_id < (*b)->grp->group_id;
     int idcmpba = (*b)->grp->group_id < (*a)->grp->group_id;
@@ -947,8 +946,8 @@ static int tls_group_ix_cmp(const TLS_GROUP_IX *const *a,
 }
 
 int tls1_get0_implemented_groups(int min_proto_version, int max_proto_version,
-                                 TLS_GROUP_INFO *grps, size_t num, long all,
-                                 STACK_OF(OPENSSL_CSTRING) *out)
+    TLS_GROUP_INFO *grps, size_t num, long all,
+    STACK_OF(OPENSSL_CSTRING) *out)
 {
     STACK_OF(TLS_GROUP_IX) *collect = NULL;
     TLS_GROUP_IX *gix;
@@ -962,7 +961,7 @@ int tls1_get0_implemented_groups(int min_proto_version, int max_proto_version,
         return 0;
     for (ix = 0; ix < num; ++ix, ++grps) {
         if (grps->mintls > 0 && max_proto_version > 0
-             && grps->mintls > max_proto_version)
+            && grps->mintls > max_proto_version)
             continue;
         if (grps->maxtls > 0 && min_proto_version > 0
             && grps->maxtls < min_proto_version)
@@ -990,7 +989,7 @@ int tls1_get0_implemented_groups(int min_proto_version, int max_proto_version,
     }
     ret = 1;
 
- end:
+end:
     sk_TLS_GROUP_IX_pop_free(collect, free_wrapper);
     return ret;
 }
@@ -1048,16 +1047,18 @@ uint16_t tls1_shared_group(SSL_CONNECTION *s, int nmatch)
         int minversion, maxversion;
 
         if (!tls1_in_list(id, supp, num_supp)
-                || !tls_group_allowed(s, id, SSL_SECOP_CURVE_SHARED))
+            || !tls_group_allowed(s, id, SSL_SECOP_CURVE_SHARED))
             continue;
         inf = tls1_group_id_lookup(ctx, id);
         if (!ossl_assert(inf != NULL))
             return 0;
 
         minversion = SSL_CONNECTION_IS_DTLS(s)
-                         ? inf->mindtls : inf->mintls;
+            ? inf->mindtls
+            : inf->mintls;
         maxversion = SSL_CONNECTION_IS_DTLS(s)
-                         ? inf->maxdtls : inf->maxtls;
+            ? inf->maxdtls
+            : inf->maxtls;
         if (maxversion == -1)
             continue;
         if ((minversion != 0 && ssl_version_cmp(s, s->version, minversion) < 0)
@@ -1067,7 +1068,7 @@ uint16_t tls1_shared_group(SSL_CONNECTION *s, int nmatch)
 
         if (nmatch == k)
             return id;
-         k++;
+        k++;
     }
     if (nmatch == -1)
         return k;
@@ -1076,9 +1077,9 @@ uint16_t tls1_shared_group(SSL_CONNECTION *s, int nmatch)
 }
 
 int tls1_set_groups(uint16_t **grpext, size_t *grpextlen,
-                    uint16_t **ksext, size_t *ksextlen,
-                    size_t **tplext, size_t *tplextlen,
-                    int *groups, size_t ngroups)
+    uint16_t **ksext, size_t *ksextlen,
+    size_t **tplext, size_t *tplextlen,
+    int *groups, size_t ngroups)
 {
     uint16_t *glist = NULL, *kslist = NULL;
     size_t *tpllist = NULL;
@@ -1119,7 +1120,13 @@ int tls1_set_groups(uint16_t **grpext, size_t *grpextlen,
     OPENSSL_free(*tplext);
     *grpext = glist;
     *grpextlen = ngroups;
-    kslist[0] = glist[0];
+    /*
+     * No * prefix was used, let tls_construct_ctos_key_share choose a key
+     * share. This has the advantage that it will filter unsupported groups
+     * before choosing one, which this function does not do. See also the
+     * comment for tls1_get_requested_keyshare_groups.
+     */
+    kslist[0] = 0;
     *ksext = kslist;
     *ksextlen = 1;
     tpllist[0] = ngroups;
@@ -1143,15 +1150,15 @@ err:
 typedef struct {
     const char *list_name; /* The name of this pseudo group */
     const char *group_string; /* The group string of this pseudo group */
-} default_group_string_st;    /* (can include '?', '*'. '-', '/' as needed) */
+} default_group_string_st; /* (can include '?', '*'. '-', '/' as needed) */
 
 /* Built-in pseudo group-names must start with a (D or d) */
 static const char *DEFAULT_GROUPNAME_FIRST_CHARACTER = "D";
 
 /* The list of all built-in pseudo-group-name structures */
 static const default_group_string_st default_group_strings[] = {
-    {DEFAULT_GROUP_NAME, TLS_DEFAULT_GROUP_LIST},
-    {SUITE_B_GROUP_NAME, SUITE_B_GROUP_LIST}
+    { DEFAULT_GROUP_NAME, TLS_DEFAULT_GROUP_LIST },
+    { SUITE_B_GROUP_NAME, SUITE_B_GROUP_LIST }
 };
 
 /*
@@ -1163,13 +1170,13 @@ typedef struct {
     uint16_t groupID;
 } name2id_st;
 static const name2id_st name2id_arr[] = {
-    {"GC256A", OSSL_TLS_GROUP_ID_gc256A },
-    {"GC256B", OSSL_TLS_GROUP_ID_gc256B },
-    {"GC256C", OSSL_TLS_GROUP_ID_gc256C },
-    {"GC256D", OSSL_TLS_GROUP_ID_gc256D },
-    {"GC512A", OSSL_TLS_GROUP_ID_gc512A },
-    {"GC512B", OSSL_TLS_GROUP_ID_gc512B },
-    {"GC512C", OSSL_TLS_GROUP_ID_gc512C },
+    { "GC256A", OSSL_TLS_GROUP_ID_gc256A },
+    { "GC256B", OSSL_TLS_GROUP_ID_gc256B },
+    { "GC256C", OSSL_TLS_GROUP_ID_gc256C },
+    { "GC256D", OSSL_TLS_GROUP_ID_gc256D },
+    { "GC512A", OSSL_TLS_GROUP_ID_gc512A },
+    { "GC512B", OSSL_TLS_GROUP_ID_gc512B },
+    { "GC512C", OSSL_TLS_GROUP_ID_gc512C },
 };
 
 /*
@@ -1190,30 +1197,30 @@ static const name2id_st name2id_arr[] = {
  */
 #ifndef TUPLE_DELIMITER_CHARACTER
 /* The prefix characters to indicate group tuple boundaries */
-# define TUPLE_DELIMITER_CHARACTER '/'
+#define TUPLE_DELIMITER_CHARACTER '/'
 #endif
 #ifndef GROUP_DELIMITER_CHARACTER
 /* The prefix characters to indicate group tuple boundaries */
-# define GROUP_DELIMITER_CHARACTER ':'
+#define GROUP_DELIMITER_CHARACTER ':'
 #endif
 #ifndef IGNORE_UNKNOWN_GROUP_CHARACTER
 /* The prefix character to ignore unknown groups */
-# define IGNORE_UNKNOWN_GROUP_CHARACTER '?'
+#define IGNORE_UNKNOWN_GROUP_CHARACTER '?'
 #endif
 #ifndef KEY_SHARE_INDICATOR_CHARACTER
 /* The prefix character to trigger a key share addition */
-# define KEY_SHARE_INDICATOR_CHARACTER '*'
+#define KEY_SHARE_INDICATOR_CHARACTER '*'
 #endif
 #ifndef REMOVE_GROUP_INDICATOR_CHARACTER
 /* The prefix character to trigger a key share removal */
-# define REMOVE_GROUP_INDICATOR_CHARACTER '-'
+#define REMOVE_GROUP_INDICATOR_CHARACTER '-'
 #endif
-static const char prefixes[] = {TUPLE_DELIMITER_CHARACTER,
-                                GROUP_DELIMITER_CHARACTER,
-                                IGNORE_UNKNOWN_GROUP_CHARACTER,
-                                KEY_SHARE_INDICATOR_CHARACTER,
-                                REMOVE_GROUP_INDICATOR_CHARACTER,
-                                '\0'};
+static const char prefixes[] = { TUPLE_DELIMITER_CHARACTER,
+    GROUP_DELIMITER_CHARACTER,
+    IGNORE_UNKNOWN_GROUP_CHARACTER,
+    KEY_SHARE_INDICATOR_CHARACTER,
+    REMOVE_GROUP_INDICATOR_CHARACTER,
+    '\0' };
 
 /*
  * High-level description of how group strings are analyzed:
@@ -1237,8 +1244,8 @@ typedef struct {
     size_t ksidcnt; /* Number of key shares */
     uint16_t *ksid_arr; /* The IDs of the key share groups (flat list) */
     /* Variable to keep state between execution of callback or helper functions */
-    size_t tuple_mode; /* Keeps track whether tuple_cb called from 'the top' or from gid_cb */
-    int ignore_unknown_default; /* Flag such that unknown groups for DEFAULT[_XYZ] are ignored */
+    int inner; /* Are we expanding a DEFAULT list */
+    int first; /* First tuple of possibly nested expansion? */
 } gid_cb_st;
 
 /* Forward declaration of tuple callback function */
@@ -1257,7 +1264,7 @@ static int gid_cb(const char *elem, int len, void *arg)
     int found_group = 0;
     char etmp[GROUP_NAME_BUFFER_LENGTH];
     int retval = 1; /* We assume success */
-    char *current_prefix;
+    const char *current_prefix;
     int ignore_unknown = 0;
     int add_keyshare = 0;
     int remove_group = 0;
@@ -1273,8 +1280,8 @@ static int gid_cb(const char *elem, int len, void *arg)
 
     /* Check the possible prefixes (remark: Leading and trailing spaces already cleared) */
     while (continue_while_loop && len > 0
-           && ((current_prefix = strchr(prefixes, elem[0])) != NULL
-               || OPENSSL_strncasecmp(current_prefix = (char *)DEFAULT_GROUPNAME_FIRST_CHARACTER, elem, 1) == 0)) {
+        && ((current_prefix = strchr(prefixes, elem[0])) != NULL
+            || OPENSSL_strncasecmp(current_prefix = (char *)DEFAULT_GROUPNAME_FIRST_CHARACTER, elem, 1) == 0)) {
 
         switch (*current_prefix) {
         case TUPLE_DELIMITER_CHARACTER:
@@ -1313,16 +1320,16 @@ static int gid_cb(const char *elem, int len, void *arg)
             for (i = 0; i < OSSL_NELEM(default_group_strings); i++) {
                 if ((size_t)len == (strlen(default_group_strings[i].list_name))
                     && OPENSSL_strncasecmp(default_group_strings[i].list_name, elem, len) == 0) {
+                    int saved_first;
+
                     /*
                      * We're asked to insert an entire list of groups from a
                      * DEFAULT[_XYZ] 'pseudo group' which we do by
                      * recursively calling this function (indirectly via
                      * CONF_parse_list and tuple_cb); essentially, we treat a DEFAULT
                      * group string like a tuple which is appended to the current tuple
-                     * rather then starting a new tuple. Variable tuple_mode is the flag which
-                     * controls append tuple vs start new tuple.
+                     * rather then starting a new tuple.
                      */
-
                     if (ignore_unknown || remove_group)
                         return -1; /* removal or ignore not allowed here -> syntax error */
 
@@ -1330,32 +1337,30 @@ static int gid_cb(const char *elem, int len, void *arg)
                      * First, we restore any keyshare prefix in a new zero-terminated string
                      * (if not already present)
                      */
-                    restored_default_group_string = OPENSSL_malloc((1 /* max prefix length */ +
-                                                                    strlen(default_group_strings[i].group_string) +
-                                                                    1 /* \0 */) * sizeof(char));
+                    restored_default_group_string = OPENSSL_malloc((1 /* max prefix length */ + strlen(default_group_strings[i].group_string) + 1 /* \0 */) * sizeof(char));
                     if (restored_default_group_string == NULL)
                         return 0;
                     if (add_keyshare
                         /* Remark: we tolerate a duplicated keyshare indicator here */
                         && default_group_strings[i].group_string[0]
-                        != KEY_SHARE_INDICATOR_CHARACTER)
-                        restored_default_group_string[restored_prefix_index++] =
-                            KEY_SHARE_INDICATOR_CHARACTER;
+                            != KEY_SHARE_INDICATOR_CHARACTER)
+                        restored_default_group_string[restored_prefix_index++] = KEY_SHARE_INDICATOR_CHARACTER;
 
                     memcpy(restored_default_group_string + restored_prefix_index,
-                           default_group_strings[i].group_string,
-                           strlen(default_group_strings[i].group_string));
-                    restored_default_group_string[strlen(default_group_strings[i].group_string) +
-                                                  restored_prefix_index] = '\0';
-                    /* We execute the recursive call */
-                    garg->ignore_unknown_default = 1; /* We ignore unknown groups for DEFAULT_XYZ */
-                    /* we enforce group mode (= append tuple) for DEFAULT_XYZ group lists */
-                    garg->tuple_mode = 0;
-                    /* We use the tuple_cb callback to process the pseudo group tuple */
+                        default_group_strings[i].group_string,
+                        strlen(default_group_strings[i].group_string));
+                    restored_default_group_string[strlen(default_group_strings[i].group_string) + restored_prefix_index] = '\0';
+                    /*
+                     * Append first tuple of result to current tuple, and don't
+                     * terminate the last tuple until we return to a top-level
+                     * tuple_cb.
+                     */
+                    saved_first = garg->first;
+                    garg->inner = garg->first = 1;
                     retval = CONF_parse_list(restored_default_group_string,
-                                             TUPLE_DELIMITER_CHARACTER, 1, tuple_cb, garg);
-                    garg->tuple_mode = 1; /* next call to tuple_cb will again start new tuple */
-                    garg->ignore_unknown_default = 0; /* reset to original value */
+                        TUPLE_DELIMITER_CHARACTER, 1, tuple_cb, garg);
+                    garg->inner = 0;
+                    garg->first = saved_first;
                     /* We don't need the \0-terminated string anymore */
                     OPENSSL_free(restored_default_group_string);
 
@@ -1375,14 +1380,10 @@ static int gid_cb(const char *elem, int len, void *arg)
     if (len == 0)
         return -1; /* Seems we have prefxes without a group name -> syntax error */
 
-    if (garg->ignore_unknown_default == 1) /* Always ignore unknown groups for DEFAULT[_XYZ] */
-        ignore_unknown = 1;
-
     /* Memory management in case more groups are present compared to initial allocation */
     if (garg->gidcnt == garg->gidmax) {
-        uint16_t *tmp =
-            OPENSSL_realloc(garg->gid_arr,
-                            (garg->gidmax + GROUPLIST_INCREMENT) * sizeof(*garg->gid_arr));
+        uint16_t *tmp = OPENSSL_realloc(garg->gid_arr,
+            (garg->gidmax + GROUPLIST_INCREMENT) * sizeof(*garg->gid_arr));
 
         if (tmp == NULL)
             return 0;
@@ -1392,9 +1393,8 @@ static int gid_cb(const char *elem, int len, void *arg)
     }
     /* Memory management for key share groups */
     if (garg->ksidcnt == garg->ksidmax) {
-        uint16_t *tmp =
-            OPENSSL_realloc(garg->ksid_arr,
-                            (garg->ksidmax + GROUPLIST_INCREMENT) * sizeof(*garg->ksid_arr));
+        uint16_t *tmp = OPENSSL_realloc(garg->ksid_arr,
+            (garg->ksidmax + GROUPLIST_INCREMENT) * sizeof(*garg->ksid_arr));
 
         if (tmp == NULL)
             return 0;
@@ -1513,7 +1513,7 @@ static int gid_cb(const char *elem, int len, void *arg)
         /* and update the book keeping for the number of groups in current tuple */
         garg->tuplcnt_arr[garg->tplcnt]++;
 
-        /* We memorize if needed that we want to add a key share for the current group */
+        /* We want to add a key share for the current group */
         if (add_keyshare)
             garg->ksid_arr[garg->ksidcnt++] = gid;
     }
@@ -1522,6 +1522,39 @@ done:
     return retval;
 }
 
+static int grow_tuples(gid_cb_st *garg)
+{
+    static size_t max_tplcnt = (~(size_t)0) / sizeof(size_t);
+
+    /* This uses OPENSSL_realloc_array() in newer releases */
+    if (garg->tplcnt == garg->tplmax) {
+        size_t newcnt = garg->tplmax + GROUPLIST_INCREMENT;
+        size_t newsz = newcnt * sizeof(size_t);
+        size_t *tmp;
+
+        if (newsz > max_tplcnt
+            || (tmp = OPENSSL_realloc(garg->tuplcnt_arr, newsz)) == NULL)
+            return 0;
+
+        garg->tplmax = newcnt;
+        garg->tuplcnt_arr = tmp;
+    }
+    return 1;
+}
+
+static int close_tuple(gid_cb_st *garg)
+{
+    size_t gidcnt = garg->tuplcnt_arr[garg->tplcnt];
+
+    if (gidcnt == 0)
+        return 1;
+    if (!grow_tuples(garg))
+        return 0;
+
+    garg->tuplcnt_arr[++garg->tplcnt] = 0;
+    return 1;
+}
+
 /* Extract and process a tuple of groups */
 static int tuple_cb(const char *tuple, int len, void *arg)
 {
@@ -1535,17 +1568,9 @@ static int tuple_cb(const char *tuple, int len, void *arg)
         return 0;
     }
 
-    /* Memory management for tuples */
-    if (garg->tplcnt == garg->tplmax) {
-        size_t *tmp =
-            OPENSSL_realloc(garg->tuplcnt_arr,
-                            (garg->tplmax + GROUPLIST_INCREMENT) * sizeof(*garg->tuplcnt_arr));
-
-        if (tmp == NULL)
-            return 0;
-        garg->tplmax += GROUPLIST_INCREMENT;
-        garg->tuplcnt_arr = tmp;
-    }
+    if (garg->inner && !garg->first && !close_tuple(garg))
+        return 0;
+    garg->first = 0;
 
     /* Convert to \0-terminated string */
     restored_tuple_string = OPENSSL_malloc((len + 1 /* \0 */) * sizeof(char));
@@ -1560,33 +1585,26 @@ static int tuple_cb(const char *tuple, int len, void *arg)
     /* We don't need the \o-terminated string anymore */
     OPENSSL_free(restored_tuple_string);
 
-    if (garg->tuplcnt_arr[garg->tplcnt] > 0) { /* Some valid groups are present in current tuple... */
-        if (garg->tuple_mode) {
-            /* We 'close' the tuple */
-            garg->tplcnt++;
-            garg->tuplcnt_arr[garg->tplcnt] = 0; /* Next tuple is initialized to be empty */
-            garg->tuple_mode = 1; /* next call will start a tuple (unless overridden in gid_cb) */
-        }
-    }
-
+    if (!garg->inner && !close_tuple(garg))
+        return 0;
     return retval;
 }
 
 /*
  * Set groups and prepare generation of keyshares based on a string of groupnames,
  * names separated by the group or the tuple delimiter, with per-group prefixes to
- * (1) add a key share for this group, (2) ignore the group if unkown to the current
+ * (1) add a key share for this group, (2) ignore the group if unknown to the current
  * context, (3) delete a previous occurrence of the group in the current tuple.
  *
- * The list parsing is done in two hierachical steps: The top-level step extracts the
+ * The list parsing is done in two hierarchical steps: The top-level step extracts the
  * string of a tuple using tuple_cb, while the next lower step uses gid_cb to
  * parse and process the groups inside a tuple
  */
 int tls1_set_groups_list(SSL_CTX *ctx,
-                         uint16_t **grpext, size_t *grpextlen,
-                         uint16_t **ksext, size_t *ksextlen,
-                         size_t **tplext, size_t *tplextlen,
-                         const char *str)
+    uint16_t **grpext, size_t *grpextlen,
+    uint16_t **ksext, size_t *ksextlen,
+    size_t **tplext, size_t *tplextlen,
+    const char *str)
 {
     size_t i = 0, j;
     int ret = 0, parse_ret = 0;
@@ -1599,8 +1617,6 @@ int tls1_set_groups_list(SSL_CTX *ctx,
     }
 
     memset(&gcb, 0, sizeof(gcb));
-    gcb.tuple_mode = 1; /* We prepare to collect the first tuple */
-    gcb.ignore_unknown_default = 0;
     gcb.gidmax = GROUPLIST_INCREMENT;
     gcb.tplmax = GROUPLIST_INCREMENT;
     gcb.ksidmax = GROUPLIST_INCREMENT;
@@ -1633,12 +1649,12 @@ int tls1_set_groups_list(SSL_CTX *ctx,
         goto end;
     if (parse_ret == -1) {
         ERR_raise_data(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT,
-                       "Syntax error in '%s'", str);
+            "Syntax error in '%s'", str);
         goto end;
     }
 
     /*
-     * We check whether a tuple was completly emptied by using "-" prefix
+     * We check whether a tuple was completely emptied by using "-" prefix
      * excessively, in which case we remove the tuple
      */
     for (i = j = 0; j < gcb.tplcnt; j++) {
@@ -1654,8 +1670,8 @@ int tls1_set_groups_list(SSL_CTX *ctx,
 
     if (gcb.ksidcnt > OPENSSL_CLIENT_MAX_KEY_SHARES) {
         ERR_raise_data(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT,
-                       "To many keyshares requested in '%s' (max = %d)",
-                       str, OPENSSL_CLIENT_MAX_KEY_SHARES);
+            "To many keyshares requested in '%s' (max = %d)",
+            str, OPENSSL_CLIENT_MAX_KEY_SHARES);
         goto end;
     }
 
@@ -1672,20 +1688,19 @@ int tls1_set_groups_list(SSL_CTX *ctx,
         gcb.ksid_arr[0] = 0;
     }
 
- empty_list:
+empty_list:
     /*
      * A call to tls1_set_groups_list with any of the args (other than ctx) set
      * to NULL only does a syntax check, hence we're done here and report success
      */
-    if (grpext == NULL || ksext == NULL || tplext == NULL ||
-        grpextlen == NULL || ksextlen == NULL || tplextlen == NULL) {
+    if (grpext == NULL || ksext == NULL || tplext == NULL || grpextlen == NULL || ksextlen == NULL || tplextlen == NULL) {
         ret = 1;
         goto end;
     }
 
     /*
      * tuple_cb and gid_cb combo ensures there are no duplicates or unknown groups so we
-     * can just go ahead and set the results (after diposing the existing)
+     * can just go ahead and set the results (after disposing the existing)
      */
     OPENSSL_free(*grpext);
     *grpext = gcb.gid_arr;
@@ -1699,7 +1714,7 @@ int tls1_set_groups_list(SSL_CTX *ctx,
 
     return 1;
 
- end:
+end:
     OPENSSL_free(gcb.gid_arr);
     OPENSSL_free(gcb.tuplcnt_arr);
     OPENSSL_free(gcb.ksid_arr);
@@ -1708,8 +1723,8 @@ int tls1_set_groups_list(SSL_CTX *ctx,
 
 /* Check a group id matches preferences */
 int tls1_check_group_id(SSL_CONNECTION *s, uint16_t group_id,
-                        int check_own_groups)
-    {
+    int check_own_groups)
+{
     const uint16_t *groups;
     size_t groups_len;
 
@@ -1756,12 +1771,12 @@ int tls1_check_group_id(SSL_CONNECTION *s, uint16_t group_id,
      * extension, so groups_len == 0 always means no extension.
      */
     if (groups_len == 0)
-            return 1;
+        return 1;
     return tls1_in_list(group_id, groups, groups_len);
 }
 
 void tls1_get_formatlist(SSL_CONNECTION *s, const unsigned char **pformats,
-                         size_t *num_formats)
+    size_t *num_formats)
 {
     /*
      * If we have a custom point format list use it otherwise use default
@@ -1790,13 +1805,12 @@ static int tls1_check_pkey_comp(SSL_CONNECTION *s, EVP_PKEY *pkey)
     if (!EVP_PKEY_is_a(pkey, "EC"))
         return 1;
 
-
     /* Get required compression id */
     point_conv = EVP_PKEY_get_ec_point_conv_form(pkey);
     if (point_conv == 0)
         return 0;
     if (point_conv == POINT_CONVERSION_UNCOMPRESSED) {
-            comp_id = TLSEXT_ECPOINTFORMAT_uncompressed;
+        comp_id = TLSEXT_ECPOINTFORMAT_uncompressed;
     } else if (SSL_CONNECTION_IS_TLS13(s)) {
         /*
          * ec_point_formats extension is not used in TLSv1.3 so we ignore
@@ -1875,7 +1889,7 @@ static int tls1_check_cert_param(SSL_CONNECTION *s, X509 *x, int check_ee_md)
         else if (group_id == OSSL_TLS_GROUP_ID_secp384r1)
             check_md = NID_ecdsa_with_SHA384;
         else
-            return 0;           /* Should never happen */
+            return 0; /* Should never happen */
         for (i = 0; i < s->shared_sigalgslen; i++) {
             if (check_md == s->shared_sigalgs[i]->sigandhash)
                 return 1;
@@ -1959,198 +1973,197 @@ static const uint16_t tls12_sigalgs[] = {
 #endif
 };
 
-
 static const uint16_t suiteb_sigalgs[] = {
     TLSEXT_SIGALG_ecdsa_secp256r1_sha256,
     TLSEXT_SIGALG_ecdsa_secp384r1_sha384
 };
 
 static const SIGALG_LOOKUP sigalg_lookup_tbl[] = {
-    {TLSEXT_SIGALG_ecdsa_secp256r1_sha256_name,
-     "ECDSA+SHA256", TLSEXT_SIGALG_ecdsa_secp256r1_sha256,
-     NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
-     NID_ecdsa_with_SHA256, NID_X9_62_prime256v1, 1, 0,
-     TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0},
-    {TLSEXT_SIGALG_ecdsa_secp384r1_sha384_name,
-     "ECDSA+SHA384", TLSEXT_SIGALG_ecdsa_secp384r1_sha384,
-     NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
-     NID_ecdsa_with_SHA384, NID_secp384r1, 1, 0,
-     TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0},
-    {TLSEXT_SIGALG_ecdsa_secp521r1_sha512_name,
-     "ECDSA+SHA512", TLSEXT_SIGALG_ecdsa_secp521r1_sha512,
-     NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
-     NID_ecdsa_with_SHA512, NID_secp521r1, 1, 0,
-     TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0},
+    { TLSEXT_SIGALG_ecdsa_secp256r1_sha256_name,
+        "ECDSA+SHA256", TLSEXT_SIGALG_ecdsa_secp256r1_sha256,
+        NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
+        NID_ecdsa_with_SHA256, NID_X9_62_prime256v1, 1, 0,
+        TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0 },
+    { TLSEXT_SIGALG_ecdsa_secp384r1_sha384_name,
+        "ECDSA+SHA384", TLSEXT_SIGALG_ecdsa_secp384r1_sha384,
+        NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
+        NID_ecdsa_with_SHA384, NID_secp384r1, 1, 0,
+        TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0 },
+    { TLSEXT_SIGALG_ecdsa_secp521r1_sha512_name,
+        "ECDSA+SHA512", TLSEXT_SIGALG_ecdsa_secp521r1_sha512,
+        NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
+        NID_ecdsa_with_SHA512, NID_secp521r1, 1, 0,
+        TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0 },
 
-    {TLSEXT_SIGALG_ed25519_name,
-     NULL, TLSEXT_SIGALG_ed25519,
-     NID_undef, -1, EVP_PKEY_ED25519, SSL_PKEY_ED25519,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0},
-    {TLSEXT_SIGALG_ed448_name,
-     NULL, TLSEXT_SIGALG_ed448,
-     NID_undef, -1, EVP_PKEY_ED448, SSL_PKEY_ED448,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0},
+    { TLSEXT_SIGALG_ed25519_name,
+        NULL, TLSEXT_SIGALG_ed25519,
+        NID_undef, -1, EVP_PKEY_ED25519, SSL_PKEY_ED25519,
+        NID_undef, NID_undef, 1, 0,
+        TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0 },
+    { TLSEXT_SIGALG_ed448_name,
+        NULL, TLSEXT_SIGALG_ed448,
+        NID_undef, -1, EVP_PKEY_ED448, SSL_PKEY_ED448,
+        NID_undef, NID_undef, 1, 0,
+        TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0 },
 
-    {TLSEXT_SIGALG_ecdsa_sha224_name,
-     "ECDSA+SHA224", TLSEXT_SIGALG_ecdsa_sha224,
-     NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
-     NID_ecdsa_with_SHA224, NID_undef, 1, 0,
-     TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION},
-    {TLSEXT_SIGALG_ecdsa_sha1_name,
-     "ECDSA+SHA1", TLSEXT_SIGALG_ecdsa_sha1,
-     NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
-     NID_ecdsa_with_SHA1, NID_undef, 1, 0,
-     TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION},
+    { TLSEXT_SIGALG_ecdsa_sha224_name,
+        "ECDSA+SHA224", TLSEXT_SIGALG_ecdsa_sha224,
+        NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
+        NID_ecdsa_with_SHA224, NID_undef, 1, 0,
+        TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION },
+    { TLSEXT_SIGALG_ecdsa_sha1_name,
+        "ECDSA+SHA1", TLSEXT_SIGALG_ecdsa_sha1,
+        NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
+        NID_ecdsa_with_SHA1, NID_undef, 1, 0,
+        TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION },
 
-    {TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256_name,
-     TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256_alias,
-     TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256,
-     NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
-     NID_ecdsa_with_SHA256, NID_brainpoolP256r1, 1, 0,
-     TLS1_3_VERSION, 0, -1, -1},
-    {TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384_name,
-     TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384_alias,
-     TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384,
-     NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
-     NID_ecdsa_with_SHA384, NID_brainpoolP384r1, 1, 0,
-     TLS1_3_VERSION, 0, -1, -1},
-    {TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512_name,
-     TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512_alias,
-     TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512,
-     NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
-     NID_ecdsa_with_SHA512, NID_brainpoolP512r1, 1, 0,
-     TLS1_3_VERSION, 0, -1, -1},
+    { TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256_name,
+        TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256_alias,
+        TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256,
+        NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
+        NID_ecdsa_with_SHA256, NID_brainpoolP256r1, 1, 0,
+        TLS1_3_VERSION, 0, -1, -1 },
+    { TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384_name,
+        TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384_alias,
+        TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384,
+        NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
+        NID_ecdsa_with_SHA384, NID_brainpoolP384r1, 1, 0,
+        TLS1_3_VERSION, 0, -1, -1 },
+    { TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512_name,
+        TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512_alias,
+        TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512,
+        NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,
+        NID_ecdsa_with_SHA512, NID_brainpoolP512r1, 1, 0,
+        TLS1_3_VERSION, 0, -1, -1 },
 
-    {TLSEXT_SIGALG_rsa_pss_rsae_sha256_name,
-     "PSS+SHA256", TLSEXT_SIGALG_rsa_pss_rsae_sha256,
-     NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0},
-    {TLSEXT_SIGALG_rsa_pss_rsae_sha384_name,
-     "PSS+SHA384", TLSEXT_SIGALG_rsa_pss_rsae_sha384,
-     NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0},
-    {TLSEXT_SIGALG_rsa_pss_rsae_sha512_name,
-     "PSS+SHA512", TLSEXT_SIGALG_rsa_pss_rsae_sha512,
-     NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0},
+    { TLSEXT_SIGALG_rsa_pss_rsae_sha256_name,
+        "PSS+SHA256", TLSEXT_SIGALG_rsa_pss_rsae_sha256,
+        NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA,
+        NID_undef, NID_undef, 1, 0,
+        TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0 },
+    { TLSEXT_SIGALG_rsa_pss_rsae_sha384_name,
+        "PSS+SHA384", TLSEXT_SIGALG_rsa_pss_rsae_sha384,
+        NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA,
+        NID_undef, NID_undef, 1, 0,
+        TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0 },
+    { TLSEXT_SIGALG_rsa_pss_rsae_sha512_name,
+        "PSS+SHA512", TLSEXT_SIGALG_rsa_pss_rsae_sha512,
+        NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA,
+        NID_undef, NID_undef, 1, 0,
+        TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0 },
 
-    {TLSEXT_SIGALG_rsa_pss_pss_sha256_name,
-     NULL, TLSEXT_SIGALG_rsa_pss_pss_sha256,
-     NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0},
-    {TLSEXT_SIGALG_rsa_pss_pss_sha384_name,
-     NULL, TLSEXT_SIGALG_rsa_pss_pss_sha384,
-     NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0},
-    {TLSEXT_SIGALG_rsa_pss_pss_sha512_name,
-     NULL, TLSEXT_SIGALG_rsa_pss_pss_sha512,
-     NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0},
+    { TLSEXT_SIGALG_rsa_pss_pss_sha256_name,
+        NULL, TLSEXT_SIGALG_rsa_pss_pss_sha256,
+        NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN,
+        NID_undef, NID_undef, 1, 0,
+        TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0 },
+    { TLSEXT_SIGALG_rsa_pss_pss_sha384_name,
+        NULL, TLSEXT_SIGALG_rsa_pss_pss_sha384,
+        NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN,
+        NID_undef, NID_undef, 1, 0,
+        TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0 },
+    { TLSEXT_SIGALG_rsa_pss_pss_sha512_name,
+        NULL, TLSEXT_SIGALG_rsa_pss_pss_sha512,
+        NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN,
+        NID_undef, NID_undef, 1, 0,
+        TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0 },
 
-    {TLSEXT_SIGALG_rsa_pkcs1_sha256_name,
-     "RSA+SHA256", TLSEXT_SIGALG_rsa_pkcs1_sha256,
-     NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
-     NID_sha256WithRSAEncryption, NID_undef, 1, 0,
-     TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0},
-    {TLSEXT_SIGALG_rsa_pkcs1_sha384_name,
-     "RSA+SHA384", TLSEXT_SIGALG_rsa_pkcs1_sha384,
-     NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
-     NID_sha384WithRSAEncryption, NID_undef, 1, 0,
-     TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0},
-    {TLSEXT_SIGALG_rsa_pkcs1_sha512_name,
-     "RSA+SHA512", TLSEXT_SIGALG_rsa_pkcs1_sha512,
-     NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
-     NID_sha512WithRSAEncryption, NID_undef, 1, 0,
-     TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0},
+    { TLSEXT_SIGALG_rsa_pkcs1_sha256_name,
+        "RSA+SHA256", TLSEXT_SIGALG_rsa_pkcs1_sha256,
+        NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
+        NID_sha256WithRSAEncryption, NID_undef, 1, 0,
+        TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0 },
+    { TLSEXT_SIGALG_rsa_pkcs1_sha384_name,
+        "RSA+SHA384", TLSEXT_SIGALG_rsa_pkcs1_sha384,
+        NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
+        NID_sha384WithRSAEncryption, NID_undef, 1, 0,
+        TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0 },
+    { TLSEXT_SIGALG_rsa_pkcs1_sha512_name,
+        "RSA+SHA512", TLSEXT_SIGALG_rsa_pkcs1_sha512,
+        NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
+        NID_sha512WithRSAEncryption, NID_undef, 1, 0,
+        TLS1_2_VERSION, 0, DTLS1_2_VERSION, 0 },
 
-    {TLSEXT_SIGALG_rsa_pkcs1_sha224_name,
-     "RSA+SHA224", TLSEXT_SIGALG_rsa_pkcs1_sha224,
-     NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
-     NID_sha224WithRSAEncryption, NID_undef, 1, 0,
-     TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION},
-    {TLSEXT_SIGALG_rsa_pkcs1_sha1_name,
-     "RSA+SHA1", TLSEXT_SIGALG_rsa_pkcs1_sha1,
-     NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
-     NID_sha1WithRSAEncryption, NID_undef, 1, 0,
-     TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION},
+    { TLSEXT_SIGALG_rsa_pkcs1_sha224_name,
+        "RSA+SHA224", TLSEXT_SIGALG_rsa_pkcs1_sha224,
+        NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
+        NID_sha224WithRSAEncryption, NID_undef, 1, 0,
+        TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION },
+    { TLSEXT_SIGALG_rsa_pkcs1_sha1_name,
+        "RSA+SHA1", TLSEXT_SIGALG_rsa_pkcs1_sha1,
+        NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,
+        NID_sha1WithRSAEncryption, NID_undef, 1, 0,
+        TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION },
 
-    {TLSEXT_SIGALG_dsa_sha256_name,
-     "DSA+SHA256", TLSEXT_SIGALG_dsa_sha256,
-     NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
-     NID_dsa_with_SHA256, NID_undef, 1, 0,
-     TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION},
-    {TLSEXT_SIGALG_dsa_sha384_name,
-     "DSA+SHA384", TLSEXT_SIGALG_dsa_sha384,
-     NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION},
-    {TLSEXT_SIGALG_dsa_sha512_name,
-     "DSA+SHA512", TLSEXT_SIGALG_dsa_sha512,
-     NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION},
-    {TLSEXT_SIGALG_dsa_sha224_name,
-     "DSA+SHA224", TLSEXT_SIGALG_dsa_sha224,
-     NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION},
-    {TLSEXT_SIGALG_dsa_sha1_name,
-     "DSA+SHA1", TLSEXT_SIGALG_dsa_sha1,
-     NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
-     NID_dsaWithSHA1, NID_undef, 1, 0,
-     TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION},
+    { TLSEXT_SIGALG_dsa_sha256_name,
+        "DSA+SHA256", TLSEXT_SIGALG_dsa_sha256,
+        NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
+        NID_dsa_with_SHA256, NID_undef, 1, 0,
+        TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION },
+    { TLSEXT_SIGALG_dsa_sha384_name,
+        "DSA+SHA384", TLSEXT_SIGALG_dsa_sha384,
+        NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
+        NID_undef, NID_undef, 1, 0,
+        TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION },
+    { TLSEXT_SIGALG_dsa_sha512_name,
+        "DSA+SHA512", TLSEXT_SIGALG_dsa_sha512,
+        NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
+        NID_undef, NID_undef, 1, 0,
+        TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION },
+    { TLSEXT_SIGALG_dsa_sha224_name,
+        "DSA+SHA224", TLSEXT_SIGALG_dsa_sha224,
+        NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
+        NID_undef, NID_undef, 1, 0,
+        TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION },
+    { TLSEXT_SIGALG_dsa_sha1_name,
+        "DSA+SHA1", TLSEXT_SIGALG_dsa_sha1,
+        NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,
+        NID_dsaWithSHA1, NID_undef, 1, 0,
+        TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION },
 
 #ifndef OPENSSL_NO_GOST
-    {TLSEXT_SIGALG_gostr34102012_256_intrinsic_alias, /* RFC9189 */
-     TLSEXT_SIGALG_gostr34102012_256_intrinsic_name,
-     TLSEXT_SIGALG_gostr34102012_256_intrinsic,
-     NID_id_GostR3411_2012_256, SSL_MD_GOST12_256_IDX,
-     NID_id_GostR3410_2012_256, SSL_PKEY_GOST12_256,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION},
-    {TLSEXT_SIGALG_gostr34102012_256_intrinsic_alias, /* RFC9189 */
-     TLSEXT_SIGALG_gostr34102012_256_intrinsic_name,
-     TLSEXT_SIGALG_gostr34102012_512_intrinsic,
-     NID_id_GostR3411_2012_512, SSL_MD_GOST12_512_IDX,
-     NID_id_GostR3410_2012_512, SSL_PKEY_GOST12_512,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION},
+    { TLSEXT_SIGALG_gostr34102012_256_intrinsic_alias, /* RFC9189 */
+        TLSEXT_SIGALG_gostr34102012_256_intrinsic_name,
+        TLSEXT_SIGALG_gostr34102012_256_intrinsic,
+        NID_id_GostR3411_2012_256, SSL_MD_GOST12_256_IDX,
+        NID_id_GostR3410_2012_256, SSL_PKEY_GOST12_256,
+        NID_undef, NID_undef, 1, 0,
+        TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION },
+    { TLSEXT_SIGALG_gostr34102012_256_intrinsic_alias, /* RFC9189 */
+        TLSEXT_SIGALG_gostr34102012_256_intrinsic_name,
+        TLSEXT_SIGALG_gostr34102012_512_intrinsic,
+        NID_id_GostR3411_2012_512, SSL_MD_GOST12_512_IDX,
+        NID_id_GostR3410_2012_512, SSL_PKEY_GOST12_512,
+        NID_undef, NID_undef, 1, 0,
+        TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION },
 
-    {TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256_name,
-     NULL, TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256,
-     NID_id_GostR3411_2012_256, SSL_MD_GOST12_256_IDX,
-     NID_id_GostR3410_2012_256, SSL_PKEY_GOST12_256,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION},
-    {TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512_name,
-     NULL, TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512,
-     NID_id_GostR3411_2012_512, SSL_MD_GOST12_512_IDX,
-     NID_id_GostR3410_2012_512, SSL_PKEY_GOST12_512,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION},
-    {TLSEXT_SIGALG_gostr34102001_gostr3411_name,
-     NULL, TLSEXT_SIGALG_gostr34102001_gostr3411,
-     NID_id_GostR3411_94, SSL_MD_GOST94_IDX,
-     NID_id_GostR3410_2001, SSL_PKEY_GOST01,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION},
+    { TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256_name,
+        NULL, TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256,
+        NID_id_GostR3411_2012_256, SSL_MD_GOST12_256_IDX,
+        NID_id_GostR3410_2012_256, SSL_PKEY_GOST12_256,
+        NID_undef, NID_undef, 1, 0,
+        TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION },
+    { TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512_name,
+        NULL, TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512,
+        NID_id_GostR3411_2012_512, SSL_MD_GOST12_512_IDX,
+        NID_id_GostR3410_2012_512, SSL_PKEY_GOST12_512,
+        NID_undef, NID_undef, 1, 0,
+        TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION },
+    { TLSEXT_SIGALG_gostr34102001_gostr3411_name,
+        NULL, TLSEXT_SIGALG_gostr34102001_gostr3411,
+        NID_id_GostR3411_94, SSL_MD_GOST94_IDX,
+        NID_id_GostR3410_2001, SSL_PKEY_GOST01,
+        NID_undef, NID_undef, 1, 0,
+        TLS1_2_VERSION, TLS1_2_VERSION, DTLS1_2_VERSION, DTLS1_2_VERSION },
 #endif
 };
 /* Legacy sigalgs for TLS < 1.2 RSA TLS signatures */
 static const SIGALG_LOOKUP legacy_rsa_sigalg = {
     "rsa_pkcs1_md5_sha1", NULL, 0,
-     NID_md5_sha1, SSL_MD_MD5_SHA1_IDX,
-     EVP_PKEY_RSA, SSL_PKEY_RSA,
-     NID_undef, NID_undef, 1, 0,
-     TLS1_VERSION, TLS1_2_VERSION, DTLS1_VERSION, DTLS1_2_VERSION
+    NID_md5_sha1, SSL_MD_MD5_SHA1_IDX,
+    EVP_PKEY_RSA, SSL_PKEY_RSA,
+    NID_undef, NID_undef, 1, 0,
+    TLS1_VERSION, TLS1_2_VERSION, DTLS1_VERSION, DTLS1_2_VERSION
 };
 
 /*
@@ -2197,7 +2210,7 @@ int ssl_setup_sigalgs(SSL_CTX *ctx)
     ERR_set_mark();
     /* First fill cache and tls12_sigalgs list from legacy algorithm list */
     for (i = 0, lu = sigalg_lookup_tbl;
-         i < OSSL_NELEM(sigalg_lookup_tbl); lu++, i++) {
+        i < OSSL_NELEM(sigalg_lookup_tbl); lu++, i++) {
         EVP_PKEY_CTX *pctx;
 
         cache[i] = *lu;
@@ -2211,7 +2224,7 @@ int ssl_setup_sigalgs(SSL_CTX *ctx)
          * independently - but not as a combination. We ignore this for now.
          */
         if (lu->hash != NID_undef
-                && ctx->ssl_digest_methods[lu->hash_idx] == NULL) {
+            && ctx->ssl_digest_methods[lu->hash_idx] == NULL) {
             cache[i].available = 0;
             continue;
         }
@@ -2235,7 +2248,7 @@ int ssl_setup_sigalgs(SSL_CTX *ctx)
         cache[cache_idx].name12 = si.sigalg_name;
         cache[cache_idx].sigalg = si.code_point;
         tls12_sigalgs_list[cache_idx] = si.code_point;
-        cache[cache_idx].hash = si.hash_name?OBJ_txt2nid(si.hash_name):NID_undef;
+        cache[cache_idx].hash = si.hash_name ? OBJ_txt2nid(si.hash_name) : NID_undef;
         cache[cache_idx].hash_idx = ssl_get_md_idx(cache[cache_idx].hash);
         cache[cache_idx].sig = OBJ_txt2nid(si.sigalg_name);
         cache[cache_idx].sig_idx = i + SSL_PKEY_NUM;
@@ -2285,7 +2298,7 @@ int ssl_setup_sigalgs(SSL_CTX *ctx)
     tls12_sigalgs_list = NULL;
 
     ret = 1;
- err:
+err:
     OPENSSL_free(cache);
     OPENSSL_free(tls12_sigalgs_list);
     EVP_PKEY_free(tmpkey);
@@ -2308,7 +2321,7 @@ char *SSL_get1_builtin_sigalgs(OSSL_LIB_CTX *libctx)
     retval[0] = (char)0;
 
     for (i = 0, lu = sigalg_lookup_tbl;
-         i < OSSL_NELEM(sigalg_lookup_tbl); lu++, i++) {
+        i < OSSL_NELEM(sigalg_lookup_tbl); lu++, i++) {
         EVP_PKEY_CTX *pctx;
         int enabled = 1;
 
@@ -2369,7 +2382,7 @@ char *SSL_get1_builtin_sigalgs(OSSL_LIB_CTX *libctx)
 
 /* Lookup TLS signature algorithm */
 static const SIGALG_LOOKUP *tls1_lookup_sigalg(const SSL_CTX *ctx,
-                                               uint16_t sigalg)
+    uint16_t sigalg)
 {
     size_t i;
     const SIGALG_LOOKUP *lu = ctx->sigalg_lookup_cache;
@@ -2413,7 +2426,7 @@ int tls1_lookup_md(SSL_CTX *ctx, const SIGALG_LOOKUP *lu, const EVP_MD **pmd)
  */
 #define RSA_PSS_MINIMUM_KEY_SIZE(md) (2 * EVP_MD_get_size(md) + 2)
 static int rsa_pss_check_min_key_size(SSL_CTX *ctx, const EVP_PKEY *pkey,
-                                      const SIGALG_LOOKUP *lu)
+    const SIGALG_LOOKUP *lu)
 {
     const EVP_MD *md;
 
@@ -2436,7 +2449,7 @@ static int rsa_pss_check_min_key_size(SSL_CTX *ctx, const EVP_PKEY *pkey,
  * Returns the signature algorithm to use, or NULL on error.
  */
 static const SIGALG_LOOKUP *tls1_get_legacy_sigalg(const SSL_CONNECTION *s,
-                                                   int idx)
+    int idx)
 {
     if (idx == -1) {
         if (s->server) {
@@ -2462,7 +2475,7 @@ static const SIGALG_LOOKUP *tls1_get_legacy_sigalg(const SSL_CONNECTION *s,
                 int real_idx;
 
                 for (real_idx = SSL_PKEY_GOST12_512; real_idx >= SSL_PKEY_GOST01;
-                     real_idx--) {
+                    real_idx--) {
                     if (s->cert->pkeys[real_idx].privatekey != NULL) {
                         idx = real_idx;
                         break;
@@ -2477,11 +2490,11 @@ static const SIGALG_LOOKUP *tls1_get_legacy_sigalg(const SSL_CONNECTION *s,
                 int real_idx;
 
                 for (real_idx = SSL_PKEY_GOST12_512; real_idx >= SSL_PKEY_GOST12_256;
-                     real_idx--) {
-                     if (s->cert->pkeys[real_idx].privatekey != NULL) {
-                         idx = real_idx;
-                         break;
-                     }
+                    real_idx--) {
+                    if (s->cert->pkeys[real_idx].privatekey != NULL) {
+                        idx = real_idx;
+                        break;
+                    }
                 }
             }
         } else {
@@ -2492,9 +2505,8 @@ static const SIGALG_LOOKUP *tls1_get_legacy_sigalg(const SSL_CONNECTION *s,
         return NULL;
 
     if (SSL_USE_SIGALGS(s) || idx != SSL_PKEY_RSA) {
-        const SIGALG_LOOKUP *lu =
-            tls1_lookup_sigalg(SSL_CONNECTION_GET_CTX(s),
-                               tls_default_sigalg[idx]);
+        const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(SSL_CONNECTION_GET_CTX(s),
+            tls_default_sigalg[idx]);
 
         if (lu == NULL)
             return NULL;
@@ -2565,8 +2577,8 @@ size_t tls12_get_psigalgs(SSL_CONNECTION *s, int sent, const uint16_t **psigs)
  */
 int tls_check_sigalg_curve(const SSL_CONNECTION *s, int curve)
 {
-   const uint16_t *sigs;
-   size_t siglen, i;
+    const uint16_t *sigs;
+    size_t siglen, i;
 
     if (s->cert->conf_sigalgs) {
         sigs = s->cert->conf_sigalgs;
@@ -2577,14 +2589,13 @@ int tls_check_sigalg_curve(const SSL_CONNECTION *s, int curve)
     }
 
     for (i = 0; i < siglen; i++) {
-        const SIGALG_LOOKUP *lu =
-            tls1_lookup_sigalg(SSL_CONNECTION_GET_CTX(s), sigs[i]);
+        const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(SSL_CONNECTION_GET_CTX(s), sigs[i]);
 
         if (lu == NULL)
             continue;
         if (lu->sig == EVP_PKEY_EC
-                && lu->curve != NID_undef
-                && curve == lu->curve)
+            && lu->curve != NID_undef
+            && curve == lu->curve)
             return 1;
     }
 
@@ -2602,8 +2613,7 @@ static int sigalg_security_bits(SSL_CTX *ctx, const SIGALG_LOOKUP *lu)
 
     if (!tls1_lookup_md(ctx, lu, &md))
         return 0;
-    if (md != NULL)
-    {
+    if (md != NULL) {
         int md_type = EVP_MD_get_type(md);
 
         /* Security bits: half digest bits */
@@ -2638,7 +2648,7 @@ static int sigalg_security_bits(SSL_CTX *ctx, const SIGALG_LOOKUP *lu)
      * in the (provider-loaded) sigalg_list structure
      */
     if ((secbits == 0) && (lu->sig_idx >= SSL_PKEY_NUM)
-               && ((lu->sig_idx - SSL_PKEY_NUM) < (int)ctx->sigalg_list_len)) {
+        && ((lu->sig_idx - SSL_PKEY_NUM) < (int)ctx->sigalg_list_len)) {
         secbits = ctx->sigalg_list[lu->sig_idx - SSL_PKEY_NUM].secbits;
     }
     return secbits;
@@ -2716,9 +2726,16 @@ int tls12_check_peer_sigalg(SSL_CONNECTION *s, uint16_t sig, EVP_PKEY *pkey)
         return 0;
     }
 
-    /* if this sigalg is loaded, set so far unknown pkeyid to its sig NID */
-    if (pkeyid == EVP_PKEY_KEYMGMT)
-        pkeyid = lu->sig;
+    /* If we don't know the pkey nid yet go and find it */
+    if (pkeyid == EVP_PKEY_KEYMGMT) {
+        const SSL_CERT_LOOKUP *scl = ssl_cert_lookup_by_pkey(pkey, NULL, SSL_CONNECTION_GET_CTX(s));
+
+        if (scl == NULL) {
+            SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_SIGNATURE_TYPE);
+            return 0;
+        }
+        pkeyid = scl->pkey_nid;
+    }
 
     /* Should never happen */
     if (pkeyid == -1) {
@@ -2733,15 +2750,15 @@ int tls12_check_peer_sigalg(SSL_CONNECTION *s, uint16_t sig, EVP_PKEY *pkey)
     if ((SSL_CONNECTION_IS_TLS13(s)
             && (lu->hash == NID_sha1 || lu->hash == NID_sha224))
         || (pkeyid != lu->sig
-        && (lu->sig != EVP_PKEY_RSA_PSS || pkeyid != EVP_PKEY_RSA))) {
+            && (lu->sig != EVP_PKEY_RSA_PSS || pkeyid != EVP_PKEY_RSA))) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_SIGNATURE_TYPE);
         return 0;
     }
     /* Check the sigalg is consistent with the key OID */
     if (!ssl_cert_lookup_by_nid(
-                 (pkeyid == EVP_PKEY_RSA_PSS) ? EVP_PKEY_get_id(pkey) : pkeyid,
-                 &cidx, SSL_CONNECTION_GET_CTX(s))
-            || lu->sig_idx != (int)cidx) {
+            (pkeyid == EVP_PKEY_RSA_PSS) ? EVP_PKEY_get_id(pkey) : pkeyid,
+            &cidx, SSL_CONNECTION_GET_CTX(s))
+        || lu->sig_idx != (int)cidx) {
         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_WRONG_SIGNATURE_TYPE);
         return 0;
     }
@@ -2751,7 +2768,7 @@ int tls12_check_peer_sigalg(SSL_CONNECTION *s, uint16_t sig, EVP_PKEY *pkey)
         /* Check point compression is permitted */
         if (!tls1_check_pkey_comp(s, pkey)) {
             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
-                     SSL_R_ILLEGAL_POINT_COMPRESSION);
+                SSL_R_ILLEGAL_POINT_COMPRESSION);
             return 0;
         }
 
@@ -2775,7 +2792,7 @@ int tls12_check_peer_sigalg(SSL_CONNECTION *s, uint16_t sig, EVP_PKEY *pkey)
                 if (sig != TLSEXT_SIGALG_ecdsa_secp256r1_sha256
                     && sig != TLSEXT_SIGALG_ecdsa_secp384r1_sha384) {
                     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                             SSL_R_WRONG_SIGNATURE_TYPE);
+                        SSL_R_WRONG_SIGNATURE_TYPE);
                     return 0;
                 }
             }
@@ -2792,8 +2809,7 @@ int tls12_check_peer_sigalg(SSL_CONNECTION *s, uint16_t sig, EVP_PKEY *pkey)
             break;
     }
     /* Allow fallback to SHA1 if not strict mode */
-    if (i == sent_sigslen && (lu->hash != NID_sha1
-        || s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)) {
+    if (i == sent_sigslen && (lu->hash != NID_sha1 || s->cert->cert_flags & SSL_CERT_FLAGS_CHECK_TLS_STRICT)) {
         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_WRONG_SIGNATURE_TYPE);
         return 0;
     }
@@ -2808,10 +2824,7 @@ int tls12_check_peer_sigalg(SSL_CONNECTION *s, uint16_t sig, EVP_PKEY *pkey)
     sigalgstr[0] = (sig >> 8) & 0xff;
     sigalgstr[1] = sig & 0xff;
     secbits = sigalg_security_bits(SSL_CONNECTION_GET_CTX(s), lu);
-    if (secbits == 0 ||
-        !ssl_security(s, SSL_SECOP_SIGALG_CHECK, secbits,
-                      md != NULL ? EVP_MD_get_type(md) : NID_undef,
-                      (void *)sigalgstr)) {
+    if (secbits == 0 || !ssl_security(s, SSL_SECOP_SIGALG_CHECK, secbits, md != NULL ? EVP_MD_get_type(md) : NID_undef, (void *)sigalgstr)) {
         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_WRONG_SIGNATURE_TYPE);
         return 0;
     }
@@ -2862,7 +2875,8 @@ int ssl_set_client_disabled(SSL_CONNECTION *s)
     s->s3.tmp.mask_k = 0;
     ssl_set_sig_mask(&s->s3.tmp.mask_a, s, SSL_SECOP_SIGALG_MASK);
     if (ssl_get_min_max_version(s, &s->s3.tmp.min_ver,
-                                &s->s3.tmp.max_ver, NULL) != 0)
+            &s->s3.tmp.max_ver, NULL)
+        != 0)
         return 0;
 #ifndef OPENSSL_NO_PSK
     /* with PSK there must be client callback set */
@@ -2870,7 +2884,7 @@ int ssl_set_client_disabled(SSL_CONNECTION *s)
         s->s3.tmp.mask_a |= SSL_aPSK;
         s->s3.tmp.mask_k |= SSL_PSK;
     }
-#endif                          /* OPENSSL_NO_PSK */
+#endif /* OPENSSL_NO_PSK */
 #ifndef OPENSSL_NO_SRP
     if (!(s->srp_ctx.srp_Mask & SSL_kSRP)) {
         s->s3.tmp.mask_a |= SSL_aSRP;
@@ -2890,7 +2904,7 @@ int ssl_set_client_disabled(SSL_CONNECTION *s)
  * Returns 1 when it's disabled, 0 when enabled.
  */
 int ssl_cipher_disabled(const SSL_CONNECTION *s, const SSL_CIPHER *c,
-                        int op, int ecdhe)
+    int op, int ecdhe)
 {
     int minversion = SSL_CONNECTION_IS_DTLS(s) ? c->min_dtls : c->min_tls;
     int maxversion = SSL_CONNECTION_IS_DTLS(s) ? c->max_dtls : c->max_tls;
@@ -2917,8 +2931,8 @@ int ssl_cipher_disabled(const SSL_CONNECTION *s, const SSL_CIPHER *c,
      * in SSLv3 if we are a client
      */
     if (minversion == TLS1_VERSION
-            && ecdhe
-            && (c->algorithm_mkey & (SSL_kECDHE | SSL_kECDHEPSK)) != 0)
+        && ecdhe
+        && (c->algorithm_mkey & (SSL_kECDHE | SSL_kECDHEPSK)) != 0)
         minversion = SSL3_VERSION;
 
     if (ssl_version_cmp(s, minversion, s->s3.tmp.max_ver) > 0
@@ -2956,7 +2970,7 @@ int tls1_set_server_sigalgs(SSL_CONNECTION *s)
      * the default algorithm for each certificate type
      */
     if (s->s3.tmp.peer_cert_sigalgs == NULL
-            && s->s3.tmp.peer_sigalgs == NULL) {
+        && s->s3.tmp.peer_sigalgs == NULL) {
         const uint16_t *sent_sigs;
         size_t sent_sigslen = tls12_get_psigalgs(s, 1, &sent_sigs);
 
@@ -2969,8 +2983,8 @@ int tls1_set_server_sigalgs(SSL_CONNECTION *s)
             /* Check default matches a type we sent */
             for (j = 0; j < sent_sigslen; j++) {
                 if (lu->sigalg == sent_sigs[j]) {
-                        s->s3.tmp.valid_flags[i] = CERT_PKEY_SIGN;
-                        break;
+                    s->s3.tmp.valid_flags[i] = CERT_PKEY_SIGN;
+                    break;
                 }
             }
         }
@@ -2986,7 +3000,7 @@ int tls1_set_server_sigalgs(SSL_CONNECTION *s)
 
     /* Fatal error if no shared signature algorithms */
     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-             SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS);
+        SSL_R_NO_SHARED_SIGNATURE_ALGORITHMS);
     return 0;
 }
 
@@ -2998,8 +3012,8 @@ int tls1_set_server_sigalgs(SSL_CONNECTION *s)
  *       point to the resulting session.
  */
 SSL_TICKET_STATUS tls_get_ticket_from_client(SSL_CONNECTION *s,
-                                             CLIENTHELLO_MSG *hello,
-                                             SSL_SESSION **ret)
+    CLIENTHELLO_MSG *hello,
+    SSL_SESSION **ret)
 {
     size_t size;
     RAW_EXTENSION *ticketext;
@@ -3022,7 +3036,7 @@ SSL_TICKET_STATUS tls_get_ticket_from_client(SSL_CONNECTION *s,
     size = PACKET_remaining(&ticketext->data);
 
     return tls_decrypt_ticket(s, PACKET_data(&ticketext->data), size,
-                              hello->session_id, hello->session_id_len, ret);
+        hello->session_id, hello->session_id_len, ret);
 }
 
 /*-
@@ -3049,10 +3063,10 @@ SSL_TICKET_STATUS tls_get_ticket_from_client(SSL_CONNECTION *s,
  *       point to the resulting session.
  */
 SSL_TICKET_STATUS tls_decrypt_ticket(SSL_CONNECTION *s,
-                                     const unsigned char *etick,
-                                     size_t eticklen,
-                                     const unsigned char *sess_id,
-                                     size_t sesslen, SSL_SESSION **psess)
+    const unsigned char *etick,
+    size_t eticklen,
+    const unsigned char *sess_id,
+    size_t sesslen, SSL_SESSION **psess)
 {
     SSL_SESSION *sess = NULL;
     unsigned char *sdec;
@@ -3113,17 +3127,17 @@ SSL_TICKET_STATUS tls_decrypt_ticket(SSL_CONNECTION *s,
 
         if (tctx->ext.ticket_key_evp_cb != NULL)
             rv = tctx->ext.ticket_key_evp_cb(SSL_CONNECTION_GET_USER_SSL(s),
-                                             nctick,
-                                             nctick + TLSEXT_KEYNAME_LENGTH,
-                                             ctx,
-                                             ssl_hmac_get0_EVP_MAC_CTX(hctx),
-                                             0);
+                nctick,
+                nctick + TLSEXT_KEYNAME_LENGTH,
+                ctx,
+                ssl_hmac_get0_EVP_MAC_CTX(hctx),
+                0);
 #ifndef OPENSSL_NO_DEPRECATED_3_0
         else if (tctx->ext.ticket_key_cb != NULL)
             /* if 0 is returned, write an empty ticket */
             rv = tctx->ext.ticket_key_cb(SSL_CONNECTION_GET_USER_SSL(s), nctick,
-                                         nctick + TLSEXT_KEYNAME_LENGTH,
-                                         ctx, ssl_hmac_get0_HMAC_CTX(hctx), 0);
+                nctick + TLSEXT_KEYNAME_LENGTH,
+                ctx, ssl_hmac_get0_HMAC_CTX(hctx), 0);
 #endif
         if (rv < 0) {
             ret = SSL_TICKET_FATAL_ERR_OTHER;
@@ -3140,20 +3154,23 @@ SSL_TICKET_STATUS tls_decrypt_ticket(SSL_CONNECTION *s,
 
         /* Check key name matches */
         if (memcmp(etick, tctx->ext.tick_key_name,
-                   TLSEXT_KEYNAME_LENGTH) != 0) {
+                TLSEXT_KEYNAME_LENGTH)
+            != 0) {
             ret = SSL_TICKET_NO_DECRYPT;
             goto end;
         }
 
         aes256cbc = EVP_CIPHER_fetch(sctx->libctx, "AES-256-CBC",
-                                     sctx->propq);
+            sctx->propq);
         if (aes256cbc == NULL
             || ssl_hmac_init(hctx, tctx->ext.secure->tick_hmac_key,
-                             sizeof(tctx->ext.secure->tick_hmac_key),
-                             "SHA256") <= 0
+                   sizeof(tctx->ext.secure->tick_hmac_key),
+                   "SHA256")
+                <= 0
             || EVP_DecryptInit_ex(ctx, aes256cbc, NULL,
-                                  tctx->ext.secure->tick_aes_key,
-                                  etick + TLSEXT_KEYNAME_LENGTH) <= 0) {
+                   tctx->ext.secure->tick_aes_key,
+                   etick + TLSEXT_KEYNAME_LENGTH)
+                <= 0) {
             EVP_CIPHER_free(aes256cbc);
             ret = SSL_TICKET_FATAL_ERR_OTHER;
             goto end;
@@ -3200,8 +3217,7 @@ SSL_TICKET_STATUS tls_decrypt_ticket(SSL_CONNECTION *s,
     p = etick + TLSEXT_KEYNAME_LENGTH + ivlen;
     eticklen -= TLSEXT_KEYNAME_LENGTH + ivlen;
     sdec = OPENSSL_malloc(eticklen);
-    if (sdec == NULL || EVP_DecryptUpdate(ctx, sdec, &slen, p,
-                                          (int)eticklen) <= 0) {
+    if (sdec == NULL || EVP_DecryptUpdate(ctx, sdec, &slen, p, (int)eticklen) <= 0) {
         OPENSSL_free(sdec);
         ret = SSL_TICKET_FATAL_ERR_OTHER;
         goto end;
@@ -3247,7 +3263,7 @@ SSL_TICKET_STATUS tls_decrypt_ticket(SSL_CONNECTION *s,
      */
     ret = SSL_TICKET_NO_DECRYPT;
 
- end:
+end:
     EVP_CIPHER_CTX_free(ctx);
     ssl_hmac_free(hctx);
 
@@ -3257,19 +3273,19 @@ SSL_TICKET_STATUS tls_decrypt_ticket(SSL_CONNECTION *s,
      * performs any action
      */
     if (s->session_ctx->decrypt_ticket_cb != NULL
-            && (ret == SSL_TICKET_EMPTY
-                || ret == SSL_TICKET_NO_DECRYPT
-                || ret == SSL_TICKET_SUCCESS
-                || ret == SSL_TICKET_SUCCESS_RENEW)) {
+        && (ret == SSL_TICKET_EMPTY
+            || ret == SSL_TICKET_NO_DECRYPT
+            || ret == SSL_TICKET_SUCCESS
+            || ret == SSL_TICKET_SUCCESS_RENEW)) {
         size_t keyname_len = eticklen;
         int retcb;
 
         if (keyname_len > TLSEXT_KEYNAME_LENGTH)
             keyname_len = TLSEXT_KEYNAME_LENGTH;
         retcb = s->session_ctx->decrypt_ticket_cb(SSL_CONNECTION_GET_SSL(s),
-                                                  sess, etick, keyname_len,
-                                                  ret,
-                                                  s->session_ctx->ticket_cb_data);
+            sess, etick, keyname_len,
+            ret,
+            s->session_ctx->ticket_cb_data);
         switch (retcb) {
         case SSL_TICKET_RETURN_ABORT:
             ret = SSL_TICKET_FATAL_ERR_OTHER;
@@ -3292,7 +3308,7 @@ SSL_TICKET_STATUS tls_decrypt_ticket(SSL_CONNECTION *s,
         case SSL_TICKET_RETURN_USE:
         case SSL_TICKET_RETURN_USE_RENEW:
             if (ret != SSL_TICKET_SUCCESS
-                    && ret != SSL_TICKET_SUCCESS_RENEW)
+                && ret != SSL_TICKET_SUCCESS_RENEW)
                 ret = SSL_TICKET_FATAL_ERR_OTHER;
             else if (retcb == SSL_TICKET_RETURN_USE)
                 ret = SSL_TICKET_SUCCESS;
@@ -3321,7 +3337,7 @@ SSL_TICKET_STATUS tls_decrypt_ticket(SSL_CONNECTION *s,
 
 /* Check to see if a signature algorithm is allowed */
 static int tls12_sigalg_allowed(const SSL_CONNECTION *s, int op,
-                                const SIGALG_LOOKUP *lu)
+    const SIGALG_LOOKUP *lu)
 {
     unsigned char sigalgstr[2];
     int secbits;
@@ -3347,14 +3363,14 @@ static int tls12_sigalg_allowed(const SSL_CONNECTION *s, int op,
         return 0;
 
     if (lu->sig == NID_id_GostR3410_2012_256
-            || lu->sig == NID_id_GostR3410_2012_512
-            || lu->sig == NID_id_GostR3410_2001) {
+        || lu->sig == NID_id_GostR3410_2012_512
+        || lu->sig == NID_id_GostR3410_2001) {
         /* We never allow GOST sig algs on the server with TLSv1.3 */
         if (s->server && SSL_CONNECTION_IS_TLS13(s))
             return 0;
         if (!s->server
-                && SSL_CONNECTION_GET_SSL(s)->method->version == TLS_ANY_VERSION
-                && s->s3.tmp.max_ver >= TLS1_3_VERSION) {
+            && SSL_CONNECTION_GET_SSL(s)->method->version == TLS_ANY_VERSION
+            && s->s3.tmp.max_ver >= TLS1_3_VERSION) {
             int i, num;
             STACK_OF(SSL_CIPHER) *sk;
 
@@ -3409,35 +3425,33 @@ void ssl_set_sig_mask(uint32_t *pmask_a, SSL_CONNECTION *s, int op)
      */
     sigalgslen = tls12_get_psigalgs(s, 1, &sigalgs);
     for (i = 0; i < sigalgslen; i++, sigalgs++) {
-        const SIGALG_LOOKUP *lu =
-            tls1_lookup_sigalg(SSL_CONNECTION_GET_CTX(s), *sigalgs);
+        const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(SSL_CONNECTION_GET_CTX(s), *sigalgs);
         const SSL_CERT_LOOKUP *clu;
 
         if (lu == NULL)
             continue;
 
         clu = ssl_cert_lookup_by_idx(lu->sig_idx,
-                                     SSL_CONNECTION_GET_CTX(s));
+            SSL_CONNECTION_GET_CTX(s));
         if (clu == NULL)
-                continue;
+            continue;
 
         /* If algorithm is disabled see if we can enable it */
         if ((clu->amask & disabled_mask) != 0
-                && tls12_sigalg_allowed(s, op, lu))
+            && tls12_sigalg_allowed(s, op, lu))
             disabled_mask &= ~clu->amask;
     }
     *pmask_a |= disabled_mask;
 }
 
 int tls12_copy_sigalgs(SSL_CONNECTION *s, WPACKET *pkt,
-                       const uint16_t *psig, size_t psiglen)
+    const uint16_t *psig, size_t psiglen)
 {
     size_t i;
     int rv = 0;
 
     for (i = 0; i < psiglen; i++, psig++) {
-        const SIGALG_LOOKUP *lu =
-            tls1_lookup_sigalg(SSL_CONNECTION_GET_CTX(s), *psig);
+        const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(SSL_CONNECTION_GET_CTX(s), *psig);
 
         if (lu == NULL || !tls_sigalg_compat(s, lu))
             continue;
@@ -3447,10 +3461,7 @@ int tls12_copy_sigalgs(SSL_CONNECTION *s, WPACKET *pkt,
          * If TLS 1.3 must have at least one valid TLS 1.3 message
          * signing algorithm: i.e. neither RSA nor SHA1/SHA224
          */
-        if (rv == 0 && (!SSL_CONNECTION_IS_TLS13(s)
-            || (lu->sig != EVP_PKEY_RSA
-                && lu->hash != NID_sha1
-                && lu->hash != NID_sha224)))
+        if (rv == 0 && (!SSL_CONNECTION_IS_TLS13(s) || (lu->sig != EVP_PKEY_RSA && lu->hash != NID_sha1 && lu->hash != NID_sha224)))
             rv = 1;
     }
     if (rv == 0)
@@ -3460,19 +3471,18 @@ int tls12_copy_sigalgs(SSL_CONNECTION *s, WPACKET *pkt,
 
 /* Given preference and allowed sigalgs set shared sigalgs */
 static size_t tls12_shared_sigalgs(SSL_CONNECTION *s,
-                                   const SIGALG_LOOKUP **shsig,
-                                   const uint16_t *pref, size_t preflen,
-                                   const uint16_t *allow, size_t allowlen)
+    const SIGALG_LOOKUP **shsig,
+    const uint16_t *pref, size_t preflen,
+    const uint16_t *allow, size_t allowlen)
 {
     const uint16_t *ptmp, *atmp;
     size_t i, j, nmatch = 0;
     for (i = 0, ptmp = pref; i < preflen; i++, ptmp++) {
-        const SIGALG_LOOKUP *lu =
-            tls1_lookup_sigalg(SSL_CONNECTION_GET_CTX(s), *ptmp);
+        const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(SSL_CONNECTION_GET_CTX(s), *ptmp);
 
         /* Skip disabled hashes or signature algorithms */
         if (lu == NULL
-                || !tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SHARED, lu))
+            || !tls12_sigalg_allowed(s, SSL_SECOP_SIGALG_SHARED, lu))
             continue;
         for (j = 0, atmp = allow; j < allowlen; j++, atmp++) {
             if (*ptmp == *atmp) {
@@ -3574,11 +3584,10 @@ int tls1_save_sigalgs(SSL_CONNECTION *s, PACKET *pkt, int cert)
 
     if (cert)
         return tls1_save_u16(pkt, &s->s3.tmp.peer_cert_sigalgs,
-                             &s->s3.tmp.peer_cert_sigalgslen);
+            &s->s3.tmp.peer_cert_sigalgslen);
     else
         return tls1_save_u16(pkt, &s->s3.tmp.peer_sigalgs,
-                             &s->s3.tmp.peer_sigalgslen);
-
+            &s->s3.tmp.peer_sigalgslen);
 }
 
 /* Set preferred digest for each key type */
@@ -3610,8 +3619,8 @@ int tls1_process_sigalgs(SSL_CONNECTION *s)
 }
 
 int SSL_get_sigalgs(SSL *s, int idx,
-                    int *psign, int *phash, int *psignhash,
-                    unsigned char *rsig, unsigned char *rhash)
+    int *psign, int *phash, int *psignhash,
+    unsigned char *rsig, unsigned char *rhash)
 {
     uint16_t *psig;
     size_t numsigalgs;
@@ -3647,8 +3656,8 @@ int SSL_get_sigalgs(SSL *s, int idx,
 }
 
 int SSL_get_shared_sigalgs(SSL *s, int idx,
-                           int *psign, int *phash, int *psignhash,
-                           unsigned char *rsig, unsigned char *rhash)
+    int *psign, int *phash, int *psignhash,
+    unsigned char *rsig, unsigned char *rhash)
 {
     const SIGALG_LOOKUP *shsigalgs;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
@@ -3690,7 +3699,7 @@ static void get_sigorhash(int *psig, int *phash, const char *str)
     if (OPENSSL_strcasecmp(str, "RSA") == 0) {
         *psig = EVP_PKEY_RSA;
     } else if (OPENSSL_strcasecmp(str, "RSA-PSS") == 0
-               || OPENSSL_strcasecmp(str, "PSS") == 0) {
+        || OPENSSL_strcasecmp(str, "PSS") == 0) {
         *psig = EVP_PKEY_RSA_PSS;
     } else if (OPENSSL_strcasecmp(str, "DSA") == 0) {
         *psig = EVP_PKEY_DSA;
@@ -3703,7 +3712,7 @@ static void get_sigorhash(int *psig, int *phash, const char *str)
     }
 }
 /* Maximum length of a signature algorithm string component */
-#define TLS_MAX_SIGSTRING_LEN   40
+#define TLS_MAX_SIGSTRING_LEN 40
 
 static int sig_cb(const char *elem, int len, void *arg)
 {
@@ -3748,15 +3757,14 @@ static int sig_cb(const char *elem, int len, void *arg)
                     /* Ignore known, but unavailable sigalgs. */
                     if (!sarg->ctx->sigalg_lookup_cache[i].available)
                         return 1;
-                    sarg->sigalgs[sarg->sigalgcnt++] =
-                        sarg->ctx->sigalg_lookup_cache[i].sigalg;
+                    sarg->sigalgs[sarg->sigalgcnt++] = sarg->ctx->sigalg_lookup_cache[i].sigalg;
                     goto found;
                 }
             }
         } else {
             /* Syntax checks use the built-in sigalgs */
             for (i = 0, s = sigalg_lookup_tbl;
-                 i < OSSL_NELEM(sigalg_lookup_tbl); i++, s++) {
+                i < OSSL_NELEM(sigalg_lookup_tbl); i++, s++) {
                 iana = s->name;
                 alias = s->name12;
                 if ((alias != NULL && OPENSSL_strcasecmp(etmp, alias) == 0)
@@ -3799,7 +3807,7 @@ static int sig_cb(const char *elem, int len, void *arg)
     /* Ignore unknown algorithms if ignore_unknown */
     return ignore_unknown;
 
- found:
+found:
     /* Ignore duplicates */
     for (i = 0; i < sarg->sigalgcnt - 1; i++) {
         if (sarg->sigalgs[i] == sarg->sigalgs[sarg->sigalgcnt - 1]) {
@@ -3825,7 +3833,7 @@ int tls1_set_sigalgs_list(SSL_CTX *ctx, CERT *c, const char *str, int client)
         return 0;
     if (sig.sigalgcnt == 0) {
         ERR_raise_data(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT,
-                       "No valid signature algorithms in '%s'", str);
+            "No valid signature algorithms in '%s'", str);
         return 0;
     }
     if (c == NULL)
@@ -3834,7 +3842,7 @@ int tls1_set_sigalgs_list(SSL_CTX *ctx, CERT *c, const char *str, int client)
 }
 
 int tls1_set_raw_sigalgs(CERT *c, const uint16_t *psigs, size_t salglen,
-                     int client)
+    int client)
 {
     uint16_t *sigalgs;
 
@@ -3871,7 +3879,7 @@ int tls1_set_sigalgs(CERT *c, const int *psig_nids, size_t salglen, int client)
         int sig_id = *psig_nids++;
 
         for (j = 0, curr = sigalg_lookup_tbl; j < OSSL_NELEM(sigalg_lookup_tbl);
-             j++, curr++) {
+            j++, curr++) {
             if (curr->hash == md_id && curr->sig == sig_id) {
                 *sptr++ = curr->sigalg;
                 break;
@@ -3894,7 +3902,7 @@ int tls1_set_sigalgs(CERT *c, const int *psig_nids, size_t salglen, int client)
 
     return 1;
 
- err:
+err:
     OPENSSL_free(sigalgs);
     return 0;
 }
@@ -3937,9 +3945,9 @@ static int tls1_check_sig_alg(SSL_CONNECTION *s, X509 *x, int default_nid)
         int mdnid, pknid;
 
         sigalg = use_pc_sigalgs
-                 ? tls1_lookup_sigalg(SSL_CONNECTION_GET_CTX(s),
-                                      s->s3.tmp.peer_cert_sigalgs[i])
-                 : s->shared_sigalgs[i];
+            ? tls1_lookup_sigalg(SSL_CONNECTION_GET_CTX(s),
+                  s->s3.tmp.peer_cert_sigalgs[i])
+            : s->shared_sigalgs[i];
         if (sigalg == NULL)
             continue;
         if (sig_nid == sigalg->sigandhash)
@@ -3989,14 +3997,14 @@ static int ssl_check_ca_name(STACK_OF(X509_NAME) *names, X509 *x)
 /* Flags which need to be set for a certificate when strict mode not set */
 
 #define CERT_PKEY_VALID_FLAGS \
-        (CERT_PKEY_EE_SIGNATURE|CERT_PKEY_EE_PARAM)
+    (CERT_PKEY_EE_SIGNATURE | CERT_PKEY_EE_PARAM)
 /* Strict mode flags */
-#define CERT_PKEY_STRICT_FLAGS \
-         (CERT_PKEY_VALID_FLAGS|CERT_PKEY_CA_SIGNATURE|CERT_PKEY_CA_PARAM \
-         | CERT_PKEY_ISSUER_NAME|CERT_PKEY_CERT_TYPE)
+#define CERT_PKEY_STRICT_FLAGS                                           \
+    (CERT_PKEY_VALID_FLAGS | CERT_PKEY_CA_SIGNATURE | CERT_PKEY_CA_PARAM \
+        | CERT_PKEY_ISSUER_NAME | CERT_PKEY_CERT_TYPE)
 
 int tls1_check_chain(SSL_CONNECTION *s, X509 *x, EVP_PKEY *pk,
-                     STACK_OF(X509) *chain, int idx)
+    STACK_OF(X509) *chain, int idx)
 {
     int i;
     int rv = 0;
@@ -4041,7 +4049,8 @@ int tls1_check_chain(SSL_CONNECTION *s, X509 *x, EVP_PKEY *pk,
             return 0;
 
         if (ssl_cert_lookup_by_pkey(pk, &certidx,
-                                    SSL_CONNECTION_GET_CTX(s)) == NULL)
+                SSL_CONNECTION_GET_CTX(s))
+            == NULL)
             return 0;
         idx = certidx;
         pvalid = s->s3.tmp.valid_flags + idx;
@@ -4074,9 +4083,9 @@ int tls1_check_chain(SSL_CONNECTION *s, X509 *x, EVP_PKEY *pk,
         int rsign = 0;
 
         if (s->s3.tmp.peer_cert_sigalgs != NULL
-                || s->s3.tmp.peer_sigalgs != NULL) {
+            || s->s3.tmp.peer_sigalgs != NULL) {
             default_nid = 0;
-        /* If no sigalgs extension use defaults from RFC5246 */
+            /* If no sigalgs extension use defaults from RFC5246 */
         } else {
             switch (idx) {
             case SSL_PKEY_RSA:
@@ -4122,8 +4131,7 @@ int tls1_check_chain(SSL_CONNECTION *s, X509 *x, EVP_PKEY *pk,
             size_t j;
             const uint16_t *p = c->conf_sigalgs;
             for (j = 0; j < c->conf_sigalgslen; j++, p++) {
-                const SIGALG_LOOKUP *lu =
-                    tls1_lookup_sigalg(SSL_CONNECTION_GET_CTX(s), *p);
+                const SIGALG_LOOKUP *lu = tls1_lookup_sigalg(SSL_CONNECTION_GET_CTX(s), *p);
 
                 if (lu != NULL && lu->hash == NID_sha1 && lu->sig == rsign)
                     break;
@@ -4162,7 +4170,7 @@ int tls1_check_chain(SSL_CONNECTION *s, X509 *x, EVP_PKEY *pk,
     /* Else not TLS 1.2, so mark EE and CA signing algorithms OK */
     else if (check_flags)
         rv |= CERT_PKEY_EE_SIGNATURE | CERT_PKEY_CA_SIGNATURE;
- skip_sigs:
+skip_sigs:
     /* Check cert parameters are consistent */
     if (tls1_check_cert_param(s, x, 1))
         rv |= CERT_PKEY_EE_PARAM;
@@ -4235,7 +4243,7 @@ int tls1_check_chain(SSL_CONNECTION *s, X509 *x, EVP_PKEY *pk,
     if (!check_flags || (rv & check_flags) == check_flags)
         rv |= CERT_PKEY_VALID;
 
- end:
+end:
 
     if (TLS1_get_version(SSL_CONNECTION_GET_SSL(s)) >= TLS1_2_VERSION)
         rv |= *pvalid & (CERT_PKEY_EXPLICIT_SIGN | CERT_PKEY_SIGN);
@@ -4308,7 +4316,7 @@ EVP_PKEY *ssl_get_auto_dh(SSL_CONNECTION *s)
 
     /* Do not pick a prime that is too weak for the current security level */
     sec_level_bits = ssl_get_security_level_bits(SSL_CONNECTION_GET_SSL(s),
-                                                 NULL, NULL);
+        NULL, NULL);
     if (dh_secbits < sec_level_bits)
         dh_secbits = sec_level_bits;
 
@@ -4327,18 +4335,18 @@ EVP_PKEY *ssl_get_auto_dh(SSL_CONNECTION *s)
 
     pctx = EVP_PKEY_CTX_new_from_name(sctx->libctx, "DH", sctx->propq);
     if (pctx == NULL
-            || EVP_PKEY_fromdata_init(pctx) != 1)
+        || EVP_PKEY_fromdata_init(pctx) != 1)
         goto err;
 
     tmpl = OSSL_PARAM_BLD_new();
     if (tmpl == NULL
-            || !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_FFC_P, p)
-            || !OSSL_PARAM_BLD_push_uint(tmpl, OSSL_PKEY_PARAM_FFC_G, 2))
+        || !OSSL_PARAM_BLD_push_BN(tmpl, OSSL_PKEY_PARAM_FFC_P, p)
+        || !OSSL_PARAM_BLD_push_uint(tmpl, OSSL_PKEY_PARAM_FFC_G, 2))
         goto err;
 
     params = OSSL_PARAM_BLD_to_param(tmpl);
     if (params == NULL
-            || EVP_PKEY_fromdata(pctx, &dhp, EVP_PKEY_KEY_PARAMETERS, params) != 1)
+        || EVP_PKEY_fromdata(pctx, &dhp, EVP_PKEY_KEY_PARAMETERS, params) != 1)
         goto err;
 
 err:
@@ -4350,7 +4358,7 @@ err:
 }
 
 static int ssl_security_cert_key(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x,
-                                 int op)
+    int op)
 {
     int secbits = -1;
     EVP_PKEY *pkey = X509_get0_pubkey(x);
@@ -4371,7 +4379,7 @@ static int ssl_security_cert_key(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x,
 }
 
 static int ssl_security_cert_sig(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x,
-                                 int op)
+    int op)
 {
     /* Lookup signature algorithm digest */
     int secbits, nid, pknid;
@@ -4391,7 +4399,7 @@ static int ssl_security_cert_sig(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x,
 }
 
 int ssl_security_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x, int vfy,
-                      int is_ee)
+    int is_ee)
 {
     if (vfy)
         vfy = SSL_SECOP_PEER;
@@ -4414,7 +4422,7 @@ int ssl_security_cert(SSL_CONNECTION *s, SSL_CTX *ctx, X509 *x, int vfy,
  */
 
 int ssl_security_cert_chain(SSL_CONNECTION *s, STACK_OF(X509) *sk,
-                            X509 *x, int vfy)
+    X509 *x, int vfy)
 {
     int rv, start_idx, i;
 
@@ -4445,22 +4453,22 @@ int ssl_security_cert_chain(SSL_CONNECTION *s, STACK_OF(X509) *sk,
  */
 
 static int tls12_get_cert_sigalg_idx(const SSL_CONNECTION *s,
-                                     const SIGALG_LOOKUP *lu)
+    const SIGALG_LOOKUP *lu)
 {
     int sig_idx = lu->sig_idx;
     const SSL_CERT_LOOKUP *clu = ssl_cert_lookup_by_idx(sig_idx,
-                                                        SSL_CONNECTION_GET_CTX(s));
+        SSL_CONNECTION_GET_CTX(s));
 
     /* If not recognised or not supported by cipher mask it is not suitable */
     if (clu == NULL
-            || (clu->amask & s->s3.tmp.new_cipher->algorithm_auth) == 0
-            || (clu->nid == EVP_PKEY_RSA_PSS
-                && (s->s3.tmp.new_cipher->algorithm_mkey & SSL_kRSA) != 0))
+        || (clu->amask & s->s3.tmp.new_cipher->algorithm_auth) == 0
+        || (clu->pkey_nid == EVP_PKEY_RSA_PSS
+            && (s->s3.tmp.new_cipher->algorithm_mkey & SSL_kRSA) != 0))
         return -1;
 
     /* If doing RPK, the CERT_PKEY won't be "valid" */
     if (tls12_rpk_and_privkey(s, sig_idx))
-        return  s->s3.tmp.valid_flags[sig_idx] & CERT_PKEY_RPK ? sig_idx : -1;
+        return s->s3.tmp.valid_flags[sig_idx] & CERT_PKEY_RPK ? sig_idx : -1;
 
     return s->s3.tmp.valid_flags[sig_idx] & CERT_PKEY_VALID ? sig_idx : -1;
 }
@@ -4472,7 +4480,7 @@ static int tls12_get_cert_sigalg_idx(const SSL_CONNECTION *s,
  * Returns true if the cert is usable and false otherwise.
  */
 static int check_cert_usable(SSL_CONNECTION *s, const SIGALG_LOOKUP *sig,
-                             X509 *x, EVP_PKEY *pkey)
+    X509 *x, EVP_PKEY *pkey)
 {
     const SIGALG_LOOKUP *lu;
     int mdnid, pknid, supported;
@@ -4487,8 +4495,8 @@ static int check_cert_usable(SSL_CONNECTION *s, const SIGALG_LOOKUP *sig,
     if (sig->hash != NID_undef)
         mdname = OBJ_nid2sn(sig->hash);
     supported = EVP_PKEY_digestsign_supports_digest(pkey, sctx->libctx,
-                                                    mdname,
-                                                    sctx->propq);
+        mdname,
+        sctx->propq);
     if (supported <= 0)
         return 0;
 
@@ -4501,7 +4509,7 @@ static int check_cert_usable(SSL_CONNECTION *s, const SIGALG_LOOKUP *sig,
             return 0;
         for (i = 0; i < s->s3.tmp.peer_cert_sigalgslen; i++) {
             lu = tls1_lookup_sigalg(SSL_CONNECTION_GET_CTX(s),
-                                    s->s3.tmp.peer_cert_sigalgs[i]);
+                s->s3.tmp.peer_cert_sigalgs[i]);
             if (lu == NULL)
                 continue;
 
@@ -4540,7 +4548,7 @@ static int has_usable_cert(SSL_CONNECTION *s, const SIGALG_LOOKUP *sig, int idx)
         return 0;
 
     return check_cert_usable(s, sig, s->cert->pkeys[idx].x509,
-                             s->cert->pkeys[idx].privatekey);
+        s->cert->pkeys[idx].privatekey);
 }
 
 /*
@@ -4548,7 +4556,7 @@ static int has_usable_cert(SSL_CONNECTION *s, const SIGALG_LOOKUP *sig, int idx)
  * specified signature scheme |sig|, or false otherwise.
  */
 static int is_cert_usable(SSL_CONNECTION *s, const SIGALG_LOOKUP *sig, X509 *x,
-                          EVP_PKEY *pkey)
+    EVP_PKEY *pkey)
 {
     size_t idx;
 
@@ -4568,7 +4576,7 @@ static int is_cert_usable(SSL_CONNECTION *s, const SIGALG_LOOKUP *sig, X509 *x,
  * available certs/keys to find one that works.
  */
 static const SIGALG_LOOKUP *find_sig_alg(SSL_CONNECTION *s, X509 *x,
-                                         EVP_PKEY *pkey)
+    EVP_PKEY *pkey)
 {
     const SIGALG_LOOKUP *lu = NULL;
     size_t i;
@@ -4591,7 +4599,7 @@ static const SIGALG_LOOKUP *find_sig_alg(SSL_CONNECTION *s, X509 *x,
         if (!tls1_lookup_md(sctx, lu, NULL))
             continue;
         if ((pkey == NULL && !has_usable_cert(s, lu, -1))
-                || (pkey != NULL && !is_cert_usable(s, lu, x, pkey)))
+            || (pkey != NULL && !is_cert_usable(s, lu, x, pkey)))
             continue;
 
         tmppkey = (pkey != NULL) ? pkey
@@ -4641,7 +4649,7 @@ int tls_choose_sigalg(SSL_CONNECTION *s, int fatalerrs)
             if (!fatalerrs)
                 return 1;
             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                     SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
+                SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
             return 0;
         }
     } else {
@@ -4649,7 +4657,7 @@ int tls_choose_sigalg(SSL_CONNECTION *s, int fatalerrs)
         if (!(s->s3.tmp.new_cipher->algorithm_auth & SSL_aCERT))
             return 1;
         if (!s->server && !ssl_has_cert(s, s->cert->key - s->cert->pkeys))
-                return 1;
+            return 1;
 
         if (SSL_USE_SIGALGS(s)) {
             size_t i;
@@ -4660,7 +4668,7 @@ int tls_choose_sigalg(SSL_CONNECTION *s, int fatalerrs)
                 /* For Suite B need to match signature algorithm to curve */
                 if (tls1_suiteb(s))
                     curve = ssl_get_EC_curve_nid(s->cert->pkeys[SSL_PKEY_ECC]
-                                                 .privatekey);
+                            .privatekey);
 
                 /*
                  * Find highest preference signature algorithm matching
@@ -4702,24 +4710,25 @@ int tls_choose_sigalg(SSL_CONNECTION *s, int fatalerrs)
                  */
                 if (i == s->shared_sigalgslen
                     && (s->s3.tmp.new_cipher->algorithm_auth
-                        & (SSL_aGOST01 | SSL_aGOST12)) != 0) {
-                  if ((lu = tls1_get_legacy_sigalg(s, -1)) == NULL) {
-                    if (!fatalerrs)
-                      return 1;
-                    SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                             SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
-                    return 0;
-                  } else {
-                    i = 0;
-                    sig_idx = lu->sig_idx;
-                  }
+                           & (SSL_aGOST01 | SSL_aGOST12))
+                        != 0) {
+                    if ((lu = tls1_get_legacy_sigalg(s, -1)) == NULL) {
+                        if (!fatalerrs)
+                            return 1;
+                        SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
+                            SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
+                        return 0;
+                    } else {
+                        i = 0;
+                        sig_idx = lu->sig_idx;
+                    }
                 }
 #endif
                 if (i == s->shared_sigalgslen) {
                     if (!fatalerrs)
                         return 1;
                     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                             SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
+                        SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
                     return 0;
                 }
             } else {
@@ -4733,7 +4742,7 @@ int tls_choose_sigalg(SSL_CONNECTION *s, int fatalerrs)
                     if (!fatalerrs)
                         return 1;
                     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                             SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
+                        SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
                     return 0;
                 }
 
@@ -4741,14 +4750,14 @@ int tls_choose_sigalg(SSL_CONNECTION *s, int fatalerrs)
                 sent_sigslen = tls12_get_psigalgs(s, 1, &sent_sigs);
                 for (i = 0; i < sent_sigslen; i++, sent_sigs++) {
                     if (lu->sigalg == *sent_sigs
-                            && has_usable_cert(s, lu, lu->sig_idx))
+                        && has_usable_cert(s, lu, lu->sig_idx))
                         break;
                 }
                 if (i == sent_sigslen) {
                     if (!fatalerrs)
                         return 1;
                     SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
-                             SSL_R_WRONG_SIGNATURE_TYPE);
+                        SSL_R_WRONG_SIGNATURE_TYPE);
                     return 0;
                 }
             }
@@ -4757,7 +4766,7 @@ int tls_choose_sigalg(SSL_CONNECTION *s, int fatalerrs)
                 if (!fatalerrs)
                     return 1;
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
-                         SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
+                    SSL_R_NO_SUITABLE_SIGNATURE_ALGORITHM);
                 return 0;
             }
         }
@@ -4773,7 +4782,7 @@ int tls_choose_sigalg(SSL_CONNECTION *s, int fatalerrs)
 int SSL_CTX_set_tlsext_max_fragment_length(SSL_CTX *ctx, uint8_t mode)
 {
     if (mode != TLSEXT_max_fragment_length_DISABLED
-            && !IS_MAX_FRAGMENT_LENGTH_EXT_VALID(mode)) {
+        && !IS_MAX_FRAGMENT_LENGTH_EXT_VALID(mode)) {
         ERR_raise(ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
         return 0;
     }
@@ -4791,7 +4800,7 @@ int SSL_set_tlsext_max_fragment_length(SSL *ssl, uint8_t mode)
         return 0;
 
     if (mode != TLSEXT_max_fragment_length_DISABLED
-            && !IS_MAX_FRAGMENT_LENGTH_EXT_VALID(mode)) {
+        && !IS_MAX_FRAGMENT_LENGTH_EXT_VALID(mode)) {
         ERR_raise(ERR_LIB_SSL, SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
         return 0;
     }
@@ -4819,7 +4828,7 @@ SSL_HMAC *ssl_hmac_new(const SSL_CTX *ctx)
         return NULL;
 #ifndef OPENSSL_NO_DEPRECATED_3_0
     if (ctx->ext.ticket_key_evp_cb == NULL
-            && ctx->ext.ticket_key_cb != NULL) {
+        && ctx->ext.ticket_key_cb != NULL) {
         if (!ssl_hmac_old_new(ret))
             goto err;
         return ret;
@@ -4830,7 +4839,7 @@ SSL_HMAC *ssl_hmac_new(const SSL_CTX *ctx)
         goto err;
     EVP_MAC_free(mac);
     return ret;
- err:
+err:
     EVP_MAC_CTX_free(ret->ctx);
     EVP_MAC_free(mac);
     OPENSSL_free(ret);
@@ -4882,7 +4891,7 @@ int ssl_hmac_update(SSL_HMAC *ctx, const unsigned char *data, size_t len)
 }
 
 int ssl_hmac_final(SSL_HMAC *ctx, unsigned char *md, size_t *len,
-                   size_t max_size)
+    size_t max_size)
 {
     if (ctx->ctx != NULL)
         return EVP_MAC_final(ctx->ctx, md, len, max_size);
@@ -4915,8 +4924,8 @@ int ssl_get_EC_curve_nid(const EVP_PKEY *pkey)
 }
 
 __owur int tls13_set_encoded_pub_key(EVP_PKEY *pkey,
-                                     const unsigned char *enckey,
-                                     size_t enckeylen)
+    const unsigned char *enckey,
+    size_t enckeylen)
 {
     if (EVP_PKEY_is_a(pkey, "DH")) {
         int bits = EVP_PKEY_get_bits(pkey);
diff --git a/crypto/openssl/ssl/t1_trce.c b/crypto/openssl/ssl/t1_trce.c
index 73fd4ebaa4b0..e8075d04278c 100644
--- a/crypto/openssl/ssl/t1_trce.c
+++ b/crypto/openssl/ssl/t1_trce.c
@@ -21,15 +21,15 @@ typedef struct {
     const char *name;
 } ssl_trace_tbl;
 
-# define ssl_trace_str(val, tbl) \
+#define ssl_trace_str(val, tbl) \
     do_ssl_trace_str(val, tbl, OSSL_NELEM(tbl))
 
-# define ssl_trace_list(bio, indent, msg, msglen, value, table) \
-    do_ssl_trace_list(bio, indent, msg, msglen, value, \
-                      table, OSSL_NELEM(table))
+#define ssl_trace_list(bio, indent, msg, msglen, value, table) \
+    do_ssl_trace_list(bio, indent, msg, msglen, value,         \
+        table, OSSL_NELEM(table))
 
 static const char *do_ssl_trace_str(int val, const ssl_trace_tbl *tbl,
-                                    size_t ntbl)
+    size_t ntbl)
 {
     size_t i;
 
@@ -41,8 +41,8 @@ static const char *do_ssl_trace_str(int val, const ssl_trace_tbl *tbl,
 }
 
 static int do_ssl_trace_list(BIO *bio, int indent,
-                             const unsigned char *msg, size_t msglen,
-                             size_t vlen, const ssl_trace_tbl *tbl, size_t ntbl)
+    const unsigned char *msg, size_t msglen,
+    size_t vlen, const ssl_trace_tbl *tbl, size_t ntbl)
 {
     int val;
 
@@ -63,590 +63,590 @@ static int do_ssl_trace_list(BIO *bio, int indent,
 /* Version number */
 
 static const ssl_trace_tbl ssl_version_tbl[] = {
-    {SSL3_VERSION, "SSL 3.0"},
-    {TLS1_VERSION, "TLS 1.0"},
-    {TLS1_1_VERSION, "TLS 1.1"},
-    {TLS1_2_VERSION, "TLS 1.2"},
-    {TLS1_3_VERSION, "TLS 1.3"},
-    {DTLS1_VERSION, "DTLS 1.0"},
-    {DTLS1_2_VERSION, "DTLS 1.2"},
-    {DTLS1_BAD_VER, "DTLS 1.0 (bad)"}
+    { SSL3_VERSION, "SSL 3.0" },
+    { TLS1_VERSION, "TLS 1.0" },
+    { TLS1_1_VERSION, "TLS 1.1" },
+    { TLS1_2_VERSION, "TLS 1.2" },
+    { TLS1_3_VERSION, "TLS 1.3" },
+    { DTLS1_VERSION, "DTLS 1.0" },
+    { DTLS1_2_VERSION, "DTLS 1.2" },
+    { DTLS1_BAD_VER, "DTLS 1.0 (bad)" }
 };
 
 static const ssl_trace_tbl ssl_content_tbl[] = {
-    {SSL3_RT_CHANGE_CIPHER_SPEC, "ChangeCipherSpec"},
-    {SSL3_RT_ALERT, "Alert"},
-    {SSL3_RT_HANDSHAKE, "Handshake"},
-    {SSL3_RT_APPLICATION_DATA, "ApplicationData"},
+    { SSL3_RT_CHANGE_CIPHER_SPEC, "ChangeCipherSpec" },
+    { SSL3_RT_ALERT, "Alert" },
+    { SSL3_RT_HANDSHAKE, "Handshake" },
+    { SSL3_RT_APPLICATION_DATA, "ApplicationData" },
 };
 
 /* Handshake types, sorted by ascending id  */
 static const ssl_trace_tbl ssl_handshake_tbl[] = {
-    {SSL3_MT_HELLO_REQUEST, "HelloRequest"},
-    {SSL3_MT_CLIENT_HELLO, "ClientHello"},
-    {SSL3_MT_SERVER_HELLO, "ServerHello"},
-    {DTLS1_MT_HELLO_VERIFY_REQUEST, "HelloVerifyRequest"},
-    {SSL3_MT_NEWSESSION_TICKET, "NewSessionTicket"},
-    {SSL3_MT_END_OF_EARLY_DATA, "EndOfEarlyData"},
-    {SSL3_MT_ENCRYPTED_EXTENSIONS, "EncryptedExtensions"},
-    {SSL3_MT_CERTIFICATE, "Certificate"},
-    {SSL3_MT_SERVER_KEY_EXCHANGE, "ServerKeyExchange"},
-    {SSL3_MT_CERTIFICATE_REQUEST, "CertificateRequest"},
-    {SSL3_MT_SERVER_DONE, "ServerHelloDone"},
-    {SSL3_MT_CERTIFICATE_VERIFY, "CertificateVerify"},
-    {SSL3_MT_CLIENT_KEY_EXCHANGE, "ClientKeyExchange"},
-    {SSL3_MT_FINISHED, "Finished"},
-    {SSL3_MT_CERTIFICATE_URL, "CertificateUrl"},
-    {SSL3_MT_CERTIFICATE_STATUS, "CertificateStatus"},
-    {SSL3_MT_SUPPLEMENTAL_DATA, "SupplementalData"},
-    {SSL3_MT_KEY_UPDATE, "KeyUpdate"},
-    {SSL3_MT_COMPRESSED_CERTIFICATE, "CompressedCertificate"},
-# ifndef OPENSSL_NO_NEXTPROTONEG
-    {SSL3_MT_NEXT_PROTO, "NextProto"},
-# endif
-    {SSL3_MT_MESSAGE_HASH, "MessageHash"}
+    { SSL3_MT_HELLO_REQUEST, "HelloRequest" },
+    { SSL3_MT_CLIENT_HELLO, "ClientHello" },
+    { SSL3_MT_SERVER_HELLO, "ServerHello" },
+    { DTLS1_MT_HELLO_VERIFY_REQUEST, "HelloVerifyRequest" },
+    { SSL3_MT_NEWSESSION_TICKET, "NewSessionTicket" },
+    { SSL3_MT_END_OF_EARLY_DATA, "EndOfEarlyData" },
+    { SSL3_MT_ENCRYPTED_EXTENSIONS, "EncryptedExtensions" },
+    { SSL3_MT_CERTIFICATE, "Certificate" },
+    { SSL3_MT_SERVER_KEY_EXCHANGE, "ServerKeyExchange" },
+    { SSL3_MT_CERTIFICATE_REQUEST, "CertificateRequest" },
+    { SSL3_MT_SERVER_DONE, "ServerHelloDone" },
+    { SSL3_MT_CERTIFICATE_VERIFY, "CertificateVerify" },
+    { SSL3_MT_CLIENT_KEY_EXCHANGE, "ClientKeyExchange" },
+    { SSL3_MT_FINISHED, "Finished" },
+    { SSL3_MT_CERTIFICATE_URL, "CertificateUrl" },
+    { SSL3_MT_CERTIFICATE_STATUS, "CertificateStatus" },
+    { SSL3_MT_SUPPLEMENTAL_DATA, "SupplementalData" },
+    { SSL3_MT_KEY_UPDATE, "KeyUpdate" },
+    { SSL3_MT_COMPRESSED_CERTIFICATE, "CompressedCertificate" },
+#ifndef OPENSSL_NO_NEXTPROTONEG
+    { SSL3_MT_NEXT_PROTO, "NextProto" },
+#endif
+    { SSL3_MT_MESSAGE_HASH, "MessageHash" }
 };
 
 /* Cipher suites */
 static const ssl_trace_tbl ssl_ciphers_tbl[] = {
-    {0x0000, "TLS_NULL_WITH_NULL_NULL"},
-    {0x0001, "TLS_RSA_WITH_NULL_MD5"},
-    {0x0002, "TLS_RSA_WITH_NULL_SHA"},
-    {0x0003, "TLS_RSA_EXPORT_WITH_RC4_40_MD5"},
-    {0x0004, "TLS_RSA_WITH_RC4_128_MD5"},
-    {0x0005, "TLS_RSA_WITH_RC4_128_SHA"},
-    {0x0006, "TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5"},
-    {0x0007, "TLS_RSA_WITH_IDEA_CBC_SHA"},
-    {0x0008, "TLS_RSA_EXPORT_WITH_DES40_CBC_SHA"},
-    {0x0009, "TLS_RSA_WITH_DES_CBC_SHA"},
-    {0x000A, "TLS_RSA_WITH_3DES_EDE_CBC_SHA"},
-    {0x000B, "TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA"},
-    {0x000C, "TLS_DH_DSS_WITH_DES_CBC_SHA"},
-    {0x000D, "TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA"},
-    {0x000E, "TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA"},
-    {0x000F, "TLS_DH_RSA_WITH_DES_CBC_SHA"},
-    {0x0010, "TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA"},
-    {0x0011, "TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA"},
-    {0x0012, "TLS_DHE_DSS_WITH_DES_CBC_SHA"},
-    {0x0013, "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA"},
-    {0x0014, "TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA"},
-    {0x0015, "TLS_DHE_RSA_WITH_DES_CBC_SHA"},
-    {0x0016, "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA"},
-    {0x0017, "TLS_DH_anon_EXPORT_WITH_RC4_40_MD5"},
-    {0x0018, "TLS_DH_anon_WITH_RC4_128_MD5"},
-    {0x0019, "TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA"},
-    {0x001A, "TLS_DH_anon_WITH_DES_CBC_SHA"},
-    {0x001B, "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA"},
-    {0x001D, "SSL_FORTEZZA_KEA_WITH_FORTEZZA_CBC_SHA"},
-    {0x001E, "SSL_FORTEZZA_KEA_WITH_RC4_128_SHA"},
-    {0x001F, "TLS_KRB5_WITH_3DES_EDE_CBC_SHA"},
-    {0x0020, "TLS_KRB5_WITH_RC4_128_SHA"},
-    {0x0021, "TLS_KRB5_WITH_IDEA_CBC_SHA"},
-    {0x0022, "TLS_KRB5_WITH_DES_CBC_MD5"},
-    {0x0023, "TLS_KRB5_WITH_3DES_EDE_CBC_MD5"},
-    {0x0024, "TLS_KRB5_WITH_RC4_128_MD5"},
-    {0x0025, "TLS_KRB5_WITH_IDEA_CBC_MD5"},
-    {0x0026, "TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA"},
-    {0x0027, "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA"},
-    {0x0028, "TLS_KRB5_EXPORT_WITH_RC4_40_SHA"},
-    {0x0029, "TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5"},
-    {0x002A, "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5"},
-    {0x002B, "TLS_KRB5_EXPORT_WITH_RC4_40_MD5"},
-    {0x002C, "TLS_PSK_WITH_NULL_SHA"},
-    {0x002D, "TLS_DHE_PSK_WITH_NULL_SHA"},
-    {0x002E, "TLS_RSA_PSK_WITH_NULL_SHA"},
-    {0x002F, "TLS_RSA_WITH_AES_128_CBC_SHA"},
-    {0x0030, "TLS_DH_DSS_WITH_AES_128_CBC_SHA"},
-    {0x0031, "TLS_DH_RSA_WITH_AES_128_CBC_SHA"},
-    {0x0032, "TLS_DHE_DSS_WITH_AES_128_CBC_SHA"},
-    {0x0033, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA"},
-    {0x0034, "TLS_DH_anon_WITH_AES_128_CBC_SHA"},
-    {0x0035, "TLS_RSA_WITH_AES_256_CBC_SHA"},
-    {0x0036, "TLS_DH_DSS_WITH_AES_256_CBC_SHA"},
-    {0x0037, "TLS_DH_RSA_WITH_AES_256_CBC_SHA"},
-    {0x0038, "TLS_DHE_DSS_WITH_AES_256_CBC_SHA"},
-    {0x0039, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA"},
-    {0x003A, "TLS_DH_anon_WITH_AES_256_CBC_SHA"},
-    {0x003B, "TLS_RSA_WITH_NULL_SHA256"},
-    {0x003C, "TLS_RSA_WITH_AES_128_CBC_SHA256"},
-    {0x003D, "TLS_RSA_WITH_AES_256_CBC_SHA256"},
-    {0x003E, "TLS_DH_DSS_WITH_AES_128_CBC_SHA256"},
-    {0x003F, "TLS_DH_RSA_WITH_AES_128_CBC_SHA256"},
-    {0x0040, "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256"},
-    {0x0041, "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA"},
-    {0x0042, "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA"},
-    {0x0043, "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA"},
-    {0x0044, "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA"},
-    {0x0045, "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA"},
-    {0x0046, "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA"},
-    {0x0067, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256"},
-    {0x0068, "TLS_DH_DSS_WITH_AES_256_CBC_SHA256"},
-    {0x0069, "TLS_DH_RSA_WITH_AES_256_CBC_SHA256"},
-    {0x006A, "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256"},
-    {0x006B, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256"},
-    {0x006C, "TLS_DH_anon_WITH_AES_128_CBC_SHA256"},
-    {0x006D, "TLS_DH_anon_WITH_AES_256_CBC_SHA256"},
-    {0x0081, "TLS_GOSTR341001_WITH_28147_CNT_IMIT"},
-    {0x0083, "TLS_GOSTR341001_WITH_NULL_GOSTR3411"},
-    {0x0084, "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA"},
-    {0x0085, "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA"},
-    {0x0086, "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA"},
-    {0x0087, "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA"},
-    {0x0088, "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA"},
-    {0x0089, "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA"},
-    {0x008A, "TLS_PSK_WITH_RC4_128_SHA"},
-    {0x008B, "TLS_PSK_WITH_3DES_EDE_CBC_SHA"},
-    {0x008C, "TLS_PSK_WITH_AES_128_CBC_SHA"},
-    {0x008D, "TLS_PSK_WITH_AES_256_CBC_SHA"},
-    {0x008E, "TLS_DHE_PSK_WITH_RC4_128_SHA"},
-    {0x008F, "TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA"},
-    {0x0090, "TLS_DHE_PSK_WITH_AES_128_CBC_SHA"},
-    {0x0091, "TLS_DHE_PSK_WITH_AES_256_CBC_SHA"},
-    {0x0092, "TLS_RSA_PSK_WITH_RC4_128_SHA"},
-    {0x0093, "TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA"},
-    {0x0094, "TLS_RSA_PSK_WITH_AES_128_CBC_SHA"},
-    {0x0095, "TLS_RSA_PSK_WITH_AES_256_CBC_SHA"},
-    {0x0096, "TLS_RSA_WITH_SEED_CBC_SHA"},
-    {0x0097, "TLS_DH_DSS_WITH_SEED_CBC_SHA"},
-    {0x0098, "TLS_DH_RSA_WITH_SEED_CBC_SHA"},
-    {0x0099, "TLS_DHE_DSS_WITH_SEED_CBC_SHA"},
-    {0x009A, "TLS_DHE_RSA_WITH_SEED_CBC_SHA"},
-    {0x009B, "TLS_DH_anon_WITH_SEED_CBC_SHA"},
-    {0x009C, "TLS_RSA_WITH_AES_128_GCM_SHA256"},
-    {0x009D, "TLS_RSA_WITH_AES_256_GCM_SHA384"},
-    {0x009E, "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256"},
-    {0x009F, "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384"},
-    {0x00A0, "TLS_DH_RSA_WITH_AES_128_GCM_SHA256"},
-    {0x00A1, "TLS_DH_RSA_WITH_AES_256_GCM_SHA384"},
-    {0x00A2, "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256"},
-    {0x00A3, "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384"},
-    {0x00A4, "TLS_DH_DSS_WITH_AES_128_GCM_SHA256"},
-    {0x00A5, "TLS_DH_DSS_WITH_AES_256_GCM_SHA384"},
-    {0x00A6, "TLS_DH_anon_WITH_AES_128_GCM_SHA256"},
-    {0x00A7, "TLS_DH_anon_WITH_AES_256_GCM_SHA384"},
-    {0x00A8, "TLS_PSK_WITH_AES_128_GCM_SHA256"},
-    {0x00A9, "TLS_PSK_WITH_AES_256_GCM_SHA384"},
-    {0x00AA, "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256"},
-    {0x00AB, "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384"},
-    {0x00AC, "TLS_RSA_PSK_WITH_AES_128_GCM_SHA256"},
-    {0x00AD, "TLS_RSA_PSK_WITH_AES_256_GCM_SHA384"},
-    {0x00AE, "TLS_PSK_WITH_AES_128_CBC_SHA256"},
-    {0x00AF, "TLS_PSK_WITH_AES_256_CBC_SHA384"},
-    {0x00B0, "TLS_PSK_WITH_NULL_SHA256"},
-    {0x00B1, "TLS_PSK_WITH_NULL_SHA384"},
-    {0x00B2, "TLS_DHE_PSK_WITH_AES_128_CBC_SHA256"},
-    {0x00B3, "TLS_DHE_PSK_WITH_AES_256_CBC_SHA384"},
-    {0x00B4, "TLS_DHE_PSK_WITH_NULL_SHA256"},
-    {0x00B5, "TLS_DHE_PSK_WITH_NULL_SHA384"},
-    {0x00B6, "TLS_RSA_PSK_WITH_AES_128_CBC_SHA256"},
-    {0x00B7, "TLS_RSA_PSK_WITH_AES_256_CBC_SHA384"},
-    {0x00B8, "TLS_RSA_PSK_WITH_NULL_SHA256"},
-    {0x00B9, "TLS_RSA_PSK_WITH_NULL_SHA384"},
-    {0x00BA, "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256"},
-    {0x00BB, "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256"},
-    {0x00BC, "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256"},
-    {0x00BD, "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256"},
-    {0x00BE, "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"},
-    {0x00BF, "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256"},
-    {0x00C0, "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256"},
-    {0x00C1, "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256"},
-    {0x00C2, "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256"},
-    {0x00C3, "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256"},
-    {0x00C4, "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256"},
-    {0x00C5, "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256"},
-    {0x00FF, "TLS_EMPTY_RENEGOTIATION_INFO_SCSV"},
-    {0x5600, "TLS_FALLBACK_SCSV"},
-    {0xC001, "TLS_ECDH_ECDSA_WITH_NULL_SHA"},
-    {0xC002, "TLS_ECDH_ECDSA_WITH_RC4_128_SHA"},
-    {0xC003, "TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA"},
-    {0xC004, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA"},
-    {0xC005, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA"},
-    {0xC006, "TLS_ECDHE_ECDSA_WITH_NULL_SHA"},
-    {0xC007, "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA"},
-    {0xC008, "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA"},
-    {0xC009, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"},
-    {0xC00A, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"},
-    {0xC00B, "TLS_ECDH_RSA_WITH_NULL_SHA"},
-    {0xC00C, "TLS_ECDH_RSA_WITH_RC4_128_SHA"},
-    {0xC00D, "TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA"},
-    {0xC00E, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA"},
-    {0xC00F, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA"},
-    {0xC010, "TLS_ECDHE_RSA_WITH_NULL_SHA"},
-    {0xC011, "TLS_ECDHE_RSA_WITH_RC4_128_SHA"},
-    {0xC012, "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA"},
-    {0xC013, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"},
-    {0xC014, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA"},
-    {0xC015, "TLS_ECDH_anon_WITH_NULL_SHA"},
-    {0xC016, "TLS_ECDH_anon_WITH_RC4_128_SHA"},
-    {0xC017, "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA"},
-    {0xC018, "TLS_ECDH_anon_WITH_AES_128_CBC_SHA"},
-    {0xC019, "TLS_ECDH_anon_WITH_AES_256_CBC_SHA"},
-    {0xC01A, "TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA"},
-    {0xC01B, "TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA"},
-    {0xC01C, "TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA"},
-    {0xC01D, "TLS_SRP_SHA_WITH_AES_128_CBC_SHA"},
-    {0xC01E, "TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA"},
-    {0xC01F, "TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA"},
-    {0xC020, "TLS_SRP_SHA_WITH_AES_256_CBC_SHA"},
-    {0xC021, "TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA"},
-    {0xC022, "TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA"},
-    {0xC023, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256"},
-    {0xC024, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384"},
-    {0xC025, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256"},
-    {0xC026, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384"},
-    {0xC027, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"},
-    {0xC028, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384"},
-    {0xC029, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256"},
-    {0xC02A, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384"},
-    {0xC02B, "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"},
-    {0xC02C, "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384"},
-    {0xC02D, "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256"},
-    {0xC02E, "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384"},
-    {0xC02F, "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"},
-    {0xC030, "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"},
-    {0xC031, "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256"},
-    {0xC032, "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384"},
-    {0xC033, "TLS_ECDHE_PSK_WITH_RC4_128_SHA"},
-    {0xC034, "TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA"},
-    {0xC035, "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA"},
-    {0xC036, "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA"},
-    {0xC037, "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256"},
-    {0xC038, "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384"},
-    {0xC039, "TLS_ECDHE_PSK_WITH_NULL_SHA"},
-    {0xC03A, "TLS_ECDHE_PSK_WITH_NULL_SHA256"},
-    {0xC03B, "TLS_ECDHE_PSK_WITH_NULL_SHA384"},
-    {0xC03C, "TLS_RSA_WITH_ARIA_128_CBC_SHA256"},
-    {0xC03D, "TLS_RSA_WITH_ARIA_256_CBC_SHA384"},
-    {0xC03E, "TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256"},
-    {0xC03F, "TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384"},
-    {0xC040, "TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256"},
-    {0xC041, "TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384"},
-    {0xC042, "TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256"},
-    {0xC043, "TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384"},
-    {0xC044, "TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256"},
-    {0xC045, "TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384"},
-    {0xC046, "TLS_DH_anon_WITH_ARIA_128_CBC_SHA256"},
-    {0xC047, "TLS_DH_anon_WITH_ARIA_256_CBC_SHA384"},
-    {0xC048, "TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256"},
-    {0xC049, "TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384"},
-    {0xC04A, "TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256"},
-    {0xC04B, "TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384"},
-    {0xC04C, "TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256"},
-    {0xC04D, "TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384"},
-    {0xC04E, "TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256"},
-    {0xC04F, "TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384"},
-    {0xC050, "TLS_RSA_WITH_ARIA_128_GCM_SHA256"},
-    {0xC051, "TLS_RSA_WITH_ARIA_256_GCM_SHA384"},
-    {0xC052, "TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256"},
-    {0xC053, "TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384"},
-    {0xC054, "TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256"},
-    {0xC055, "TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384"},
-    {0xC056, "TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256"},
-    {0xC057, "TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384"},
-    {0xC058, "TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256"},
-    {0xC059, "TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384"},
-    {0xC05A, "TLS_DH_anon_WITH_ARIA_128_GCM_SHA256"},
-    {0xC05B, "TLS_DH_anon_WITH_ARIA_256_GCM_SHA384"},
-    {0xC05C, "TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256"},
-    {0xC05D, "TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384"},
-    {0xC05E, "TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256"},
-    {0xC05F, "TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384"},
-    {0xC060, "TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256"},
-    {0xC061, "TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384"},
-    {0xC062, "TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256"},
-    {0xC063, "TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384"},
-    {0xC064, "TLS_PSK_WITH_ARIA_128_CBC_SHA256"},
-    {0xC065, "TLS_PSK_WITH_ARIA_256_CBC_SHA384"},
-    {0xC066, "TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256"},
-    {0xC067, "TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384"},
-    {0xC068, "TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256"},
-    {0xC069, "TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384"},
-    {0xC06A, "TLS_PSK_WITH_ARIA_128_GCM_SHA256"},
-    {0xC06B, "TLS_PSK_WITH_ARIA_256_GCM_SHA384"},
-    {0xC06C, "TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256"},
-    {0xC06D, "TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384"},
-    {0xC06E, "TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256"},
-    {0xC06F, "TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384"},
-    {0xC070, "TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256"},
-    {0xC071, "TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384"},
-    {0xC072, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256"},
-    {0xC073, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384"},
-    {0xC074, "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256"},
-    {0xC075, "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384"},
-    {0xC076, "TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256"},
-    {0xC077, "TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384"},
-    {0xC078, "TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256"},
-    {0xC079, "TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384"},
-    {0xC07A, "TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256"},
-    {0xC07B, "TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384"},
-    {0xC07C, "TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256"},
-    {0xC07D, "TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384"},
-    {0xC07E, "TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256"},
-    {0xC07F, "TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384"},
-    {0xC080, "TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256"},
-    {0xC081, "TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384"},
-    {0xC082, "TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256"},
-    {0xC083, "TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384"},
-    {0xC084, "TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256"},
-    {0xC085, "TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384"},
-    {0xC086, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256"},
-    {0xC087, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384"},
-    {0xC088, "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256"},
-    {0xC089, "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384"},
-    {0xC08A, "TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256"},
-    {0xC08B, "TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384"},
-    {0xC08C, "TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256"},
-    {0xC08D, "TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384"},
-    {0xC08E, "TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256"},
-    {0xC08F, "TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384"},
-    {0xC090, "TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256"},
-    {0xC091, "TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384"},
-    {0xC092, "TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256"},
-    {0xC093, "TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384"},
-    {0xC094, "TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256"},
-    {0xC095, "TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384"},
-    {0xC096, "TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"},
-    {0xC097, "TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"},
-    {0xC098, "TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256"},
-    {0xC099, "TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384"},
-    {0xC09A, "TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256"},
-    {0xC09B, "TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384"},
-    {0xC09C, "TLS_RSA_WITH_AES_128_CCM"},
-    {0xC09D, "TLS_RSA_WITH_AES_256_CCM"},
-    {0xC09E, "TLS_DHE_RSA_WITH_AES_128_CCM"},
-    {0xC09F, "TLS_DHE_RSA_WITH_AES_256_CCM"},
-    {0xC0A0, "TLS_RSA_WITH_AES_128_CCM_8"},
-    {0xC0A1, "TLS_RSA_WITH_AES_256_CCM_8"},
-    {0xC0A2, "TLS_DHE_RSA_WITH_AES_128_CCM_8"},
-    {0xC0A3, "TLS_DHE_RSA_WITH_AES_256_CCM_8"},
-    {0xC0A4, "TLS_PSK_WITH_AES_128_CCM"},
-    {0xC0A5, "TLS_PSK_WITH_AES_256_CCM"},
-    {0xC0A6, "TLS_DHE_PSK_WITH_AES_128_CCM"},
-    {0xC0A7, "TLS_DHE_PSK_WITH_AES_256_CCM"},
-    {0xC0A8, "TLS_PSK_WITH_AES_128_CCM_8"},
-    {0xC0A9, "TLS_PSK_WITH_AES_256_CCM_8"},
-    {0xC0AA, "TLS_PSK_DHE_WITH_AES_128_CCM_8"},
-    {0xC0AB, "TLS_PSK_DHE_WITH_AES_256_CCM_8"},
-    {0xC0AC, "TLS_ECDHE_ECDSA_WITH_AES_128_CCM"},
-    {0xC0AD, "TLS_ECDHE_ECDSA_WITH_AES_256_CCM"},
-    {0xC0AE, "TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8"},
-    {0xC0AF, "TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8"},
-    {0xC102, "IANA-GOST2012-GOST8912-GOST8912"},
-    {0xCCA8, "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256"},
-    {0xCCA9, "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256"},
-    {0xCCAA, "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256"},
-    {0xCCAB, "TLS_PSK_WITH_CHACHA20_POLY1305_SHA256"},
-    {0xCCAC, "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256"},
-    {0xCCAD, "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256"},
-    {0xCCAE, "TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256"},
-    {0x1301, "TLS_AES_128_GCM_SHA256"},
-    {0x1302, "TLS_AES_256_GCM_SHA384"},
-    {0x1303, "TLS_CHACHA20_POLY1305_SHA256"},
-    {0x1304, "TLS_AES_128_CCM_SHA256"},
-    {0x1305, "TLS_AES_128_CCM_8_SHA256"},
-    {0xFEFE, "SSL_RSA_FIPS_WITH_DES_CBC_SHA"},
-    {0xFEFF, "SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA"},
-    {0xFF85, "LEGACY-GOST2012-GOST8912-GOST8912"},
-    {0xFF87, "GOST2012-NULL-GOST12"},
-    {0xC0B4, "TLS_SHA256_SHA256"},
-    {0xC0B5, "TLS_SHA384_SHA384"},
-    {0xC100, "GOST2012-KUZNYECHIK-KUZNYECHIKOMAC"},
-    {0xC101, "GOST2012-MAGMA-MAGMAOMAC"},
-    {0xC102, "GOST2012-GOST8912-IANA"},
+    { 0x0000, "TLS_NULL_WITH_NULL_NULL" },
+    { 0x0001, "TLS_RSA_WITH_NULL_MD5" },
+    { 0x0002, "TLS_RSA_WITH_NULL_SHA" },
+    { 0x0003, "TLS_RSA_EXPORT_WITH_RC4_40_MD5" },
+    { 0x0004, "TLS_RSA_WITH_RC4_128_MD5" },
+    { 0x0005, "TLS_RSA_WITH_RC4_128_SHA" },
+    { 0x0006, "TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5" },
+    { 0x0007, "TLS_RSA_WITH_IDEA_CBC_SHA" },
+    { 0x0008, "TLS_RSA_EXPORT_WITH_DES40_CBC_SHA" },
+    { 0x0009, "TLS_RSA_WITH_DES_CBC_SHA" },
+    { 0x000A, "TLS_RSA_WITH_3DES_EDE_CBC_SHA" },
+    { 0x000B, "TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA" },
+    { 0x000C, "TLS_DH_DSS_WITH_DES_CBC_SHA" },
+    { 0x000D, "TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA" },
+    { 0x000E, "TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA" },
+    { 0x000F, "TLS_DH_RSA_WITH_DES_CBC_SHA" },
+    { 0x0010, "TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA" },
+    { 0x0011, "TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA" },
+    { 0x0012, "TLS_DHE_DSS_WITH_DES_CBC_SHA" },
+    { 0x0013, "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA" },
+    { 0x0014, "TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA" },
+    { 0x0015, "TLS_DHE_RSA_WITH_DES_CBC_SHA" },
+    { 0x0016, "TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA" },
+    { 0x0017, "TLS_DH_anon_EXPORT_WITH_RC4_40_MD5" },
+    { 0x0018, "TLS_DH_anon_WITH_RC4_128_MD5" },
+    { 0x0019, "TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA" },
+    { 0x001A, "TLS_DH_anon_WITH_DES_CBC_SHA" },
+    { 0x001B, "TLS_DH_anon_WITH_3DES_EDE_CBC_SHA" },
+    { 0x001D, "SSL_FORTEZZA_KEA_WITH_FORTEZZA_CBC_SHA" },
+    { 0x001E, "SSL_FORTEZZA_KEA_WITH_RC4_128_SHA" },
+    { 0x001F, "TLS_KRB5_WITH_3DES_EDE_CBC_SHA" },
+    { 0x0020, "TLS_KRB5_WITH_RC4_128_SHA" },
+    { 0x0021, "TLS_KRB5_WITH_IDEA_CBC_SHA" },
+    { 0x0022, "TLS_KRB5_WITH_DES_CBC_MD5" },
+    { 0x0023, "TLS_KRB5_WITH_3DES_EDE_CBC_MD5" },
+    { 0x0024, "TLS_KRB5_WITH_RC4_128_MD5" },
+    { 0x0025, "TLS_KRB5_WITH_IDEA_CBC_MD5" },
+    { 0x0026, "TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA" },
+    { 0x0027, "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA" },
+    { 0x0028, "TLS_KRB5_EXPORT_WITH_RC4_40_SHA" },
+    { 0x0029, "TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5" },
+    { 0x002A, "TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5" },
+    { 0x002B, "TLS_KRB5_EXPORT_WITH_RC4_40_MD5" },
+    { 0x002C, "TLS_PSK_WITH_NULL_SHA" },
+    { 0x002D, "TLS_DHE_PSK_WITH_NULL_SHA" },
+    { 0x002E, "TLS_RSA_PSK_WITH_NULL_SHA" },
+    { 0x002F, "TLS_RSA_WITH_AES_128_CBC_SHA" },
+    { 0x0030, "TLS_DH_DSS_WITH_AES_128_CBC_SHA" },
+    { 0x0031, "TLS_DH_RSA_WITH_AES_128_CBC_SHA" },
+    { 0x0032, "TLS_DHE_DSS_WITH_AES_128_CBC_SHA" },
+    { 0x0033, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA" },
+    { 0x0034, "TLS_DH_anon_WITH_AES_128_CBC_SHA" },
+    { 0x0035, "TLS_RSA_WITH_AES_256_CBC_SHA" },
+    { 0x0036, "TLS_DH_DSS_WITH_AES_256_CBC_SHA" },
+    { 0x0037, "TLS_DH_RSA_WITH_AES_256_CBC_SHA" },
+    { 0x0038, "TLS_DHE_DSS_WITH_AES_256_CBC_SHA" },
+    { 0x0039, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA" },
+    { 0x003A, "TLS_DH_anon_WITH_AES_256_CBC_SHA" },
+    { 0x003B, "TLS_RSA_WITH_NULL_SHA256" },
+    { 0x003C, "TLS_RSA_WITH_AES_128_CBC_SHA256" },
+    { 0x003D, "TLS_RSA_WITH_AES_256_CBC_SHA256" },
+    { 0x003E, "TLS_DH_DSS_WITH_AES_128_CBC_SHA256" },
+    { 0x003F, "TLS_DH_RSA_WITH_AES_128_CBC_SHA256" },
+    { 0x0040, "TLS_DHE_DSS_WITH_AES_128_CBC_SHA256" },
+    { 0x0041, "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA" },
+    { 0x0042, "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA" },
+    { 0x0043, "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA" },
+    { 0x0044, "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA" },
+    { 0x0045, "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA" },
+    { 0x0046, "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA" },
+    { 0x0067, "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256" },
+    { 0x0068, "TLS_DH_DSS_WITH_AES_256_CBC_SHA256" },
+    { 0x0069, "TLS_DH_RSA_WITH_AES_256_CBC_SHA256" },
+    { 0x006A, "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256" },
+    { 0x006B, "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256" },
+    { 0x006C, "TLS_DH_anon_WITH_AES_128_CBC_SHA256" },
+    { 0x006D, "TLS_DH_anon_WITH_AES_256_CBC_SHA256" },
+    { 0x0081, "TLS_GOSTR341001_WITH_28147_CNT_IMIT" },
+    { 0x0083, "TLS_GOSTR341001_WITH_NULL_GOSTR3411" },
+    { 0x0084, "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA" },
+    { 0x0085, "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA" },
+    { 0x0086, "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA" },
+    { 0x0087, "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA" },
+    { 0x0088, "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA" },
+    { 0x0089, "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA" },
+    { 0x008A, "TLS_PSK_WITH_RC4_128_SHA" },
+    { 0x008B, "TLS_PSK_WITH_3DES_EDE_CBC_SHA" },
+    { 0x008C, "TLS_PSK_WITH_AES_128_CBC_SHA" },
+    { 0x008D, "TLS_PSK_WITH_AES_256_CBC_SHA" },
+    { 0x008E, "TLS_DHE_PSK_WITH_RC4_128_SHA" },
+    { 0x008F, "TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA" },
+    { 0x0090, "TLS_DHE_PSK_WITH_AES_128_CBC_SHA" },
+    { 0x0091, "TLS_DHE_PSK_WITH_AES_256_CBC_SHA" },
+    { 0x0092, "TLS_RSA_PSK_WITH_RC4_128_SHA" },
+    { 0x0093, "TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA" },
+    { 0x0094, "TLS_RSA_PSK_WITH_AES_128_CBC_SHA" },
+    { 0x0095, "TLS_RSA_PSK_WITH_AES_256_CBC_SHA" },
+    { 0x0096, "TLS_RSA_WITH_SEED_CBC_SHA" },
+    { 0x0097, "TLS_DH_DSS_WITH_SEED_CBC_SHA" },
+    { 0x0098, "TLS_DH_RSA_WITH_SEED_CBC_SHA" },
+    { 0x0099, "TLS_DHE_DSS_WITH_SEED_CBC_SHA" },
+    { 0x009A, "TLS_DHE_RSA_WITH_SEED_CBC_SHA" },
+    { 0x009B, "TLS_DH_anon_WITH_SEED_CBC_SHA" },
+    { 0x009C, "TLS_RSA_WITH_AES_128_GCM_SHA256" },
+    { 0x009D, "TLS_RSA_WITH_AES_256_GCM_SHA384" },
+    { 0x009E, "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256" },
+    { 0x009F, "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384" },
+    { 0x00A0, "TLS_DH_RSA_WITH_AES_128_GCM_SHA256" },
+    { 0x00A1, "TLS_DH_RSA_WITH_AES_256_GCM_SHA384" },
+    { 0x00A2, "TLS_DHE_DSS_WITH_AES_128_GCM_SHA256" },
+    { 0x00A3, "TLS_DHE_DSS_WITH_AES_256_GCM_SHA384" },
+    { 0x00A4, "TLS_DH_DSS_WITH_AES_128_GCM_SHA256" },
+    { 0x00A5, "TLS_DH_DSS_WITH_AES_256_GCM_SHA384" },
+    { 0x00A6, "TLS_DH_anon_WITH_AES_128_GCM_SHA256" },
+    { 0x00A7, "TLS_DH_anon_WITH_AES_256_GCM_SHA384" },
+    { 0x00A8, "TLS_PSK_WITH_AES_128_GCM_SHA256" },
+    { 0x00A9, "TLS_PSK_WITH_AES_256_GCM_SHA384" },
+    { 0x00AA, "TLS_DHE_PSK_WITH_AES_128_GCM_SHA256" },
+    { 0x00AB, "TLS_DHE_PSK_WITH_AES_256_GCM_SHA384" },
+    { 0x00AC, "TLS_RSA_PSK_WITH_AES_128_GCM_SHA256" },
+    { 0x00AD, "TLS_RSA_PSK_WITH_AES_256_GCM_SHA384" },
+    { 0x00AE, "TLS_PSK_WITH_AES_128_CBC_SHA256" },
+    { 0x00AF, "TLS_PSK_WITH_AES_256_CBC_SHA384" },
+    { 0x00B0, "TLS_PSK_WITH_NULL_SHA256" },
+    { 0x00B1, "TLS_PSK_WITH_NULL_SHA384" },
+    { 0x00B2, "TLS_DHE_PSK_WITH_AES_128_CBC_SHA256" },
+    { 0x00B3, "TLS_DHE_PSK_WITH_AES_256_CBC_SHA384" },
+    { 0x00B4, "TLS_DHE_PSK_WITH_NULL_SHA256" },
+    { 0x00B5, "TLS_DHE_PSK_WITH_NULL_SHA384" },
+    { 0x00B6, "TLS_RSA_PSK_WITH_AES_128_CBC_SHA256" },
+    { 0x00B7, "TLS_RSA_PSK_WITH_AES_256_CBC_SHA384" },
+    { 0x00B8, "TLS_RSA_PSK_WITH_NULL_SHA256" },
+    { 0x00B9, "TLS_RSA_PSK_WITH_NULL_SHA384" },
+    { 0x00BA, "TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256" },
+    { 0x00BB, "TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256" },
+    { 0x00BC, "TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256" },
+    { 0x00BD, "TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256" },
+    { 0x00BE, "TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256" },
+    { 0x00BF, "TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256" },
+    { 0x00C0, "TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256" },
+    { 0x00C1, "TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256" },
+    { 0x00C2, "TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256" },
+    { 0x00C3, "TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256" },
+    { 0x00C4, "TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256" },
+    { 0x00C5, "TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256" },
+    { 0x00FF, "TLS_EMPTY_RENEGOTIATION_INFO_SCSV" },
+    { 0x5600, "TLS_FALLBACK_SCSV" },
+    { 0xC001, "TLS_ECDH_ECDSA_WITH_NULL_SHA" },
+    { 0xC002, "TLS_ECDH_ECDSA_WITH_RC4_128_SHA" },
+    { 0xC003, "TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA" },
+    { 0xC004, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA" },
+    { 0xC005, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA" },
+    { 0xC006, "TLS_ECDHE_ECDSA_WITH_NULL_SHA" },
+    { 0xC007, "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA" },
+    { 0xC008, "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA" },
+    { 0xC009, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA" },
+    { 0xC00A, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA" },
+    { 0xC00B, "TLS_ECDH_RSA_WITH_NULL_SHA" },
+    { 0xC00C, "TLS_ECDH_RSA_WITH_RC4_128_SHA" },
+    { 0xC00D, "TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA" },
+    { 0xC00E, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA" },
+    { 0xC00F, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA" },
+    { 0xC010, "TLS_ECDHE_RSA_WITH_NULL_SHA" },
+    { 0xC011, "TLS_ECDHE_RSA_WITH_RC4_128_SHA" },
+    { 0xC012, "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA" },
+    { 0xC013, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA" },
+    { 0xC014, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA" },
+    { 0xC015, "TLS_ECDH_anon_WITH_NULL_SHA" },
+    { 0xC016, "TLS_ECDH_anon_WITH_RC4_128_SHA" },
+    { 0xC017, "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA" },
+    { 0xC018, "TLS_ECDH_anon_WITH_AES_128_CBC_SHA" },
+    { 0xC019, "TLS_ECDH_anon_WITH_AES_256_CBC_SHA" },
+    { 0xC01A, "TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA" },
+    { 0xC01B, "TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA" },
+    { 0xC01C, "TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA" },
+    { 0xC01D, "TLS_SRP_SHA_WITH_AES_128_CBC_SHA" },
+    { 0xC01E, "TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA" },
+    { 0xC01F, "TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA" },
+    { 0xC020, "TLS_SRP_SHA_WITH_AES_256_CBC_SHA" },
+    { 0xC021, "TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA" },
+    { 0xC022, "TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA" },
+    { 0xC023, "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256" },
+    { 0xC024, "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384" },
+    { 0xC025, "TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256" },
+    { 0xC026, "TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384" },
+    { 0xC027, "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256" },
+    { 0xC028, "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384" },
+    { 0xC029, "TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256" },
+    { 0xC02A, "TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384" },
+    { 0xC02B, "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256" },
+    { 0xC02C, "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384" },
+    { 0xC02D, "TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256" },
+    { 0xC02E, "TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384" },
+    { 0xC02F, "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256" },
+    { 0xC030, "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384" },
+    { 0xC031, "TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256" },
+    { 0xC032, "TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384" },
+    { 0xC033, "TLS_ECDHE_PSK_WITH_RC4_128_SHA" },
+    { 0xC034, "TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA" },
+    { 0xC035, "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA" },
+    { 0xC036, "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA" },
+    { 0xC037, "TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256" },
+    { 0xC038, "TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384" },
+    { 0xC039, "TLS_ECDHE_PSK_WITH_NULL_SHA" },
+    { 0xC03A, "TLS_ECDHE_PSK_WITH_NULL_SHA256" },
+    { 0xC03B, "TLS_ECDHE_PSK_WITH_NULL_SHA384" },
+    { 0xC03C, "TLS_RSA_WITH_ARIA_128_CBC_SHA256" },
+    { 0xC03D, "TLS_RSA_WITH_ARIA_256_CBC_SHA384" },
+    { 0xC03E, "TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256" },
+    { 0xC03F, "TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384" },
+    { 0xC040, "TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256" },
+    { 0xC041, "TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384" },
+    { 0xC042, "TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256" },
+    { 0xC043, "TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384" },
+    { 0xC044, "TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256" },
+    { 0xC045, "TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384" },
+    { 0xC046, "TLS_DH_anon_WITH_ARIA_128_CBC_SHA256" },
+    { 0xC047, "TLS_DH_anon_WITH_ARIA_256_CBC_SHA384" },
+    { 0xC048, "TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256" },
+    { 0xC049, "TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384" },
+    { 0xC04A, "TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256" },
+    { 0xC04B, "TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384" },
+    { 0xC04C, "TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256" },
+    { 0xC04D, "TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384" },
+    { 0xC04E, "TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256" },
+    { 0xC04F, "TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384" },
+    { 0xC050, "TLS_RSA_WITH_ARIA_128_GCM_SHA256" },
+    { 0xC051, "TLS_RSA_WITH_ARIA_256_GCM_SHA384" },
+    { 0xC052, "TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256" },
+    { 0xC053, "TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384" },
+    { 0xC054, "TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256" },
+    { 0xC055, "TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384" },
+    { 0xC056, "TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256" },
+    { 0xC057, "TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384" },
+    { 0xC058, "TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256" },
+    { 0xC059, "TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384" },
+    { 0xC05A, "TLS_DH_anon_WITH_ARIA_128_GCM_SHA256" },
+    { 0xC05B, "TLS_DH_anon_WITH_ARIA_256_GCM_SHA384" },
+    { 0xC05C, "TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256" },
+    { 0xC05D, "TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384" },
+    { 0xC05E, "TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256" },
+    { 0xC05F, "TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384" },
+    { 0xC060, "TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256" },
+    { 0xC061, "TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384" },
+    { 0xC062, "TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256" },
+    { 0xC063, "TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384" },
+    { 0xC064, "TLS_PSK_WITH_ARIA_128_CBC_SHA256" },
+    { 0xC065, "TLS_PSK_WITH_ARIA_256_CBC_SHA384" },
+    { 0xC066, "TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256" },
+    { 0xC067, "TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384" },
+    { 0xC068, "TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256" },
+    { 0xC069, "TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384" },
+    { 0xC06A, "TLS_PSK_WITH_ARIA_128_GCM_SHA256" },
+    { 0xC06B, "TLS_PSK_WITH_ARIA_256_GCM_SHA384" },
+    { 0xC06C, "TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256" },
+    { 0xC06D, "TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384" },
+    { 0xC06E, "TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256" },
+    { 0xC06F, "TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384" },
+    { 0xC070, "TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256" },
+    { 0xC071, "TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384" },
+    { 0xC072, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256" },
+    { 0xC073, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384" },
+    { 0xC074, "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256" },
+    { 0xC075, "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384" },
+    { 0xC076, "TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256" },
+    { 0xC077, "TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384" },
+    { 0xC078, "TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256" },
+    { 0xC079, "TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384" },
+    { 0xC07A, "TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256" },
+    { 0xC07B, "TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384" },
+    { 0xC07C, "TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256" },
+    { 0xC07D, "TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384" },
+    { 0xC07E, "TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256" },
+    { 0xC07F, "TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384" },
+    { 0xC080, "TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256" },
+    { 0xC081, "TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384" },
+    { 0xC082, "TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256" },
+    { 0xC083, "TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384" },
+    { 0xC084, "TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256" },
+    { 0xC085, "TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384" },
+    { 0xC086, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256" },
+    { 0xC087, "TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384" },
+    { 0xC088, "TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256" },
+    { 0xC089, "TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384" },
+    { 0xC08A, "TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256" },
+    { 0xC08B, "TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384" },
+    { 0xC08C, "TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256" },
+    { 0xC08D, "TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384" },
+    { 0xC08E, "TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256" },
+    { 0xC08F, "TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384" },
+    { 0xC090, "TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256" },
+    { 0xC091, "TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384" },
+    { 0xC092, "TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256" },
+    { 0xC093, "TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384" },
+    { 0xC094, "TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256" },
+    { 0xC095, "TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384" },
+    { 0xC096, "TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256" },
+    { 0xC097, "TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384" },
+    { 0xC098, "TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256" },
+    { 0xC099, "TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384" },
+    { 0xC09A, "TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256" },
+    { 0xC09B, "TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384" },
+    { 0xC09C, "TLS_RSA_WITH_AES_128_CCM" },
+    { 0xC09D, "TLS_RSA_WITH_AES_256_CCM" },
+    { 0xC09E, "TLS_DHE_RSA_WITH_AES_128_CCM" },
+    { 0xC09F, "TLS_DHE_RSA_WITH_AES_256_CCM" },
+    { 0xC0A0, "TLS_RSA_WITH_AES_128_CCM_8" },
+    { 0xC0A1, "TLS_RSA_WITH_AES_256_CCM_8" },
+    { 0xC0A2, "TLS_DHE_RSA_WITH_AES_128_CCM_8" },
+    { 0xC0A3, "TLS_DHE_RSA_WITH_AES_256_CCM_8" },
+    { 0xC0A4, "TLS_PSK_WITH_AES_128_CCM" },
+    { 0xC0A5, "TLS_PSK_WITH_AES_256_CCM" },
+    { 0xC0A6, "TLS_DHE_PSK_WITH_AES_128_CCM" },
+    { 0xC0A7, "TLS_DHE_PSK_WITH_AES_256_CCM" },
+    { 0xC0A8, "TLS_PSK_WITH_AES_128_CCM_8" },
+    { 0xC0A9, "TLS_PSK_WITH_AES_256_CCM_8" },
+    { 0xC0AA, "TLS_PSK_DHE_WITH_AES_128_CCM_8" },
+    { 0xC0AB, "TLS_PSK_DHE_WITH_AES_256_CCM_8" },
+    { 0xC0AC, "TLS_ECDHE_ECDSA_WITH_AES_128_CCM" },
+    { 0xC0AD, "TLS_ECDHE_ECDSA_WITH_AES_256_CCM" },
+    { 0xC0AE, "TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8" },
+    { 0xC0AF, "TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8" },
+    { 0xC102, "IANA-GOST2012-GOST8912-GOST8912" },
+    { 0xCCA8, "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256" },
+    { 0xCCA9, "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256" },
+    { 0xCCAA, "TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256" },
+    { 0xCCAB, "TLS_PSK_WITH_CHACHA20_POLY1305_SHA256" },
+    { 0xCCAC, "TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256" },
+    { 0xCCAD, "TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256" },
+    { 0xCCAE, "TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256" },
+    { 0x1301, "TLS_AES_128_GCM_SHA256" },
+    { 0x1302, "TLS_AES_256_GCM_SHA384" },
+    { 0x1303, "TLS_CHACHA20_POLY1305_SHA256" },
+    { 0x1304, "TLS_AES_128_CCM_SHA256" },
+    { 0x1305, "TLS_AES_128_CCM_8_SHA256" },
+    { 0xFEFE, "SSL_RSA_FIPS_WITH_DES_CBC_SHA" },
+    { 0xFEFF, "SSL_RSA_FIPS_WITH_3DES_EDE_CBC_SHA" },
+    { 0xFF85, "LEGACY-GOST2012-GOST8912-GOST8912" },
+    { 0xFF87, "GOST2012-NULL-GOST12" },
+    { 0xC0B4, "TLS_SHA256_SHA256" },
+    { 0xC0B5, "TLS_SHA384_SHA384" },
+    { 0xC100, "GOST2012-KUZNYECHIK-KUZNYECHIKOMAC" },
+    { 0xC101, "GOST2012-MAGMA-MAGMAOMAC" },
+    { 0xC102, "GOST2012-GOST8912-IANA" },
 };
 
 /* Compression methods */
 static const ssl_trace_tbl ssl_comp_tbl[] = {
-    {0x0000, "No Compression"},
-    {0x0001, "Zlib Compression"}
+    { 0x0000, "No Compression" },
+    { 0x0001, "Zlib Compression" }
 };
 
 /* Extensions sorted by ascending id */
 static const ssl_trace_tbl ssl_exts_tbl[] = {
-    {TLSEXT_TYPE_server_name, "server_name"},
-    {TLSEXT_TYPE_max_fragment_length, "max_fragment_length"},
-    {TLSEXT_TYPE_client_certificate_url, "client_certificate_url"},
-    {TLSEXT_TYPE_trusted_ca_keys, "trusted_ca_keys"},
-    {TLSEXT_TYPE_truncated_hmac, "truncated_hmac"},
-    {TLSEXT_TYPE_status_request, "status_request"},
-    {TLSEXT_TYPE_user_mapping, "user_mapping"},
-    {TLSEXT_TYPE_client_authz, "client_authz"},
-    {TLSEXT_TYPE_server_authz, "server_authz"},
-    {TLSEXT_TYPE_cert_type, "cert_type"},
-    {TLSEXT_TYPE_supported_groups, "supported_groups"},
-    {TLSEXT_TYPE_ec_point_formats, "ec_point_formats"},
-    {TLSEXT_TYPE_srp, "srp"},
-    {TLSEXT_TYPE_signature_algorithms, "signature_algorithms"},
-    {TLSEXT_TYPE_use_srtp, "use_srtp"},
-    {TLSEXT_TYPE_application_layer_protocol_negotiation,
-     "application_layer_protocol_negotiation"},
-    {TLSEXT_TYPE_signed_certificate_timestamp, "signed_certificate_timestamps"},
-    {TLSEXT_TYPE_client_cert_type, "client_cert_type"},
-    {TLSEXT_TYPE_server_cert_type, "server_cert_type"},
-    {TLSEXT_TYPE_padding, "padding"},
-    {TLSEXT_TYPE_encrypt_then_mac, "encrypt_then_mac"},
-    {TLSEXT_TYPE_extended_master_secret, "extended_master_secret"},
-    {TLSEXT_TYPE_compress_certificate, "compress_certificate"},
-    {TLSEXT_TYPE_session_ticket, "session_ticket"},
-    {TLSEXT_TYPE_psk, "psk"},
-    {TLSEXT_TYPE_early_data, "early_data"},
-    {TLSEXT_TYPE_supported_versions, "supported_versions"},
-    {TLSEXT_TYPE_cookie, "cookie_ext"},
-    {TLSEXT_TYPE_psk_kex_modes, "psk_key_exchange_modes"},
-    {TLSEXT_TYPE_certificate_authorities, "certificate_authorities"},
-    {TLSEXT_TYPE_post_handshake_auth, "post_handshake_auth"},
-    {TLSEXT_TYPE_signature_algorithms_cert, "signature_algorithms_cert"},
-    {TLSEXT_TYPE_key_share, "key_share"},
-    {TLSEXT_TYPE_renegotiate, "renegotiate"},
-# ifndef OPENSSL_NO_NEXTPROTONEG
-    {TLSEXT_TYPE_next_proto_neg, "next_proto_neg"},
-# endif
+    { TLSEXT_TYPE_server_name, "server_name" },
+    { TLSEXT_TYPE_max_fragment_length, "max_fragment_length" },
+    { TLSEXT_TYPE_client_certificate_url, "client_certificate_url" },
+    { TLSEXT_TYPE_trusted_ca_keys, "trusted_ca_keys" },
+    { TLSEXT_TYPE_truncated_hmac, "truncated_hmac" },
+    { TLSEXT_TYPE_status_request, "status_request" },
+    { TLSEXT_TYPE_user_mapping, "user_mapping" },
+    { TLSEXT_TYPE_client_authz, "client_authz" },
+    { TLSEXT_TYPE_server_authz, "server_authz" },
+    { TLSEXT_TYPE_cert_type, "cert_type" },
+    { TLSEXT_TYPE_supported_groups, "supported_groups" },
+    { TLSEXT_TYPE_ec_point_formats, "ec_point_formats" },
+    { TLSEXT_TYPE_srp, "srp" },
+    { TLSEXT_TYPE_signature_algorithms, "signature_algorithms" },
+    { TLSEXT_TYPE_use_srtp, "use_srtp" },
+    { TLSEXT_TYPE_application_layer_protocol_negotiation,
+        "application_layer_protocol_negotiation" },
+    { TLSEXT_TYPE_signed_certificate_timestamp, "signed_certificate_timestamps" },
+    { TLSEXT_TYPE_client_cert_type, "client_cert_type" },
+    { TLSEXT_TYPE_server_cert_type, "server_cert_type" },
+    { TLSEXT_TYPE_padding, "padding" },
+    { TLSEXT_TYPE_encrypt_then_mac, "encrypt_then_mac" },
+    { TLSEXT_TYPE_extended_master_secret, "extended_master_secret" },
+    { TLSEXT_TYPE_compress_certificate, "compress_certificate" },
+    { TLSEXT_TYPE_session_ticket, "session_ticket" },
+    { TLSEXT_TYPE_psk, "psk" },
+    { TLSEXT_TYPE_early_data, "early_data" },
+    { TLSEXT_TYPE_supported_versions, "supported_versions" },
+    { TLSEXT_TYPE_cookie, "cookie_ext" },
+    { TLSEXT_TYPE_psk_kex_modes, "psk_key_exchange_modes" },
+    { TLSEXT_TYPE_certificate_authorities, "certificate_authorities" },
+    { TLSEXT_TYPE_post_handshake_auth, "post_handshake_auth" },
+    { TLSEXT_TYPE_signature_algorithms_cert, "signature_algorithms_cert" },
+    { TLSEXT_TYPE_key_share, "key_share" },
+    { TLSEXT_TYPE_renegotiate, "renegotiate" },
+#ifndef OPENSSL_NO_NEXTPROTONEG
+    { TLSEXT_TYPE_next_proto_neg, "next_proto_neg" },
+#endif
 };
 
 static const ssl_trace_tbl ssl_groups_tbl[] = {
-    {1, "sect163k1 (K-163)"},
-    {2, "sect163r1"},
-    {3, "sect163r2 (B-163)"},
-    {4, "sect193r1"},
-    {5, "sect193r2"},
-    {6, "sect233k1 (K-233)"},
-    {7, "sect233r1 (B-233)"},
-    {8, "sect239k1"},
-    {9, "sect283k1 (K-283)"},
-    {10, "sect283r1 (B-283)"},
-    {11, "sect409k1 (K-409)"},
-    {12, "sect409r1 (B-409)"},
-    {13, "sect571k1 (K-571)"},
-    {14, "sect571r1 (B-571)"},
-    {15, "secp160k1"},
-    {16, "secp160r1"},
-    {17, "secp160r2"},
-    {18, "secp192k1"},
-    {19, "secp192r1 (P-192)"},
-    {20, "secp224k1"},
-    {21, "secp224r1 (P-224)"},
-    {22, "secp256k1"},
-    {23, "secp256r1 (P-256)"},
-    {24, "secp384r1 (P-384)"},
-    {25, "secp521r1 (P-521)"},
-    {26, "brainpoolP256r1"},
-    {27, "brainpoolP384r1"},
-    {28, "brainpoolP512r1"},
-    {29, "ecdh_x25519"},
-    {30, "ecdh_x448"},
-    {31, "brainpoolP256r1tls13"},
-    {32, "brainpoolP384r1tls13"},
-    {33, "brainpoolP512r1tls13"},
-    {34, "GC256A"},
-    {35, "GC256B"},
-    {36, "GC256C"},
-    {37, "GC256D"},
-    {38, "GC512A"},
-    {39, "GC512B"},
-    {40, "GC512C"},
-    {256, "ffdhe2048"},
-    {257, "ffdhe3072"},
-    {258, "ffdhe4096"},
-    {259, "ffdhe6144"},
-    {260, "ffdhe8192"},
-    {512, "MLKEM512"},
-    {513, "MLKEM768"},
-    {514, "MLKEM1024"},
-    {4587, "SecP256r1MLKEM768"},
-    {4588, "X25519MLKEM768"},
-    {4589, "SecP384r1MLKEM1024"},
-    {25497, "X25519Kyber768Draft00"},
-    {25498, "SecP256r1Kyber768Draft00"},
-    {0xFF01, "arbitrary_explicit_prime_curves"},
-    {0xFF02, "arbitrary_explicit_char2_curves"}
+    { 1, "sect163k1 (K-163)" },
+    { 2, "sect163r1" },
+    { 3, "sect163r2 (B-163)" },
+    { 4, "sect193r1" },
+    { 5, "sect193r2" },
+    { 6, "sect233k1 (K-233)" },
+    { 7, "sect233r1 (B-233)" },
+    { 8, "sect239k1" },
+    { 9, "sect283k1 (K-283)" },
+    { 10, "sect283r1 (B-283)" },
+    { 11, "sect409k1 (K-409)" },
+    { 12, "sect409r1 (B-409)" },
+    { 13, "sect571k1 (K-571)" },
+    { 14, "sect571r1 (B-571)" },
+    { 15, "secp160k1" },
+    { 16, "secp160r1" },
+    { 17, "secp160r2" },
+    { 18, "secp192k1" },
+    { 19, "secp192r1 (P-192)" },
+    { 20, "secp224k1" },
+    { 21, "secp224r1 (P-224)" },
+    { 22, "secp256k1" },
+    { 23, "secp256r1 (P-256)" },
+    { 24, "secp384r1 (P-384)" },
+    { 25, "secp521r1 (P-521)" },
+    { 26, "brainpoolP256r1" },
+    { 27, "brainpoolP384r1" },
+    { 28, "brainpoolP512r1" },
+    { 29, "ecdh_x25519" },
+    { 30, "ecdh_x448" },
+    { 31, "brainpoolP256r1tls13" },
+    { 32, "brainpoolP384r1tls13" },
+    { 33, "brainpoolP512r1tls13" },
+    { 34, "GC256A" },
+    { 35, "GC256B" },
+    { 36, "GC256C" },
+    { 37, "GC256D" },
+    { 38, "GC512A" },
+    { 39, "GC512B" },
+    { 40, "GC512C" },
+    { 256, "ffdhe2048" },
+    { 257, "ffdhe3072" },
+    { 258, "ffdhe4096" },
+    { 259, "ffdhe6144" },
+    { 260, "ffdhe8192" },
+    { 512, "MLKEM512" },
+    { 513, "MLKEM768" },
+    { 514, "MLKEM1024" },
+    { 4587, "SecP256r1MLKEM768" },
+    { 4588, "X25519MLKEM768" },
+    { 4589, "SecP384r1MLKEM1024" },
+    { 25497, "X25519Kyber768Draft00" },
+    { 25498, "SecP256r1Kyber768Draft00" },
+    { 0xFF01, "arbitrary_explicit_prime_curves" },
+    { 0xFF02, "arbitrary_explicit_char2_curves" }
 };
 
 static const ssl_trace_tbl ssl_point_tbl[] = {
-    {0, "uncompressed"},
-    {1, "ansiX962_compressed_prime"},
-    {2, "ansiX962_compressed_char2"}
+    { 0, "uncompressed" },
+    { 1, "ansiX962_compressed_prime" },
+    { 2, "ansiX962_compressed_char2" }
 };
 
 static const ssl_trace_tbl ssl_mfl_tbl[] = {
-    {0, "disabled"},
-    {1, "max_fragment_length := 2^9 (512 bytes)"},
-    {2, "max_fragment_length := 2^10 (1024 bytes)"},
-    {3, "max_fragment_length := 2^11 (2048 bytes)"},
-    {4, "max_fragment_length := 2^12 (4096 bytes)"}
+    { 0, "disabled" },
+    { 1, "max_fragment_length := 2^9 (512 bytes)" },
+    { 2, "max_fragment_length := 2^10 (1024 bytes)" },
+    { 3, "max_fragment_length := 2^11 (2048 bytes)" },
+    { 4, "max_fragment_length := 2^12 (4096 bytes)" }
 };
 
 static const ssl_trace_tbl ssl_sigalg_tbl[] = {
-    {TLSEXT_SIGALG_ecdsa_secp256r1_sha256, TLSEXT_SIGALG_ecdsa_secp256r1_sha256_name},
-    {TLSEXT_SIGALG_ecdsa_secp384r1_sha384, TLSEXT_SIGALG_ecdsa_secp384r1_sha384_name},
-    {TLSEXT_SIGALG_ecdsa_secp521r1_sha512,TLSEXT_SIGALG_ecdsa_secp521r1_sha512_name},
-    {TLSEXT_SIGALG_ecdsa_sha224, TLSEXT_SIGALG_ecdsa_sha224_name},
-    {TLSEXT_SIGALG_ed25519, TLSEXT_SIGALG_ed25519_name},
-    {TLSEXT_SIGALG_ed448, TLSEXT_SIGALG_ed448_name},
-    {TLSEXT_SIGALG_ecdsa_sha1, TLSEXT_SIGALG_ecdsa_sha1_name},
-    {TLSEXT_SIGALG_rsa_pss_rsae_sha256, TLSEXT_SIGALG_rsa_pss_rsae_sha256_name},
-    {TLSEXT_SIGALG_rsa_pss_rsae_sha384, TLSEXT_SIGALG_rsa_pss_rsae_sha384_name},
-    {TLSEXT_SIGALG_rsa_pss_rsae_sha512, TLSEXT_SIGALG_rsa_pss_rsae_sha512_name},
-    {TLSEXT_SIGALG_rsa_pss_pss_sha256, TLSEXT_SIGALG_rsa_pss_pss_sha256_name},
-    {TLSEXT_SIGALG_rsa_pss_pss_sha384, TLSEXT_SIGALG_rsa_pss_pss_sha384_name},
-    {TLSEXT_SIGALG_rsa_pss_pss_sha512, TLSEXT_SIGALG_rsa_pss_pss_sha512_name},
-    {TLSEXT_SIGALG_rsa_pkcs1_sha256, TLSEXT_SIGALG_rsa_pkcs1_sha256_name},
-    {TLSEXT_SIGALG_rsa_pkcs1_sha384, TLSEXT_SIGALG_rsa_pkcs1_sha384_name},
-    {TLSEXT_SIGALG_rsa_pkcs1_sha512, TLSEXT_SIGALG_rsa_pkcs1_sha512_name},
-    {TLSEXT_SIGALG_rsa_pkcs1_sha224, TLSEXT_SIGALG_rsa_pkcs1_sha224_name},
-    {TLSEXT_SIGALG_rsa_pkcs1_sha1, TLSEXT_SIGALG_rsa_pkcs1_sha1_name},
-    {TLSEXT_SIGALG_dsa_sha256, TLSEXT_SIGALG_dsa_sha256_name},
-    {TLSEXT_SIGALG_dsa_sha384, TLSEXT_SIGALG_dsa_sha384_name},
-    {TLSEXT_SIGALG_dsa_sha512, TLSEXT_SIGALG_dsa_sha512_name},
-    {TLSEXT_SIGALG_dsa_sha224, TLSEXT_SIGALG_dsa_sha224_name},
-    {TLSEXT_SIGALG_dsa_sha1, TLSEXT_SIGALG_dsa_sha1_name},
-    {TLSEXT_SIGALG_gostr34102012_256_intrinsic, TLSEXT_SIGALG_gostr34102012_256_intrinsic_name},
-    {TLSEXT_SIGALG_gostr34102012_512_intrinsic, TLSEXT_SIGALG_gostr34102012_512_intrinsic_name},
-    {TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256, TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256_name},
-    {TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512, TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512_name},
-    {TLSEXT_SIGALG_gostr34102001_gostr3411, TLSEXT_SIGALG_gostr34102001_gostr3411_name},
-    {TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256, TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256_name},
-    {TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384, TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384_name},
-    {TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512, TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512_name},
+    { TLSEXT_SIGALG_ecdsa_secp256r1_sha256, TLSEXT_SIGALG_ecdsa_secp256r1_sha256_name },
+    { TLSEXT_SIGALG_ecdsa_secp384r1_sha384, TLSEXT_SIGALG_ecdsa_secp384r1_sha384_name },
+    { TLSEXT_SIGALG_ecdsa_secp521r1_sha512, TLSEXT_SIGALG_ecdsa_secp521r1_sha512_name },
+    { TLSEXT_SIGALG_ecdsa_sha224, TLSEXT_SIGALG_ecdsa_sha224_name },
+    { TLSEXT_SIGALG_ed25519, TLSEXT_SIGALG_ed25519_name },
+    { TLSEXT_SIGALG_ed448, TLSEXT_SIGALG_ed448_name },
+    { TLSEXT_SIGALG_ecdsa_sha1, TLSEXT_SIGALG_ecdsa_sha1_name },
+    { TLSEXT_SIGALG_rsa_pss_rsae_sha256, TLSEXT_SIGALG_rsa_pss_rsae_sha256_name },
+    { TLSEXT_SIGALG_rsa_pss_rsae_sha384, TLSEXT_SIGALG_rsa_pss_rsae_sha384_name },
+    { TLSEXT_SIGALG_rsa_pss_rsae_sha512, TLSEXT_SIGALG_rsa_pss_rsae_sha512_name },
+    { TLSEXT_SIGALG_rsa_pss_pss_sha256, TLSEXT_SIGALG_rsa_pss_pss_sha256_name },
+    { TLSEXT_SIGALG_rsa_pss_pss_sha384, TLSEXT_SIGALG_rsa_pss_pss_sha384_name },
+    { TLSEXT_SIGALG_rsa_pss_pss_sha512, TLSEXT_SIGALG_rsa_pss_pss_sha512_name },
+    { TLSEXT_SIGALG_rsa_pkcs1_sha256, TLSEXT_SIGALG_rsa_pkcs1_sha256_name },
+    { TLSEXT_SIGALG_rsa_pkcs1_sha384, TLSEXT_SIGALG_rsa_pkcs1_sha384_name },
+    { TLSEXT_SIGALG_rsa_pkcs1_sha512, TLSEXT_SIGALG_rsa_pkcs1_sha512_name },
+    { TLSEXT_SIGALG_rsa_pkcs1_sha224, TLSEXT_SIGALG_rsa_pkcs1_sha224_name },
+    { TLSEXT_SIGALG_rsa_pkcs1_sha1, TLSEXT_SIGALG_rsa_pkcs1_sha1_name },
+    { TLSEXT_SIGALG_dsa_sha256, TLSEXT_SIGALG_dsa_sha256_name },
+    { TLSEXT_SIGALG_dsa_sha384, TLSEXT_SIGALG_dsa_sha384_name },
+    { TLSEXT_SIGALG_dsa_sha512, TLSEXT_SIGALG_dsa_sha512_name },
+    { TLSEXT_SIGALG_dsa_sha224, TLSEXT_SIGALG_dsa_sha224_name },
+    { TLSEXT_SIGALG_dsa_sha1, TLSEXT_SIGALG_dsa_sha1_name },
+    { TLSEXT_SIGALG_gostr34102012_256_intrinsic, TLSEXT_SIGALG_gostr34102012_256_intrinsic_name },
+    { TLSEXT_SIGALG_gostr34102012_512_intrinsic, TLSEXT_SIGALG_gostr34102012_512_intrinsic_name },
+    { TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256, TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256_name },
+    { TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512, TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512_name },
+    { TLSEXT_SIGALG_gostr34102001_gostr3411, TLSEXT_SIGALG_gostr34102001_gostr3411_name },
+    { TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256, TLSEXT_SIGALG_ecdsa_brainpoolP256r1_sha256_name },
+    { TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384, TLSEXT_SIGALG_ecdsa_brainpoolP384r1_sha384_name },
+    { TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512, TLSEXT_SIGALG_ecdsa_brainpoolP512r1_sha512_name },
     /*
      * Well known groups that we happen to know about, but only come from
      * provider capability declarations (hence no macros for the
      * codepoints/names)
      */
-    {0x0904, "mldsa44"},
-    {0x0905, "mldsa65"},
-    {0x0906, "mldsa87"}
+    { 0x0904, "mldsa44" },
+    { 0x0905, "mldsa65" },
+    { 0x0906, "mldsa87" }
 };
 
 static const ssl_trace_tbl ssl_ctype_tbl[] = {
-    {1, "rsa_sign"},
-    {2, "dss_sign"},
-    {3, "rsa_fixed_dh"},
-    {4, "dss_fixed_dh"},
-    {5, "rsa_ephemeral_dh"},
-    {6, "dss_ephemeral_dh"},
-    {20, "fortezza_dms"},
-    {64, "ecdsa_sign"},
-    {65, "rsa_fixed_ecdh"},
-    {66, "ecdsa_fixed_ecdh"},
-    {67, "gost_sign256"},
-    {68, "gost_sign512"},
+    { 1, "rsa_sign" },
+    { 2, "dss_sign" },
+    { 3, "rsa_fixed_dh" },
+    { 4, "dss_fixed_dh" },
+    { 5, "rsa_ephemeral_dh" },
+    { 6, "dss_ephemeral_dh" },
+    { 20, "fortezza_dms" },
+    { 64, "ecdsa_sign" },
+    { 65, "rsa_fixed_ecdh" },
+    { 66, "ecdsa_fixed_ecdh" },
+    { 67, "gost_sign256" },
+    { 68, "gost_sign512" },
 };
 
 static const ssl_trace_tbl ssl_psk_kex_modes_tbl[] = {
-    {TLSEXT_KEX_MODE_KE, "psk_ke"},
-    {TLSEXT_KEX_MODE_KE_DHE, "psk_dhe_ke"}
+    { TLSEXT_KEX_MODE_KE, "psk_ke" },
+    { TLSEXT_KEX_MODE_KE_DHE, "psk_dhe_ke" }
 };
 
 static const ssl_trace_tbl ssl_key_update_tbl[] = {
-    {SSL_KEY_UPDATE_NOT_REQUESTED, "update_not_requested"},
-    {SSL_KEY_UPDATE_REQUESTED, "update_requested"}
+    { SSL_KEY_UPDATE_NOT_REQUESTED, "update_not_requested" },
+    { SSL_KEY_UPDATE_REQUESTED, "update_requested" }
 };
 
 static const ssl_trace_tbl ssl_comp_cert_tbl[] = {
-    {TLSEXT_comp_cert_none, "none"},
-    {TLSEXT_comp_cert_zlib, "zlib"},
-    {TLSEXT_comp_cert_brotli, "brotli"},
-    {TLSEXT_comp_cert_zstd, "zstd"}
+    { TLSEXT_comp_cert_none, "none" },
+    { TLSEXT_comp_cert_zlib, "zlib" },
+    { TLSEXT_comp_cert_brotli, "brotli" },
+    { TLSEXT_comp_cert_zstd, "zstd" }
 };
 
 /*
@@ -655,14 +655,14 @@ static const ssl_trace_tbl ssl_comp_cert_tbl[] = {
  * at least report them in traces
  */
 static const ssl_trace_tbl ssl_cert_type_tbl[] = {
-    {TLSEXT_cert_type_x509, "x509"},
-    {TLSEXT_cert_type_pgp, "pgp"},
-    {TLSEXT_cert_type_rpk, "rpk"},
-    {TLSEXT_cert_type_1609dot2, "1609dot2"}
+    { TLSEXT_cert_type_x509, "x509" },
+    { TLSEXT_cert_type_pgp, "pgp" },
+    { TLSEXT_cert_type_rpk, "rpk" },
+    { TLSEXT_cert_type_1609dot2, "1609dot2" }
 };
 
 static void ssl_print_hex(BIO *bio, int indent, const char *name,
-                          const unsigned char *msg, size_t msglen)
+    const unsigned char *msg, size_t msglen)
 {
     size_t i;
 
@@ -674,7 +674,7 @@ static void ssl_print_hex(BIO *bio, int indent, const char *name,
 }
 
 static int ssl_print_hexbuf(BIO *bio, int indent, const char *name, size_t nlen,
-                            const unsigned char **pmsg, size_t *pmsglen)
+    const unsigned char **pmsg, size_t *pmsglen)
 {
     size_t blen;
     const unsigned char *p = *pmsg;
@@ -694,8 +694,8 @@ static int ssl_print_hexbuf(BIO *bio, int indent, const char *name, size_t nlen,
 }
 
 static int ssl_print_version(BIO *bio, int indent, const char *name,
-                             const unsigned char **pmsg, size_t *pmsglen,
-                             unsigned int *version)
+    const unsigned char **pmsg, size_t *pmsglen,
+    unsigned int *version)
 {
     int vers;
 
@@ -706,14 +706,14 @@ static int ssl_print_version(BIO *bio, int indent, const char *name,
         *version = vers;
     BIO_indent(bio, indent, 80);
     BIO_printf(bio, "%s=0x%x (%s)\n",
-               name, vers, ssl_trace_str(vers, ssl_version_tbl));
+        name, vers, ssl_trace_str(vers, ssl_version_tbl));
     *pmsg += 2;
     *pmsglen -= 2;
     return 1;
 }
 
 static int ssl_print_random(BIO *bio, int indent,
-                            const unsigned char **pmsg, size_t *pmsglen)
+    const unsigned char **pmsg, size_t *pmsglen)
 {
     unsigned int tm;
     const unsigned char *p = *pmsg;
@@ -721,9 +721,9 @@ static int ssl_print_random(BIO *bio, int indent,
     if (*pmsglen < 32)
         return 0;
     tm = ((unsigned int)p[0] << 24)
-         | ((unsigned int)p[1] << 16)
-         | ((unsigned int)p[2] << 8)
-         | (unsigned int)p[3];
+        | ((unsigned int)p[1] << 16)
+        | ((unsigned int)p[2] << 8)
+        | (unsigned int)p[3];
     p += 4;
     BIO_indent(bio, indent, 80);
     BIO_puts(bio, "Random:\n");
@@ -736,7 +736,7 @@ static int ssl_print_random(BIO *bio, int indent,
 }
 
 static int ssl_print_signature(BIO *bio, int indent, const SSL_CONNECTION *sc,
-                               const unsigned char **pmsg, size_t *pmsglen)
+    const unsigned char **pmsg, size_t *pmsglen)
 {
     if (*pmsglen < 2)
         return 0;
@@ -746,7 +746,7 @@ static int ssl_print_signature(BIO *bio, int indent, const SSL_CONNECTION *sc,
 
         BIO_indent(bio, indent, 80);
         BIO_printf(bio, "Signature Algorithm: %s (0x%04x)\n",
-                   ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg);
+            ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg);
         *pmsg += 2;
         *pmsglen -= 2;
     }
@@ -754,8 +754,8 @@ static int ssl_print_signature(BIO *bio, int indent, const SSL_CONNECTION *sc,
 }
 
 static int ssl_print_extension(BIO *bio, int indent, int server,
-                               unsigned char mt, int extype,
-                               const unsigned char *ext, size_t extlen)
+    unsigned char mt, int extype,
+    const unsigned char *ext, size_t extlen)
 {
     size_t xlen, share_len;
     unsigned int sigalg;
@@ -763,7 +763,7 @@ static int ssl_print_extension(BIO *bio, int indent, int server,
 
     BIO_indent(bio, indent, 80);
     BIO_printf(bio, "extension_type=%s(%d), length=%d\n",
-               ssl_trace_str(extype, ssl_exts_tbl), extype, (int)extlen);
+        ssl_trace_str(extype, ssl_exts_tbl), extype, (int)extlen);
     switch (extype) {
     case TLSEXT_TYPE_compress_certificate:
         if (extlen < 1)
@@ -828,7 +828,7 @@ static int ssl_print_extension(BIO *bio, int indent, int server,
             BIO_indent(bio, indent + 2, 80);
             sigalg = (ext[0] << 8) | ext[1];
             BIO_printf(bio, "%s (0x%04x)\n",
-                       ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg);
+                ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg);
             xlen -= 2;
             ext += 2;
         }
@@ -871,7 +871,7 @@ static int ssl_print_extension(BIO *bio, int indent, int server,
             group_id = (ext[0] << 8) | ext[1];
             BIO_indent(bio, indent + 4, 80);
             BIO_printf(bio, "NamedGroup: %s (%d)\n",
-                       ssl_trace_str(group_id, ssl_groups_tbl), group_id);
+                ssl_trace_str(group_id, ssl_groups_tbl), group_id);
             break;
         }
         if (extlen < 2)
@@ -897,7 +897,7 @@ static int ssl_print_extension(BIO *bio, int indent, int server,
                 return 0;
             BIO_indent(bio, indent + 4, 80);
             BIO_printf(bio, "NamedGroup: %s (%d)\n",
-                       ssl_trace_str(group_id, ssl_groups_tbl), group_id);
+                ssl_trace_str(group_id, ssl_groups_tbl), group_id);
             ssl_print_hex(bio, indent + 4, "key_exchange: ", ext, share_len);
         }
         break;
@@ -911,7 +911,7 @@ static int ssl_print_extension(BIO *bio, int indent, int server,
             version = (ext[0] << 8) | ext[1];
             BIO_indent(bio, indent + 4, 80);
             BIO_printf(bio, "%s (%d)\n",
-                       ssl_trace_str(version, ssl_version_tbl), version);
+                ssl_trace_str(version, ssl_version_tbl), version);
             break;
         }
         if (extlen < 1)
@@ -920,7 +920,7 @@ static int ssl_print_extension(BIO *bio, int indent, int server,
         if (extlen != xlen + 1)
             return 0;
         return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 2,
-                              ssl_version_tbl);
+            ssl_version_tbl);
 
     case TLSEXT_TYPE_psk_kex_modes:
         if (extlen < 1)
@@ -929,7 +929,7 @@ static int ssl_print_extension(BIO *bio, int indent, int server,
         if (extlen != xlen + 1)
             return 0;
         return ssl_trace_list(bio, indent + 2, ext + 1, xlen, 1,
-                              ssl_psk_kex_modes_tbl);
+            ssl_psk_kex_modes_tbl);
 
     case TLSEXT_TYPE_early_data:
         if (mt != SSL3_MT_NEWSESSION_TICKET)
@@ -937,9 +937,9 @@ static int ssl_print_extension(BIO *bio, int indent, int server,
         if (extlen != 4)
             return 0;
         max_early_data = ((unsigned int)ext[0] << 24)
-                         | ((unsigned int)ext[1] << 16)
-                         | ((unsigned int)ext[2] << 8)
-                         | (unsigned int)ext[3];
+            | ((unsigned int)ext[1] << 16)
+            | ((unsigned int)ext[2] << 8)
+            | (unsigned int)ext[3];
         BIO_indent(bio, indent + 2, 80);
         BIO_printf(bio, "max_early_data=%u\n", (unsigned int)max_early_data);
         break;
@@ -965,8 +965,8 @@ static int ssl_print_extension(BIO *bio, int indent, int server,
 }
 
 static int ssl_print_extensions(BIO *bio, int indent, int server,
-                                unsigned char mt, const unsigned char **msgin,
-                                size_t *msginlen)
+    unsigned char mt, const unsigned char **msgin,
+    size_t *msginlen)
 {
     size_t extslen, msglen = *msginlen;
     const unsigned char *msg = *msgin;
@@ -1000,13 +1000,13 @@ static int ssl_print_extensions(BIO *bio, int indent, int server,
         extlen = (msg[2] << 8) | msg[3];
         if (extslen < extlen + 4) {
             BIO_printf(bio, "extensions, extype = %d, extlen = %d\n", extype,
-                       (int)extlen);
+                (int)extlen);
             BIO_dump_indent(bio, (const char *)msg, extslen, indent + 2);
             return 0;
         }
         msg += 4;
         if (!ssl_print_extension(bio, indent + 2, server, mt, extype, msg,
-                                 extlen))
+                extlen))
             return 0;
         msg += extlen;
         extslen -= extlen + 4;
@@ -1018,7 +1018,7 @@ static int ssl_print_extensions(BIO *bio, int indent, int server,
 }
 
 static int ssl_print_client_hello(BIO *bio, const SSL_CONNECTION *sc, int indent,
-                                  const unsigned char *msg, size_t msglen)
+    const unsigned char *msg, size_t msglen)
 {
     size_t len;
     unsigned int cs;
@@ -1046,7 +1046,7 @@ static int ssl_print_client_hello(BIO *bio, const SSL_CONNECTION *sc, int indent
         cs = (msg[0] << 8) | msg[1];
         BIO_indent(bio, indent + 2, 80);
         BIO_printf(bio, "{0x%02X, 0x%02X} %s\n",
-                   msg[0], msg[1], ssl_trace_str(cs, ssl_ciphers_tbl));
+            msg[0], msg[1], ssl_trace_str(cs, ssl_ciphers_tbl));
         msg += 2;
         msglen -= 2;
         len -= 2;
@@ -1063,19 +1063,19 @@ static int ssl_print_client_hello(BIO *bio, const SSL_CONNECTION *sc, int indent
     while (len > 0) {
         BIO_indent(bio, indent + 2, 80);
         BIO_printf(bio, "%s (0x%02X)\n",
-                   ssl_trace_str(msg[0], ssl_comp_tbl), msg[0]);
+            ssl_trace_str(msg[0], ssl_comp_tbl), msg[0]);
         msg++;
         msglen--;
         len--;
     }
     if (!ssl_print_extensions(bio, indent, 0, SSL3_MT_CLIENT_HELLO, &msg,
-                              &msglen))
+            &msglen))
         return 0;
     return 1;
 }
 
 static int dtls_print_hello_vfyrequest(BIO *bio, int indent,
-                                       const unsigned char *msg, size_t msglen)
+    const unsigned char *msg, size_t msglen)
 {
     if (!ssl_print_version(bio, indent, "server_version", &msg, &msglen, NULL))
         return 0;
@@ -1085,7 +1085,7 @@ static int dtls_print_hello_vfyrequest(BIO *bio, int indent,
 }
 
 static int ssl_print_server_hello(BIO *bio, int indent,
-                                  const unsigned char *msg, size_t msglen)
+    const unsigned char *msg, size_t msglen)
 {
     unsigned int cs;
     unsigned int vers;
@@ -1095,14 +1095,14 @@ static int ssl_print_server_hello(BIO *bio, int indent,
     if (!ssl_print_random(bio, indent, &msg, &msglen))
         return 0;
     if (vers != TLS1_3_VERSION
-            && !ssl_print_hexbuf(bio, indent, "session_id", 1, &msg, &msglen))
+        && !ssl_print_hexbuf(bio, indent, "session_id", 1, &msg, &msglen))
         return 0;
     if (msglen < 2)
         return 0;
     cs = (msg[0] << 8) | msg[1];
     BIO_indent(bio, indent, 80);
     BIO_printf(bio, "cipher_suite {0x%02X, 0x%02X} %s\n",
-               msg[0], msg[1], ssl_trace_str(cs, ssl_ciphers_tbl));
+        msg[0], msg[1], ssl_trace_str(cs, ssl_ciphers_tbl));
     msg += 2;
     msglen -= 2;
     if (vers != TLS1_3_VERSION) {
@@ -1110,12 +1110,12 @@ static int ssl_print_server_hello(BIO *bio, int indent,
             return 0;
         BIO_indent(bio, indent, 80);
         BIO_printf(bio, "compression_method: %s (0x%02X)\n",
-                   ssl_trace_str(msg[0], ssl_comp_tbl), msg[0]);
+            ssl_trace_str(msg[0], ssl_comp_tbl), msg[0]);
         msg++;
         msglen--;
     }
     if (!ssl_print_extensions(bio, indent, 1, SSL3_MT_SERVER_HELLO, &msg,
-                              &msglen))
+            &msglen))
         return 0;
     return 1;
 }
@@ -1169,7 +1169,7 @@ static int ssl_get_keyex(const char **pname, const SSL_CONNECTION *sc)
 }
 
 static int ssl_print_client_keyex(BIO *bio, int indent, const SSL_CONNECTION *sc,
-                                  const unsigned char *msg, size_t msglen)
+    const unsigned char *msg, size_t msglen)
 {
     const char *algname;
     int id = ssl_get_keyex(&algname, sc);
@@ -1178,7 +1178,7 @@ static int ssl_print_client_keyex(BIO *bio, int indent, const SSL_CONNECTION *sc
     BIO_printf(bio, "KeyExchangeAlgorithm=%s\n", algname);
     if (id & SSL_PSK) {
         if (!ssl_print_hexbuf(bio, indent + 2,
-                              "psk_identity", 2, &msg, &msglen))
+                "psk_identity", 2, &msg, &msglen))
             return 0;
     }
     switch (id) {
@@ -1187,10 +1187,10 @@ static int ssl_print_client_keyex(BIO *bio, int indent, const SSL_CONNECTION *sc
     case SSL_kRSAPSK:
         if (TLS1_get_version(SSL_CONNECTION_GET_SSL(sc)) == SSL3_VERSION) {
             ssl_print_hex(bio, indent + 2,
-                          "EncryptedPreMasterSecret", msg, msglen);
+                "EncryptedPreMasterSecret", msg, msglen);
         } else {
             if (!ssl_print_hexbuf(bio, indent + 2,
-                                  "EncryptedPreMasterSecret", 2, &msg, &msglen))
+                    "EncryptedPreMasterSecret", 2, &msg, &msglen))
                 return 0;
         }
         break;
@@ -1212,7 +1212,7 @@ static int ssl_print_client_keyex(BIO *bio, int indent, const SSL_CONNECTION *sc
         break;
     case SSL_kGOST18:
         ssl_print_hex(bio, indent + 2,
-                      "GOST-wrapped PreMasterSecret", msg, msglen);
+            "GOST-wrapped PreMasterSecret", msg, msglen);
         msglen = 0;
         break;
     }
@@ -1221,7 +1221,7 @@ static int ssl_print_client_keyex(BIO *bio, int indent, const SSL_CONNECTION *sc
 }
 
 static int ssl_print_server_keyex(BIO *bio, int indent, const SSL_CONNECTION *sc,
-                                  const unsigned char *msg, size_t msglen)
+    const unsigned char *msg, size_t msglen)
 {
     const char *algname;
     int id = ssl_get_keyex(&algname, sc);
@@ -1230,7 +1230,7 @@ static int ssl_print_server_keyex(BIO *bio, int indent, const SSL_CONNECTION *sc
     BIO_printf(bio, "KeyExchangeAlgorithm=%s\n", algname);
     if (id & SSL_PSK) {
         if (!ssl_print_hexbuf(bio, indent + 2,
-                              "psk_identity_hint", 2, &msg, &msglen))
+                "psk_identity_hint", 2, &msg, &msglen))
             return 0;
     }
     switch (id) {
@@ -1239,7 +1239,7 @@ static int ssl_print_server_keyex(BIO *bio, int indent, const SSL_CONNECTION *sc
         if (!ssl_print_hexbuf(bio, indent + 2, "rsa_modulus", 2, &msg, &msglen))
             return 0;
         if (!ssl_print_hexbuf(bio, indent + 2, "rsa_exponent", 2,
-                              &msg, &msglen))
+                &msg, &msglen))
             return 0;
         break;
 
@@ -1268,7 +1268,7 @@ static int ssl_print_server_keyex(BIO *bio, int indent, const SSL_CONNECTION *sc
                 return 0;
             curve = (msg[1] << 8) | msg[2];
             BIO_printf(bio, "named_curve: %s (%d)\n",
-                       ssl_trace_str(curve, ssl_groups_tbl), curve);
+                ssl_trace_str(curve, ssl_groups_tbl), curve);
             msg += 3;
             msglen -= 3;
             if (!ssl_print_hexbuf(bio, indent + 2, "point", 1, &msg, &msglen))
@@ -1289,7 +1289,7 @@ static int ssl_print_server_keyex(BIO *bio, int indent, const SSL_CONNECTION *sc
 }
 
 static int ssl_print_certificate(BIO *bio, const SSL_CONNECTION *sc, int indent,
-                                 const unsigned char **pmsg, size_t *pmsglen)
+    const unsigned char **pmsg, size_t *pmsglen)
 {
     size_t msglen = *pmsglen;
     size_t clen;
@@ -1310,8 +1310,8 @@ static int ssl_print_certificate(BIO *bio, const SSL_CONNECTION *sc, int indent,
         X509_free(x);
         x = NULL;
     }
-    if (x ==  NULL)
-        BIO_puts(bio, "<UNPARSEABLE CERTIFICATE>\n");
+    if (x == NULL)
+        BIO_puts(bio, "<UNPARSABLE CERTIFICATE>\n");
     else {
         BIO_puts(bio, "\n------details-----\n");
         X509_print_ex(bio, x, XN_FLAG_ONELINE, 0);
@@ -1329,8 +1329,8 @@ static int ssl_print_certificate(BIO *bio, const SSL_CONNECTION *sc, int indent,
 }
 
 static int ssl_print_raw_public_key(BIO *bio, const SSL *ssl, int server,
-                                    int indent, const unsigned char **pmsg,
-                                    size_t *pmsglen)
+    int indent, const unsigned char **pmsg,
+    size_t *pmsglen)
 {
     EVP_PKEY *pkey;
     size_t clen;
@@ -1359,13 +1359,13 @@ static int ssl_print_raw_public_key(BIO *bio, const SSL *ssl, int server,
 }
 
 static int ssl_print_certificates(BIO *bio, const SSL_CONNECTION *sc, int server,
-                                  int indent, const unsigned char *msg,
-                                  size_t msglen)
+    int indent, const unsigned char *msg,
+    size_t msglen)
 {
     size_t clen;
 
     if (SSL_CONNECTION_IS_TLS13(sc)
-            && !ssl_print_hexbuf(bio, indent, "context", 1, &msg, &msglen))
+        && !ssl_print_hexbuf(bio, indent, "context", 1, &msg, &msglen))
         return 0;
 
     if (msglen < 3)
@@ -1375,12 +1375,12 @@ static int ssl_print_certificates(BIO *bio, const SSL_CONNECTION *sc, int server
         return 0;
     msg += 3;
     if ((server && sc->ext.server_cert_type == TLSEXT_cert_type_rpk)
-            || (!server && sc->ext.client_cert_type == TLSEXT_cert_type_rpk)) {
+        || (!server && sc->ext.client_cert_type == TLSEXT_cert_type_rpk)) {
         if (!ssl_print_raw_public_key(bio, &sc->ssl, server, indent, &msg, &clen))
             return 0;
         if (SSL_CONNECTION_IS_TLS13(sc)
             && !ssl_print_extensions(bio, indent + 2, server,
-                                     SSL3_MT_CERTIFICATE, &msg, &clen))
+                SSL3_MT_CERTIFICATE, &msg, &clen))
             return 0;
         return 1;
     }
@@ -1391,17 +1391,16 @@ static int ssl_print_certificates(BIO *bio, const SSL_CONNECTION *sc, int server
             return 0;
         if (SSL_CONNECTION_IS_TLS13(sc)
             && !ssl_print_extensions(bio, indent + 2, server,
-                                     SSL3_MT_CERTIFICATE, &msg, &clen))
+                SSL3_MT_CERTIFICATE, &msg, &clen))
             return 0;
-
     }
     return 1;
 }
 
 static int ssl_print_compressed_certificates(BIO *bio, const SSL_CONNECTION *sc,
-                                             int server, int indent,
-                                             const unsigned char *msg,
-                                             size_t msglen)
+    int server, int indent,
+    const unsigned char *msg,
+    size_t msglen)
 {
     size_t uclen;
     size_t clen;
@@ -1410,7 +1409,7 @@ static int ssl_print_compressed_certificates(BIO *bio, const SSL_CONNECTION *sc,
 #ifndef OPENSSL_NO_COMP_ALG
     COMP_METHOD *method;
     COMP_CTX *comp = NULL;
-    unsigned char* ucdata = NULL;
+    unsigned char *ucdata = NULL;
 #endif
 
     if (msglen < 8)
@@ -1458,11 +1457,11 @@ static int ssl_print_compressed_certificates(BIO *bio, const SSL_CONNECTION *sc,
     }
 
     if ((comp = COMP_CTX_new(method)) == NULL
-            || COMP_expand_block(comp, ucdata, uclen, (unsigned char*)msg, clen) != (int)uclen)
+        || COMP_expand_block(comp, ucdata, uclen, (unsigned char *)msg, clen) != (int)uclen)
         goto err;
 
     ret = ssl_print_certificates(bio, sc, server, indent, ucdata, uclen);
- err:
+err:
     COMP_CTX_free(comp);
     OPENSSL_free(ucdata);
 #endif
@@ -1470,7 +1469,7 @@ static int ssl_print_compressed_certificates(BIO *bio, const SSL_CONNECTION *sc,
 }
 
 static int ssl_print_cert_request(BIO *bio, int indent, const SSL_CONNECTION *sc,
-                                  const unsigned char *msg, size_t msglen)
+    const unsigned char *msg, size_t msglen)
 {
     size_t xlen;
     unsigned int sigalg;
@@ -1479,7 +1478,7 @@ static int ssl_print_cert_request(BIO *bio, int indent, const SSL_CONNECTION *sc
         if (!ssl_print_hexbuf(bio, indent, "request_context", 1, &msg, &msglen))
             return 0;
         if (!ssl_print_extensions(bio, indent, 1,
-                                  SSL3_MT_CERTIFICATE_REQUEST, &msg, &msglen))
+                SSL3_MT_CERTIFICATE_REQUEST, &msg, &msglen))
             return 0;
         return 1;
     } else {
@@ -1510,7 +1509,7 @@ static int ssl_print_cert_request(BIO *bio, int indent, const SSL_CONNECTION *sc
             BIO_indent(bio, indent + 2, 80);
             sigalg = (msg[0] << 8) | msg[1];
             BIO_printf(bio, "%s (0x%04x)\n",
-                       ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg);
+                ssl_trace_str(sigalg, ssl_sigalg_tbl), sigalg);
             xlen -= 2;
             msg += 2;
         }
@@ -1541,7 +1540,7 @@ static int ssl_print_cert_request(BIO *bio, int indent, const SSL_CONNECTION *sc
         p = msg;
         nm = d2i_X509_NAME(NULL, &p, dlen);
         if (!nm) {
-            BIO_puts(bio, "<UNPARSEABLE DN>\n");
+            BIO_puts(bio, "<UNPARSABLE DN>\n");
         } else {
             X509_NAME_print_ex(bio, nm, 0, XN_FLAG_ONELINE);
             BIO_puts(bio, "\n");
@@ -1552,14 +1551,14 @@ static int ssl_print_cert_request(BIO *bio, int indent, const SSL_CONNECTION *sc
     }
     if (SSL_CONNECTION_IS_TLS13(sc)) {
         if (!ssl_print_hexbuf(bio, indent, "request_extensions", 2,
-                              &msg, &msglen))
+                &msg, &msglen))
             return 0;
     }
     return msglen == 0;
 }
 
 static int ssl_print_ticket(BIO *bio, int indent, const SSL_CONNECTION *sc,
-                            const unsigned char *msg, size_t msglen)
+    const unsigned char *msg, size_t msglen)
 {
     unsigned int tick_life;
 
@@ -1571,9 +1570,9 @@ static int ssl_print_ticket(BIO *bio, int indent, const SSL_CONNECTION *sc,
     if (msglen < 4)
         return 0;
     tick_life = ((unsigned int)msg[0] << 24)
-                | ((unsigned int)msg[1] << 16)
-                | ((unsigned int)msg[2] << 8)
-                | (unsigned int)msg[3];
+        | ((unsigned int)msg[1] << 16)
+        | ((unsigned int)msg[2] << 8)
+        | (unsigned int)msg[3];
     msglen -= 4;
     msg += 4;
     BIO_indent(bio, indent + 2, 80);
@@ -1583,8 +1582,7 @@ static int ssl_print_ticket(BIO *bio, int indent, const SSL_CONNECTION *sc,
 
         if (msglen < 4)
             return 0;
-        ticket_age_add =
-            ((unsigned int)msg[0] << 24)
+        ticket_age_add = ((unsigned int)msg[0] << 24)
             | ((unsigned int)msg[1] << 16)
             | ((unsigned int)msg[2] << 8)
             | (unsigned int)msg[3];
@@ -1593,14 +1591,14 @@ static int ssl_print_ticket(BIO *bio, int indent, const SSL_CONNECTION *sc,
         BIO_indent(bio, indent + 2, 80);
         BIO_printf(bio, "ticket_age_add=%u\n", ticket_age_add);
         if (!ssl_print_hexbuf(bio, indent + 2, "ticket_nonce", 1, &msg,
-                              &msglen))
+                &msglen))
             return 0;
     }
     if (!ssl_print_hexbuf(bio, indent + 2, "ticket", 2, &msg, &msglen))
         return 0;
     if (SSL_CONNECTION_IS_TLS13(sc)
-            && !ssl_print_extensions(bio, indent + 2, 0,
-                                     SSL3_MT_NEWSESSION_TICKET, &msg, &msglen))
+        && !ssl_print_extensions(bio, indent + 2, 0,
+            SSL3_MT_NEWSESSION_TICKET, &msg, &msglen))
         return 0;
     if (msglen)
         return 0;
@@ -1608,8 +1606,8 @@ static int ssl_print_ticket(BIO *bio, int indent, const SSL_CONNECTION *sc,
 }
 
 static int ssl_print_handshake(BIO *bio, const SSL_CONNECTION *sc, int server,
-                               const unsigned char *msg, size_t msglen,
-                               int indent)
+    const unsigned char *msg, size_t msglen,
+    int indent)
 {
     size_t hlen;
     unsigned char htype;
@@ -1620,7 +1618,7 @@ static int ssl_print_handshake(BIO *bio, const SSL_CONNECTION *sc, int server,
     hlen = (msg[1] << 16) | (msg[2] << 8) | msg[3];
     BIO_indent(bio, indent, 80);
     BIO_printf(bio, "%s, Length=%d\n",
-               ssl_trace_str(htype, ssl_handshake_tbl), (int)hlen);
+        ssl_trace_str(htype, ssl_handshake_tbl), (int)hlen);
     msg += 4;
     msglen -= 4;
     if (SSL_CONNECTION_IS_DTLS(sc)) {
@@ -1628,10 +1626,10 @@ static int ssl_print_handshake(BIO *bio, const SSL_CONNECTION *sc, int server,
             return 0;
         BIO_indent(bio, indent, 80);
         BIO_printf(bio, "message_seq=%d, fragment_offset=%d, "
-                   "fragment_length=%d\n",
-                   (msg[0] << 8) | msg[1],
-                   (msg[2] << 16) | (msg[3] << 8) | msg[4],
-                   (msg[5] << 16) | (msg[6] << 8) | msg[7]);
+                        "fragment_length=%d\n",
+            (msg[0] << 8) | msg[1],
+            (msg[2] << 16) | (msg[3] << 8) | msg[4],
+            (msg[5] << 16) | (msg[6] << 8) | msg[7]);
         msg += 8;
         msglen -= 8;
     }
@@ -1700,7 +1698,7 @@ static int ssl_print_handshake(BIO *bio, const SSL_CONNECTION *sc, int server,
 
     case SSL3_MT_ENCRYPTED_EXTENSIONS:
         if (!ssl_print_extensions(bio, indent + 2, 1,
-                                  SSL3_MT_ENCRYPTED_EXTENSIONS, &msg, &msglen))
+                SSL3_MT_ENCRYPTED_EXTENSIONS, &msg, &msglen))
             return 0;
         break;
 
@@ -1710,7 +1708,7 @@ static int ssl_print_handshake(BIO *bio, const SSL_CONNECTION *sc, int server,
             return 0;
         }
         if (!ssl_trace_list(bio, indent + 2, msg, msglen, 1,
-                            ssl_key_update_tbl))
+                ssl_key_update_tbl))
             return 0;
         break;
 
@@ -1723,7 +1721,7 @@ static int ssl_print_handshake(BIO *bio, const SSL_CONNECTION *sc, int server,
 }
 
 void SSL_trace(int write_p, int version, int content_type,
-               const void *buf, size_t msglen, SSL *ssl, void *arg)
+    const void *buf, size_t msglen, SSL *ssl, void *arg)
 {
     const unsigned char *msg = buf;
     BIO *bio = arg;
@@ -1733,7 +1731,7 @@ void SSL_trace(int write_p, int version, int content_type,
 
     if (qc != NULL) {
         if (ossl_quic_trace(write_p, version, content_type, buf, msglen, ssl,
-                            arg))
+                arg))
             return;
         /*
          * Otherwise ossl_quic_trace didn't handle this content_type so we
@@ -1746,43 +1744,40 @@ void SSL_trace(int write_p, int version, int content_type,
         return;
 
     switch (content_type) {
-    case SSL3_RT_HEADER:
-        {
-            int hvers;
+    case SSL3_RT_HEADER: {
+        int hvers;
 
-            /* avoid overlapping with length at the end of buffer */
-            if (msglen < (size_t)(SSL_CONNECTION_IS_DTLS(sc) ?
-                     DTLS1_RT_HEADER_LENGTH : SSL3_RT_HEADER_LENGTH)) {
-                BIO_puts(bio, write_p ? "Sent" : "Received");
-                ssl_print_hex(bio, 0, " too short message", msg, msglen);
-                break;
-            }
-            hvers = msg[1] << 8 | msg[2];
+        /* avoid overlapping with length at the end of buffer */
+        if (msglen < (size_t)(SSL_CONNECTION_IS_DTLS(sc) ? DTLS1_RT_HEADER_LENGTH : SSL3_RT_HEADER_LENGTH)) {
             BIO_puts(bio, write_p ? "Sent" : "Received");
-            BIO_printf(bio, " TLS Record\nHeader:\n  Version = %s (0x%x)\n",
-                       ssl_trace_str(hvers, ssl_version_tbl), hvers);
-            if (SSL_CONNECTION_IS_DTLS(sc)) {
-                BIO_printf(bio,
-                           "  epoch=%d, sequence_number=%04x%04x%04x\n",
-                           (msg[3] << 8 | msg[4]),
-                           (msg[5] << 8 | msg[6]),
-                           (msg[7] << 8 | msg[8]), (msg[9] << 8 | msg[10]));
-            }
-
-            BIO_printf(bio, "  Content Type = %s (%d)\n  Length = %d",
-                       ssl_trace_str(msg[0], ssl_content_tbl), msg[0],
-                       msg[msglen - 2] << 8 | msg[msglen - 1]);
+            ssl_print_hex(bio, 0, " too short message", msg, msglen);
+            break;
+        }
+        hvers = msg[1] << 8 | msg[2];
+        BIO_puts(bio, write_p ? "Sent" : "Received");
+        BIO_printf(bio, " TLS Record\nHeader:\n  Version = %s (0x%x)\n",
+            ssl_trace_str(hvers, ssl_version_tbl), hvers);
+        if (SSL_CONNECTION_IS_DTLS(sc)) {
+            BIO_printf(bio,
+                "  epoch=%d, sequence_number=%04x%04x%04x\n",
+                (msg[3] << 8 | msg[4]),
+                (msg[5] << 8 | msg[6]),
+                (msg[7] << 8 | msg[8]), (msg[9] << 8 | msg[10]));
         }
-        break;
+
+        BIO_printf(bio, "  Content Type = %s (%d)\n  Length = %d",
+            ssl_trace_str(msg[0], ssl_content_tbl), msg[0],
+            msg[msglen - 2] << 8 | msg[msglen - 1]);
+    } break;
 
     case SSL3_RT_INNER_CONTENT_TYPE:
         BIO_printf(bio, "  Inner Content Type = %s (%d)",
-                   ssl_trace_str(msg[0], ssl_content_tbl), msg[0]);
+            ssl_trace_str(msg[0], ssl_content_tbl), msg[0]);
         break;
 
     case SSL3_RT_HANDSHAKE:
         if (!ssl_print_handshake(bio, sc, sc->server ? write_p : !write_p,
-                                 msg, msglen, 4))
+                msg, msglen, 4))
             BIO_printf(bio, "Message length parse error!\n");
         break;
 
@@ -1798,10 +1793,9 @@ void SSL_trace(int write_p, int version, int content_type,
             BIO_puts(bio, "    Illegal Alert Length\n");
         else {
             BIO_printf(bio, "    Level=%s(%d), description=%s(%d)\n",
-                       SSL_alert_type_string_long(msg[0] << 8),
-                       msg[0], SSL_alert_desc_string_long(msg[1]), msg[1]);
+                SSL_alert_type_string_long(msg[0] << 8),
+                msg[0], SSL_alert_desc_string_long(msg[1]), msg[1]);
         }
-
     }
 
     BIO_puts(bio, "\n");
diff --git a/crypto/openssl/ssl/tls13_enc.c b/crypto/openssl/ssl/tls13_enc.c
index 0aa97648c4ed..de201d924301 100644
--- a/crypto/openssl/ssl/tls13_enc.c
+++ b/crypto/openssl/ssl/tls13_enc.c
@@ -17,7 +17,7 @@
 #include <openssl/kdf.h>
 #include <openssl/core_names.h>
 
-#define TLS13_MAX_LABEL_LEN     249
+#define TLS13_MAX_LABEL_LEN 249
 
 /* ASCII: "tls13 ", in hex for EBCDIC compatibility */
 static const unsigned char label_prefix[] = "\x74\x6C\x73\x31\x33\x20";
@@ -31,11 +31,11 @@ static const unsigned char label_prefix[] = "\x74\x6C\x73\x31\x33\x20";
  * If |raise_error| is set, ERR_raise is called on failure.
  */
 int tls13_hkdf_expand_ex(OSSL_LIB_CTX *libctx, const char *propq,
-                         const EVP_MD *md,
-                         const unsigned char *secret,
-                         const unsigned char *label, size_t labellen,
-                         const unsigned char *data, size_t datalen,
-                         unsigned char *out, size_t outlen, int raise_error)
+    const EVP_MD *md,
+    const unsigned char *secret,
+    const unsigned char *label, size_t labellen,
+    const unsigned char *data, size_t datalen,
+    unsigned char *out, size_t outlen, int raise_error)
 {
     EVP_KDF *kdf = EVP_KDF_fetch(libctx, OSSL_KDF_NAME_TLS1_3_KDF, propq);
     EVP_KDF_CTX *kctx;
@@ -72,18 +72,18 @@ int tls13_hkdf_expand_ex(OSSL_LIB_CTX *libctx, const char *propq,
 
     *p++ = OSSL_PARAM_construct_int(OSSL_KDF_PARAM_MODE, &mode);
     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST,
-                                            (char *)mdname, 0);
+        (char *)mdname, 0);
     *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY,
-                                             (unsigned char *)secret, hashlen);
+        (unsigned char *)secret, hashlen);
     *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_PREFIX,
-                                             (unsigned char *)label_prefix,
-                                             sizeof(label_prefix) - 1);
+        (unsigned char *)label_prefix,
+        sizeof(label_prefix) - 1);
     *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_LABEL,
-                                             (unsigned char *)label, labellen);
+        (unsigned char *)label, labellen);
     if (data != NULL)
         *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_DATA,
-                                                 (unsigned char *)data,
-                                                 datalen);
+            (unsigned char *)data,
+            datalen);
     *p++ = OSSL_PARAM_construct_end();
 
     ret = EVP_KDF_derive(kctx, out, outlen, params) <= 0;
@@ -98,17 +98,17 @@ int tls13_hkdf_expand_ex(OSSL_LIB_CTX *libctx, const char *propq,
 }
 
 int tls13_hkdf_expand(SSL_CONNECTION *s, const EVP_MD *md,
-                      const unsigned char *secret,
-                      const unsigned char *label, size_t labellen,
-                      const unsigned char *data, size_t datalen,
-                      unsigned char *out, size_t outlen, int fatal)
+    const unsigned char *secret,
+    const unsigned char *label, size_t labellen,
+    const unsigned char *data, size_t datalen,
+    unsigned char *out, size_t outlen, int fatal)
 {
     int ret;
     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
 
     ret = tls13_hkdf_expand_ex(sctx->libctx, sctx->propq, md,
-                               secret, label, labellen, data, datalen,
-                               out, outlen, !fatal);
+        secret, label, labellen, data, datalen,
+        out, outlen, !fatal);
     if (ret == 0 && fatal)
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
 
@@ -120,14 +120,14 @@ int tls13_hkdf_expand(SSL_CONNECTION *s, const EVP_MD *md,
  * success  0 on failure.
  */
 int tls13_derive_key(SSL_CONNECTION *s, const EVP_MD *md,
-                     const unsigned char *secret,
-                     unsigned char *key, size_t keylen)
+    const unsigned char *secret,
+    unsigned char *key, size_t keylen)
 {
     /* ASCII: "key", in hex for EBCDIC compatibility */
     static const unsigned char keylabel[] = "\x6B\x65\x79";
 
     return tls13_hkdf_expand(s, md, secret, keylabel, sizeof(keylabel) - 1,
-                             NULL, 0, key, keylen, 1);
+        NULL, 0, key, keylen, 1);
 }
 
 /*
@@ -135,25 +135,25 @@ int tls13_derive_key(SSL_CONNECTION *s, const EVP_MD *md,
  * success  0 on failure.
  */
 int tls13_derive_iv(SSL_CONNECTION *s, const EVP_MD *md,
-                    const unsigned char *secret,
-                    unsigned char *iv, size_t ivlen)
+    const unsigned char *secret,
+    unsigned char *iv, size_t ivlen)
 {
     /* ASCII: "iv", in hex for EBCDIC compatibility */
     static const unsigned char ivlabel[] = "\x69\x76";
 
     return tls13_hkdf_expand(s, md, secret, ivlabel, sizeof(ivlabel) - 1,
-                             NULL, 0, iv, ivlen, 1);
+        NULL, 0, iv, ivlen, 1);
 }
 
 int tls13_derive_finishedkey(SSL_CONNECTION *s, const EVP_MD *md,
-                             const unsigned char *secret,
-                             unsigned char *fin, size_t finlen)
+    const unsigned char *secret,
+    unsigned char *fin, size_t finlen)
 {
     /* ASCII: "finished", in hex for EBCDIC compatibility */
     static const unsigned char finishedlabel[] = "\x66\x69\x6E\x69\x73\x68\x65\x64";
 
     return tls13_hkdf_expand(s, md, secret, finishedlabel,
-                             sizeof(finishedlabel) - 1, NULL, 0, fin, finlen, 1);
+        sizeof(finishedlabel) - 1, NULL, 0, fin, finlen, 1);
 }
 
 /*
@@ -162,10 +162,10 @@ int tls13_derive_finishedkey(SSL_CONNECTION *s, const EVP_MD *md,
  * pointed to by |outsecret|. Returns 1 on success  0 on failure.
  */
 int tls13_generate_secret(SSL_CONNECTION *s, const EVP_MD *md,
-                          const unsigned char *prevsecret,
-                          const unsigned char *insecret,
-                          size_t insecretlen,
-                          unsigned char *outsecret)
+    const unsigned char *prevsecret,
+    const unsigned char *insecret,
+    size_t insecretlen,
+    unsigned char *outsecret)
 {
     size_t mdlen;
     int mdleni;
@@ -198,20 +198,20 @@ int tls13_generate_secret(SSL_CONNECTION *s, const EVP_MD *md,
 
     *p++ = OSSL_PARAM_construct_int(OSSL_KDF_PARAM_MODE, &mode);
     *p++ = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_DIGEST,
-                                            (char *)mdname, 0);
+        (char *)mdname, 0);
     if (insecret != NULL)
         *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_KEY,
-                                                 (unsigned char *)insecret,
-                                                 insecretlen);
+            (unsigned char *)insecret,
+            insecretlen);
     if (prevsecret != NULL)
         *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_SALT,
-                                                 (unsigned char *)prevsecret, mdlen);
+            (unsigned char *)prevsecret, mdlen);
     *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_PREFIX,
-                                             (unsigned char *)label_prefix,
-                                             sizeof(label_prefix) - 1);
+        (unsigned char *)label_prefix,
+        sizeof(label_prefix) - 1);
     *p++ = OSSL_PARAM_construct_octet_string(OSSL_KDF_PARAM_LABEL,
-                                             (unsigned char *)derived_secret_label,
-                                             sizeof(derived_secret_label) - 1);
+        (unsigned char *)derived_secret_label,
+        sizeof(derived_secret_label) - 1);
     *p++ = OSSL_PARAM_construct_end();
 
     ret = EVP_KDF_derive(kctx, outsecret, mdlen, params) <= 0;
@@ -229,13 +229,13 @@ int tls13_generate_secret(SSL_CONNECTION *s, const EVP_MD *md,
  * generated. Returns 1 on success  0 on failure.
  */
 int tls13_generate_handshake_secret(SSL_CONNECTION *s,
-                                    const unsigned char *insecret,
-                                    size_t insecretlen)
+    const unsigned char *insecret,
+    size_t insecretlen)
 {
     /* Calls SSLfatal() if required */
     return tls13_generate_secret(s, ssl_handshake_md(s), s->early_secret,
-                                 insecret, insecretlen,
-                                 (unsigned char *)&s->handshake_secret);
+        insecret, insecretlen,
+        (unsigned char *)&s->handshake_secret);
 }
 
 /*
@@ -244,8 +244,8 @@ int tls13_generate_handshake_secret(SSL_CONNECTION *s,
  * failure.
  */
 int tls13_generate_master_secret(SSL_CONNECTION *s, unsigned char *out,
-                                 unsigned char *prev, size_t prevlen,
-                                 size_t *secret_size)
+    unsigned char *prev, size_t prevlen,
+    size_t *secret_size)
 {
     const EVP_MD *md = ssl_handshake_md(s);
     int md_size;
@@ -265,7 +265,7 @@ int tls13_generate_master_secret(SSL_CONNECTION *s, unsigned char *out,
  * 0 on error.
  */
 size_t tls13_final_finish_mac(SSL_CONNECTION *s, const char *str, size_t slen,
-                             unsigned char *out)
+    unsigned char *out)
 {
     const EVP_MD *md = ssl_handshake_md(s);
     const char *mdname = EVP_MD_get0_name(md);
@@ -282,8 +282,8 @@ size_t tls13_final_finish_mac(SSL_CONNECTION *s, const char *str, size_t slen,
     /* Safe to cast away const here since we're not "getting" any data */
     if (sctx->propq != NULL)
         *p++ = OSSL_PARAM_construct_utf8_string(OSSL_ALG_PARAM_PROPERTIES,
-                                                (char *)sctx->propq,
-                                                0);
+            (char *)sctx->propq,
+            0);
     *p = OSSL_PARAM_construct_end();
 
     if (!ssl_handshake_hash(s, hash, sizeof(hash), &hashlen)) {
@@ -297,21 +297,21 @@ size_t tls13_final_finish_mac(SSL_CONNECTION *s, const char *str, size_t slen,
         key = s->client_finished_secret;
     } else {
         if (!tls13_derive_finishedkey(s, md,
-                                      s->client_app_traffic_secret,
-                                      finsecret, hashlen))
+                s->client_app_traffic_secret,
+                finsecret, hashlen))
             goto err;
         key = finsecret;
     }
 
     if (!EVP_Q_mac(sctx->libctx, "HMAC", sctx->propq, mdname,
-                   params, key, hashlen, hash, hashlen,
-                   /* outsize as per sizeof(peer_finish_md) */
-                   out, EVP_MAX_MD_SIZE * 2, &len)) {
+            params, key, hashlen, hash, hashlen,
+            /* outsize as per sizeof(peer_finish_md) */
+            out, EVP_MAX_MD_SIZE * 2, &len)) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
 
- err:
+err:
     OPENSSL_cleanse(finsecret, sizeof(finsecret));
     return len;
 }
@@ -329,7 +329,7 @@ int tls13_setup_key_block(SSL_CONNECTION *s)
 
     s->session->cipher = s->s3.tmp.new_cipher;
     if (!ssl_cipher_get_evp(SSL_CONNECTION_GET_CTX(s), s->session, &c, &hash,
-                            &mac_type, &mac_secret_size, NULL, 0)) {
+            &mac_type, &mac_secret_size, NULL, 0)) {
         /* Error is already recorded */
         SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR);
         return 0;
@@ -346,16 +346,16 @@ int tls13_setup_key_block(SSL_CONNECTION *s)
 }
 
 static int derive_secret_key_and_iv(SSL_CONNECTION *s, const EVP_MD *md,
-                                    const EVP_CIPHER *ciph,
-                                    int mac_type,
-                                    const EVP_MD *mac_md,
-                                    const unsigned char *insecret,
-                                    const unsigned char *hash,
-                                    const unsigned char *label,
-                                    size_t labellen, unsigned char *secret,
-                                    unsigned char *key, size_t *keylen,
-                                    unsigned char **iv, size_t *ivlen,
-                                    size_t *taglen)
+    const EVP_CIPHER *ciph,
+    int mac_type,
+    const EVP_MD *mac_md,
+    const unsigned char *insecret,
+    const unsigned char *hash,
+    const unsigned char *label,
+    size_t labellen, unsigned char *secret,
+    unsigned char *key, size_t *keylen,
+    unsigned char **iv, size_t *ivlen,
+    size_t *taglen)
 {
     int hashleni = EVP_MD_get_size(md);
     size_t hashlen;
@@ -369,7 +369,7 @@ static int derive_secret_key_and_iv(SSL_CONNECTION *s, const EVP_MD *md,
     hashlen = (size_t)hashleni;
 
     if (!tls13_hkdf_expand(s, md, insecret, label, labellen, hash, hashlen,
-                           secret, hashlen, 1)) {
+            secret, hashlen, 1)) {
         /* SSLfatal() already called */
         return 0;
     }
@@ -438,7 +438,7 @@ static int derive_secret_key_and_iv(SSL_CONNECTION *s, const EVP_MD *md,
     }
 
     if (!tls13_derive_key(s, md, secret, key, *keylen)
-            || !tls13_derive_iv(s, md, secret, *iv, *ivlen)) {
+        || !tls13_derive_iv(s, md, secret, *iv, *ivlen)) {
         /* SSLfatal() already called */
         return 0;
     }
@@ -451,7 +451,7 @@ static int tls13_store_hash(SSL_CONNECTION *s, unsigned char *hash, size_t len)
     size_t hashlen;
 
     if (!ssl3_digest_cached_records(s, 1)
-            || !ssl_handshake_hash(s, hash, len, &hashlen)) {
+        || !ssl_handshake_hash(s, hash, len, &hashlen)) {
         /* SSLfatal() already called */;
         return 0;
     }
@@ -462,13 +462,13 @@ static int tls13_store_hash(SSL_CONNECTION *s, unsigned char *hash, size_t len)
 int tls13_store_handshake_traffic_hash(SSL_CONNECTION *s)
 {
     return tls13_store_hash(s, s->handshake_traffic_hash,
-                            sizeof(s->handshake_traffic_hash));
+        sizeof(s->handshake_traffic_hash));
 }
 
 int tls13_store_server_finished_hash(SSL_CONNECTION *s)
 {
     return tls13_store_hash(s, s->server_finished_hash,
-                            sizeof(s->server_finished_hash));
+        sizeof(s->server_finished_hash));
 }
 
 int tls13_change_cipher_state(SSL_CONNECTION *s, int which)
@@ -512,7 +512,7 @@ int tls13_change_cipher_state(SSL_CONNECTION *s, int which)
                                                 : OSSL_RECORD_DIRECTION_WRITE;
 
     if (((which & SSL3_CC_CLIENT) && (which & SSL3_CC_WRITE))
-            || ((which & SSL3_CC_SERVER) && (which & SSL3_CC_READ))) {
+        || ((which & SSL3_CC_SERVER) && (which & SSL3_CC_READ))) {
         if ((which & SSL3_CC_EARLY) != 0) {
             EVP_MD_CTX *mdctx = NULL;
             long handlen;
@@ -532,16 +532,15 @@ int tls13_change_cipher_state(SSL_CONNECTION *s, int which)
             }
 
             if (s->early_data_state == SSL_EARLY_DATA_CONNECTING
-                    && s->max_early_data > 0
-                    && s->session->ext.max_early_data == 0) {
+                && s->max_early_data > 0
+                && s->session->ext.max_early_data == 0) {
                 /*
                  * If we are attempting to send early data, and we've decided to
                  * actually do it but max_early_data in s->session is 0 then we
                  * must be using an external PSK.
                  */
                 if (!ossl_assert(s->psksession != NULL
-                        && s->max_early_data ==
-                           s->psksession->ext.max_early_data)) {
+                        && s->max_early_data == s->psksession->ext.max_early_data)) {
                     SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                     goto err;
                 }
@@ -564,7 +563,7 @@ int tls13_change_cipher_state(SSL_CONNECTION *s, int which)
 
             if (((EVP_CIPHER_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER) == 0)
                 && (!ssl_cipher_get_evp_md_mac(sctx, sslcipher, &mac_md,
-                                               &mac_pkey_type, NULL))) {
+                    &mac_pkey_type, NULL))) {
                 SSLfatal_alert(s, SSL_AD_INTERNAL_ERROR);
                 goto err;
             }
@@ -582,8 +581,8 @@ int tls13_change_cipher_state(SSL_CONNECTION *s, int which)
 
             md = ssl_md(sctx, sslcipher->algorithm2);
             if (md == NULL || !EVP_DigestInit_ex(mdctx, md, NULL)
-                    || !EVP_DigestUpdate(mdctx, hdata, handlen)
-                    || !EVP_DigestFinal_ex(mdctx, hashval, &hashlenui)) {
+                || !EVP_DigestUpdate(mdctx, hdata, handlen)
+                || !EVP_DigestFinal_ex(mdctx, hashval, &hashlenui)) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 EVP_MD_CTX_free(mdctx);
                 goto err;
@@ -592,17 +591,17 @@ int tls13_change_cipher_state(SSL_CONNECTION *s, int which)
             EVP_MD_CTX_free(mdctx);
 
             if (!tls13_hkdf_expand(s, md, insecret,
-                                   early_exporter_master_secret,
-                                   sizeof(early_exporter_master_secret) - 1,
-                                   hashval, hashlen,
-                                   s->early_exporter_master_secret, hashlen,
-                                   1)) {
+                    early_exporter_master_secret,
+                    sizeof(early_exporter_master_secret) - 1,
+                    hashval, hashlen,
+                    s->early_exporter_master_secret, hashlen,
+                    1)) {
                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
                 goto err;
             }
 
             if (!ssl_log_secret(s, EARLY_EXPORTER_SECRET_LABEL,
-                                s->early_exporter_master_secret, hashlen)) {
+                    s->early_exporter_master_secret, hashlen)) {
                 /* SSLfatal() already called */
                 goto err;
             }
@@ -668,7 +667,7 @@ int tls13_change_cipher_state(SSL_CONNECTION *s, int which)
         mac_md = s->s3.tmp.new_hash;
         mac_pkey_type = s->s3.tmp.new_mac_pkey_type;
         if (!ssl3_digest_cached_records(s, 1)
-                || !ssl_handshake_hash(s, hashval, sizeof(hashval), &hashlen)) {
+            || !ssl_handshake_hash(s, hashval, sizeof(hashval), &hashlen)) {
             /* SSLfatal() already called */;
             goto err;
         }
@@ -680,10 +679,10 @@ int tls13_change_cipher_state(SSL_CONNECTION *s, int which)
          * hash for the whole handshake including the Client Finished
          */
         if (!tls13_hkdf_expand(s, ssl_handshake_md(s), insecret,
-                               resumption_master_secret,
-                               sizeof(resumption_master_secret) - 1,
-                               hashval, hashlen, s->resumption_master_secret,
-                               hashlen, 1)) {
+                resumption_master_secret,
+                sizeof(resumption_master_secret) - 1,
+                hashval, hashlen, s->resumption_master_secret,
+                hashlen, 1)) {
             /* SSLfatal() already called */
             goto err;
         }
@@ -694,8 +693,8 @@ int tls13_change_cipher_state(SSL_CONNECTION *s, int which)
         goto err;
 
     if (!derive_secret_key_and_iv(s, md, cipher, mac_pkey_type, mac_md,
-                                  insecret, hash, label, labellen, secret, key,
-                                  &keylen, &iv, &ivlen, &taglen)) {
+            insecret, hash, label, labellen, secret, key,
+            &keylen, &iv, &ivlen, &taglen)) {
         /* SSLfatal() already called */
         goto err;
     }
@@ -704,16 +703,16 @@ int tls13_change_cipher_state(SSL_CONNECTION *s, int which)
         memcpy(s->server_app_traffic_secret, secret, hashlen);
         /* Now we create the exporter master secret */
         if (!tls13_hkdf_expand(s, ssl_handshake_md(s), insecret,
-                               exporter_master_secret,
-                               sizeof(exporter_master_secret) - 1,
-                               hash, hashlen, s->exporter_master_secret,
-                               hashlen, 1)) {
+                exporter_master_secret,
+                sizeof(exporter_master_secret) - 1,
+                hash, hashlen, s->exporter_master_secret,
+                hashlen, 1)) {
             /* SSLfatal() already called */
             goto err;
         }
 
         if (!ssl_log_secret(s, EXPORTER_SECRET_LABEL, s->exporter_master_secret,
-                            hashlen)) {
+                hashlen)) {
             /* SSLfatal() already called */
             goto err;
         }
@@ -726,8 +725,8 @@ int tls13_change_cipher_state(SSL_CONNECTION *s, int which)
     }
 
     if (finsecret != NULL
-            && !tls13_derive_finishedkey(s, ssl_handshake_md(s), secret,
-                                         finsecret, (size_t)finsecretlen)) {
+        && !tls13_derive_finishedkey(s, ssl_handshake_md(s), secret,
+            finsecret, (size_t)finsecretlen)) {
         /* SSLfatal() already called */
         goto err;
     }
@@ -740,22 +739,22 @@ int tls13_change_cipher_state(SSL_CONNECTION *s, int which)
     }
 
     level = (which & SSL3_CC_EARLY) != 0
-            ? OSSL_RECORD_PROTECTION_LEVEL_EARLY
-            : ((which &SSL3_CC_HANDSHAKE) != 0
-               ? OSSL_RECORD_PROTECTION_LEVEL_HANDSHAKE
-               : OSSL_RECORD_PROTECTION_LEVEL_APPLICATION);
+        ? OSSL_RECORD_PROTECTION_LEVEL_EARLY
+        : ((which & SSL3_CC_HANDSHAKE) != 0
+                  ? OSSL_RECORD_PROTECTION_LEVEL_HANDSHAKE
+                  : OSSL_RECORD_PROTECTION_LEVEL_APPLICATION);
 
     if (!ssl_set_new_record_layer(s, s->version,
-                                  direction,
-                                  level, secret, hashlen, key, keylen, iv,
-                                  ivlen, NULL, 0, cipher, taglen,
-                                  mac_pkey_type, mac_md, NULL, md)) {
+            direction,
+            level, secret, hashlen, key, keylen, iv,
+            ivlen, NULL, 0, cipher, taglen,
+            mac_pkey_type, mac_md, NULL, md)) {
         /* SSLfatal already called */
         goto err;
     }
 
     ret = 1;
- err:
+err:
     if ((which & SSL3_CC_EARLY) != 0) {
         /* We up-refed this so now we need to down ref */
         if ((EVP_CIPHER_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER) == 0)
@@ -798,12 +797,12 @@ int tls13_update_key(SSL_CONNECTION *s, int sending)
         insecret = s->client_app_traffic_secret;
 
     if (!derive_secret_key_and_iv(s, md,
-                                  s->s3.tmp.new_sym_enc,
-                                  s->s3.tmp.new_mac_pkey_type, s->s3.tmp.new_hash,
-                                  insecret, NULL,
-                                  application_traffic,
-                                  sizeof(application_traffic) - 1, secret, key,
-                                  &keylen, &iv, &ivlen, &taglen)) {
+            s->s3.tmp.new_sym_enc,
+            s->s3.tmp.new_mac_pkey_type, s->s3.tmp.new_hash,
+            insecret, NULL,
+            application_traffic,
+            sizeof(application_traffic) - 1, secret, key,
+            &keylen, &iv, &ivlen, &taglen)) {
         /* SSLfatal() already called */
         goto err;
     }
@@ -811,11 +810,11 @@ int tls13_update_key(SSL_CONNECTION *s, int sending)
     memcpy(insecret, secret, hashlen);
 
     if (!ssl_set_new_record_layer(s, s->version,
-                            direction,
-                            OSSL_RECORD_PROTECTION_LEVEL_APPLICATION,
-                            insecret, hashlen, key, keylen, iv, ivlen, NULL, 0,
-                            s->s3.tmp.new_sym_enc, taglen, NID_undef, NULL,
-                            NULL, md)) {
+            direction,
+            OSSL_RECORD_PROTECTION_LEVEL_APPLICATION,
+            insecret, hashlen, key, keylen, iv, ivlen, NULL, 0,
+            s->s3.tmp.new_sym_enc, taglen, NID_undef, NULL,
+            NULL, md)) {
         /* SSLfatal already called */
         goto err;
     }
@@ -827,7 +826,7 @@ int tls13_update_key(SSL_CONNECTION *s, int sending)
         goto err;
     }
     ret = 1;
- err:
+err:
     OPENSSL_cleanse(key, sizeof(key));
     OPENSSL_cleanse(secret, sizeof(secret));
     if (iv != iv_intern)
@@ -845,10 +844,10 @@ int tls13_alert_code(int code)
 }
 
 int tls13_export_keying_material(SSL_CONNECTION *s,
-                                 unsigned char *out, size_t olen,
-                                 const char *label, size_t llen,
-                                 const unsigned char *context,
-                                 size_t contextlen, int use_context)
+    unsigned char *out, size_t olen,
+    const char *label, size_t llen,
+    const unsigned char *context,
+    size_t contextlen, int use_context)
 {
     unsigned char exportsecret[EVP_MAX_MD_SIZE];
     /* ASCII: "exporter", in hex for EBCDIC compatibility */
@@ -866,29 +865,29 @@ int tls13_export_keying_material(SSL_CONNECTION *s,
         contextlen = 0;
 
     if (EVP_DigestInit_ex(ctx, md, NULL) <= 0
-            || EVP_DigestUpdate(ctx, context, contextlen) <= 0
-            || EVP_DigestFinal_ex(ctx, hash, &hashsize) <= 0
-            || EVP_DigestInit_ex(ctx, md, NULL) <= 0
-            || EVP_DigestFinal_ex(ctx, data, &datalen) <= 0
-            || !tls13_hkdf_expand(s, md, s->exporter_master_secret,
-                                  (const unsigned char *)label, llen,
-                                  data, datalen, exportsecret, hashsize, 0)
-            || !tls13_hkdf_expand(s, md, exportsecret, exporterlabel,
-                                  sizeof(exporterlabel) - 1, hash, hashsize,
-                                  out, olen, 0))
+        || EVP_DigestUpdate(ctx, context, contextlen) <= 0
+        || EVP_DigestFinal_ex(ctx, hash, &hashsize) <= 0
+        || EVP_DigestInit_ex(ctx, md, NULL) <= 0
+        || EVP_DigestFinal_ex(ctx, data, &datalen) <= 0
+        || !tls13_hkdf_expand(s, md, s->exporter_master_secret,
+            (const unsigned char *)label, llen,
+            data, datalen, exportsecret, hashsize, 0)
+        || !tls13_hkdf_expand(s, md, exportsecret, exporterlabel,
+            sizeof(exporterlabel) - 1, hash, hashsize,
+            out, olen, 0))
         goto err;
 
     ret = 1;
- err:
+err:
     EVP_MD_CTX_free(ctx);
     return ret;
 }
 
 int tls13_export_keying_material_early(SSL_CONNECTION *s,
-                                       unsigned char *out, size_t olen,
-                                       const char *label, size_t llen,
-                                       const unsigned char *context,
-                                       size_t contextlen)
+    unsigned char *out, size_t olen,
+    const char *label, size_t llen,
+    const unsigned char *context,
+    size_t contextlen)
 {
     /* ASCII: "exporter", in hex for EBCDIC compatibility */
     static const unsigned char exporterlabel[] = "\x65\x78\x70\x6F\x72\x74\x65\x72";
@@ -904,7 +903,7 @@ int tls13_export_keying_material_early(SSL_CONNECTION *s,
         goto err;
 
     if (!s->server && s->max_early_data > 0
-            && s->session->ext.max_early_data == 0)
+        && s->session->ext.max_early_data == 0)
         sslcipher = SSL_SESSION_get0_cipher(s->psksession);
     else
         sslcipher = SSL_SESSION_get0_cipher(s->session);
@@ -927,21 +926,21 @@ int tls13_export_keying_material_early(SSL_CONNECTION *s,
      * Here Transcript-Hash is the cipher suite hash algorithm.
      */
     if (md == NULL
-            || EVP_DigestInit_ex(ctx, md, NULL) <= 0
-            || EVP_DigestUpdate(ctx, context, contextlen) <= 0
-            || EVP_DigestFinal_ex(ctx, hash, &hashsize) <= 0
-            || EVP_DigestInit_ex(ctx, md, NULL) <= 0
-            || EVP_DigestFinal_ex(ctx, data, &datalen) <= 0
-            || !tls13_hkdf_expand(s, md, s->early_exporter_master_secret,
-                                  (const unsigned char *)label, llen,
-                                  data, datalen, exportsecret, hashsize, 0)
-            || !tls13_hkdf_expand(s, md, exportsecret, exporterlabel,
-                                  sizeof(exporterlabel) - 1, hash, hashsize,
-                                  out, olen, 0))
+        || EVP_DigestInit_ex(ctx, md, NULL) <= 0
+        || EVP_DigestUpdate(ctx, context, contextlen) <= 0
+        || EVP_DigestFinal_ex(ctx, hash, &hashsize) <= 0
+        || EVP_DigestInit_ex(ctx, md, NULL) <= 0
+        || EVP_DigestFinal_ex(ctx, data, &datalen) <= 0
+        || !tls13_hkdf_expand(s, md, s->early_exporter_master_secret,
+            (const unsigned char *)label, llen,
+            data, datalen, exportsecret, hashsize, 0)
+        || !tls13_hkdf_expand(s, md, exportsecret, exporterlabel,
+            sizeof(exporterlabel) - 1, hash, hashsize,
+            out, olen, 0))
         goto err;
 
     ret = 1;
- err:
+err:
     EVP_MD_CTX_free(ctx);
     return ret;
 }
diff --git a/crypto/openssl/ssl/tls_depr.c b/crypto/openssl/ssl/tls_depr.c
index 64a9a7942b3f..72cc528ec851 100644
--- a/crypto/openssl/ssl/tls_depr.c
+++ b/crypto/openssl/ssl/tls_depr.c
@@ -66,14 +66,14 @@ const EVP_MD *tls_get_digest_from_engine(int nid)
 
 #ifndef OPENSSL_NO_ENGINE
 int tls_engine_load_ssl_client_cert(SSL_CONNECTION *s, X509 **px509,
-                                    EVP_PKEY **ppkey)
+    EVP_PKEY **ppkey)
 {
     SSL *ssl = SSL_CONNECTION_GET_SSL(s);
 
     return ENGINE_load_ssl_client_cert(SSL_CONNECTION_GET_CTX(s)->client_cert_engine,
-                                       ssl,
-                                       SSL_get_client_CA_list(ssl),
-                                       px509, ppkey, NULL, NULL, NULL);
+        ssl,
+        SSL_get_client_CA_list(ssl),
+        px509, ppkey, NULL, NULL, NULL);
 }
 #endif
 
@@ -153,7 +153,7 @@ HMAC_CTX *ssl_hmac_get0_HMAC_CTX(SSL_HMAC *ctx)
 /* Some deprecated public APIs pass DH objects */
 EVP_PKEY *ssl_dh_to_pkey(DH *dh)
 {
-# ifndef OPENSSL_NO_DH
+#ifndef OPENSSL_NO_DH
     EVP_PKEY *ret;
 
     if (dh == NULL)
@@ -164,18 +164,18 @@ EVP_PKEY *ssl_dh_to_pkey(DH *dh)
         return NULL;
     }
     return ret;
-# else
+#else
     return NULL;
-# endif
+#endif
 }
 
 /* Some deprecated public APIs pass EC_KEY objects */
 int ssl_set_tmp_ecdh_groups(uint16_t **pext, size_t *pextlen,
-                            uint16_t **ksext, size_t *ksextlen,
-                            size_t **tplext, size_t *tplextlen,
-                            void *key)
+    uint16_t **ksext, size_t *ksextlen,
+    size_t **tplext, size_t *tplextlen,
+    void *key)
 {
-# ifndef OPENSSL_NO_EC
+#ifndef OPENSSL_NO_EC
     const EC_GROUP *group = EC_KEY_get0_group((const EC_KEY *)key);
     int nid;
 
@@ -187,12 +187,12 @@ int ssl_set_tmp_ecdh_groups(uint16_t **pext, size_t *pextlen,
     if (nid == NID_undef)
         return 0;
     return tls1_set_groups(pext, pextlen,
-                           ksext, ksextlen,
-                           tplext, tplextlen,
-                           &nid, 1);
-# else
+        ksext, ksextlen,
+        tplext, tplextlen,
+        &nid, 1);
+#else
     return 0;
-# endif
+#endif
 }
 
 /*
@@ -200,18 +200,17 @@ int ssl_set_tmp_ecdh_groups(uint16_t **pext, size_t *pextlen,
  * ctx: the SSL context.
  * dh: the callback
  */
-# if !defined(OPENSSL_NO_DH)
+#if !defined(OPENSSL_NO_DH)
 void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,
-                                 DH *(*dh) (SSL *ssl, int is_export,
-                                            int keylength))
+    DH *(*dh)(SSL *ssl, int is_export,
+        int keylength))
 {
     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh);
 }
 
-void SSL_set_tmp_dh_callback(SSL *ssl, DH *(*dh) (SSL *ssl, int is_export,
-                                                  int keylength))
+void SSL_set_tmp_dh_callback(SSL *ssl, DH *(*dh)(SSL *ssl, int is_export, int keylength))
 {
     SSL_callback_ctrl(ssl, SSL_CTRL_SET_TMP_DH_CB, (void (*)(void))dh);
 }
-# endif
+#endif
 #endif /* OPENSSL_NO_DEPRECATED */
diff --git a/crypto/openssl/ssl/tls_srp.c b/crypto/openssl/ssl/tls_srp.c
index e61bed5f0525..51f0950a16f1 100644
--- a/crypto/openssl/ssl/tls_srp.c
+++ b/crypto/openssl/ssl/tls_srp.c
@@ -24,7 +24,7 @@
 #include "internal/ssl_unwrap.h"
 
 #ifndef OPENSSL_NO_SRP
-# include <openssl/srp.h>
+#include <openssl/srp.h>
 
 /*
  * The public API SSL_CTX_SRP_CTX_free() is deprecated so we use
@@ -100,50 +100,30 @@ int ssl_srp_ctx_init_intern(SSL_CONNECTION *s)
 
     s->srp_ctx.SRP_cb_arg = ctx->srp_ctx.SRP_cb_arg;
     /* set client Hello login callback */
-    s->srp_ctx.TLS_ext_srp_username_callback =
-        ctx->srp_ctx.TLS_ext_srp_username_callback;
+    s->srp_ctx.TLS_ext_srp_username_callback = ctx->srp_ctx.TLS_ext_srp_username_callback;
     /* set SRP N/g param callback for verification */
-    s->srp_ctx.SRP_verify_param_callback =
-        ctx->srp_ctx.SRP_verify_param_callback;
+    s->srp_ctx.SRP_verify_param_callback = ctx->srp_ctx.SRP_verify_param_callback;
     /* set SRP client passwd callback */
-    s->srp_ctx.SRP_give_srp_client_pwd_callback =
-        ctx->srp_ctx.SRP_give_srp_client_pwd_callback;
+    s->srp_ctx.SRP_give_srp_client_pwd_callback = ctx->srp_ctx.SRP_give_srp_client_pwd_callback;
 
     s->srp_ctx.strength = ctx->srp_ctx.strength;
 
-    if (((ctx->srp_ctx.N != NULL) &&
-         ((s->srp_ctx.N = BN_dup(ctx->srp_ctx.N)) == NULL)) ||
-        ((ctx->srp_ctx.g != NULL) &&
-         ((s->srp_ctx.g = BN_dup(ctx->srp_ctx.g)) == NULL)) ||
-        ((ctx->srp_ctx.s != NULL) &&
-         ((s->srp_ctx.s = BN_dup(ctx->srp_ctx.s)) == NULL)) ||
-        ((ctx->srp_ctx.B != NULL) &&
-         ((s->srp_ctx.B = BN_dup(ctx->srp_ctx.B)) == NULL)) ||
-        ((ctx->srp_ctx.A != NULL) &&
-         ((s->srp_ctx.A = BN_dup(ctx->srp_ctx.A)) == NULL)) ||
-        ((ctx->srp_ctx.a != NULL) &&
-         ((s->srp_ctx.a = BN_dup(ctx->srp_ctx.a)) == NULL)) ||
-        ((ctx->srp_ctx.v != NULL) &&
-         ((s->srp_ctx.v = BN_dup(ctx->srp_ctx.v)) == NULL)) ||
-        ((ctx->srp_ctx.b != NULL) &&
-         ((s->srp_ctx.b = BN_dup(ctx->srp_ctx.b)) == NULL))) {
+    if (((ctx->srp_ctx.N != NULL) && ((s->srp_ctx.N = BN_dup(ctx->srp_ctx.N)) == NULL)) || ((ctx->srp_ctx.g != NULL) && ((s->srp_ctx.g = BN_dup(ctx->srp_ctx.g)) == NULL)) || ((ctx->srp_ctx.s != NULL) && ((s->srp_ctx.s = BN_dup(ctx->srp_ctx.s)) == NULL)) || ((ctx->srp_ctx.B != NULL) && ((s->srp_ctx.B = BN_dup(ctx->srp_ctx.B)) == NULL)) || ((ctx->srp_ctx.A != NULL) && ((s->srp_ctx.A = BN_dup(ctx->srp_ctx.A)) == NULL)) || ((ctx->srp_ctx.a != NULL) && ((s->srp_ctx.a = BN_dup(ctx->srp_ctx.a)) == NULL)) || ((ctx->srp_ctx.v != NULL) && ((s->srp_ctx.v = BN_dup(ctx->srp_ctx.v)) == NULL)) || ((ctx->srp_ctx.b != NULL) && ((s->srp_ctx.b = BN_dup(ctx->srp_ctx.b)) == NULL))) {
         ERR_raise(ERR_LIB_SSL, ERR_R_BN_LIB);
         goto err;
     }
-    if ((ctx->srp_ctx.login != NULL) &&
-        ((s->srp_ctx.login = OPENSSL_strdup(ctx->srp_ctx.login)) == NULL)) {
+    if ((ctx->srp_ctx.login != NULL) && ((s->srp_ctx.login = OPENSSL_strdup(ctx->srp_ctx.login)) == NULL)) {
         ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
         goto err;
     }
-    if ((ctx->srp_ctx.info != NULL) &&
-        ((s->srp_ctx.info = OPENSSL_strdup(ctx->srp_ctx.info)) == NULL)) {
+    if ((ctx->srp_ctx.info != NULL) && ((s->srp_ctx.info = OPENSSL_strdup(ctx->srp_ctx.info)) == NULL)) {
         ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
         goto err;
     }
     s->srp_ctx.srp_Mask = ctx->srp_ctx.srp_Mask;
 
     return 1;
- err:
+err:
     OPENSSL_free(s->srp_ctx.login);
     OPENSSL_free(s->srp_ctx.info);
     BN_free(s->srp_ctx.N);
@@ -198,32 +178,27 @@ int ssl_srp_server_param_with_username_intern(SSL_CONNECTION *s, int *ad)
     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
 
     *ad = SSL_AD_UNKNOWN_PSK_IDENTITY;
-    if ((s->srp_ctx.TLS_ext_srp_username_callback != NULL) &&
-        ((al =
-          s->srp_ctx.TLS_ext_srp_username_callback(SSL_CONNECTION_GET_USER_SSL(s),
-                                                   ad,
-                                                   s->srp_ctx.SRP_cb_arg)) !=
-         SSL_ERROR_NONE))
+    if ((s->srp_ctx.TLS_ext_srp_username_callback != NULL) && ((al = s->srp_ctx.TLS_ext_srp_username_callback(SSL_CONNECTION_GET_USER_SSL(s), ad, s->srp_ctx.SRP_cb_arg)) != SSL_ERROR_NONE))
         return al;
 
     *ad = SSL_AD_INTERNAL_ERROR;
-    if ((s->srp_ctx.N == NULL) ||
-        (s->srp_ctx.g == NULL) ||
-        (s->srp_ctx.s == NULL) || (s->srp_ctx.v == NULL))
+    if ((s->srp_ctx.N == NULL) || (s->srp_ctx.g == NULL) || (s->srp_ctx.s == NULL) || (s->srp_ctx.v == NULL))
         return SSL3_AL_FATAL;
 
     if (RAND_priv_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx, b, sizeof(b),
-                           0) <= 0)
+            0)
+        <= 0)
         return SSL3_AL_FATAL;
     s->srp_ctx.b = BN_bin2bn(b, sizeof(b), NULL);
     OPENSSL_cleanse(b, sizeof(b));
 
     /* Calculate:  B = (kv + g^b) % N  */
 
-    return ((s->srp_ctx.B =
-             SRP_Calc_B_ex(s->srp_ctx.b, s->srp_ctx.N, s->srp_ctx.g,
-                           s->srp_ctx.v, sctx->libctx, sctx->propq)) !=
-            NULL) ? SSL_ERROR_NONE : SSL3_AL_FATAL;
+    return ((s->srp_ctx.B = SRP_Calc_B_ex(s->srp_ctx.b, s->srp_ctx.N, s->srp_ctx.g,
+                 s->srp_ctx.v, sctx->libctx, sctx->propq))
+               != NULL)
+        ? SSL_ERROR_NONE
+        : SSL3_AL_FATAL;
 }
 
 int SSL_srp_server_param_with_username(SSL *s, int *ad)
@@ -241,7 +216,7 @@ int SSL_srp_server_param_with_username(SSL *s, int *ad)
  * fly
  */
 int SSL_set_srp_server_param_pw(SSL *s, const char *user, const char *pass,
-                                const char *grp)
+    const char *grp)
 {
     SRP_gN *GN;
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
@@ -259,15 +234,15 @@ int SSL_set_srp_server_param_pw(SSL *s, const char *user, const char *pass,
     BN_clear_free(sc->srp_ctx.s);
     sc->srp_ctx.s = NULL;
     if (!SRP_create_verifier_BN_ex(user, pass, &sc->srp_ctx.s, &sc->srp_ctx.v,
-                                   sc->srp_ctx.N, sc->srp_ctx.g, s->ctx->libctx,
-                                   s->ctx->propq))
+            sc->srp_ctx.N, sc->srp_ctx.g, s->ctx->libctx,
+            s->ctx->propq))
         return -1;
 
     return 1;
 }
 
 int SSL_set_srp_server_param(SSL *s, const BIGNUM *N, const BIGNUM *g,
-                             BIGNUM *sa, BIGNUM *v, char *info)
+    BIGNUM *sa, BIGNUM *v, char *info)
 {
     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 
@@ -317,8 +292,7 @@ int SSL_set_srp_server_param(SSL *s, const BIGNUM *N, const BIGNUM *g,
             return -1;
     }
 
-    if (!(sc->srp_ctx.N) ||
-        !(sc->srp_ctx.g) || !(sc->srp_ctx.s) || !(sc->srp_ctx.v))
+    if (!(sc->srp_ctx.N) || !(sc->srp_ctx.g) || !(sc->srp_ctx.s) || !(sc->srp_ctx.v))
         return -1;
 
     return 1;
@@ -334,10 +308,12 @@ int srp_generate_server_master_secret(SSL_CONNECTION *s)
     if (!SRP_Verify_A_mod_N(s->srp_ctx.A, s->srp_ctx.N))
         goto err;
     if ((u = SRP_Calc_u_ex(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N,
-                           sctx->libctx, sctx->propq)) == NULL)
+             sctx->libctx, sctx->propq))
+        == NULL)
         goto err;
     if ((K = SRP_Calc_server_key(s->srp_ctx.A, s->srp_ctx.v, u, s->srp_ctx.b,
-                                 s->srp_ctx.N)) == NULL)
+             s->srp_ctx.N))
+        == NULL)
         goto err;
 
     tmp_len = BN_num_bytes(K);
@@ -348,7 +324,7 @@ int srp_generate_server_master_secret(SSL_CONNECTION *s)
     BN_bn2bin(K, tmp);
     /* Calls SSLfatal() as required */
     ret = ssl_generate_master_secret(s, tmp, tmp_len, 1);
- err:
+err:
     BN_clear_free(K);
     BN_clear_free(u);
     return ret;
@@ -367,26 +343,28 @@ int srp_generate_client_master_secret(SSL_CONNECTION *s)
      * Checks if b % n == 0
      */
     if (SRP_Verify_B_mod_N(s->srp_ctx.B, s->srp_ctx.N) == 0
-            || (u = SRP_Calc_u_ex(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N,
-                                  sctx->libctx, sctx->propq))
-               == NULL
-            || s->srp_ctx.SRP_give_srp_client_pwd_callback == NULL) {
+        || (u = SRP_Calc_u_ex(s->srp_ctx.A, s->srp_ctx.B, s->srp_ctx.N,
+                sctx->libctx, sctx->propq))
+            == NULL
+        || s->srp_ctx.SRP_give_srp_client_pwd_callback == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
     if ((passwd = s->srp_ctx.SRP_give_srp_client_pwd_callback(SSL_CONNECTION_GET_USER_SSL(s),
-                                                              s->srp_ctx.SRP_cb_arg))
-            == NULL) {
+             s->srp_ctx.SRP_cb_arg))
+        == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_CALLBACK_FAILED);
         goto err;
     }
     if ((x = SRP_Calc_x_ex(s->srp_ctx.s, s->srp_ctx.login, passwd,
-                           sctx->libctx, sctx->propq)) == NULL
-            || (K = SRP_Calc_client_key_ex(s->srp_ctx.N, s->srp_ctx.B,
-                                           s->srp_ctx.g, x,
-                                           s->srp_ctx.a, u,
-                                           sctx->libctx,
-                                           sctx->propq)) == NULL) {
+             sctx->libctx, sctx->propq))
+            == NULL
+        || (K = SRP_Calc_client_key_ex(s->srp_ctx.N, s->srp_ctx.B,
+                s->srp_ctx.g, x,
+                s->srp_ctx.a, u,
+                sctx->libctx,
+                sctx->propq))
+            == NULL) {
         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
         goto err;
     }
@@ -399,7 +377,7 @@ int srp_generate_client_master_secret(SSL_CONNECTION *s)
     BN_bn2bin(K, tmp);
     /* Calls SSLfatal() as required */
     ret = ssl_generate_master_secret(s, tmp, tmp_len, 1);
- err:
+err:
     BN_clear_free(K);
     BN_clear_free(x);
     if (passwd != NULL)
@@ -428,13 +406,14 @@ int srp_verify_server_param(SSL_CONNECTION *s)
 
     if (srp->SRP_verify_param_callback) {
         if (srp->SRP_verify_param_callback(SSL_CONNECTION_GET_USER_SSL(s),
-                                           srp->SRP_cb_arg) <= 0) {
+                srp->SRP_cb_arg)
+            <= 0) {
             SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY, SSL_R_CALLBACK_FAILED);
             return 0;
         }
     } else if (!SRP_check_known_gN_param(srp->g, srp->N)) {
         SSLfatal(s, SSL_AD_INSUFFICIENT_SECURITY,
-                 SSL_R_INSUFFICIENT_SECURITY);
+            SSL_R_INSUFFICIENT_SECURITY);
         return 0;
     }
 
@@ -450,7 +429,8 @@ int ssl_srp_calc_a_param_intern(SSL_CONNECTION *s)
     unsigned char rnd[SSL_MAX_MASTER_KEY_LENGTH];
 
     if (RAND_priv_bytes_ex(SSL_CONNECTION_GET_CTX(s)->libctx,
-                           rnd, sizeof(rnd), 0) <= 0)
+            rnd, sizeof(rnd), 0)
+        <= 0)
         return 0;
     s->srp_ctx.a = BN_bin2bn(rnd, sizeof(rnd), s->srp_ctx.a);
     OPENSSL_cleanse(rnd, sizeof(rnd));
@@ -519,8 +499,8 @@ char *SSL_get_srp_userinfo(SSL *s)
     return s->ctx->srp_ctx.info;
 }
 
-# define tls1_ctx_ctrl ssl3_ctx_ctrl
-# define tls1_ctx_callback_ctrl ssl3_ctx_callback_ctrl
+#define tls1_ctx_ctrl ssl3_ctx_ctrl
+#define tls1_ctx_callback_ctrl ssl3_ctx_callback_ctrl
 
 int SSL_CTX_set_srp_username(SSL_CTX *ctx, char *name)
 {
@@ -535,14 +515,14 @@ int SSL_CTX_set_srp_password(SSL_CTX *ctx, char *password)
 int SSL_CTX_set_srp_strength(SSL_CTX *ctx, int strength)
 {
     return tls1_ctx_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_STRENGTH, strength,
-                         NULL);
+        NULL);
 }
 
 int SSL_CTX_set_srp_verify_param_callback(SSL_CTX *ctx,
-                                          int (*cb) (SSL *, void *))
+    int (*cb)(SSL *, void *))
 {
     return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_SRP_VERIFY_PARAM_CB,
-                                  (void (*)(void))cb);
+        (void (*)(void))cb);
 }
 
 int SSL_CTX_set_srp_cb_arg(SSL_CTX *ctx, void *arg)
@@ -551,17 +531,17 @@ int SSL_CTX_set_srp_cb_arg(SSL_CTX *ctx, void *arg)
 }
 
 int SSL_CTX_set_srp_username_callback(SSL_CTX *ctx,
-                                      int (*cb) (SSL *, int *, void *))
+    int (*cb)(SSL *, int *, void *))
 {
     return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_TLS_EXT_SRP_USERNAME_CB,
-                                  (void (*)(void))cb);
+        (void (*)(void))cb);
 }
 
 int SSL_CTX_set_srp_client_pwd_callback(SSL_CTX *ctx,
-                                        char *(*cb) (SSL *, void *))
+    char *(*cb)(SSL *, void *))
 {
     return tls1_ctx_callback_ctrl(ctx, SSL_CTRL_SET_SRP_GIVE_CLIENT_PWD_CB,
-                                  (void (*)(void))cb);
+        (void (*)(void))cb);
 }
 
 #endif