diff --git a/programs/test/udp_proxy.c b/programs/test/udp_proxy.c
index aa01562..34c23ea 100644
--- a/programs/test/udp_proxy.c
+++ b/programs/test/udp_proxy.c
@@ -28,367 +28,353 @@
 #include "mbedtls/build_info.h"
 
 #if defined(MBEDTLS_PLATFORM_C)
-#include "mbedtls/platform.h"
+#    include "mbedtls/platform.h"
 #else
-#include <stdio.h>
-#include <stdlib.h>
-#include <time.h>
-#define mbedtls_time            time
-#define mbedtls_time_t          time_t
-#define mbedtls_printf          printf
-#define mbedtls_calloc          calloc
-#define mbedtls_free            free
-#define mbedtls_exit            exit
-#define MBEDTLS_EXIT_SUCCESS    EXIT_SUCCESS
-#define MBEDTLS_EXIT_FAILURE    EXIT_FAILURE
+#    include <stdio.h>
+#    include <stdlib.h>
+#    include <time.h>
+#    define mbedtls_time         time
+#    define mbedtls_time_t       time_t
+#    define mbedtls_printf       printf
+#    define mbedtls_calloc       calloc
+#    define mbedtls_free         free
+#    define mbedtls_exit         exit
+#    define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS
+#    define MBEDTLS_EXIT_FAILURE EXIT_FAILURE
 #endif /* MBEDTLS_PLATFORM_C */
 
 #if !defined(MBEDTLS_NET_C)
-int main( void )
+int main(void)
 {
-    mbedtls_printf( "MBEDTLS_NET_C not defined.\n" );
-    mbedtls_exit( 0 );
+    mbedtls_printf("MBEDTLS_NET_C not defined.\n");
+    mbedtls_exit(0);
 }
 #else
 
-#include "mbedtls/net_sockets.h"
-#include "mbedtls/error.h"
-#include "mbedtls/ssl.h"
-#include "mbedtls/timing.h"
+#    include "mbedtls/net_sockets.h"
+#    include "mbedtls/error.h"
+#    include "mbedtls/ssl.h"
+#    include "mbedtls/timing.h"
 
-#include <string.h>
+#    include <string.h>
 
 /* For select() */
-#if (defined(_WIN32) || defined(_WIN32_WCE)) && !defined(EFIX64) && \
-    !defined(EFI32)
-#include <winsock2.h>
-#include <windows.h>
-#if defined(_MSC_VER)
-#if defined(_WIN32_WCE)
-#pragma comment( lib, "ws2.lib" )
-#else
-#pragma comment( lib, "ws2_32.lib" )
-#endif
-#endif /* _MSC_VER */
-#else /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */
-#include <sys/time.h>
-#include <sys/types.h>
-#include <unistd.h>
-#endif /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */
+#    if (defined(_WIN32) || defined(_WIN32_WCE)) && !defined(EFIX64) && \
+        !defined(EFI32)
+#        include <winsock2.h>
+#        include <windows.h>
+#        if defined(_MSC_VER)
+#            if defined(_WIN32_WCE)
+#                pragma comment(lib, "ws2.lib")
+#            else
+#                pragma comment(lib, "ws2_32.lib")
+#            endif
+#        endif /* _MSC_VER */
+#    else /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */
+#        include <sys/time.h>
+#        include <sys/types.h>
+#        include <unistd.h>
+#    endif /* ( _WIN32 || _WIN32_WCE ) && !EFIX64 && !EFI32 */
 
-#define MAX_MSG_SIZE            16384 + 2048 /* max record/datagram size */
+#    define MAX_MSG_SIZE 16384 + 2048 /* max record/datagram size */
 
-#define DFL_SERVER_ADDR         "localhost"
-#define DFL_SERVER_PORT         "4433"
-#define DFL_LISTEN_ADDR         "localhost"
-#define DFL_LISTEN_PORT         "5556"
-#define DFL_PACK                0
+#    define DFL_SERVER_ADDR "localhost"
+#    define DFL_SERVER_PORT "4433"
+#    define DFL_LISTEN_ADDR "localhost"
+#    define DFL_LISTEN_PORT "5556"
+#    define DFL_PACK        0
 
-#if defined(MBEDTLS_TIMING_C)
-#define USAGE_PACK                                                          \
-    "    pack=%%d             default: 0     (don't pack)\n"                \
-    "                         options: t > 0 (pack for t milliseconds)\n"
-#else
-#define USAGE_PACK
-#endif
+#    if defined(MBEDTLS_TIMING_C)
+#        define USAGE_PACK                                           \
+            "    pack=%%d             default: 0     (don't pack)\n" \
+            "                         options: t > 0 (pack for t milliseconds)\n"
+#    else
+#        define USAGE_PACK
+#    endif
 
-#define USAGE                                                               \
-    "\n usage: udp_proxy param=<>...\n"                                     \
-    "\n acceptable parameters:\n"                                           \
-    "    server_addr=%%s      default: localhost\n"                         \
-    "    server_port=%%d      default: 4433\n"                              \
-    "    listen_addr=%%s      default: localhost\n"                         \
-    "    listen_port=%%d      default: 4433\n"                              \
-    "\n"                                                                    \
-    "    duplicate=%%d        default: 0 (no duplication)\n"                \
-    "                        duplicate about 1:N packets randomly\n"        \
-    "    delay=%%d            default: 0 (no delayed packets)\n"            \
-    "                        delay about 1:N packets randomly\n"            \
-    "    delay_ccs=0/1       default: 0 (don't delay ChangeCipherSpec)\n"   \
-    "    delay_cli=%%s        Handshake message from client that should be\n"\
-    "                        delayed. Possible values are 'ClientHello',\n" \
-    "                        'Certificate', 'CertificateVerify', and\n"     \
-    "                        'ClientKeyExchange'.\n"                        \
-    "                        May be used multiple times, even for the same\n"\
-    "                        message, in which case the respective message\n"\
-    "                        gets delayed multiple times.\n"                 \
-    "    delay_srv=%%s        Handshake message from server that should be\n"\
-    "                        delayed. Possible values are 'HelloRequest',\n"\
-    "                        'ServerHello', 'ServerHelloDone', 'Certificate'\n"\
-    "                        'ServerKeyExchange', 'NewSessionTicket',\n"\
-    "                        'HelloVerifyRequest' and ''CertificateRequest'.\n"\
-    "                        May be used multiple times, even for the same\n"\
-    "                        message, in which case the respective message\n"\
-    "                        gets delayed multiple times.\n"                 \
-    "    drop=%%d             default: 0 (no dropped packets)\n"            \
-    "                        drop about 1:N packets randomly\n"             \
-    "    mtu=%%d              default: 0 (unlimited)\n"                     \
-    "                        drop packets larger than N bytes\n"            \
-    "    bad_ad=0/1          default: 0 (don't add bad ApplicationData)\n"  \
-    "    bad_cid=%%d          default: 0 (don't corrupt Connection IDs)\n"   \
-    "                        duplicate 1:N packets containing a CID,\n" \
-    "                        modifying CID in first instance of the packet.\n" \
-    "    protect_hvr=0/1     default: 0 (don't protect HelloVerifyRequest)\n" \
-    "    protect_len=%%d      default: (don't protect packets of this size)\n" \
-    "    inject_clihlo=0/1   default: 0 (don't inject fake ClientHello)\n"  \
-    "\n"                                                                    \
-    "    seed=%%d             default: (use current time)\n"                \
-    USAGE_PACK                                                              \
-    "\n"
+#    define USAGE                                                                   \
+        "\n usage: udp_proxy param=<>...\n"                                         \
+        "\n acceptable parameters:\n"                                               \
+        "    server_addr=%%s      default: localhost\n"                             \
+        "    server_port=%%d      default: 4433\n"                                  \
+        "    listen_addr=%%s      default: localhost\n"                             \
+        "    listen_port=%%d      default: 4433\n"                                  \
+        "\n"                                                                        \
+        "    duplicate=%%d        default: 0 (no duplication)\n"                    \
+        "                        duplicate about 1:N packets randomly\n"            \
+        "    delay=%%d            default: 0 (no delayed packets)\n"                \
+        "                        delay about 1:N packets randomly\n"                \
+        "    delay_ccs=0/1       default: 0 (don't delay ChangeCipherSpec)\n"       \
+        "    delay_cli=%%s        Handshake message from client that should be\n"   \
+        "                        delayed. Possible values are 'ClientHello',\n"     \
+        "                        'Certificate', 'CertificateVerify', and\n"         \
+        "                        'ClientKeyExchange'.\n"                            \
+        "                        May be used multiple times, even for the same\n"   \
+        "                        message, in which case the respective message\n"   \
+        "                        gets delayed multiple times.\n"                    \
+        "    delay_srv=%%s        Handshake message from server that should be\n"   \
+        "                        delayed. Possible values are 'HelloRequest',\n"    \
+        "                        'ServerHello', 'ServerHelloDone', 'Certificate'\n" \
+        "                        'ServerKeyExchange', 'NewSessionTicket',\n"        \
+        "                        'HelloVerifyRequest' and ''CertificateRequest'.\n" \
+        "                        May be used multiple times, even for the same\n"   \
+        "                        message, in which case the respective message\n"   \
+        "                        gets delayed multiple times.\n"                    \
+        "    drop=%%d             default: 0 (no dropped packets)\n"                \
+        "                        drop about 1:N packets randomly\n"                 \
+        "    mtu=%%d              default: 0 (unlimited)\n"                         \
+        "                        drop packets larger than N bytes\n"                \
+        "    bad_ad=0/1          default: 0 (don't add bad ApplicationData)\n"      \
+        "    bad_cid=%%d          default: 0 (don't corrupt Connection IDs)\n"      \
+        "                        duplicate 1:N packets containing a CID,\n"         \
+        "                        modifying CID in first instance of the packet.\n"  \
+        "    protect_hvr=0/1     default: 0 (don't protect HelloVerifyRequest)\n"   \
+        "    protect_len=%%d      default: (don't protect packets of this size)\n"  \
+        "    inject_clihlo=0/1   default: 0 (don't inject fake ClientHello)\n"      \
+        "\n"                                                                        \
+        "    seed=%%d             default: (use current time)\n" USAGE_PACK         \
+        "\n"
 
 /*
  * global options
  */
 
