diff --git a/configs/baremetal.h b/configs/baremetal.h
index 9541542..7a2bd0f 100644
--- a/configs/baremetal.h
+++ b/configs/baremetal.h
@@ -89,6 +89,7 @@
 #define MBEDTLS_SSL_TRANSFORM_OPTIMIZE_CIPHERS
 
 /* Compile-time fixed parts of the SSL configuration */
+#define MBEDTLS_SSL_CONF_TRANSPORT MBEDTLS_SSL_TRANSPORT_DATAGRAM
 #define MBEDTLS_SSL_CONF_CERT_REQ_CA_LIST MBEDTLS_SSL_CERT_REQ_CA_LIST_DISABLED
 #define MBEDTLS_SSL_CONF_READ_TIMEOUT 0
 #define MBEDTLS_SSL_CONF_HS_TIMEOUT_MIN 1000
diff --git a/include/mbedtls/config.h b/include/mbedtls/config.h
index cf7f403..0e539be 100644
--- a/include/mbedtls/config.h
+++ b/include/mbedtls/config.h
@@ -3860,6 +3860,9 @@
 /* Endpoint (Client/Server) */
 //#define MBEDTLS_SSL_CONF_ENDPOINT MBEDTLS_SSL_IS_CLIENT
 
+/* Transport (Stream/Datagram) */
+//#define MBEDTLS_SSL_CONF_TRANSPORT MBEDTLS_SSL_TRANSPORT_STREAM
+
 //#define MBEDTLS_SSL_CONF_CERT_REQ_CA_LIST MBEDTLS_SSL_CERT_REQ_CA_LIST_ENABLED
 
 /* DTLS-specific settings */
diff --git a/include/mbedtls/ssl.h b/include/mbedtls/ssl.h
index f447cf3..c0a4a55 100644
--- a/include/mbedtls/ssl.h
+++ b/include/mbedtls/ssl.h
@@ -971,8 +971,6 @@
     int compression;            /*!< chosen compression */
 #endif /* MBEDTLS_ZLIB_SUPPORT */
     size_t id_len;              /*!< session id length  */
-    unsigned char id[32];       /*!< session identifier */
-    unsigned char master[48];   /*!< the master secret  */
 
 #if defined(MBEDTLS_X509_CRT_PARSE_C)
 #if defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
@@ -1004,6 +1002,9 @@
 #if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
     int encrypt_then_mac;       /*!< flag for EtM activation                */
 #endif
