diff --git a/library/ssl_cookie.c b/library/ssl_cookie.c
index 2958c5c..efcce3c 100644
--- a/library/ssl_cookie.c
+++ b/library/ssl_cookie.c
@@ -24,27 +24,27 @@
  * to store and retrieve the session information.
  */
 
-#if !defined(POLARSSL_CONFIG_FILE)
+#if !defined(MBEDTLS_CONFIG_FILE)
 #include "mbedtls/config.h"
 #else
-#include POLARSSL_CONFIG_FILE
+#include MBEDTLS_CONFIG_FILE
 #endif
 
-#if defined(POLARSSL_SSL_COOKIE_C)
+#if defined(MBEDTLS_SSL_COOKIE_C)
 
 #include "mbedtls/ssl_cookie.h"
 
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
 #include "mbedtls/platform.h"
 #else
-#define polarssl_malloc     malloc
-#define polarssl_free       free
+#define mbedtls_malloc     malloc
+#define mbedtls_free       free
 #endif
 
 #include <string.h>
 
 /* Implementation that should never be optimized out by the compiler */
-static void polarssl_zeroize( void *v, size_t n ) {
+static void mbedtls_zeroize( void *v, size_t n ) {
     volatile unsigned char *p = v; while( n-- ) *p++ = 0;
 }
 
@@ -53,16 +53,16 @@
  * available. Try SHA-256 first, 512 wastes resources since we need to stay
  * with max 32 bytes of cookie for DTLS 1.0
  */
-#if defined(POLARSSL_SHA256_C)
-#define COOKIE_MD           POLARSSL_MD_SHA224
+#if defined(MBEDTLS_SHA256_C)
+#define COOKIE_MD           MBEDTLS_MD_SHA224
 #define COOKIE_MD_OUTLEN    32
 #define COOKIE_HMAC_LEN     28
-#elif defined(POLARSSL_SHA512_C)
-#define COOKIE_MD           POLARSSL_MD_SHA384
+#elif defined(MBEDTLS_SHA512_C)
+#define COOKIE_MD           MBEDTLS_MD_SHA384
 #define COOKIE_MD_OUTLEN    48
 #define COOKIE_HMAC_LEN     28
-#elif defined(POLARSSL_SHA1_C)
-#define COOKIE_MD           POLARSSL_MD_SHA1
+#elif defined(MBEDTLS_SHA1_C)
+#define COOKIE_MD           MBEDTLS_MD_SHA1
 #define COOKIE_MD_OUTLEN    20
 #define COOKIE_HMAC_LEN     20
 #else
@@ -75,26 +75,26 @@
  */
 #define COOKIE_LEN      ( 4 + COOKIE_HMAC_LEN )
 
-void ssl_cookie_init( ssl_cookie_ctx *ctx )
+void mbedtls_ssl_cookie_init( mbedtls_ssl_cookie_ctx *ctx )
 {
-    md_init( &ctx->hmac_ctx );
-#if !defined(POLARSSL_HAVE_TIME)
+    mbedtls_md_init( &ctx->hmac_ctx );
+#if !defined(MBEDTLS_HAVE_TIME)
     ctx->serial = 0;
 #endif
-    ctx->timeout = POLARSSL_SSL_COOKIE_TIMEOUT;
+    ctx->timeout = MBEDTLS_SSL_COOKIE_TIMEOUT;
 }
 
-void ssl_cookie_set_timeout( ssl_cookie_ctx *ctx, unsigned long delay )
+void mbedtls_ssl_cookie_set_timeout( mbedtls_ssl_cookie_ctx *ctx, unsigned long delay )
 {
     ctx->timeout = delay;
 }
 
-void ssl_cookie_free( ssl_cookie_ctx *ctx )
+void mbedtls_ssl_cookie_free( mbedtls_ssl_cookie_ctx *ctx )
 {
-    md_free( &ctx->hmac_ctx );
+    mbedtls_md_free( &ctx->hmac_ctx );
 }
 
-int ssl_cookie_setup( ssl_cookie_ctx *ctx,
+int mbedtls_ssl_cookie_setup( mbedtls_ssl_cookie_ctx *ctx,
                       int (*f_rng)(void *, unsigned char *, size_t),
                       void *p_rng )
 {
@@ -104,15 +104,15 @@
     if( ( ret = f_rng( p_rng, key, sizeof( key ) ) ) != 0 )
         return( ret );
 
-    ret = md_setup( &ctx->hmac_ctx, md_info_from_type( COOKIE_MD ), 1 );
+    ret = mbedtls_md_setup( &ctx->hmac_ctx, mbedtls_md_info_from_type( COOKIE_MD ), 1 );
     if( ret != 0 )
         return( ret );
 
-    ret = md_hmac_starts( &ctx->hmac_ctx, key, sizeof( key ) );
+    ret = mbedtls_md_hmac_starts( &ctx->hmac_ctx, key, sizeof( key ) );
     if( ret != 0 )
         return( ret );
 
-    polarssl_zeroize( key, sizeof( key ) );
+    mbedtls_zeroize( key, sizeof( key ) );
 
     return( 0 );
 }
@@ -120,7 +120,7 @@
 /*
  * Generate the HMAC part of a cookie
  */
-static int ssl_cookie_hmac( md_context_t *hmac_ctx,
+static int ssl_cookie_hmac( mbedtls_md_context_t *hmac_ctx,
                             const unsigned char time[4],
                             unsigned char **p, unsigned char *end,
                             const unsigned char *cli_id, size_t cli_id_len )
@@ -129,14 +129,14 @@
     unsigned char hmac_out[COOKIE_MD_OUTLEN];
 
     if( (size_t)( end - *p ) < COOKIE_HMAC_LEN )
-        return( POLARSSL_ERR_SSL_BUFFER_TOO_SMALL );
+        return( MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
 
-    if( ( ret = md_hmac_reset(  hmac_ctx ) ) != 0 ||
-        ( ret = md_hmac_update( hmac_ctx, time, 4 ) ) != 0 ||
-        ( ret = md_hmac_update( hmac_ctx, cli_id, cli_id_len ) ) != 0 ||
-        ( ret = md_hmac_finish( hmac_ctx, hmac_out ) ) != 0 )
+    if( ( ret = mbedtls_md_hmac_reset(  hmac_ctx ) ) != 0 ||
+        ( ret = mbedtls_md_hmac_update( hmac_ctx, time, 4 ) ) != 0 ||
+        ( ret = mbedtls_md_hmac_update( hmac_ctx, cli_id, cli_id_len ) ) != 0 ||
+        ( ret = mbedtls_md_hmac_finish( hmac_ctx, hmac_out ) ) != 0 )
     {
-        return( POLARSSL_ERR_SSL_INTERNAL_ERROR );
+        return( MBEDTLS_ERR_SSL_INTERNAL_ERROR );
     }
 
     memcpy( *p, hmac_out, COOKIE_HMAC_LEN );
@@ -148,20 +148,20 @@
 /*
  * Generate cookie for DTLS ClientHello verification
  */
-int ssl_cookie_write( void *p_ctx,
+int mbedtls_ssl_cookie_write( void *p_ctx,
                       unsigned char **p, unsigned char *end,
                       const unsigned char *cli_id, size_t cli_id_len )
 {
-    ssl_cookie_ctx *ctx = (ssl_cookie_ctx *) p_ctx;
+    mbedtls_ssl_cookie_ctx *ctx = (mbedtls_ssl_cookie_ctx *) p_ctx;
     unsigned long t;
 
     if( ctx == NULL || cli_id == NULL )
-        return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+        return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
 
     if( (size_t)( end - *p ) < COOKIE_LEN )
-        return( POLARSSL_ERR_SSL_BUFFER_TOO_SMALL );
+        return( MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL );
 
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
     t = (unsigned long) time( NULL );
 #else
     t = ctx->serial++;
@@ -180,17 +180,17 @@
 /*
  * Check a cookie
  */
-int ssl_cookie_check( void *p_ctx,
+int mbedtls_ssl_cookie_check( void *p_ctx,
                       const unsigned char *cookie, size_t cookie_len,
                       const unsigned char *cli_id, size_t cli_id_len )
 {
     unsigned char ref_hmac[COOKIE_HMAC_LEN];
     unsigned char *p = ref_hmac;
-    ssl_cookie_ctx *ctx = (ssl_cookie_ctx *) p_ctx;
+    mbedtls_ssl_cookie_ctx *ctx = (mbedtls_ssl_cookie_ctx *) p_ctx;
     unsigned long cur_time, cookie_time;
 
     if( ctx == NULL || cli_id == NULL )
-        return( POLARSSL_ERR_SSL_BAD_INPUT_DATA );
+        return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
 
     if( cookie_len != COOKIE_LEN )
         return( -1 );
@@ -200,10 +200,10 @@
                          cli_id, cli_id_len ) != 0 )
         return( -1 );
 
-    if( safer_memcmp( cookie + 4, ref_hmac, sizeof( ref_hmac ) ) != 0 )
+    if( mbedtls_ssl_safer_memcmp( cookie + 4, ref_hmac, sizeof( ref_hmac ) ) != 0 )
         return( -1 );
 
-#if defined(POLARSSL_HAVE_TIME)
+#if defined(MBEDTLS_HAVE_TIME)
     cur_time = (unsigned long) time( NULL );
 #else
     cur_time = ctx->serial;
@@ -219,4 +219,4 @@
 
     return( 0 );
 }
-#endif /* POLARSSL_SSL_COOKIE_C */
+#endif /* MBEDTLS_SSL_COOKIE_C */