-#define MAX_DELAYED_HS 10
+#    define MAX_DELAYED_HS 10
 
-static struct options
-{
-    const char *server_addr;    /* address to forward packets to            */
-    const char *server_port;    /* port to forward packets to               */
-    const char *listen_addr;    /* address for accepting client connections */
-    const char *listen_port;    /* port for accepting client connections    */
+static struct options {
+    const char *server_addr; /* address to forward packets to            */
+    const char *server_port; /* port to forward packets to               */
+    const char *listen_addr; /* address for accepting client connections */
+    const char *listen_port; /* port for accepting client connections    */
 
-    int duplicate;              /* duplicate 1 in N packets (none if 0)     */
-    int delay;                  /* delay 1 packet in N (none if 0)          */
-    int delay_ccs;              /* delay ChangeCipherSpec                   */
-    char* delay_cli[MAX_DELAYED_HS];  /* handshake types of messages from
-                                       * client that should be delayed.     */
-    uint8_t delay_cli_cnt;      /* Number of entries in delay_cli.          */
-    char* delay_srv[MAX_DELAYED_HS];  /* handshake types of messages from
-                                       * server that should be delayed.     */
-    uint8_t delay_srv_cnt;      /* Number of entries in delay_srv.          */
-    int drop;                   /* drop 1 packet in N (none if 0)           */
-    int mtu;                    /* drop packets larger than this            */
-    int bad_ad;                 /* inject corrupted ApplicationData record  */
-    unsigned bad_cid;           /* inject corrupted CID record              */
-    int protect_hvr;            /* never drop or delay HelloVerifyRequest   */
-    int protect_len;            /* never drop/delay packet of the given size*/
-    int inject_clihlo;          /* inject fake ClientHello after handshake  */
-    unsigned pack;              /* merge packets into single datagram for
-                                 * at most \c merge milliseconds if > 0     */
-    unsigned int seed;          /* seed for "random" events                 */
+    int duplicate; /* duplicate 1 in N packets (none if 0)     */
+    int delay; /* delay 1 packet in N (none if 0)          */
+    int delay_ccs; /* delay ChangeCipherSpec                   */
+    char *delay_cli[MAX_DELAYED_HS]; /* handshake types of messages from
+                                      * client that should be delayed.     */
+    uint8_t delay_cli_cnt; /* Number of entries in delay_cli.          */
+    char *delay_srv[MAX_DELAYED_HS]; /* handshake types of messages from
+                                      * server that should be delayed.     */
+    uint8_t delay_srv_cnt; /* Number of entries in delay_srv.          */
+    int drop; /* drop 1 packet in N (none if 0)           */
+    int mtu; /* drop packets larger than this            */
+    int bad_ad; /* inject corrupted ApplicationData record  */
+    unsigned bad_cid; /* inject corrupted CID record              */
+    int protect_hvr; /* never drop or delay HelloVerifyRequest   */
+    int protect_len; /* never drop/delay packet of the given size*/
+    int inject_clihlo; /* inject fake ClientHello after handshake  */
+    unsigned pack; /* merge packets into single datagram for
+                    * at most \c merge milliseconds if > 0     */
+    unsigned int seed; /* seed for "random" events                 */
 } opt;
 
-static void exit_usage( const char *name, const char *value )
+static void exit_usage(const char *name, const char *value)
 {
-    if( value == NULL )
-        mbedtls_printf( " unknown option or missing value: %s\n", name );
+    if (value == NULL)
+        mbedtls_printf(" unknown option or missing value: %s\n", name);
     else
-        mbedtls_printf( " option %s: illegal value: %s\n", name, value );
+        mbedtls_printf(" option %s: illegal value: %s\n", name, value);
 
-    mbedtls_printf( USAGE );
-    mbedtls_exit( 1 );
+    mbedtls_printf(USAGE);
+    mbedtls_exit(1);
 }
 
-static void get_options( int argc, char *argv[] )
+static void get_options(int argc, char *argv[])
 {
     int i;
     char *p, *q;
 
-    opt.server_addr    = DFL_SERVER_ADDR;
-    opt.server_port    = DFL_SERVER_PORT;
-    opt.listen_addr    = DFL_LISTEN_ADDR;
-    opt.listen_port    = DFL_LISTEN_PORT;
-    opt.pack           = DFL_PACK;
+    opt.server_addr = DFL_SERVER_ADDR;
+    opt.server_port = DFL_SERVER_PORT;
+    opt.listen_addr = DFL_LISTEN_ADDR;
+    opt.listen_port = DFL_LISTEN_PORT;
+    opt.pack = DFL_PACK;
     /* Other members default to 0 */
 
     opt.delay_cli_cnt = 0;
     opt.delay_srv_cnt = 0;
-    memset( opt.delay_cli, 0, sizeof( opt.delay_cli ) );
-    memset( opt.delay_srv, 0, sizeof( opt.delay_srv ) );
+    memset(opt.delay_cli, 0, sizeof(opt.delay_cli));
+    memset(opt.delay_srv, 0, sizeof(opt.delay_srv));
 
-    for( i = 1; i < argc; i++ )
-    {
+    for (i = 1; i < argc; i++) {
         p = argv[i];
-        if( ( q = strchr( p, '=' ) ) == NULL )
-            exit_usage( p, NULL );
+        if ((q = strchr(p, '=')) == NULL)
+            exit_usage(p, NULL);
         *q++ = '\0';
 
-        if( strcmp( p, "server_addr" ) == 0 )
+        if (strcmp(p, "server_addr") == 0)
             opt.server_addr = q;
-        else if( strcmp( p, "server_port" ) == 0 )
+        else if (strcmp(p, "server_port") == 0)
             opt.server_port = q;
-        else if( strcmp( p, "listen_addr" ) == 0 )
+        else if (strcmp(p, "listen_addr") == 0)
             opt.listen_addr = q;
-        else if( strcmp( p, "listen_port" ) == 0 )
+        else if (strcmp(p, "listen_port") == 0)
             opt.listen_port = q;
-        else if( strcmp( p, "duplicate" ) == 0 )
-        {
-            opt.duplicate = atoi( q );
-            if( opt.duplicate < 0 || opt.duplicate > 20 )
-                exit_usage( p, q );
-        }
-        else if( strcmp( p, "delay" ) == 0 )
-        {
-            opt.delay = atoi( q );
-            if( opt.delay < 0 || opt.delay > 20 || opt.delay == 1 )
-                exit_usage( p, q );
-        }
-        else if( strcmp( p, "delay_ccs" ) == 0 )
-        {
-            opt.delay_ccs = atoi( q );
-            if( opt.delay_ccs < 0 || opt.delay_ccs > 1 )
-                exit_usage( p, q );
-        }
-        else if( strcmp( p, "delay_cli" ) == 0 ||
-                 strcmp( p, "delay_srv" ) == 0 )
-        {
+        else if (strcmp(p, "duplicate") == 0) {
+            opt.duplicate = atoi(q);
+            if (opt.duplicate < 0 || opt.duplicate > 20)
+                exit_usage(p, q);
+        } else if (strcmp(p, "delay") == 0) {
+            opt.delay = atoi(q);
+            if (opt.delay < 0 || opt.delay > 20 || opt.delay == 1)
+                exit_usage(p, q);
+        } else if (strcmp(p, "delay_ccs") == 0) {
+            opt.delay_ccs = atoi(q);
+            if (opt.delay_ccs < 0 || opt.delay_ccs > 1)
+                exit_usage(p, q);
+        } else if (strcmp(p, "delay_cli") == 0 || strcmp(p, "delay_srv") == 0) {
             uint8_t *delay_cnt;
             char **delay_list;
             size_t len;
             char *buf;
 
-            if( strcmp( p, "delay_cli" ) == 0 )
-            {
-                delay_cnt  = &opt.delay_cli_cnt;
+            if (strcmp(p, "delay_cli") == 0) {
+                delay_cnt = &opt.delay_cli_cnt;
                 delay_list = opt.delay_cli;
-            }
-            else
-            {
-                delay_cnt  = &opt.delay_srv_cnt;
+            } else {
+                delay_cnt = &opt.delay_srv_cnt;
                 delay_list = opt.delay_srv;
             }
 
-            if( *delay_cnt == MAX_DELAYED_HS )
-            {
-                mbedtls_printf( " too many uses of %s: only %d allowed\n",
-                                p, MAX_DELAYED_HS );
-                exit_usage( p, NULL );
+            if (*delay_cnt == MAX_DELAYED_HS) {
+                mbedtls_printf(" too many uses of %s: only %d allowed\n", p,
+                               MAX_DELAYED_HS);
+                exit_usage(p, NULL);
             }
 
-            len = strlen( q );
-            buf = mbedtls_calloc( 1, len + 1 );
-            if( buf == NULL )
-            {
-                mbedtls_printf( " Allocation failure\n" );
-                exit( 1 );
+            len = strlen(q);
+            buf = mbedtls_calloc(1, len + 1);
+            if (buf == NULL) {
+                mbedtls_printf(" Allocation failure\n");
+                exit(1);
             }
-            memcpy( buf, q, len + 1 );
+            memcpy(buf, q, len + 1);
 
-            delay_list[ (*delay_cnt)++ ] = buf;
+            delay_list[(*delay_cnt)++] = buf;
+        } else if (strcmp(p, "drop") == 0) {
+            opt.drop = atoi(q);
+            if (opt.drop < 0 || opt.drop > 20 || opt.drop == 1)
+                exit_usage(p, q);
+        } else if (strcmp(p, "pack") == 0) {
+#    if defined(MBEDTLS_TIMING_C)
+            opt.pack = (unsigned)atoi(q);
+#    else
+            mbedtls_printf(
+                " option pack only defined if MBEDTLS_TIMING_C is enabled\n");
+            exit(1);
+#    endif
+        } else if (strcmp(p, "mtu") == 0) {
+            opt.mtu = atoi(q);
+            if (opt.mtu < 0 || opt.mtu > MAX_MSG_SIZE)
+                exit_usage(p, q);
+        } else if (strcmp(p, "bad_ad") == 0) {
+            opt.bad_ad = atoi(q);
+            if (opt.bad_ad < 0 || opt.bad_ad > 1)
+                exit_usage(p, q);
         }
-        else if( strcmp( p, "drop" ) == 0 )
-        {
-            opt.drop = atoi( q );
-            if( opt.drop < 0 || opt.drop > 20 || opt.drop == 1 )
-                exit_usage( p, q );
+#    if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
+        else if (strcmp(p, "bad_cid") == 0) {
+            opt.bad_cid = (unsigned)atoi(q);
         }
-        else if( strcmp( p, "pack" ) == 0 )
-        {
-#if defined(MBEDTLS_TIMING_C)
-            opt.pack = (unsigned) atoi( q );
-#else
-            mbedtls_printf( " option pack only defined if MBEDTLS_TIMING_C is enabled\n" );
-            exit( 1 );
-#endif
-        }
-        else if( strcmp( p, "mtu" ) == 0 )
-        {
-            opt.mtu = atoi( q );
-            if( opt.mtu < 0 || opt.mtu > MAX_MSG_SIZE )
-                exit_usage( p, q );
-        }
-        else if( strcmp( p, "bad_ad" ) == 0 )
-        {
-            opt.bad_ad = atoi( q );
-            if( opt.bad_ad < 0 || opt.bad_ad > 1 )
-                exit_usage( p, q );
-        }
-#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
-        else if( strcmp( p, "bad_cid" ) == 0 )
-        {
-            opt.bad_cid = (unsigned) atoi( q );
-        }
-#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
-        else if( strcmp( p, "protect_hvr" ) == 0 )
-        {
-            opt.protect_hvr = atoi( q );
-            if( opt.protect_hvr < 0 || opt.protect_hvr > 1 )
-                exit_usage( p, q );
-        }
-        else if( strcmp( p, "protect_len" ) == 0 )
-        {
-            opt.protect_len = atoi( q );
-            if( opt.protect_len < 0 )
-                exit_usage( p, q );
-        }
-        else if( strcmp( p, "inject_clihlo" ) == 0 )
-        {
-            opt.inject_clihlo = atoi( q );
-            if( opt.inject_clihlo < 0 || opt.inject_clihlo > 1 )
-                exit_usage( p, q );
-        }
-        else if( strcmp( p, "seed" ) == 0 )
-        {
-            opt.seed = atoi( q );
-            if( opt.seed == 0 )
-                exit_usage( p, q );
-        }
-        else
-            exit_usage( p, NULL );
+#    endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
+        else if (strcmp(p, "protect_hvr") == 0) {
+            opt.protect_hvr = atoi(q);
+            if (opt.protect_hvr < 0 || opt.protect_hvr > 1)
+                exit_usage(p, q);
+        } else if (strcmp(p, "protect_len") == 0) {
+            opt.protect_len = atoi(q);
+            if (opt.protect_len < 0)
+                exit_usage(p, q);
+        } else if (strcmp(p, "inject_clihlo") == 0) {
+            opt.inject_clihlo = atoi(q);
+            if (opt.inject_clihlo < 0 || opt.inject_clihlo > 1)
+                exit_usage(p, q);
+        } else if (strcmp(p, "seed") == 0) {
+            opt.seed = atoi(q);
+            if (opt.seed == 0)
+                exit_usage(p, q);
+        } else
+            exit_usage(p, NULL);
     }
 }
 
-static const char *msg_type( unsigned char *msg, size_t len )
+static const char *msg_type(unsigned char *msg, size_t len)
 {
-    if( len < 1 )                           return "Invalid" ;
-    switch( msg[0] )
-    {
-        case MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC:    return "ChangeCipherSpec" ;
-        case MBEDTLS_SSL_MSG_ALERT:                 return "Alert" ;
-        case MBEDTLS_SSL_MSG_APPLICATION_DATA:      return "ApplicationData" ;
-        case MBEDTLS_SSL_MSG_CID:                   return "CID" ;
-        case MBEDTLS_SSL_MSG_HANDSHAKE:             break; /* See below */
-        default:                            return "Unknown" ;
+    if (len < 1)
+        return "Invalid";
+    switch (msg[0]) {
+        case MBEDTLS_SSL_MSG_CHANGE_CIPHER_SPEC:
+            return "ChangeCipherSpec";
+        case MBEDTLS_SSL_MSG_ALERT:
+            return "Alert";
+        case MBEDTLS_SSL_MSG_APPLICATION_DATA:
+            return "ApplicationData";
+        case MBEDTLS_SSL_MSG_CID:
+            return "CID";
+        case MBEDTLS_SSL_MSG_HANDSHAKE:
+            break; /* See below */
+        default:
+            return "Unknown";
     }
 
-    if( len < 13 + 12 )                     return "Invalid handshake" ;
+    if (len < 13 + 12)
+        return "Invalid handshake";
 
     /*
      * Our handshake message are less than 2^16 bytes long, so they should
      * have 0 as the first byte of length, frag_offset and frag_length.
      * Otherwise, assume they are encrypted.
      */
-    if( msg[14] || msg[19] || msg[22] )     return "Encrypted handshake" ;
+    if (msg[14] || msg[19] || msg[22])
+        return "Encrypted handshake";
 
-    switch( msg[13] )
-    {
-        case MBEDTLS_SSL_HS_HELLO_REQUEST:          return "HelloRequest" ;
-        case MBEDTLS_SSL_HS_CLIENT_HELLO:           return "ClientHello" ;
-        case MBEDTLS_SSL_HS_SERVER_HELLO:           return "ServerHello" ;
-        case MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST:   return "HelloVerifyRequest" ;
-        case MBEDTLS_SSL_HS_NEW_SESSION_TICKET:     return "NewSessionTicket" ;
-        case MBEDTLS_SSL_HS_CERTIFICATE:            return "Certificate" ;
-        case MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE:    return "ServerKeyExchange" ;
-        case MBEDTLS_SSL_HS_CERTIFICATE_REQUEST:    return "CertificateRequest" ;
-        case MBEDTLS_SSL_HS_SERVER_HELLO_DONE:      return "ServerHelloDone" ;
-        case MBEDTLS_SSL_HS_CERTIFICATE_VERIFY:     return "CertificateVerify" ;
-        case MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE:    return "ClientKeyExchange" ;
-        case MBEDTLS_SSL_HS_FINISHED:               return "Finished" ;
-        default:                            return "Unknown handshake" ;
+    switch (msg[13]) {
+        case MBEDTLS_SSL_HS_HELLO_REQUEST:
+            return "HelloRequest";
+        case MBEDTLS_SSL_HS_CLIENT_HELLO:
+            return "ClientHello";
+        case MBEDTLS_SSL_HS_SERVER_HELLO:
+            return "ServerHello";
+        case MBEDTLS_SSL_HS_HELLO_VERIFY_REQUEST:
+            return "HelloVerifyRequest";
+        case MBEDTLS_SSL_HS_NEW_SESSION_TICKET:
+            return "NewSessionTicket";
+        case MBEDTLS_SSL_HS_CERTIFICATE:
+            return "Certificate";
+        case MBEDTLS_SSL_HS_SERVER_KEY_EXCHANGE:
+            return "ServerKeyExchange";
+        case MBEDTLS_SSL_HS_CERTIFICATE_REQUEST:
+            return "CertificateRequest";
+        case MBEDTLS_SSL_HS_SERVER_HELLO_DONE:
+            return "ServerHelloDone";
+        case MBEDTLS_SSL_HS_CERTIFICATE_VERIFY:
+            return "CertificateVerify";
+        case MBEDTLS_SSL_HS_CLIENT_KEY_EXCHANGE:
+            return "ClientKeyExchange";
+        case MBEDTLS_SSL_HS_FINISHED:
+            return "Finished";
+        default:
+            return "Unknown handshake";
     }
 }
 
-#if defined(MBEDTLS_TIMING_C)
+#    if defined(MBEDTLS_TIMING_C)
 /* Return elapsed time in milliseconds since the first call */
-static unsigned ellapsed_time( void )
+static unsigned ellapsed_time(void)
 {
     static int initialized = 0;
     static struct mbedtls_timing_hr_time hires;
 
-    if( initialized == 0 )
-    {
-        (void) mbedtls_timing_get_timer( &hires, 1 );
+    if (initialized == 0) {
+        (void)mbedtls_timing_get_timer(&hires, 1);
         initialized = 1;
-        return 0 ;
+        return 0;
     }
 
-    return mbedtls_timing_get_timer( &hires, 0 ) ;
+    return mbedtls_timing_get_timer(&hires, 0);
 }
 
-typedef struct
-{
+typedef struct {
     mbedtls_net_context *ctx;
 
     const char *description;
@@ -403,102 +389,94 @@
 
 static ctx_buffer outbuf[2];
 
-static int ctx_buffer_flush( ctx_buffer *buf )
+static int ctx_buffer_flush(ctx_buffer *buf)
 {
     int ret;
 
-    mbedtls_printf( "  %05u flush    %s: %u bytes, %u datagrams, last %u ms\n",
-                    ellapsed_time(), buf->description,
-                    (unsigned) buf->len, buf->num_datagrams,
-                    ellapsed_time() - buf->packet_lifetime );
+    mbedtls_printf("  %05u flush    %s: %u bytes, %u datagrams, last %u ms\n",
+                   ellapsed_time(), buf->description, (unsigned)buf->len,
+                   buf->num_datagrams, ellapsed_time() - buf->packet_lifetime);
 
-    ret = mbedtls_net_send( buf->ctx, buf->data, buf->len );
+    ret = mbedtls_net_send(buf->ctx, buf->data, buf->len);
 
-    buf->len           = 0;
+    buf->len = 0;
     buf->num_datagrams = 0;
 
-    return ret ;
+    return ret;
 }
 
-static unsigned ctx_buffer_time_remaining( ctx_buffer *buf )
+static unsigned ctx_buffer_time_remaining(ctx_buffer *buf)
 {
     unsigned const cur_time = ellapsed_time();
 
-    if( buf->num_datagrams == 0 )
-        return (unsigned) -1 ;
+    if (buf->num_datagrams == 0)
+        return (unsigned)-1;
 
-    if( cur_time - buf->packet_lifetime >= opt.pack )
-        return 0 ;
+    if (cur_time - buf->packet_lifetime >= opt.pack)
+        return 0;
 
-    return opt.pack - ( cur_time - buf->packet_lifetime ) ;
+    return opt.pack - (cur_time - buf->packet_lifetime);
 }
 
-static int ctx_buffer_append( ctx_buffer *buf,
-                              const unsigned char * data,
-                              size_t len )
+static int
+ctx_buffer_append(ctx_buffer *buf, const unsigned char *data, size_t len)
 {
     int ret;
 
-    if( len > (size_t) INT_MAX )
-        return -1 ;
+    if (len > (size_t)INT_MAX)
+        return -1;
 
-    if( len > sizeof( buf->data ) )
-    {
-        mbedtls_printf( "  ! buffer size %u too large (max %u)\n",
-                        (unsigned) len, (unsigned) sizeof( buf->data ) );
-        return -1 ;
+    if (len > sizeof(buf->data)) {
+        mbedtls_printf("  ! buffer size %u too large (max %u)\n", (unsigned)len,
+                       (unsigned)sizeof(buf->data));
+        return -1;
     }
 
-    if( sizeof( buf->data ) - buf->len < len )
-    {
-        if( ( ret = ctx_buffer_flush( buf ) ) <= 0 )
-        {
-            mbedtls_printf( "ctx_buffer_flush failed with -%#04x", (unsigned int) -ret );
-            return ret ;
+    if (sizeof(buf->data) - buf->len < len) {
+        if ((ret = ctx_buffer_flush(buf)) <= 0) {
+            mbedtls_printf("ctx_buffer_flush failed with -%#04x",
+                           (unsigned int)-ret);
+            return ret;
         }
     }
 
-    memcpy( buf->data + buf->len, data, len );
+    memcpy(buf->data + buf->len, data, len);
 
     buf->len += len;
-    if( ++buf->num_datagrams == 1 )
+    if (++buf->num_datagrams == 1)
         buf->packet_lifetime = ellapsed_time();
 
-    return (int) len ;
+    return (int)len;
 }
-#endif /* MBEDTLS_TIMING_C */
+#    endif /* MBEDTLS_TIMING_C */
 
-static int dispatch_data( mbedtls_net_context *ctx,
-                          const unsigned char * data,
-                          size_t len )
+static int
+dispatch_data(mbedtls_net_context *ctx, const unsigned char *data, size_t len)
 {
     int ret;
-#if defined(MBEDTLS_TIMING_C)
+#    if defined(MBEDTLS_TIMING_C)
     ctx_buffer *buf = NULL;
-    if( opt.pack > 0 )
-    {
-        if( outbuf[0].ctx == ctx )
+    if (opt.pack > 0) {
+        if (outbuf[0].ctx == ctx)
             buf = &outbuf[0];
-        else if( outbuf[1].ctx == ctx )
+        else if (outbuf[1].ctx == ctx)
             buf = &outbuf[1];
 
-        if( buf == NULL )
-            return -1 ;
+        if (buf == NULL)
+            return -1;
 
-        return ctx_buffer_append( buf, data, len ) ;
+        return ctx_buffer_append(buf, data, len);
     }
-#endif /* MBEDTLS_TIMING_C */
+#    endif /* MBEDTLS_TIMING_C */
 
-    ret = mbedtls_net_send( ctx, data, len );
-    if( ret < 0 )
-    {
-        mbedtls_printf( "net_send returned -%#04x\n", (unsigned int) -ret );
+    ret = mbedtls_net_send(ctx, data, len);
+    if (ret < 0) {
+        mbedtls_printf("net_send returned -%#04x\n", (unsigned int)-ret);
     }
-    return ret ;
+    return ret;
 }
 
-typedef struct
-{
+typedef struct {
     mbedtls_net_context *dst;
     const char *way;
     const char *type;
@@ -507,25 +485,25 @@
 } packet;
 
 /* Print packet. Outgoing packets come with a reason (forward, dupl, etc.) */
-void print_packet( const packet *p, const char *why )
+void print_packet(const packet *p, const char *why)
 {
-#if defined(MBEDTLS_TIMING_C)
-    if( why == NULL )
-        mbedtls_printf( "  %05u dispatch %s %s (%u bytes)\n",
-                ellapsed_time(), p->way, p->type, p->len );
+#    if defined(MBEDTLS_TIMING_C)
+    if (why == NULL)
+        mbedtls_printf("  %05u dispatch %s %s (%u bytes)\n", ellapsed_time(),
+                       p->way, p->type, p->len);
     else
-        mbedtls_printf( "  %05u dispatch %s %s (%u bytes): %s\n",
-                ellapsed_time(), p->way, p->type, p->len, why );
-#else
-    if( why == NULL )
-        mbedtls_printf( "        dispatch %s %s (%u bytes)\n",
-                p->way, p->type, p->len );
+        mbedtls_printf("  %05u dispatch %s %s (%u bytes): %s\n",
+                       ellapsed_time(), p->way, p->type, p->len, why);
+#    else
+    if (why == NULL)
+        mbedtls_printf("        dispatch %s %s (%u bytes)\n", p->way, p->type,
+                       p->len);
     else
-        mbedtls_printf( "        dispatch %s %s (%u bytes): %s\n",
-                p->way, p->type, p->len, why );
-#endif
+        mbedtls_printf("        dispatch %s %s (%u bytes): %s\n", p->way,
+                       p->type, p->len, why);
+#    endif
 
-    fflush( stdout );
+    fflush(stdout);
 }
 
 /*
@@ -540,144 +518,126 @@
  *
  * We want an explicit state and a place to store the packet.
  */
-typedef enum {
-    ICH_INIT,       /* haven't seen the first ClientHello yet */
-    ICH_CACHED,     /* cached the initial ClientHello */
-    ICH_INJECTED,   /* ClientHello already injected, done */
+typedef enum
+{
+    ICH_INIT, /* haven't seen the first ClientHello yet */
+    ICH_CACHED, /* cached the initial ClientHello */
+    ICH_INJECTED, /* ClientHello already injected, done */
 } inject_clihlo_state_t;
 
 static inject_clihlo_state_t inject_clihlo_state;
 static packet initial_clihlo;
 
-int send_packet( const packet *p, const char *why )
+int send_packet(const packet *p, const char *why)
 {
     int ret;
     mbedtls_net_context *dst = p->dst;
 
     /* save initial ClientHello? */
-    if( opt.inject_clihlo != 0 &&
-        inject_clihlo_state == ICH_INIT &&
-        strcmp( p->type, "ClientHello" ) == 0 )
-    {
-        memcpy( &initial_clihlo, p, sizeof( packet ) );
+    if (opt.inject_clihlo != 0 && inject_clihlo_state == ICH_INIT &&
+        strcmp(p->type, "ClientHello") == 0) {
+        memcpy(&initial_clihlo, p, sizeof(packet));
         inject_clihlo_state = ICH_CACHED;
     }
 
     /* insert corrupted CID record? */
-    if( opt.bad_cid != 0 &&
-        strcmp( p->type, "CID" ) == 0 &&
-        ( rand() % opt.bad_cid ) == 0 )
-    {
+    if (opt.bad_cid != 0 && strcmp(p->type, "CID") == 0 &&
+        (rand() % opt.bad_cid) == 0) {
         unsigned char buf[MAX_MSG_SIZE];
-        memcpy( buf, p->buf, p->len );
+        memcpy(buf, p->buf, p->len);
 
         /* The CID resides at offset 11 in the DTLS record header. */
         buf[11] ^= 1;
-        print_packet( p, "modified CID" );
+        print_packet(p, "modified CID");
 
-        if( ( ret = dispatch_data( dst, buf, p->len ) ) <= 0 )
-        {
-            mbedtls_printf( "  ! dispatch returned %d\n", ret );
-            return ret ;
+        if ((ret = dispatch_data(dst, buf, p->len)) <= 0) {
+            mbedtls_printf("  ! dispatch returned %d\n", ret);
+            return ret;
         }
     }
 
     /* insert corrupted ApplicationData record? */
-    if( opt.bad_ad &&
-        strcmp( p->type, "ApplicationData" ) == 0 )
-    {
+    if (opt.bad_ad && strcmp(p->type, "ApplicationData") == 0) {
         unsigned char buf[MAX_MSG_SIZE];
-        memcpy( buf, p->buf, p->len );
+        memcpy(buf, p->buf, p->len);
 
-        if( p->len <= 13 )
-        {
-            mbedtls_printf( "  ! can't corrupt empty AD record" );
-        }
-        else
-        {
+        if (p->len <= 13) {
+            mbedtls_printf("  ! can't corrupt empty AD record");
+        } else {
             ++buf[13];
-            print_packet( p, "corrupted" );
+            print_packet(p, "corrupted");
         }
 
-        if( ( ret = dispatch_data( dst, buf, p->len ) ) <= 0 )
-        {
-            mbedtls_printf( "  ! dispatch returned %d\n", ret );
-            return ret ;
+        if ((ret = dispatch_data(dst, buf, p->len)) <= 0) {
+            mbedtls_printf("  ! dispatch returned %d\n", ret);
+            return ret;
         }
     }
 
-    print_packet( p, why );
-    if( ( ret = dispatch_data( dst, p->buf, p->len ) ) <= 0 )
-    {
-        mbedtls_printf( "  ! dispatch returned %d\n", ret );
-        return ret ;
+    print_packet(p, why);
+    if ((ret = dispatch_data(dst, p->buf, p->len)) <= 0) {
+        mbedtls_printf("  ! dispatch returned %d\n", ret);
+        return ret;
     }
 
     /* Don't duplicate Application Data, only handshake covered */
-    if( opt.duplicate != 0 &&
-        strcmp( p->type, "ApplicationData" ) != 0 &&
-        rand() % opt.duplicate == 0 )
-    {
-        print_packet( p, "duplicated" );
+    if (opt.duplicate != 0 && strcmp(p->type, "ApplicationData") != 0 &&
+        rand() % opt.duplicate == 0) {
+        print_packet(p, "duplicated");
 
-        if( ( ret = dispatch_data( dst, p->buf, p->len ) ) <= 0 )
-        {
-            mbedtls_printf( "  ! dispatch returned %d\n", ret );
-            return ret ;
+        if ((ret = dispatch_data(dst, p->buf, p->len)) <= 0) {
+            mbedtls_printf("  ! dispatch returned %d\n", ret);
+            return ret;
         }
     }
 
     /* Inject ClientHello after first ApplicationData */
-    if( opt.inject_clihlo != 0 &&
-        inject_clihlo_state == ICH_CACHED &&
-        strcmp( p->type, "ApplicationData" ) == 0 )
-    {
-        print_packet( &initial_clihlo, "injected" );
+    if (opt.inject_clihlo != 0 && inject_clihlo_state == ICH_CACHED &&
+        strcmp(p->type, "ApplicationData") == 0) {
+        print_packet(&initial_clihlo, "injected");
 
-        if( ( ret = dispatch_data( dst, initial_clihlo.buf,
-                                        initial_clihlo.len ) ) <= 0 )
-        {
-            mbedtls_printf( "  ! dispatch returned %d\n", ret );
-            return ret ;
+        if ((ret = dispatch_data(dst, initial_clihlo.buf,
+                                 initial_clihlo.len)) <= 0) {
+            mbedtls_printf("  ! dispatch returned %d\n", ret);
+            return ret;
         }
 
         inject_clihlo_state = ICH_INJECTED;
     }
 
-    return 0 ;
+    return 0;
 }
 
-#define MAX_DELAYED_MSG 5
+#    define MAX_DELAYED_MSG 5
 static size_t prev_len;
 static packet prev[MAX_DELAYED_MSG];
 
-void clear_pending( void )
+void clear_pending(void)
 {
-    memset( &prev, 0, sizeof( prev ) );
+    memset(&prev, 0, sizeof(prev));
     prev_len = 0;
 }
 
-void delay_packet( packet *delay )
+void delay_packet(packet *delay)
 {
-    if( prev_len == MAX_DELAYED_MSG )
+    if (prev_len == MAX_DELAYED_MSG)
         return;
 
-    memcpy( &prev[prev_len++], delay, sizeof( packet ) );
+    memcpy(&prev[prev_len++], delay, sizeof(packet));
 }
 
 int send_delayed()
 {
     uint8_t offset;
     int ret;
-    for( offset = 0; offset < prev_len; offset++ )
-    {
-        ret = send_packet( &prev[offset], "delayed" );
-        if( ret != 0 )
-            return ret ;
+    for (offset = 0; offset < prev_len; offset++) {
+        ret = send_packet(&prev[offset], "delayed");
+        if (ret != 0)
+            return ret;
     }
 
     clear_pending();
-    return 0 ;
+    return 0;
 }
 
 /*
@@ -695,110 +655,93 @@
  * HOLD_MAX + 1 times.
  */
 static unsigned char held[2048] = { 0 };
-#define HOLD_MAX 2
+#    define HOLD_MAX        2
 
-int handle_message( const char *way,
-                    mbedtls_net_context *dst,
-                    mbedtls_net_context *src )
+int handle_message(const char *way,
+                   mbedtls_net_context *dst,
+                   mbedtls_net_context *src)
 {
     int ret;
     packet cur;
     size_t id;
 
     uint8_t delay_idx;
-    char ** delay_list;
+    char **delay_list;
     uint8_t delay_list_len;
 
     /* receive packet */
-    if( ( ret = mbedtls_net_recv( src, cur.buf, sizeof( cur.buf ) ) ) <= 0 )
-    {
-        mbedtls_printf( "  ! mbedtls_net_recv returned %d\n", ret );
-        return ret ;
+    if ((ret = mbedtls_net_recv(src, cur.buf, sizeof(cur.buf))) <= 0) {
+        mbedtls_printf("  ! mbedtls_net_recv returned %d\n", ret);
+        return ret;
     }
 
-    cur.len  = ret;
-    cur.type = msg_type( cur.buf, cur.len );
-    cur.way  = way;
-    cur.dst  = dst;
-    print_packet( &cur, NULL );
+    cur.len = ret;
+    cur.type = msg_type(cur.buf, cur.len);
+    cur.way = way;
+    cur.dst = dst;
+    print_packet(&cur, NULL);
 
-    id = cur.len % sizeof( held );
+    id = cur.len % sizeof(held);
 
-    if( strcmp( way, "S <- C" ) == 0 )
-    {
-        delay_list     = opt.delay_cli;
+    if (strcmp(way, "S <- C") == 0) {
+        delay_list = opt.delay_cli;
         delay_list_len = opt.delay_cli_cnt;
-    }
-    else
-    {
-        delay_list     = opt.delay_srv;
+    } else {
+        delay_list = opt.delay_srv;
         delay_list_len = opt.delay_srv_cnt;
     }
 
     /* Check if message type is in the list of messages
      * that should be delayed */
-    for( delay_idx = 0; delay_idx < delay_list_len; delay_idx++ )
-    {
-        if( delay_list[ delay_idx ] == NULL )
+    for (delay_idx = 0; delay_idx < delay_list_len; delay_idx++) {
+        if (delay_list[delay_idx] == NULL)
             continue;
 
-        if( strcmp( delay_list[ delay_idx ], cur.type ) == 0 )
-        {
+        if (strcmp(delay_list[delay_idx], cur.type) == 0) {
             /* Delay message */
-            delay_packet( &cur );
+            delay_packet(&cur);
 
             /* Remove entry from list */
-            mbedtls_free( delay_list[delay_idx] );
+            mbedtls_free(delay_list[delay_idx]);
             delay_list[delay_idx] = NULL;
 
-            return 0 ;
+            return 0;
         }
     }
 
     /* do we want to drop, delay, or forward it? */
-    if( ( opt.mtu != 0 &&
-          cur.len > (unsigned) opt.mtu ) ||
-        ( opt.drop != 0 &&
-          strcmp( cur.type, "CID" ) != 0             &&
-          strcmp( cur.type, "ApplicationData" ) != 0 &&
-          ! ( opt.protect_hvr &&
-              strcmp( cur.type, "HelloVerifyRequest" ) == 0 ) &&
-          cur.len != (size_t) opt.protect_len &&
-          held[id] < HOLD_MAX &&
-          rand() % opt.drop == 0 ) )
-    {
+    if ((opt.mtu != 0 && cur.len > (unsigned)opt.mtu) ||
+        (opt.drop != 0 && strcmp(cur.type, "CID") != 0 &&
+         strcmp(cur.type, "ApplicationData") != 0 &&
+         !(opt.protect_hvr && strcmp(cur.type, "HelloVerifyRequest") == 0) &&
+         cur.len != (size_t)opt.protect_len && held[id] < HOLD_MAX &&
+         rand() % opt.drop == 0)) {
         ++held[id];
-    }
-    else if( ( opt.delay_ccs == 1 &&
-               strcmp( cur.type, "ChangeCipherSpec" ) == 0 ) ||
-             ( opt.delay != 0 &&
-               strcmp( cur.type, "CID" ) != 0             &&
-               strcmp( cur.type, "ApplicationData" ) != 0 &&
-               ! ( opt.protect_hvr &&
-                   strcmp( cur.type, "HelloVerifyRequest" ) == 0 ) &&
-               cur.len != (size_t) opt.protect_len &&
-               held[id] < HOLD_MAX &&
-               rand() % opt.delay == 0 ) )
-    {
+    } else if ((opt.delay_ccs == 1 &&
+                strcmp(cur.type, "ChangeCipherSpec") == 0) ||
+               (opt.delay != 0 && strcmp(cur.type, "CID") != 0 &&
+                strcmp(cur.type, "ApplicationData") != 0 &&
+                !(opt.protect_hvr &&
+                  strcmp(cur.type, "HelloVerifyRequest") == 0) &&
+                cur.len != (size_t)opt.protect_len && held[id] < HOLD_MAX &&
+                rand() % opt.delay == 0)) {
         ++held[id];
-        delay_packet( &cur );
-    }
-    else
-    {
+        delay_packet(&cur);
+    } else {
         /* forward and possibly duplicate */
-        if( ( ret = send_packet( &cur, "forwarded" ) ) != 0 )
-            return ret ;
+        if ((ret = send_packet(&cur, "forwarded")) != 0)
+            return ret;
 
         /* send previously delayed messages if any */
         ret = send_delayed();
-        if( ret != 0 )
-            return ret ;
+        if (ret != 0)
+            return ret;
     }
 
-    return 0 ;
+    return 0;
 }
 
-int main( int argc, char *argv[] )
+int main(int argc, char *argv[])
 {
     int ret = 1;
     int exit_code = MBEDTLS_EXIT_FAILURE;
@@ -806,20 +749,20 @@
 
     mbedtls_net_context listen_fd, client_fd, server_fd;
 
-#if defined( MBEDTLS_TIMING_C )
+#    if defined(MBEDTLS_TIMING_C)
     struct timeval tm;
-#endif
+#    endif
 
     struct timeval *tm_ptr = NULL;
 
     int nb_fds;
     fd_set read_fds;
 
-    mbedtls_net_init( &listen_fd );
-    mbedtls_net_init( &client_fd );
-    mbedtls_net_init( &server_fd );
+    mbedtls_net_init(&listen_fd);
+    mbedtls_net_init(&client_fd);
+    mbedtls_net_init(&server_fd);
 
-    get_options( argc, argv );
+    get_options(argc, argv);
 
     /*
      * Decisions to drop/delay/duplicate packets are pseudo-random: dropping
@@ -829,80 +772,75 @@
      * In order to be able to reproduce problems reliably, the seed may be
      * specified explicitly.
      */
-    if( opt.seed == 0 )
-    {
-        opt.seed = (unsigned int) time( NULL );
-        mbedtls_printf( "  . Pseudo-random seed: %u\n", opt.seed );
+    if (opt.seed == 0) {
+        opt.seed = (unsigned int)time(NULL);
+        mbedtls_printf("  . Pseudo-random seed: %u\n", opt.seed);
     }
 
-    srand( opt.seed );
+    srand(opt.seed);
 
     /*
      * 0. "Connect" to the server
      */
-    mbedtls_printf( "  . Connect to server on UDP/%s/%s ...",
-            opt.server_addr, opt.server_port );
-    fflush( stdout );
+    mbedtls_printf("  . Connect to server on UDP/%s/%s ...", opt.server_addr,
+                   opt.server_port);
+    fflush(stdout);
 
-    if( ( ret = mbedtls_net_connect( &server_fd, opt.server_addr, opt.server_port,
-                             MBEDTLS_NET_PROTO_UDP ) ) != 0 )
-    {
-        mbedtls_printf( " failed\n  ! mbedtls_net_connect returned %d\n\n", ret );
+    if ((ret = mbedtls_net_connect(&server_fd, opt.server_addr, opt.server_port,
+                                   MBEDTLS_NET_PROTO_UDP)) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_net_connect returned %d\n\n", ret);
         goto exit;
     }
 
-    mbedtls_printf( " ok\n" );
+    mbedtls_printf(" ok\n");
 
     /*
      * 1. Setup the "listening" UDP socket
      */
-    mbedtls_printf( "  . Bind on UDP/%s/%s ...",
-            opt.listen_addr, opt.listen_port );
-    fflush( stdout );
+    mbedtls_printf("  . Bind on UDP/%s/%s ...", opt.listen_addr,
+                   opt.listen_port);
+    fflush(stdout);
 
-    if( ( ret = mbedtls_net_bind( &listen_fd, opt.listen_addr, opt.listen_port,
-                          MBEDTLS_NET_PROTO_UDP ) ) != 0 )
-    {
-        mbedtls_printf( " failed\n  ! mbedtls_net_bind returned %d\n\n", ret );
+    if ((ret = mbedtls_net_bind(&listen_fd, opt.listen_addr, opt.listen_port,
+                                MBEDTLS_NET_PROTO_UDP)) != 0) {
+        mbedtls_printf(" failed\n  ! mbedtls_net_bind returned %d\n\n", ret);
         goto exit;
     }
 
-    mbedtls_printf( " ok\n" );
+    mbedtls_printf(" ok\n");
 
     /*
      * 2. Wait until a client connects
      */
 accept:
-    mbedtls_net_free( &client_fd );
+    mbedtls_net_free(&client_fd);
 
-    mbedtls_printf( "  . Waiting for a remote connection ..." );
-    fflush( stdout );
+    mbedtls_printf("  . Waiting for a remote connection ...");
+    fflush(stdout);
 
-    if( ( ret = mbedtls_net_accept( &listen_fd, &client_fd,
-                                    NULL, 0, NULL ) ) != 0 )
-    {
-        mbedtls_printf( " failed\n  ! mbedtls_net_accept returned %d\n\n", ret );
+    if ((ret = mbedtls_net_accept(&listen_fd, &client_fd, NULL, 0, NULL)) !=
+        0) {
+        mbedtls_printf(" failed\n  ! mbedtls_net_accept returned %d\n\n", ret);
         goto exit;
     }
 
-    mbedtls_printf( " ok\n" );
+    mbedtls_printf(" ok\n");
 
     /*
      * 3. Forward packets forever (kill the process to terminate it)
      */
     clear_pending();
-    memset( held, 0, sizeof( held ) );
+    memset(held, 0, sizeof(held));
 
     nb_fds = client_fd.fd;
-    if( nb_fds < server_fd.fd )
+    if (nb_fds < server_fd.fd)
         nb_fds = server_fd.fd;
-    if( nb_fds < listen_fd.fd )
+    if (nb_fds < listen_fd.fd)
         nb_fds = listen_fd.fd;
     ++nb_fds;
 
-#if defined(MBEDTLS_TIMING_C)
-    if( opt.pack > 0 )
-    {
+#    if defined(MBEDTLS_TIMING_C)
+    if (opt.pack > 0) {
         outbuf[0].ctx = &server_fd;
         outbuf[0].description = "S <- C";
         outbuf[0].num_datagrams = 0;
@@ -913,106 +851,94 @@
         outbuf[1].num_datagrams = 0;
         outbuf[1].len = 0;
     }
-#endif /* MBEDTLS_TIMING_C */
+#    endif /* MBEDTLS_TIMING_C */
 
-    while( 1 )
-    {
-#if defined(MBEDTLS_TIMING_C)
-        if( opt.pack > 0 )
-        {
+    while (1) {
+#    if defined(MBEDTLS_TIMING_C)
+        if (opt.pack > 0) {
             unsigned max_wait_server, max_wait_client, max_wait;
-            max_wait_server = ctx_buffer_time_remaining( &outbuf[0] );
-            max_wait_client = ctx_buffer_time_remaining( &outbuf[1] );
+            max_wait_server = ctx_buffer_time_remaining(&outbuf[0]);
+            max_wait_client = ctx_buffer_time_remaining(&outbuf[1]);
 
-            max_wait = (unsigned) -1;
+            max_wait = (unsigned)-1;
 
-            if( max_wait_server == 0 )
-                ctx_buffer_flush( &outbuf[0] );
+            if (max_wait_server == 0)
+                ctx_buffer_flush(&outbuf[0]);
             else
                 max_wait = max_wait_server;
 
-            if( max_wait_client == 0 )
-                ctx_buffer_flush( &outbuf[1] );
-            else
-            {
-                if( max_wait_client < max_wait )
+            if (max_wait_client == 0)
+                ctx_buffer_flush(&outbuf[1]);
+            else {
+                if (max_wait_client < max_wait)
                     max_wait = max_wait_client;
             }
 
-            if( max_wait != (unsigned) -1 )
-            {
-                tm.tv_sec  = max_wait / 1000;
-                tm.tv_usec = ( max_wait % 1000 ) * 1000;
+            if (max_wait != (unsigned)-1) {
+                tm.tv_sec = max_wait / 1000;
+                tm.tv_usec = (max_wait % 1000) * 1000;
 
                 tm_ptr = &tm;
-            }
-            else
-            {
+            } else {
                 tm_ptr = NULL;
             }
         }
-#endif /* MBEDTLS_TIMING_C */
+#    endif /* MBEDTLS_TIMING_C */
 
-        FD_ZERO( &read_fds );
-        FD_SET( server_fd.fd, &read_fds );
-        FD_SET( client_fd.fd, &read_fds );
-        FD_SET( listen_fd.fd, &read_fds );
+        FD_ZERO(&read_fds);
+        FD_SET(server_fd.fd, &read_fds);
+        FD_SET(client_fd.fd, &read_fds);
+        FD_SET(listen_fd.fd, &read_fds);
 
-        if( ( ret = select( nb_fds, &read_fds, NULL, NULL, tm_ptr ) ) < 0 )
-        {
-            perror( "select" );
+        if ((ret = select(nb_fds, &read_fds, NULL, NULL, tm_ptr)) < 0) {
+            perror("select");
             goto exit;
         }
 
-        if( FD_ISSET( listen_fd.fd, &read_fds ) )
+        if (FD_ISSET(listen_fd.fd, &read_fds))
             goto accept;
 
-        if( FD_ISSET( client_fd.fd, &read_fds ) )
-        {
-            if( ( ret = handle_message( "S <- C",
-                                        &server_fd, &client_fd ) ) != 0 )
+        if (FD_ISSET(client_fd.fd, &read_fds)) {
+            if ((ret = handle_message("S <- C", &server_fd, &client_fd)) != 0)
                 goto accept;
         }
 
-        if( FD_ISSET( server_fd.fd, &read_fds ) )
-        {
-            if( ( ret = handle_message( "S -> C",
-                                        &client_fd, &server_fd ) ) != 0 )
+        if (FD_ISSET(server_fd.fd, &read_fds)) {
+            if ((ret = handle_message("S -> C", &client_fd, &server_fd)) != 0)
                 goto accept;
         }
-
     }
 
     exit_code = MBEDTLS_EXIT_SUCCESS;
 
 exit:
 
-#ifdef MBEDTLS_ERROR_C
-    if( exit_code != MBEDTLS_EXIT_SUCCESS )
-    {
+#    ifdef MBEDTLS_ERROR_C
+    if (exit_code != MBEDTLS_EXIT_SUCCESS) {
         char error_buf[100];
-        mbedtls_strerror( ret, error_buf, 100 );
-        mbedtls_printf( "Last error was: -0x%04X - %s\n\n", (unsigned int) -ret, error_buf );
-        fflush( stdout );
+        mbedtls_strerror(ret, error_buf, 100);
+        mbedtls_printf("Last error was: -0x%04X - %s\n\n", (unsigned int)-ret,
+                       error_buf);
+        fflush(stdout);
     }
-#endif
+#    endif
 
-    for( delay_idx = 0; delay_idx < MAX_DELAYED_HS; delay_idx++ )
-    {
-        mbedtls_free( opt.delay_cli[delay_idx] );
-        mbedtls_free( opt.delay_srv[delay_idx] );
+    for (delay_idx = 0; delay_idx < MAX_DELAYED_HS; delay_idx++) {
+        mbedtls_free(opt.delay_cli[delay_idx]);
+        mbedtls_free(opt.delay_srv[delay_idx]);
     }
 
-    mbedtls_net_free( &client_fd );
-    mbedtls_net_free( &server_fd );
-    mbedtls_net_free( &listen_fd );
+    mbedtls_net_free(&client_fd);
+    mbedtls_net_free(&server_fd);
+    mbedtls_net_free(&listen_fd);
 
-#if defined(_WIN32)
-    mbedtls_printf( "  Press Enter to exit this program.\n" );
-    fflush( stdout ); getchar();
-#endif
+#    if defined(_WIN32)
+    mbedtls_printf("  Press Enter to exit this program.\n");
+    fflush(stdout);
+    getchar();
+#    endif
 
-    mbedtls_exit( exit_code );
+    mbedtls_exit(exit_code);
 }
 
 #endif /* MBEDTLS_NET_C */