+
+    unsigned char id[32];       /*!< session identifier */
+    unsigned char master[48];   /*!< the master secret  */
 };
 
 /**
@@ -1011,7 +1012,124 @@
  */
 struct mbedtls_ssl_config
 {
-    /* Group items by size (largest first) to minimize padding overhead */
+    /* Group items by size (smallest first) to minimize padding overhead */
+
+    /*
+     * Flags (bytes)
+     */
+
+#if !defined(MBEDTLS_SSL_CONF_ENDPOINT)
+    uint8_t endpoint;               /*!< 0: client, 1: server               */
+#endif /* !MBEDTLS_SSL_CONF_ENDPOINT */
+#if !defined(MBEDTLS_SSL_CONF_TRANSPORT)
+    uint8_t transport;              /*!< stream (TLS) or datagram (DTLS)    */
+#endif /* !MBEDTLS_SSL_CONF_TRANSPORT */
+#if !defined(MBEDTLS_SSL_CONF_AUTHMODE)
+    uint8_t authmode;               /*!< MBEDTLS_SSL_VERIFY_XXX             */
+#endif /* !MBEDTLS_SSL_CONF_AUTHMODE */
+#if !defined(MBEDTLS_SSL_CONF_ALLOW_LEGACY_RENEGOTIATION)
+    /* needed even with renego disabled for LEGACY_BREAK_HANDSHAKE          */
+    uint8_t allow_legacy_renegotiation; /*!< MBEDTLS_LEGACY_XXX   */
+#endif /* !MBEDTLS_SSL_CONF_ALLOW_LEGACY_RENEGOTIATION */
+#if defined(MBEDTLS_ARC4_C)
+    uint8_t arc4_disabled;          /*!< blacklist RC4 ciphersuites?        */
+#endif
+#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
+    uint8_t mfl_code;               /*!< desired fragment length            */
+#endif
+#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
+    uint8_t encrypt_then_mac;       /*!< negotiate encrypt-then-mac?        */
+#endif
+#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
+#if !defined(MBEDTLS_SSL_CONF_EXTENDED_MASTER_SECRET)
+    uint8_t extended_ms;            /*!< negotiate extended master secret?  */
+#endif /* !MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
+#if !defined(MBEDTLS_SSL_CONF_ENFORCE_EXTENDED_MASTER_SECRET)
+    uint8_t enforce_extended_master_secret; /*!< enforce the usage of
+                                             *   extended master secret     */
+#endif /* !MBEDTLS_SSL_CONF_ENFORCE_EXTENDED_MASTER_SECRET */
+#endif
+#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
+#if !defined(MBEDTLS_SSL_CONF_ANTI_REPLAY)
+    uint8_t anti_replay;            /*!< detect and prevent replay?         */
+#endif /* !MBEDTLS_SSL_CONF_ANTI_REPLAY */
+#endif /* MBEDTLS_SSL_DTLS_ANTI_REPLAY */
+#if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING)
+    uint8_t cbc_record_splitting;   /*!< do cbc record splitting            */
+#endif
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+    uint8_t disable_renegotiation;  /*!< disable renegotiation?             */
+#endif
+#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
+    uint8_t trunc_hmac;             /*!< negotiate truncated hmac?          */
+#endif
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+    uint8_t session_tickets;        /*!< use session tickets?               */
+#endif
+#if defined(MBEDTLS_SSL_FALLBACK_SCSV) && defined(MBEDTLS_SSL_CLI_C)
+    uint8_t fallback;               /*!< is this a fallback?                */
+#endif
+#if defined(MBEDTLS_SSL_SRV_C)
+#if !defined(MBEDTLS_SSL_CONF_CERT_REQ_CA_LIST)
+    uint8_t cert_req_ca_list;       /*!< enable sending CA list in
+                                         Certificate Request messages?      */
+#endif /* !MBEDTLS_SSL_CONF_CERT_REQ_CA_LIST */
+#endif
+#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
+#if !defined(MBEDTLS_SSL_CONF_IGNORE_UNEXPECTED_CID)
+    uint8_t ignore_unexpected_cid;  /*!< Determines whether DTLS record
+                                     *   with unexpected CID should
+                                     *   lead to failure.                   */
+#endif /* !MBEDTLS_SSL_CONF_IGNORE_UNEXPECTED_CID */
+#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
+
+    /*
+     * Numerical settings
+     */
+
+#if !defined(MBEDTLS_SSL_CONF_MIN_MAJOR_VER)
+    unsigned char min_major_ver;    /*!< min. major version used            */
+#endif /* !MBEDTLS_SSL_CONF_MIN_MAJOR_VER */
+#if !defined(MBEDTLS_SSL_CONF_MAX_MAJOR_VER)
+    unsigned char max_major_ver;    /*!< max. major version used            */
+#endif /* !MBEDTLS_SSL_CONF_MAX_MAJOR_VER */
+#if !defined(MBEDTLS_SSL_CONF_MIN_MINOR_VER)
+    uint16_t min_minor_ver;    /*!< min. minor version used            */
+#endif /* !MBEDTLS_SSL_CONF_MIN_MINOR_VER */
+#if !defined(MBEDTLS_SSL_CONF_MAX_MINOR_VER)
+    uint16_t max_minor_ver;    /*!< max. minor version used            */
+#endif /* !MBEDTLS_SSL_CONF_MAX_MINOR_VER */
+
+#if !defined(MBEDTLS_SSL_CONF_READ_TIMEOUT)
+    uint32_t read_timeout;          /*!< timeout for mbedtls_ssl_read (ms)  */
+#endif /* !MBEDTLS_SSL_CONF_READ_TIMEOUT */
+
+#if defined(MBEDTLS_SSL_PROTO_DTLS)
+#if !defined(MBEDTLS_SSL_CONF_HS_TIMEOUT_MIN)
+    uint32_t hs_timeout_min;        /*!< initial value of the handshake
+                                         retransmission timeout (ms)        */
+#endif /* !MBEDTLS_SSL_CONF_HS_TIMEOUT_MIN */
+#if !defined(MBEDTLS_SSL_CONF_HS_TIMEOUT_MAX)
+    uint32_t hs_timeout_max;        /*!< maximum value of the handshake
+                                         retransmission timeout (ms)        */
+#endif /* !MBEDTLS_SSL_CONF_HS_TIMEOUT_MAX */
+#endif /* MBEDTLS_SSL_PROTO_DTLS */
+
+#if defined(MBEDTLS_SSL_RENEGOTIATION)
+    int renego_max_records;         /*!< grace period for renegotiation     */
+    unsigned char renego_period[8]; /*!< value of the record counters
+                                         that triggers renegotiation        */
+#endif
+
+#if defined(MBEDTLS_SSL_DTLS_BADMAC_LIMIT)
+#if !defined(MBEDTLS_SSL_CONF_BADMAC_LIMIT)
+    unsigned int badmac_limit;      /*!< limit of records with a bad MAC    */
+#endif /* !MBEDTLS_SSL_CONF_BADMAC_LIMIT */
+#endif
+
+#if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_SSL_CLI_C)
+    unsigned int dhm_min_bitlen;    /*!< min. bit length of the DHM prime   */
+#endif
 
     /*
      * Pointers
@@ -1145,121 +1263,6 @@
     const char **alpn_list;         /*!< ordered list of protocols          */
 #endif
 
-    /*
-     * Numerical settings (int then char)
-     */
-
-#if !defined(MBEDTLS_SSL_CONF_READ_TIMEOUT)
-    uint32_t read_timeout;          /*!< timeout for mbedtls_ssl_read (ms)  */
-#endif /* !MBEDTLS_SSL_CONF_READ_TIMEOUT */
-
-#if defined(MBEDTLS_SSL_PROTO_DTLS)
-#if !defined(MBEDTLS_SSL_CONF_HS_TIMEOUT_MIN)
-    uint32_t hs_timeout_min;        /*!< initial value of the handshake
-                                         retransmission timeout (ms)        */
-#endif /* !MBEDTLS_SSL_CONF_HS_TIMEOUT_MIN */
-#if !defined(MBEDTLS_SSL_CONF_HS_TIMEOUT_MAX)
-    uint32_t hs_timeout_max;        /*!< maximum value of the handshake
-                                         retransmission timeout (ms)        */
-#endif /* !MBEDTLS_SSL_CONF_HS_TIMEOUT_MAX */
-#endif /* MBEDTLS_SSL_PROTO_DTLS */
-
-#if defined(MBEDTLS_SSL_RENEGOTIATION)
-    int renego_max_records;         /*!< grace period for renegotiation     */
-    unsigned char renego_period[8]; /*!< value of the record counters
-                                         that triggers renegotiation        */
-#endif
-
-#if defined(MBEDTLS_SSL_DTLS_BADMAC_LIMIT)
-#if !defined(MBEDTLS_SSL_CONF_BADMAC_LIMIT)
-    unsigned int badmac_limit;      /*!< limit of records with a bad MAC    */
-#endif /* !MBEDTLS_SSL_CONF_BADMAC_LIMIT */
-#endif
-
-#if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_SSL_CLI_C)
-    unsigned int dhm_min_bitlen;    /*!< min. bit length of the DHM prime   */
-#endif
-
-#if !defined(MBEDTLS_SSL_CONF_MIN_MAJOR_VER)
-    unsigned char min_major_ver;    /*!< min. major version used            */
-#endif /* !MBEDTLS_SSL_CONF_MIN_MAJOR_VER */
-#if !defined(MBEDTLS_SSL_CONF_MAX_MAJOR_VER)
-    unsigned char max_major_ver;    /*!< max. major version used            */
-#endif /* !MBEDTLS_SSL_CONF_MAX_MAJOR_VER */
-#if !defined(MBEDTLS_SSL_CONF_MIN_MINOR_VER)
-    uint16_t min_minor_ver;    /*!< min. minor version used            */
-#endif /* !MBEDTLS_SSL_CONF_MIN_MINOR_VER */
-#if !defined(MBEDTLS_SSL_CONF_MAX_MINOR_VER)
-    uint16_t max_minor_ver;    /*!< max. minor version used            */
-#endif /* !MBEDTLS_SSL_CONF_MAX_MINOR_VER */
-
-    /*
-     * Flags (bitfields)
-     */
-
-#if !defined(MBEDTLS_SSL_CONF_ENDPOINT)
-    unsigned int endpoint : 1;      /*!< 0: client, 1: server               */
-#endif /* !MBEDTLS_SSL_CONF_ENDPOINT */
-    unsigned int transport : 1;     /*!< stream (TLS) or datagram (DTLS)    */
-#if !defined(MBEDTLS_SSL_CONF_AUTHMODE)
-    unsigned int authmode : 6;      /*!< MBEDTLS_SSL_VERIFY_XXX             */
-#endif /* !MBEDTLS_SSL_CONF_AUTHMODE */
-#if !defined(MBEDTLS_SSL_CONF_ALLOW_LEGACY_RENEGOTIATION)
-    /* needed even with renego disabled for LEGACY_BREAK_HANDSHAKE          */
-    unsigned int allow_legacy_renegotiation : 2 ; /*!< MBEDTLS_LEGACY_XXX   */
-#endif /* !MBEDTLS_SSL_CONF_ALLOW_LEGACY_RENEGOTIATION */
-#if defined(MBEDTLS_ARC4_C)
-    unsigned int arc4_disabled : 1; /*!< blacklist RC4 ciphersuites?        */
-#endif
-#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH)
-    unsigned int mfl_code : 3;      /*!< desired fragment length            */
-#endif
-#if defined(MBEDTLS_SSL_ENCRYPT_THEN_MAC)
-    unsigned int encrypt_then_mac : 1 ; /*!< negotiate encrypt-then-mac?    */
-#endif
-#if defined(MBEDTLS_SSL_EXTENDED_MASTER_SECRET)
-#if !defined(MBEDTLS_SSL_CONF_EXTENDED_MASTER_SECRET)
-    unsigned int extended_ms : 1;   /*!< negotiate extended master secret?  */
-#endif /* !MBEDTLS_SSL_EXTENDED_MASTER_SECRET */
-#if !defined(MBEDTLS_SSL_CONF_ENFORCE_EXTENDED_MASTER_SECRET)
-    unsigned int enforce_extended_master_secret : 1; /*!< enforce the usage
-                                                      *   of extended master
-                                                      *   secret            */
-#endif /* !MBEDTLS_SSL_CONF_ENFORCE_EXTENDED_MASTER_SECRET */
-#endif
-#if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY)
-#if !defined(MBEDTLS_SSL_CONF_ANTI_REPLAY)
-    unsigned int anti_replay : 1;   /*!< detect and prevent replay?         */
-#endif /* !MBEDTLS_SSL_CONF_ANTI_REPLAY */
-#endif /* MBEDTLS_SSL_DTLS_ANTI_REPLAY */
-#if defined(MBEDTLS_SSL_CBC_RECORD_SPLITTING)
-    unsigned int cbc_record_splitting : 1;  /*!< do cbc record splitting    */
-#endif
-#if defined(MBEDTLS_SSL_RENEGOTIATION)
-    unsigned int disable_renegotiation : 1; /*!< disable renegotiation?     */
-#endif
-#if defined(MBEDTLS_SSL_TRUNCATED_HMAC)
-    unsigned int trunc_hmac : 1;    /*!< negotiate truncated hmac?          */
-#endif
-#if defined(MBEDTLS_SSL_SESSION_TICKETS)
-    unsigned int session_tickets : 1;   /*!< use session tickets?           */
-#endif
-#if defined(MBEDTLS_SSL_FALLBACK_SCSV) && defined(MBEDTLS_SSL_CLI_C)
-    unsigned int fallback : 1;      /*!< is this a fallback?                */
-#endif
-#if defined(MBEDTLS_SSL_SRV_C)
-#if !defined(MBEDTLS_SSL_CONF_CERT_REQ_CA_LIST)
-    unsigned int cert_req_ca_list : 1;  /*!< enable sending CA list in
-                                          Certificate Request messages?     */
-#endif /* !MBEDTLS_SSL_CONF_CERT_REQ_CA_LIST */
-#endif
-#if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
-#if !defined(MBEDTLS_SSL_CONF_IGNORE_UNEXPECTED_CID)
-    unsigned int ignore_unexpected_cid : 1; /*!< Determines whether DTLS
-                                             *   record with unexpected CID
-                                             *   should lead to failure.    */
-#endif /* !MBEDTLS_SSL_CONF_IGNORE_UNEXPECTED_CID */
-#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
 };
 
 struct mbedtls_ssl_context
@@ -1307,19 +1310,6 @@
     unsigned badmac_seen;       /*!< records with a bad MAC received    */
 #endif /* MBEDTLS_SSL_DTLS_BADMAC_LIMIT */
 
-#if !defined(MBEDTLS_SSL_CONF_SEND)
-    mbedtls_ssl_send_t *f_send; /*!< Callback for network send */
-#endif /* !MBEDTLS_SSL_CONF_SEND */
-#if !defined(MBEDTLS_SSL_CONF_RECV)
-    mbedtls_ssl_recv_t *f_recv; /*!< Callback for network receive */
-#endif /* !MBEDTLS_SSL_CONF_RECV */
-#if !defined(MBEDTLS_SSL_CONF_RECV_TIMEOUT)
-    mbedtls_ssl_recv_timeout_t *f_recv_timeout;
-#endif /* !MBEDTLS_SSL_CONF_RECV_TIMEOUT */
-                                /*!< Callback for network receive with timeout */
-
-    void *p_bio;                /*!< context for I/O operations   */
-
     /*
      * Session layer
      */
@@ -1332,26 +1322,6 @@
                                               the handshake process        */
 
     /*
-     * Record layer transformations
-     */
-    mbedtls_ssl_transform *transform_in;        /*!<  current transform params (in)   */
-    mbedtls_ssl_transform *transform_out;       /*!<  current transform params (in)   */
-    mbedtls_ssl_transform *transform;           /*!<  negotiated transform params     */
-    mbedtls_ssl_transform *transform_negotiate; /*!<  transform params in negotiation */
-
-    /*
-     * Timers
-     */
-    void *p_timer;              /*!< context for the timer callbacks */
-
-#if !defined(MBEDTLS_SSL_CONF_SET_TIMER)
-    mbedtls_ssl_set_timer_t *f_set_timer;       /*!< set timer callback */
-#endif /* !MBEDTLS_SSL_CONF_SET_TIMER */
-#if !defined(MBEDTLS_SSL_CONF_GET_TIMER)
-    mbedtls_ssl_get_timer_t *f_get_timer;       /*!< get timer callback */
-#endif /* !MBEDTLS_SSL_CONF_GET_TIMER */
-
-    /*
      * Record layer (incoming data)
      */
     unsigned char *in_buf;      /*!< input buffer                     */
@@ -1415,6 +1385,39 @@
 #endif /* MBEDTLS_SSL_CBC_RECORD_SPLITTING */
 
     /*
+     * Record layer transformations
+     */
+    mbedtls_ssl_transform *transform_in;        /*!<  current transform params (in)   */
+    mbedtls_ssl_transform *transform_out;       /*!<  current transform params (in)   */
+    mbedtls_ssl_transform *transform;           /*!<  negotiated transform params     */
+    mbedtls_ssl_transform *transform_negotiate; /*!<  transform params in negotiation */
+
+#if !defined(MBEDTLS_SSL_CONF_SEND)
+    mbedtls_ssl_send_t *f_send; /*!< Callback for network send */
+#endif /* !MBEDTLS_SSL_CONF_SEND */
+#if !defined(MBEDTLS_SSL_CONF_RECV)
+    mbedtls_ssl_recv_t *f_recv; /*!< Callback for network receive */
+#endif /* !MBEDTLS_SSL_CONF_RECV */
+#if !defined(MBEDTLS_SSL_CONF_RECV_TIMEOUT)
+    mbedtls_ssl_recv_timeout_t *f_recv_timeout;
+#endif /* !MBEDTLS_SSL_CONF_RECV_TIMEOUT */
+                                /*!< Callback for network receive with timeout */
+
+    void *p_bio;                /*!< context for I/O operations   */
+
+    /*
+     * Timers
+     */
+    void *p_timer;              /*!< context for the timer callbacks */
+
+#if !defined(MBEDTLS_SSL_CONF_SET_TIMER)
+    mbedtls_ssl_set_timer_t *f_set_timer;       /*!< set timer callback */
+#endif /* !MBEDTLS_SSL_CONF_SET_TIMER */
+#if !defined(MBEDTLS_SSL_CONF_GET_TIMER)
+    mbedtls_ssl_get_timer_t *f_get_timer;       /*!< get timer callback */
+#endif /* !MBEDTLS_SSL_CONF_GET_TIMER */
+
+    /*
      * PKI layer
      */
     int client_auth;                    /*!<  flag for client auth.   */
@@ -1569,6 +1572,7 @@
 void mbedtls_ssl_conf_endpoint( mbedtls_ssl_config *conf, int endpoint );
 #endif /* !MBEDTLS_SSL_CONF_ENDPOINT */
 
+#if !defined(MBEDTLS_SSL_CONF_TRANSPORT)
 /**
  * \brief           Set the transport type (TLS or DTLS).
  *                  Default: TLS unless #MBEDTLS_SSL_PROTO_NO_TLS is defined,
@@ -1579,12 +1583,16 @@
  *                  \c mbedtls_ssl_set_bio(). You also need to provide timer
  *                  callbacks with \c mbedtls_ssl_set_timer_cb().
  *
+ * \note            On constrained systems, this can also be configured
+ *                  at compile-time via MBEDTLS_SSL_CONF_TRANSPORT.
+ *
  * \param conf      SSL configuration
  * \param transport transport type:
  *                  MBEDTLS_SSL_TRANSPORT_STREAM for TLS,
  *                  MBEDTLS_SSL_TRANSPORT_DATAGRAM for DTLS.
  */
 void mbedtls_ssl_conf_transport( mbedtls_ssl_config *conf, int transport );
+#endif /* !MBEDTLS_SSL_CONF_TRANSPORT */
 
 /**
  * \brief          Set the certificate verification mode
diff --git a/include/mbedtls/ssl_internal.h b/include/mbedtls/ssl_internal.h
index 17c5763..ea1b847 100644
--- a/include/mbedtls/ssl_internal.h
+++ b/include/mbedtls/ssl_internal.h
@@ -461,19 +461,6 @@
     unsigned char *psk;                 /*!<  PSK from the callback         */
     size_t psk_len;                     /*!<  Length of PSK from callback   */
 #endif
-#if defined(MBEDTLS_X509_CRT_PARSE_C)
-    mbedtls_ssl_key_cert *key_cert;     /*!< chosen key/cert pair (server)  */
-#if !defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
-    mbedtls_pk_context peer_pubkey;     /*!< The public key from the peer.  */
-#endif /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
-
-#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
-    int sni_authmode;                   /*!< authmode from SNI callback     */
-    mbedtls_ssl_key_cert *sni_key_cert; /*!< key/cert list from SNI         */
-    mbedtls_x509_crt *sni_ca_chain;     /*!< trusted CAs from SNI callback  */
-    mbedtls_x509_crl *sni_ca_crl;       /*!< trusted CAs CRLs from SNI      */
-#endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
-#endif /* MBEDTLS_X509_CRT_PARSE_C */
 #if defined(MBEDTLS_SSL__ECP_RESTARTABLE)
     int ecrs_enabled;                   /*!< Handshake supports EC restart? */
     mbedtls_x509_crt_restart_ctx ecrs_ctx;  /*!< restart context            */
@@ -518,9 +505,9 @@
 
         struct mbedtls_ssl_hs_buffer
         {
-            unsigned is_valid      : 1;
-            unsigned is_fragmented : 1;
-            unsigned is_complete   : 1;
+            uint8_t is_valid;
+            uint8_t is_fragmented;
+            uint8_t is_complete;
             unsigned char *data;
             size_t data_len;
         } hs[MBEDTLS_SSL_MAX_BUFFERED_HS];
@@ -530,6 +517,19 @@
     unsigned char peer_cid[ MBEDTLS_SSL_CID_OUT_LEN_MAX ]; /*! The peer's CID */
 #endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
 #endif /* MBEDTLS_SSL_PROTO_DTLS */
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
+    mbedtls_ssl_key_cert *key_cert;     /*!< chosen key/cert pair (server)  */
+#if !defined(MBEDTLS_SSL_KEEP_PEER_CERTIFICATE)
+    mbedtls_pk_context peer_pubkey;     /*!< The public key from the peer.  */
+#endif /* !MBEDTLS_SSL_KEEP_PEER_CERTIFICATE */
+
+#if defined(MBEDTLS_SSL_SERVER_NAME_INDICATION)
+    int sni_authmode;                   /*!< authmode from SNI callback     */
+    mbedtls_ssl_key_cert *sni_key_cert; /*!< key/cert list from SNI         */
+    mbedtls_x509_crt *sni_ca_chain;     /*!< trusted CAs from SNI callback  */
+    mbedtls_x509_crl *sni_ca_crl;       /*!< trusted CAs CRLs from SNI      */
+#endif /* MBEDTLS_SSL_SERVER_NAME_INDICATION */
+#endif /* MBEDTLS_X509_CRT_PARSE_C */
     unsigned char randbytes[64];        /*!<  random bytes            */
     unsigned char premaster[MBEDTLS_PREMASTER_SIZE];
                                         /*!<  premaster secret        */
@@ -559,7 +559,7 @@
 #endif
 
 #if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
-    unsigned int async_in_progress : 1; /*!< an asynchronous operation is in progress */
+    uint8_t async_in_progress;          /*!< an asynchronous operation is in progress */
 #endif /* MBEDTLS_SSL_ASYNC_PRIVATE */
 
 #if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
@@ -1454,6 +1454,21 @@
 }
 #endif /* MBEDTLS_SSL_CONF_ENDPOINT */
 
+#if !defined(MBEDTLS_SSL_CONF_TRANSPORT)
+static inline unsigned int mbedtls_ssl_conf_get_transport(
+    mbedtls_ssl_config const *conf )
+{
+    return( conf->transport );
+}
+#else /* !MBEDTLS_SSL_CONF_TRANSPORT */
+static inline unsigned int mbedtls_ssl_conf_get_transport(
+    mbedtls_ssl_config const *conf )
+{
+    ((void) conf);
+    return( MBEDTLS_SSL_CONF_TRANSPORT );
+}
+#endif /* MBEDTLS_SSL_CONF_TRANSPORT */
+
 #if !defined(MBEDTLS_SSL_CONF_READ_TIMEOUT)
 static inline uint32_t mbedtls_ssl_conf_get_read_timeout(
     mbedtls_ssl_config  const *conf )
diff --git a/library/aes.c b/library/aes.c
index 04c8208..f7a4898 100644
--- a/library/aes.c
+++ b/library/aes.c
@@ -547,7 +547,7 @@
  *  |0x10|0x03|0x10|0x10|0x10|0x04|0x00| ... |0x04|0x00|0x04|0x03|0x07|
  */
 #if defined(MBEDTLS_AES_SCA_COUNTERMEASURES)
-static int aes_sca_cm_data_randomize( uint8_t *tbl, uint8_t tbl_len )
+static int aes_sca_cm_data_randomize( uint8_t *tbl, int tbl_len )
 {
     int i = 0, j, is_even_pos, dummy_rounds, num;
 
diff --git a/library/ccm.c b/library/ccm.c
index 750ec9e..87fe16d 100644
--- a/library/ccm.c
+++ b/library/ccm.c
@@ -40,6 +40,7 @@
 #include "mbedtls/platform.h"
 #include "mbedtls/platform_util.h"
 
+#include <stdint.h>
 #include <string.h>
 
 #if defined(MBEDTLS_SELF_TEST) && defined(MBEDTLS_AES_C)
@@ -113,6 +114,41 @@
     mbedtls_platform_zeroize( ctx, sizeof( mbedtls_ccm_context ) );
 }
 
+/* Durstenfeld's version of Fisher-Yates shuffle */
+static void mbedtls_generate_permutation( unsigned char* table, size_t  size )
+{
+    size_t i, j;
+
+    for( i = 0; i < size; i++ )
+    {
+        table[i] = (unsigned char) i;
+    }
+
+    if( size < 2 )
+    {
+        return;
+    }
+
+    for( i = size - 1; i > 0; i-- )
+    {
+        unsigned char tmp;
+        j = mbedtls_platform_random_in_range( (uint32_t) i + 1 );
+        tmp = table[i];
+        table[i] = table[j];
+        table[j] = tmp;
+    }
+}
+
+static void mbedtls_generate_masks( unsigned char* table, size_t  size )
+{
+    size_t i;
+
+    for( i = 0; i < size; i++ )
+    {
+        table[i] = mbedtls_platform_random_in_range( 256 );
+    }
+}
+
 /*
  * Macros for common operations.
  * Results in smaller compiled code than static inline functions.
@@ -121,30 +157,55 @@
 /*
  * Update the CBC-MAC state in y using a block in b
  * (Always using b as the source helps the compiler optimise a bit better.)
+ * Initial b masking happens outside of this macro due to various sources of it.
  */
 #define UPDATE_CBC_MAC                                                      \
     for( i = 0; i < 16; i++ )                                               \
-        y[i] ^= b[i];                                                       \
+    {                                                                       \
+        y[perm_table[i]] ^= b[perm_table[i]];                               \
+        y[perm_table[i]] ^= mask_table[perm_table[i]];                      \
+    }                                                                       \
                                                                             \
     if( ( ret = mbedtls_cipher_update( &ctx->cipher_ctx, y, 16, y, &olen ) ) != 0 ) \
         return( ret );
 
 /*
+ * Copy src to dst starting at a random offset, while masking the whole dst buffer.
+ */
+#define COPY_MASK( dst, src, mask, len_src, len_dst )                   \
+    do                                                                  \
+    {                                                                   \
+        unsigned j, offset = mbedtls_platform_random_in_range( 256 );   \
+        for( i = 0; i < len_src; i++ )                                  \
+        {                                                               \
+            j = (i + offset) % len_src;                                 \
+            (dst)[j] = (src)[j] ^ (mask)[j];                            \
+        }                                                               \
+        for( ; i < len_dst; i++ )                                       \
+            (dst)[i] ^= (mask)[i];                                      \
+    } while( 0 )
+/*
  * Encrypt or decrypt a partial block with CTR
  * Warning: using b for temporary storage! src and dst must not be b!
  * This avoids allocating one more 16 bytes buffer while allowing src == dst.
  */
-#define CTR_CRYPT( dst, src, len  )                                            \
+#define CTR_CRYPT( dst, src, len )                                      \
     do                                                                  \
     {                                                                   \
+        mbedtls_generate_permutation( perm_table, len );                \
+        mbedtls_generate_masks( mask_table, len );                      \
         if( ( ret = mbedtls_cipher_update( &ctx->cipher_ctx, ctr,       \
                                            16, b, &olen ) ) != 0 )      \
         {                                                               \
             return( ret );                                              \
         }                                                               \
                                                                         \
-        for( i = 0; i < (len); i++ )                                    \
-            (dst)[i] = (src)[i] ^ b[i];                                 \
+        for( i = 0; i < len; i++ )                                      \
+        {                                                               \
+            (dst)[perm_table[i]] = (src)[perm_table[i]] ^ mask_table[perm_table[i]];\
+            (dst)[perm_table[i]] ^= b[perm_table[i]];                   \
+            (dst)[perm_table[i]] ^= mask_table[perm_table[i]];          \
+        }                                                               \
     } while( 0 )
 
 /*
@@ -157,12 +218,14 @@
                            unsigned char *tag, size_t tag_len )
 {
     int ret = MBEDTLS_ERR_PLATFORM_FAULT_DETECTED;
-    unsigned char i;
-    unsigned char q;
+    uint_fast8_t i;
+    uint_fast8_t q;
     size_t len_left, olen;
     unsigned char b[16];
     unsigned char y[16];
     unsigned char ctr[16];
+    unsigned char perm_table[16];
+    unsigned char mask_table[16];
     const unsigned char *src;
     unsigned char *dst;
 
@@ -183,7 +246,7 @@
     if( add_len > 0xFF00 )
         return( MBEDTLS_ERR_CCM_BAD_INPUT );
 
-    q = 16 - 1 - (unsigned char) iv_len;
+    q = (uint_fast8_t) (16 - 1 - iv_len);
 
     /*
      * First block B_0:
@@ -197,15 +260,16 @@
      * 5 .. 3   (t - 2) / 2
      * 2 .. 0   q - 1
      */
-    b[0] = 0;
-    b[0] |= ( add_len > 0 ) << 6;
-    b[0] |= ( ( tag_len - 2 ) / 2 ) << 3;
-    b[0] |= q - 1;
+    mbedtls_generate_masks( mask_table, 16 );
+    mbedtls_generate_permutation( perm_table, 16 );
+    b[0] = (unsigned char) ( ( ( add_len > 0 ) << 6 ) |
+                           ( ( ( tag_len - 2 ) / 2 ) << 3 ) |
+                           ( q - 1 ) ) ^ mask_table[0];
 
-    mbedtls_platform_memcpy( b + 1, iv, iv_len );
-
+    for( i = 0; i < iv_len; i++ )
+        b[i+1] = iv[i] ^ mask_table[i+1];
     for( i = 0, len_left = length; i < q; i++, len_left >>= 8 )
-        b[15-i] = (unsigned char)( len_left & 0xFF );
+        b[15-i] = (unsigned char)( ( len_left & 0xFF ) ) ^ mask_table[15-i];
 
     if( len_left > 0 )
         return( MBEDTLS_ERR_CCM_BAD_INPUT );
@@ -225,12 +289,16 @@
         len_left = add_len;
         src = add;
 
+        mbedtls_generate_masks( mask_table, 16 );
+        mbedtls_generate_permutation( perm_table, 16 );
         mbedtls_platform_memset( b, 0, 16 );
-        b[0] = (unsigned char)( ( add_len >> 8 ) & 0xFF );
-        b[1] = (unsigned char)( ( add_len      ) & 0xFF );
+        b[0] = (unsigned char)( ( ( add_len >> 8 ) & 0xFF ) ^ mask_table[0] );
+        b[1] = (unsigned char)( ( ( add_len      ) & 0xFF ) ^ mask_table[1] );
 
         use_len = len_left < 16 - 2 ? len_left : 16 - 2;
-        mbedtls_platform_memcpy( b + 2, src, use_len );
+
+        COPY_MASK( b+2, src, mask_table+2, use_len, 14 );
+
         len_left -= use_len;
         src += use_len;
 
@@ -238,10 +306,12 @@
 
         while( len_left > 0 )
         {
+            mbedtls_generate_masks( mask_table, 16 );
+            mbedtls_generate_permutation( perm_table, 16 );
             use_len = len_left > 16 ? 16 : len_left;
 
             mbedtls_platform_memset( b, 0, 16 );
-            mbedtls_platform_memcpy( b, src, use_len );
+            COPY_MASK( b, src, mask_table, use_len, 16);
             UPDATE_CBC_MAC;
 
             len_left -= use_len;
@@ -280,8 +350,10 @@
 
         if( mode == CCM_ENCRYPT )
         {
+            mbedtls_generate_masks( mask_table, 16 );
+            mbedtls_generate_permutation( perm_table, 16 );
             mbedtls_platform_memset( b, 0, 16 );
-            mbedtls_platform_memcpy( b, src, use_len );
+            COPY_MASK( b, src, mask_table, use_len, 16 );
             UPDATE_CBC_MAC;
         }
 
@@ -289,8 +361,10 @@
 
         if( mode == CCM_DECRYPT )
         {
+            mbedtls_generate_masks( mask_table, 16 );
+            mbedtls_generate_permutation( perm_table, 16 );
             mbedtls_platform_memset( b, 0, 16 );
-            mbedtls_platform_memcpy( b, dst, use_len );
+            COPY_MASK( b, dst, mask_table, use_len, 16 );
             UPDATE_CBC_MAC;
         }
 
@@ -368,7 +442,7 @@
 {
     int ret = MBEDTLS_ERR_PLATFORM_FAULT_DETECTED;
     unsigned char check_tag[16];
-    unsigned char i;
+    uint_fast8_t i;
     int diff;
 
     CCM_VALIDATE_RET( ctx != NULL );
diff --git a/library/cipher.c b/library/cipher.c
index e0fd39d..6eab899 100644
--- a/library/cipher.c
+++ b/library/cipher.c
@@ -36,6 +36,7 @@
 #include "mbedtls/platform_util.h"
 
 #include <stdlib.h>
+#include <stdint.h>
 #include <string.h>
 
 #if defined(MBEDTLS_CHACHAPOLY_C)
@@ -591,7 +592,7 @@
         size_t data_len )
 {
     size_t padding_len = output_len - data_len;
-    unsigned char i;
+    uint_fast8_t i;
 
     for( i = 0; i < padding_len; i++ )
         output[data_len + i] = (unsigned char) padding_len;
@@ -601,7 +602,7 @@
         size_t *data_len )
 {
     size_t i, pad_idx;
-    unsigned char padding_len, bad = 0;
+    uint_fast8_t padding_len, bad = 0;
 
     if( NULL == input || NULL == data_len )
         return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
@@ -631,7 +632,7 @@
                                        size_t output_len, size_t data_len )
 {
     size_t padding_len = output_len - data_len;
-    unsigned char i = 0;
+    uint_fast8_t i = 0;
 
     output[data_len] = 0x80;
     for( i = 1; i < padding_len; i++ )
@@ -642,7 +643,7 @@
                                       size_t *data_len )
 {
     size_t i;
-    unsigned char done = 0, prev_done, bad;
+    uint_fast8_t done = 0, prev_done, bad;
 
     if( NULL == input || NULL == data_len )
         return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
@@ -670,7 +671,7 @@
                                        size_t output_len, size_t data_len )
 {
     size_t padding_len = output_len - data_len;
-    unsigned char i = 0;
+    uint_fast8_t i = 0;
 
     for( i = 1; i < padding_len; i++ )
         output[data_len + i - 1] = 0x00;
diff --git a/library/ecp.c b/library/ecp.c
index 3cdd566..ff13e88 100644
--- a/library/ecp.c
+++ b/library/ecp.c
@@ -82,6 +82,7 @@
 #include "mbedtls/threading.h"
 #include "mbedtls/platform_util.h"
 
+#include <stdint.h>
 #include <string.h>
 
 #if !defined(MBEDTLS_ECP_ALT)
@@ -183,7 +184,7 @@
  */
 static void ecp_restart_rsm_free( mbedtls_ecp_restart_mul_ctx *ctx )
 {
-    unsigned char i;
+    uint_fast8_t i;
 
     if( ctx == NULL )
         return;
@@ -1753,7 +1754,7 @@
                             unsigned char i )
 {
     int ret;
-    unsigned char ii, j;
+    uint_fast8_t ii, j;
 
     /* Ignore the "sign" bit and scale down */
     ii =  ( i & 0x7Fu ) >> 1;
@@ -2019,7 +2020,8 @@
                          mbedtls_ecp_restart_ctx *rs_ctx )
 {
     int ret;
-    unsigned char w, p_eq_g, i;
+    unsigned char w, p_eq_g;
+    uint_fast8_t i;
     size_t d;
     unsigned char T_size, T_ok;
     mbedtls_ecp_point *T;
diff --git a/library/ssl_cli.c b/library/ssl_cli.c
index 523e62c..cec2f09 100644
--- a/library/ssl_cli.c
+++ b/library/ssl_cli.c
@@ -838,7 +838,7 @@
 
     mbedtls_ssl_write_version( mbedtls_ssl_conf_get_max_major_ver( ssl->conf ),
                                mbedtls_ssl_conf_get_max_minor_ver( ssl->conf ),
-                               ssl->conf->transport, p );
+                               mbedtls_ssl_conf_get_transport( ssl->conf ), p );
     p += 2;
 
     MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello, max version: [%d:%d]",
@@ -1541,7 +1541,8 @@
      * } HelloVerifyRequest;
      */
     MBEDTLS_SSL_DEBUG_BUF( 3, "server version", p, 2 );
-    mbedtls_ssl_read_version( &major_ver, &minor_ver, ssl->conf->transport, p );
+    mbedtls_ssl_read_version( &major_ver, &minor_ver,
+                              mbedtls_ssl_conf_get_transport( ssl->conf ), p );
     p += 2;
 
     /*
@@ -1704,7 +1705,7 @@
 
         MBEDTLS_SSL_DEBUG_BUF( 3, "server hello, version", buf + 0, 2 );
         mbedtls_ssl_read_version( &major_ver, &minor_ver,
-                                  ssl->conf->transport,
+                                  mbedtls_ssl_conf_get_transport( ssl->conf ),
                                   buf + 0 );
 
         if( mbedtls_ssl_ver_lt( major_ver,
@@ -2379,7 +2380,7 @@
 
     mbedtls_ssl_write_version( mbedtls_ssl_conf_get_max_major_ver( ssl->conf ),
                                mbedtls_ssl_conf_get_max_minor_ver( ssl->conf ),
-                               ssl->conf->transport, out );
+                               mbedtls_ssl_conf_get_transport( ssl->conf ), out );
 
     ret = mbedtls_ssl_conf_get_frng( ssl->conf )
           ( mbedtls_ssl_conf_get_prng( ssl->conf ), out + 2, 46 );
diff --git a/library/ssl_srv.c b/library/ssl_srv.c
index 96f7446..389a24e 100644
--- a/library/ssl_srv.c
+++ b/library/ssl_srv.c
@@ -1468,7 +1468,8 @@
     MBEDTLS_SSL_DEBUG_MSG( 3, ( "client hello v3, protocol version: [%d:%d]",
                    buf[1], buf[2] ) );
 
-    mbedtls_ssl_read_version( &major, &minor, ssl->conf->transport, buf + 1 );
+    mbedtls_ssl_read_version( &major, &minor,
+                              mbedtls_ssl_conf_get_transport( ssl->conf ), buf + 1 );
 
     /* According to RFC 5246 Appendix E.1, the version here is typically
      * "{03,00}, the lowest version number supported by the client, [or] the
@@ -1674,7 +1675,7 @@
     {
         int minor_ver, major_ver;
         mbedtls_ssl_read_version( &major_ver, &minor_ver,
-                                  ssl->conf->transport,
+                                  mbedtls_ssl_conf_get_transport( ssl->conf ),
                                   buf );
 
 #if defined(MBEDTLS_KEY_EXCHANGE_RSA_ENABLED) ||        \
@@ -2703,7 +2704,7 @@
      * version looks like the most interoperable thing to do. */
     mbedtls_ssl_write_version( mbedtls_ssl_get_major_ver( ssl ),
                                mbedtls_ssl_get_minor_ver( ssl ),
-                               ssl->conf->transport, p );
+                               mbedtls_ssl_conf_get_transport( ssl->conf ), p );
     MBEDTLS_SSL_DEBUG_BUF( 3, "server version", p, 2 );
     p += 2;
 
@@ -2797,7 +2798,7 @@
 
     mbedtls_ssl_write_version( mbedtls_ssl_get_major_ver( ssl ),
                                mbedtls_ssl_get_minor_ver( ssl ),
-                               ssl->conf->transport, p );
+                               mbedtls_ssl_conf_get_transport( ssl->conf ), p );
     p += 2;
 
     MBEDTLS_SSL_DEBUG_MSG( 3, ( "server hello, chosen version: [%d:%d]",
@@ -4001,7 +4002,7 @@
 
     mbedtls_ssl_write_version( ssl->handshake->max_major_ver,
                                ssl->handshake->max_minor_ver,
-                               ssl->conf->transport, ver );
+                               mbedtls_ssl_conf_get_transport( ssl->conf ), ver );
 
     /* Avoid data-dependent branches while checking for invalid
      * padding, to protect against timing-based Bleichenbacher-type
diff --git a/library/ssl_tls.c b/library/ssl_tls.c
index 24dbb7d..f6244dc 100644
--- a/library/ssl_tls.c
+++ b/library/ssl_tls.c
@@ -35,6 +35,8 @@
 
 #if defined(MBEDTLS_SSL_TLS_C)
 
+#include <stdint.h>
+
 #if defined(MBEDTLS_PLATFORM_C)
 #include "mbedtls/platform.h"
 #else
@@ -931,8 +933,8 @@
 {
     size_t nb;
     size_t i, j, k, md_len;
-    unsigned char tmp[128];
-    unsigned char h_i[MBEDTLS_MD_MAX_SIZE];
+    unsigned char tmp[128] = {0};
+    unsigned char h_i[MBEDTLS_MD_MAX_SIZE] = {0};
     mbedtls_md_handle_t md_info;
     mbedtls_md_context_t md_ctx;
     int ret;
@@ -2932,7 +2934,7 @@
         else if( transform->ivlen == 12 && transform->fixed_ivlen == 12 )
         {
             /* ChachaPoly: fixed XOR sequence number */
-            unsigned char i;
+            uint_fast8_t i;
 
             mbedtls_platform_memcpy( iv, transform->iv_enc, transform->fixed_ivlen );
 
@@ -3317,7 +3319,7 @@
         if( transform->ivlen == 12 && transform->fixed_ivlen == 12 )
         {
             /* ChachaPoly: fixed XOR sequence number */
-            unsigned char i;
+            uint_fast8_t i;
 
             mbedtls_platform_memcpy( iv, transform->iv_dec, transform->fixed_ivlen );
 
@@ -4021,7 +4023,7 @@
         uint32_t ratio =
             mbedtls_ssl_conf_get_hs_timeout_max( ssl->conf ) /
             mbedtls_ssl_conf_get_hs_timeout_min( ssl->conf ) + 1;
-        unsigned char doublings = 1;
+        int_fast8_t doublings = 1;
 
         while( ratio != 0 )
         {
@@ -4946,7 +4948,8 @@
 
         mbedtls_ssl_write_version( mbedtls_ssl_get_major_ver( ssl ),
                                    mbedtls_ssl_get_minor_ver( ssl ),
-                                   ssl->conf->transport, ssl->out_hdr + 1 );
+                                   mbedtls_ssl_conf_get_transport( ssl->conf ),
+                                   ssl->out_hdr + 1 );
 
         mbedtls_platform_memcpy( ssl->out_ctr, ssl->cur_out_ctr, 8 );
         (void)mbedtls_platform_put_uint16_be( ssl->out_len, len );
@@ -4963,7 +4966,8 @@
             mbedtls_platform_memcpy( &rec.ctr[0], ssl->out_ctr, 8 );
             mbedtls_ssl_write_version( mbedtls_ssl_get_major_ver( ssl ),
                                        mbedtls_ssl_get_minor_ver( ssl ),
-                                       ssl->conf->transport, rec.ver );
+                                       mbedtls_ssl_conf_get_transport( ssl->conf ),
+                                       rec.ver );
             rec.type = ssl->out_msgtype;
 
 #if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
@@ -5815,7 +5819,7 @@
     rec->ver[0] = buf[ rec_hdr_version_offset + 0 ];
     rec->ver[1] = buf[ rec_hdr_version_offset + 1 ];
     mbedtls_ssl_read_version( &major_ver, &minor_ver,
-                              ssl->conf->transport,
+                              mbedtls_ssl_conf_get_transport( ssl->conf ),
                               &rec->ver[0] );
 
     if( major_ver != mbedtls_ssl_get_major_ver( ssl ) )
@@ -8604,7 +8608,7 @@
 #if defined(MBEDTLS_SSL_PROTO_DTLS)
     if( MBEDTLS_SSL_TRANSPORT_IS_DTLS( ssl->conf->transport ) )
     {
-        unsigned char i;
+        uint_fast8_t i;
 
         /* Remember current epoch settings for resending */
         ssl->handshake->alt_transform_out = ssl->transform_out;
@@ -9318,10 +9322,12 @@
 }
 #endif /* MBEDTLS_SSL_CONF_ENDPOINT */
 
+#if !defined(MBEDTLS_SSL_CONF_TRANSPORT)
 void mbedtls_ssl_conf_transport( mbedtls_ssl_config *conf, int transport )
 {
     conf->transport = transport;
 }
+#endif /* MBEDTLS_SSL_CONF_TRANSPORT */
 
 #if defined(MBEDTLS_SSL_DTLS_ANTI_REPLAY) && \
     !defined(MBEDTLS_SSL_CONF_ANTI_REPLAY)
@@ -10322,7 +10328,7 @@
     size_t read_mfl;
 
     /* Use the configured MFL for the client if we're past SERVER_HELLO_DONE */
-    if( ssl->conf->endpoint == MBEDTLS_SSL_IS_CLIENT &&
+    if( mbedtls_ssl_conf_get_endpoint( ssl->conf ) == MBEDTLS_SSL_IS_CLIENT &&
         ssl->state >= MBEDTLS_SSL_SERVER_HELLO_DONE )
     {
         return ssl_mfl_code_to_length( ssl->conf->mfl_code );
@@ -12781,8 +12787,10 @@
     memset( conf, 0, sizeof( mbedtls_ssl_config ) );
 
 #if !defined(MBEDTLS_SSL_PROTO_TLS)
+#if !defined(MBEDTLS_SSL_CONF_TRANSPORT)
     conf->transport = MBEDTLS_SSL_TRANSPORT_DATAGRAM;
 #endif
+#endif
 }
 
 #if defined(MBEDTLS_KEY_EXCHANGE__WITH_CERT__ENABLED)
@@ -12846,8 +12854,14 @@
 
     /* Use the functions here so that they are covered in tests,
      * but otherwise access member directly for efficiency */
+#if !defined(MBEDTLS_SSL_CONF_ENDPOINT)
     mbedtls_ssl_conf_endpoint( conf, endpoint );
+#endif
+#if !defined(MBEDTLS_SSL_CONF_TRANSPORT)
     mbedtls_ssl_conf_transport( conf, transport );
+#else
+    ((void) transport);
+#endif
 
     /*
      * Things that are common to all presets
diff --git a/programs/ssl/query_config.c b/programs/ssl/query_config.c
index 21800bb..bc6499d 100644
--- a/programs/ssl/query_config.c
+++ b/programs/ssl/query_config.c
@@ -2778,6 +2778,14 @@
     }
 #endif /* MBEDTLS_SSL_CONF_ENDPOINT */
 
+#if defined(MBEDTLS_SSL_CONF_TRANSPORT)
+    if( strcmp( "MBEDTLS_SSL_CONF_TRANSPORT", config ) == 0 )
+    {
+        MACRO_EXPANSION_TO_STR( MBEDTLS_SSL_CONF_TRANSPORT );
+        return( 0 );
+    }
+#endif /* MBEDTLS_SSL_CONF_TRANSPORT */
+
 #if defined(MBEDTLS_SSL_CONF_CERT_REQ_CA_LIST)
     if( strcmp( "MBEDTLS_SSL_CONF_CERT_REQ_CA_LIST", config ) == 0 )
     {
diff --git a/programs/ssl/ssl_server2.c b/programs/ssl/ssl_server2.c
index 52c4742..952af41 100644
--- a/programs/ssl/ssl_server2.c
+++ b/programs/ssl/ssl_server2.c
@@ -1643,6 +1643,103 @@
     char *p, *q;
     const int *list;
 
+#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
+    mbedtls_memory_buffer_alloc_init( alloc_buf, sizeof(alloc_buf) );
+#if defined(MBEDTLS_MEMORY_DEBUG)
+    size_t current_heap_memory, peak_heap_memory, heap_blocks;
+#endif  /* MBEDTLS_MEMORY_DEBUG */
+#endif  /* MBEDTLS_MEMORY_BUFFER_ALLOC_C */
+
+    ssl         = mbedtls_calloc( 1, sizeof( *ssl ) );
+    conf        = mbedtls_calloc( 1, sizeof( *conf ) );
+    entropy     = mbedtls_calloc( 1, sizeof( *entropy) );
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
+    cacert      = mbedtls_calloc( 1, sizeof( *cacert ) );
+    srvcert     = mbedtls_calloc( 1, sizeof( *srvcert ) );
+    pkey        = mbedtls_calloc( 1, sizeof( *pkey ) );
+    srvcert2    = mbedtls_calloc( 1, sizeof( *srvcert2 ) );
+    pkey2       = mbedtls_calloc( 1, sizeof( *pkey2 ) );
+#endif
+#if defined(MBEDTLS_SSL_CACHE_C)
+    cache       = mbedtls_calloc( 1, sizeof( *cache ) );
+#endif
+#if defined(MBEDTLS_TIMING_C)
+    timer       = mbedtls_calloc( 1, sizeof( *timer ) );
+#endif
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+    ticket_ctx  = mbedtls_calloc( 1, sizeof( *ticket_ctx ) );
+#endif
+#if defined(MBEDTLS_CTR_DRBG_C)
+    ctr_drbg    = mbedtls_calloc( 1, sizeof( *ctr_drbg ) );
+#else
+    hmac_drbg   = mbedtls_calloc( 1, sizeof( *hmac_drbg ) );
+#endif
+
+    if( ssl         == NULL || conf     == NULL ||
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
+        cacert      == NULL || srvcert  == NULL ||
+        pkey        == NULL || srvcert2 == NULL ||
+        pkey2       == NULL ||
+#endif
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+        ticket_ctx  == NULL ||
+#endif
+#if defined(MBEDTLS_SSL_CACHE_C)
+        cache       == NULL ||
+#endif
+#if defined(MBEDTLS_TIMING_C)
+        timer       == NULL ||
+#endif
+#if defined(MBEDTLS_CTR_DRBG_C)
+        ctr_drbg    == NULL ||
+#else
+        hmac_drbg   == NULL ||
+#endif
+        entropy     == NULL)
+    {
+        mbedtls_printf( "Initial allocations failed!\n" );
+        goto exit;
+    }
+
+    /*
+     * Make sure memory references are valid in case we exit early.
+     */
+    mbedtls_net_init( &client_fd );
+    mbedtls_net_init( &listen_fd );
+    mbedtls_ssl_init( ssl );
+    mbedtls_ssl_config_init( conf );
+    mbedtls_entropy_init( entropy );
+#if defined(MBEDTLS_CTR_DRBG_C)
+    mbedtls_ctr_drbg_init( ctr_drbg );
+#else
+    mbedtls_hmac_drbg_init( hmac_drbg );
+#endif /* MBEDTLS_CTR_DRBG_C */
+#if defined(MBEDTLS_X509_CRT_PARSE_C)
+    mbedtls_x509_crt_init( cacert );
+    mbedtls_x509_crt_init( srvcert );
+    mbedtls_pk_init( pkey );
+    mbedtls_x509_crt_init( srvcert2 );
+    mbedtls_pk_init( pkey2 );
+#if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
+    memset( &ssl_async_keys, 0, sizeof( ssl_async_keys ) );
+#endif
+#endif
+#if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_FS_IO)
+    mbedtls_dhm_init( &dhm );
+#endif
+#if defined(MBEDTLS_SSL_CACHE_C)
+    mbedtls_ssl_cache_init( cache );
+#endif
+#if defined(MBEDTLS_SSL_SESSION_TICKETS)
+    mbedtls_ssl_ticket_init( ticket_ctx );
+#endif
+#if defined(MBEDTLS_SSL_ALPN)
+    memset( (void *) alpn_list, 0, sizeof( alpn_list ) );
+#endif
+#if defined(MBEDTLS_SSL_COOKIE_C)
+    mbedtls_ssl_cookie_init( &cookie_ctx );
+#endif
+
 #if !defined(_WIN32)
     /* Abort cleanly on SIGTERM and SIGINT */
     signal( SIGTERM, term_handler );
@@ -2309,104 +2406,6 @@
         }
     }
 
-
-#if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C)
-    mbedtls_memory_buffer_alloc_init( alloc_buf, sizeof(alloc_buf) );
-#if defined(MBEDTLS_MEMORY_DEBUG)
-    size_t current_heap_memory, peak_heap_memory, heap_blocks;
-#endif  /* MBEDTLS_MEMORY_DEBUG */
-#endif  /* MBEDTLS_MEMORY_BUFFER_ALLOC_C */
-
-    ssl         = mbedtls_calloc( 1, sizeof( *ssl ) );
-    conf        = mbedtls_calloc( 1, sizeof( *conf ) );
-    entropy     = mbedtls_calloc( 1, sizeof( *entropy) );
-#if defined(MBEDTLS_X509_CRT_PARSE_C)
-    cacert      = mbedtls_calloc( 1, sizeof( *cacert ) );
-    srvcert     = mbedtls_calloc( 1, sizeof( *srvcert ) );
-    pkey        = mbedtls_calloc( 1, sizeof( *pkey ) );
-    srvcert2    = mbedtls_calloc( 1, sizeof( *srvcert2 ) );
-    pkey2       = mbedtls_calloc( 1, sizeof( *pkey2 ) );
-#endif
-#if defined(MBEDTLS_SSL_CACHE_C)
-    cache       = mbedtls_calloc( 1, sizeof( *cache ) );
-#endif
-#if defined(MBEDTLS_TIMING_C)
-    timer       = mbedtls_calloc( 1, sizeof( *timer ) );
-#endif
-#if defined(MBEDTLS_SSL_SESSION_TICKETS)
-    ticket_ctx  = mbedtls_calloc( 1, sizeof( *ticket_ctx ) );
-#endif
-#if defined(MBEDTLS_CTR_DRBG_C)
-    ctr_drbg    = mbedtls_calloc( 1, sizeof( *ctr_drbg ) );
-#else
-    hmac_drbg   = mbedtls_calloc( 1, sizeof( *hmac_drbg ) );
-#endif
-
-    if( ssl         == NULL || conf     == NULL ||
-#if defined(MBEDTLS_X509_CRT_PARSE_C)
-        cacert      == NULL || srvcert  == NULL ||
-        pkey        == NULL || srvcert2 == NULL ||
-        pkey2       == NULL ||
-#endif
-#if defined(MBEDTLS_SSL_SESSION_TICKETS)
-        ticket_ctx  == NULL ||
-#endif
-#if defined(MBEDTLS_SSL_CACHE_C)
-        cache       == NULL ||
-#endif
-#if defined(MBEDTLS_TIMING_C)
-        timer       == NULL ||
-#endif
-#if defined(MBEDTLS_CTR_DRBG_C)
-        ctr_drbg    == NULL ||
-#else
-        hmac_drbg   == NULL ||
-#endif
-        entropy     == NULL)
-    {
-        mbedtls_printf( "Initial allocations failed!\n" );
-        goto exit;
-    }
-
-    /*
-     * Make sure memory references are valid in case we exit early.
-     */
-    mbedtls_net_init( &client_fd );
-    mbedtls_net_init( &listen_fd );
-    mbedtls_ssl_init( ssl );
-    mbedtls_ssl_config_init( conf );
-    mbedtls_entropy_init( entropy );
-#if defined(MBEDTLS_CTR_DRBG_C)
-    mbedtls_ctr_drbg_init( ctr_drbg );
-#else
-    mbedtls_hmac_drbg_init( hmac_drbg );
-#endif /* MBEDTLS_CTR_DRBG_C */
-#if defined(MBEDTLS_X509_CRT_PARSE_C)
-    mbedtls_x509_crt_init( cacert );
-    mbedtls_x509_crt_init( srvcert );
-    mbedtls_pk_init( pkey );
-    mbedtls_x509_crt_init( srvcert2 );
-    mbedtls_pk_init( pkey2 );
-#if defined(MBEDTLS_SSL_ASYNC_PRIVATE)
-    memset( &ssl_async_keys, 0, sizeof( ssl_async_keys ) );
-#endif
-#endif
-#if defined(MBEDTLS_DHM_C) && defined(MBEDTLS_FS_IO)
-    mbedtls_dhm_init( &dhm );
-#endif
-#if defined(MBEDTLS_SSL_CACHE_C)
-    mbedtls_ssl_cache_init( cache );
-#endif
-#if defined(MBEDTLS_SSL_SESSION_TICKETS)
-    mbedtls_ssl_ticket_init( ticket_ctx );
-#endif
-#if defined(MBEDTLS_SSL_ALPN)
-    memset( (void *) alpn_list, 0, sizeof( alpn_list ) );
-#endif
-#if defined(MBEDTLS_SSL_COOKIE_C)
-    mbedtls_ssl_cookie_init( &cookie_ctx );
-#endif
-
 #if defined(MBEDTLS_SSL_DTLS_CONNECTION_ID)
     if( unhexify( cid, opt.cid_val, &cid_len ) != 0 )
     {
diff --git a/tinycrypt/ecc.c b/tinycrypt/ecc.c
index ba4a3ac..a6c8467 100644
--- a/tinycrypt/ecc.c
+++ b/tinycrypt/ecc.c
@@ -160,7 +160,7 @@
 		0x76, 0x0a, 0xe2, 0xbc, 0xce, 0x2a, 0xa2, 0xc6,
 		0x38, 0xf2, 0x19, 0x1d, 0x76, 0x72, 0x93, 0x49,
 	};
-	unsigned char diff = 0;
+	int diff = 0;
 	unsigned char tmp1, tmp2;
 	volatile unsigned i;
 
@@ -177,7 +177,7 @@
 
 	/* i should be 32 */
 	mbedtls_platform_random_delay();
-	diff |= (unsigned char) i ^ 32;
+	diff |= i ^ 32;
 
 	return diff;
 }