The Great Renaming

A simple execution of tmp/invoke-rename.pl
diff --git a/library/bignum.c b/library/bignum.c
index 8a751a3..45f9667 100644
--- a/library/bignum.c
+++ b/library/bignum.c
@@ -23,39 +23,39 @@
  *  This MPI implementation is based on:
  *
  *  http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf
- *  http://www.stillhq.com/extracted/gnupg-api/mpi/
+ *  http://www.stillhq.com/extracted/gnupg-api/mbedtls_mpi/
  *  http://math.libtomcrypt.com/files/tommath.pdf
  */
 
-#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_BIGNUM_C)
+#if defined(MBEDTLS_BIGNUM_C)
 
 #include "mbedtls/bignum.h"
 #include "mbedtls/bn_mul.h"
 
 #include <string.h>
 
-#if defined(POLARSSL_PLATFORM_C)
+#if defined(MBEDTLS_PLATFORM_C)
 #include "mbedtls/platform.h"
 #else
 #include <stdio.h>
 #include <stdlib.h>
-#define polarssl_printf     printf
-#define polarssl_malloc     malloc
-#define polarssl_free       free
+#define mbedtls_printf     printf
+#define mbedtls_malloc     malloc
+#define mbedtls_free       free
 #endif
 
 /* 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;
 }
 
-#define ciL    (sizeof(t_uint))         /* chars in limb  */
+#define ciL    (sizeof(mbedtls_mpi_uint))         /* chars in limb  */
 #define biL    (ciL << 3)               /* bits  in limb  */
 #define biH    (ciL << 2)               /* half limb size */
 
@@ -68,7 +68,7 @@
 /*
  * Initialize one MPI
  */
-void mpi_init( mpi *X )
+void mbedtls_mpi_init( mbedtls_mpi *X )
 {
     if( X == NULL )
         return;
@@ -81,15 +81,15 @@
 /*
  * Unallocate one MPI
  */
-void mpi_free( mpi *X )
+void mbedtls_mpi_free( mbedtls_mpi *X )
 {
     if( X == NULL )
         return;
 
     if( X->p != NULL )
     {
-        polarssl_zeroize( X->p, X->n * ciL );
-        polarssl_free( X->p );
+        mbedtls_zeroize( X->p, X->n * ciL );
+        mbedtls_free( X->p );
     }
 
     X->s = 1;
@@ -100,25 +100,25 @@
 /*
  * Enlarge to the specified number of limbs
  */
-int mpi_grow( mpi *X, size_t nblimbs )
+int mbedtls_mpi_grow( mbedtls_mpi *X, size_t nblimbs )
 {
-    t_uint *p;
+    mbedtls_mpi_uint *p;
 
-    if( nblimbs > POLARSSL_MPI_MAX_LIMBS )
-        return( POLARSSL_ERR_MPI_MALLOC_FAILED );
+    if( nblimbs > MBEDTLS_MPI_MAX_LIMBS )
+        return( MBEDTLS_ERR_MPI_MALLOC_FAILED );
 
     if( X->n < nblimbs )
     {
-        if( ( p = polarssl_malloc( nblimbs * ciL ) ) == NULL )
-            return( POLARSSL_ERR_MPI_MALLOC_FAILED );
+        if( ( p = mbedtls_malloc( nblimbs * ciL ) ) == NULL )
+            return( MBEDTLS_ERR_MPI_MALLOC_FAILED );
 
         memset( p, 0, nblimbs * ciL );
 
         if( X->p != NULL )
         {
             memcpy( p, X->p, X->n * ciL );
-            polarssl_zeroize( X->p, X->n * ciL );
-            polarssl_free( X->p );
+            mbedtls_zeroize( X->p, X->n * ciL );
+            mbedtls_free( X->p );
         }
 
         X->n = nblimbs;
@@ -132,14 +132,14 @@
  * Resize down as much as possible,
  * while keeping at least the specified number of limbs
  */
-int mpi_shrink( mpi *X, size_t nblimbs )
+int mbedtls_mpi_shrink( mbedtls_mpi *X, size_t nblimbs )
 {
-    t_uint *p;
+    mbedtls_mpi_uint *p;
     size_t i;
 
     /* Actually resize up in this case */
     if( X->n <= nblimbs )
-        return( mpi_grow( X, nblimbs ) );
+        return( mbedtls_mpi_grow( X, nblimbs ) );
 
     for( i = X->n - 1; i > 0; i-- )
         if( X->p[i] != 0 )
@@ -149,16 +149,16 @@
     if( i < nblimbs )
         i = nblimbs;
 
-    if( ( p = polarssl_malloc( i * ciL ) ) == NULL )
-        return( POLARSSL_ERR_MPI_MALLOC_FAILED );
+    if( ( p = mbedtls_malloc( i * ciL ) ) == NULL )
+        return( MBEDTLS_ERR_MPI_MALLOC_FAILED );
 
     memset( p, 0, i * ciL );
 
     if( X->p != NULL )
     {
         memcpy( p, X->p, i * ciL );
-        polarssl_zeroize( X->p, X->n * ciL );
-        polarssl_free( X->p );
+        mbedtls_zeroize( X->p, X->n * ciL );
+        mbedtls_free( X->p );
     }
 
     X->n = i;
@@ -170,7 +170,7 @@
 /*
  * Copy the contents of Y into X
  */
-int mpi_copy( mpi *X, const mpi *Y )
+int mbedtls_mpi_copy( mbedtls_mpi *X, const mbedtls_mpi *Y )
 {
     int ret;
     size_t i;
@@ -180,7 +180,7 @@
 
     if( Y->p == NULL )
     {
-        mpi_free( X );
+        mbedtls_mpi_free( X );
         return( 0 );
     }
 
@@ -191,7 +191,7 @@
 
     X->s = Y->s;
 
-    MPI_CHK( mpi_grow( X, i ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, i ) );
 
     memset( X->p, 0, X->n * ciL );
     memcpy( X->p, Y->p, i * ciL );
@@ -204,13 +204,13 @@
 /*
  * Swap the contents of X and Y
  */
-void mpi_swap( mpi *X, mpi *Y )
+void mbedtls_mpi_swap( mbedtls_mpi *X, mbedtls_mpi *Y )
 {
-    mpi T;
+    mbedtls_mpi T;
 
-    memcpy( &T,  X, sizeof( mpi ) );
-    memcpy(  X,  Y, sizeof( mpi ) );
-    memcpy(  Y, &T, sizeof( mpi ) );
+    memcpy( &T,  X, sizeof( mbedtls_mpi ) );
+    memcpy(  X,  Y, sizeof( mbedtls_mpi ) );
+    memcpy(  Y, &T, sizeof( mbedtls_mpi ) );
 }
 
 /*
@@ -218,7 +218,7 @@
  * about whether the assignment was made or not.
  * (Leaking information about the respective sizes of X and Y is ok however.)
  */
-int mpi_safe_cond_assign( mpi *X, const mpi *Y, unsigned char assign )
+int mbedtls_mpi_safe_cond_assign( mbedtls_mpi *X, const mbedtls_mpi *Y, unsigned char assign )
 {
     int ret = 0;
     size_t i;
@@ -226,7 +226,7 @@
     /* make sure assign is 0 or 1 */
     assign = ( assign != 0 );
 
-    MPI_CHK( mpi_grow( X, Y->n ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, Y->n ) );
 
     X->s = X->s * ( 1 - assign ) + Y->s * assign;
 
@@ -246,11 +246,11 @@
  * Here it is not ok to simply swap the pointers, which whould lead to
  * different memory access patterns when X and Y are used afterwards.
  */
-int mpi_safe_cond_swap( mpi *X, mpi *Y, unsigned char swap )
+int mbedtls_mpi_safe_cond_swap( mbedtls_mpi *X, mbedtls_mpi *Y, unsigned char swap )
 {
     int ret, s;
     size_t i;
-    t_uint tmp;
+    mbedtls_mpi_uint tmp;
 
     if( X == Y )
         return( 0 );
@@ -258,8 +258,8 @@
     /* make sure swap is 0 or 1 */
     swap = ( swap != 0 );
 
-    MPI_CHK( mpi_grow( X, Y->n ) );
-    MPI_CHK( mpi_grow( Y, X->n ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, Y->n ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( Y, X->n ) );
 
     s = X->s;
     X->s = X->s * ( 1 - swap ) + Y->s * swap;
@@ -280,11 +280,11 @@
 /*
  * Set value from integer
  */
-int mpi_lset( mpi *X, t_sint z )
+int mbedtls_mpi_lset( mbedtls_mpi *X, mbedtls_mpi_sint z )
 {
     int ret;
 
-    MPI_CHK( mpi_grow( X, 1 ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, 1 ) );
     memset( X->p, 0, X->n * ciL );
 
     X->p[0] = ( z < 0 ) ? -z : z;
@@ -298,7 +298,7 @@
 /*
  * Get a specific bit
  */
-int mpi_get_bit( const mpi *X, size_t pos )
+int mbedtls_mpi_get_bit( const mbedtls_mpi *X, size_t pos )
 {
     if( X->n * biL <= pos )
         return( 0 );
@@ -309,25 +309,25 @@
 /*
  * Set a bit to a specific value of 0 or 1
  */
-int mpi_set_bit( mpi *X, size_t pos, unsigned char val )
+int mbedtls_mpi_set_bit( mbedtls_mpi *X, size_t pos, unsigned char val )
 {
     int ret = 0;
     size_t off = pos / biL;
     size_t idx = pos % biL;
 
     if( val != 0 && val != 1 )
-        return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
 
     if( X->n * biL <= pos )
     {
         if( val == 0 )
             return( 0 );
 
-        MPI_CHK( mpi_grow( X, off + 1 ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, off + 1 ) );
     }
 
-    X->p[off] &= ~( (t_uint) 0x01 << idx );
-    X->p[off] |= (t_uint) val << idx;
+    X->p[off] &= ~( (mbedtls_mpi_uint) 0x01 << idx );
+    X->p[off] |= (mbedtls_mpi_uint) val << idx;
 
 cleanup:
 
@@ -337,7 +337,7 @@
 /*
  * Return the number of least significant bits
  */
-size_t mpi_lsb( const mpi *X )
+size_t mbedtls_mpi_lsb( const mbedtls_mpi *X )
 {
     size_t i, j, count = 0;
 
@@ -352,7 +352,7 @@
 /*
  * Return the number of most significant bits
  */
-size_t mpi_msb( const mpi *X )
+size_t mbedtls_mpi_msb( const mbedtls_mpi *X )
 {
     size_t i, j;
 
@@ -370,15 +370,15 @@
 /*
  * Return the total size in bytes
  */
-size_t mpi_size( const mpi *X )
+size_t mbedtls_mpi_size( const mbedtls_mpi *X )
 {
-    return( ( mpi_msb( X ) + 7 ) >> 3 );
+    return( ( mbedtls_mpi_msb( X ) + 7 ) >> 3 );
 }
 
 /*
  * Convert an ASCII character to digit value
  */
-static int mpi_get_digit( t_uint *d, int radix, char c )
+static int mpi_get_digit( mbedtls_mpi_uint *d, int radix, char c )
 {
     *d = 255;
 
@@ -386,8 +386,8 @@
     if( c >= 0x41 && c <= 0x46 ) *d = c - 0x37;
     if( c >= 0x61 && c <= 0x66 ) *d = c - 0x57;
 
-    if( *d >= (t_uint) radix )
-        return( POLARSSL_ERR_MPI_INVALID_CHARACTER );
+    if( *d >= (mbedtls_mpi_uint) radix )
+        return( MBEDTLS_ERR_MPI_INVALID_CHARACTER );
 
     return( 0 );
 }
@@ -395,17 +395,17 @@
 /*
  * Import from an ASCII string
  */
-int mpi_read_string( mpi *X, int radix, const char *s )
+int mbedtls_mpi_read_string( mbedtls_mpi *X, int radix, const char *s )
 {
     int ret;
     size_t i, j, slen, n;
-    t_uint d;
-    mpi T;
+    mbedtls_mpi_uint d;
+    mbedtls_mpi T;
 
     if( radix < 2 || radix > 16 )
-        return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
 
-    mpi_init( &T );
+    mbedtls_mpi_init( &T );
 
     slen = strlen( s );
 
@@ -413,8 +413,8 @@
     {
         n = BITS_TO_LIMBS( slen << 2 );
 
-        MPI_CHK( mpi_grow( X, n ) );
-        MPI_CHK( mpi_lset( X, 0 ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, n ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );
 
         for( i = slen, j = 0; i > 0; i--, j++ )
         {
@@ -424,13 +424,13 @@
                 break;
             }
 
-            MPI_CHK( mpi_get_digit( &d, radix, s[i - 1] ) );
+            MBEDTLS_MPI_CHK( mpi_get_digit( &d, radix, s[i - 1] ) );
             X->p[j / ( 2 * ciL )] |= d << ( ( j % ( 2 * ciL ) ) << 2 );
         }
     }
     else
     {
-        MPI_CHK( mpi_lset( X, 0 ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );
 
         for( i = 0; i < slen; i++ )
         {
@@ -440,23 +440,23 @@
                 continue;
             }
 
-            MPI_CHK( mpi_get_digit( &d, radix, s[i] ) );
-            MPI_CHK( mpi_mul_int( &T, X, radix ) );
+            MBEDTLS_MPI_CHK( mpi_get_digit( &d, radix, s[i] ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T, X, radix ) );
 
             if( X->s == 1 )
             {
-                MPI_CHK( mpi_add_int( X, &T, d ) );
+                MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, &T, d ) );
             }
             else
             {
-                MPI_CHK( mpi_sub_int( X, &T, d ) );
+                MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( X, &T, d ) );
             }
         }
     }
 
 cleanup:
 
-    mpi_free( &T );
+    mbedtls_mpi_free( &T );
 
     return( ret );
 }
@@ -464,19 +464,19 @@
 /*
  * Helper to write the digits high-order first
  */
-static int mpi_write_hlp( mpi *X, int radix, char **p )
+static int mpi_write_hlp( mbedtls_mpi *X, int radix, char **p )
 {
     int ret;
-    t_uint r;
+    mbedtls_mpi_uint r;
 
     if( radix < 2 || radix > 16 )
-        return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
 
-    MPI_CHK( mpi_mod_int( &r, X, radix ) );
-    MPI_CHK( mpi_div_int( X, NULL, X, radix ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, radix ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_div_int( X, NULL, X, radix ) );
 
-    if( mpi_cmp_int( X, 0 ) != 0 )
-        MPI_CHK( mpi_write_hlp( X, radix, p ) );
+    if( mbedtls_mpi_cmp_int( X, 0 ) != 0 )
+        MBEDTLS_MPI_CHK( mpi_write_hlp( X, radix, p ) );
 
     if( r < 10 )
         *(*p)++ = (char)( r + 0x30 );
@@ -491,17 +491,17 @@
 /*
  * Export into an ASCII string
  */
-int mpi_write_string( const mpi *X, int radix, char *s, size_t *slen )
+int mbedtls_mpi_write_string( const mbedtls_mpi *X, int radix, char *s, size_t *slen )
 {
     int ret = 0;
     size_t n;
     char *p;
-    mpi T;
+    mbedtls_mpi T;
 
     if( radix < 2 || radix > 16 )
-        return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
 
-    n = mpi_msb( X );
+    n = mbedtls_mpi_msb( X );
     if( radix >=  4 ) n >>= 1;
     if( radix >= 16 ) n >>= 1;
     n += 3;
@@ -509,11 +509,11 @@
     if( *slen < n )
     {
         *slen = n;
-        return( POLARSSL_ERR_MPI_BUFFER_TOO_SMALL );
+        return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
     }
 
     p = s;
-    mpi_init( &T );
+    mbedtls_mpi_init( &T );
 
     if( X->s == -1 )
         *p++ = '-';
@@ -540,12 +540,12 @@
     }
     else
     {
-        MPI_CHK( mpi_copy( &T, X ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &T, X ) );
 
         if( T.s == -1 )
             T.s = 1;
 
-        MPI_CHK( mpi_write_hlp( &T, radix, &p ) );
+        MBEDTLS_MPI_CHK( mpi_write_hlp( &T, radix, &p ) );
     }
 
     *p++ = '\0';
@@ -553,33 +553,33 @@
 
 cleanup:
 
-    mpi_free( &T );
+    mbedtls_mpi_free( &T );
 
     return( ret );
 }
 
-#if defined(POLARSSL_FS_IO)
+#if defined(MBEDTLS_FS_IO)
 /*
  * Read X from an opened file
  */
-int mpi_read_file( mpi *X, int radix, FILE *fin )
+int mbedtls_mpi_read_file( mbedtls_mpi *X, int radix, FILE *fin )
 {
-    t_uint d;
+    mbedtls_mpi_uint d;
     size_t slen;
     char *p;
     /*
      * Buffer should have space for (short) label and decimal formatted MPI,
      * newline characters and '\0'
      */
-    char s[ POLARSSL_MPI_RW_BUFFER_SIZE ];
+    char s[ MBEDTLS_MPI_RW_BUFFER_SIZE ];
 
     memset( s, 0, sizeof( s ) );
     if( fgets( s, sizeof( s ) - 1, fin ) == NULL )
-        return( POLARSSL_ERR_MPI_FILE_IO_ERROR );
+        return( MBEDTLS_ERR_MPI_FILE_IO_ERROR );
 
     slen = strlen( s );
     if( slen == sizeof( s ) - 2 )
-        return( POLARSSL_ERR_MPI_BUFFER_TOO_SMALL );
+        return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
 
     if( s[slen - 1] == '\n' ) { slen--; s[slen] = '\0'; }
     if( s[slen - 1] == '\r' ) { slen--; s[slen] = '\0'; }
@@ -589,13 +589,13 @@
         if( mpi_get_digit( &d, radix, *p ) != 0 )
             break;
 
-    return( mpi_read_string( X, radix, p + 1 ) );
+    return( mbedtls_mpi_read_string( X, radix, p + 1 ) );
 }
 
 /*
  * Write X into an opened file (or stdout if fout == NULL)
  */
-int mpi_write_file( const char *p, const mpi *X, int radix, FILE *fout )
+int mbedtls_mpi_write_file( const char *p, const mbedtls_mpi *X, int radix, FILE *fout )
 {
     int ret;
     size_t n, slen, plen;
@@ -603,13 +603,13 @@
      * Buffer should have space for (short) label and decimal formatted MPI,
      * newline characters and '\0'
      */
-    char s[ POLARSSL_MPI_RW_BUFFER_SIZE ];
+    char s[ MBEDTLS_MPI_RW_BUFFER_SIZE ];
 
     n = sizeof( s );
     memset( s, 0, n );
     n -= 2;
 
-    MPI_CHK( mpi_write_string( X, radix, s, (size_t *) &n ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_write_string( X, radix, s, (size_t *) &n ) );
 
     if( p == NULL ) p = "";
 
@@ -622,21 +622,21 @@
     {
         if( fwrite( p, 1, plen, fout ) != plen ||
             fwrite( s, 1, slen, fout ) != slen )
-            return( POLARSSL_ERR_MPI_FILE_IO_ERROR );
+            return( MBEDTLS_ERR_MPI_FILE_IO_ERROR );
     }
     else
-        polarssl_printf( "%s%s", p, s );
+        mbedtls_printf( "%s%s", p, s );
 
 cleanup:
 
     return( ret );
 }
-#endif /* POLARSSL_FS_IO */
+#endif /* MBEDTLS_FS_IO */
 
 /*
  * Import X from unsigned binary data, big endian
  */
-int mpi_read_binary( mpi *X, const unsigned char *buf, size_t buflen )
+int mbedtls_mpi_read_binary( mbedtls_mpi *X, const unsigned char *buf, size_t buflen )
 {
     int ret;
     size_t i, j, n;
@@ -645,11 +645,11 @@
         if( buf[n] != 0 )
             break;
 
-    MPI_CHK( mpi_grow( X, CHARS_TO_LIMBS( buflen - n ) ) );
-    MPI_CHK( mpi_lset( X, 0 ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, CHARS_TO_LIMBS( buflen - n ) ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );
 
     for( i = buflen, j = 0; i > n; i--, j++ )
-        X->p[j / ciL] |= ((t_uint) buf[i - 1]) << ((j % ciL) << 3);
+        X->p[j / ciL] |= ((mbedtls_mpi_uint) buf[i - 1]) << ((j % ciL) << 3);
 
 cleanup:
 
@@ -659,14 +659,14 @@
 /*
  * Export X into unsigned binary data, big endian
  */
-int mpi_write_binary( const mpi *X, unsigned char *buf, size_t buflen )
+int mbedtls_mpi_write_binary( const mbedtls_mpi *X, unsigned char *buf, size_t buflen )
 {
     size_t i, j, n;
 
-    n = mpi_size( X );
+    n = mbedtls_mpi_size( X );
 
     if( buflen < n )
-        return( POLARSSL_ERR_MPI_BUFFER_TOO_SMALL );
+        return( MBEDTLS_ERR_MPI_BUFFER_TOO_SMALL );
 
     memset( buf, 0, buflen );
 
@@ -679,19 +679,19 @@
 /*
  * Left-shift: X <<= count
  */
-int mpi_shift_l( mpi *X, size_t count )
+int mbedtls_mpi_shift_l( mbedtls_mpi *X, size_t count )
 {
     int ret;
     size_t i, v0, t1;
-    t_uint r0 = 0, r1;
+    mbedtls_mpi_uint r0 = 0, r1;
 
     v0 = count / (biL    );
     t1 = count & (biL - 1);
 
-    i = mpi_msb( X ) + count;
+    i = mbedtls_mpi_msb( X ) + count;
 
     if( X->n * biL < i )
-        MPI_CHK( mpi_grow( X, BITS_TO_LIMBS( i ) ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, BITS_TO_LIMBS( i ) ) );
 
     ret = 0;
 
@@ -729,16 +729,16 @@
 /*
  * Right-shift: X >>= count
  */
-int mpi_shift_r( mpi *X, size_t count )
+int mbedtls_mpi_shift_r( mbedtls_mpi *X, size_t count )
 {
     size_t i, v0, v1;
-    t_uint r0 = 0, r1;
+    mbedtls_mpi_uint r0 = 0, r1;
 
     v0 = count /  biL;
     v1 = count & (biL - 1);
 
     if( v0 > X->n || ( v0 == X->n && v1 > 0 ) )
-        return mpi_lset( X, 0 );
+        return mbedtls_mpi_lset( X, 0 );
 
     /*
      * shift by count / limb_size
@@ -772,7 +772,7 @@
 /*
  * Compare unsigned values
  */
-int mpi_cmp_abs( const mpi *X, const mpi *Y )
+int mbedtls_mpi_cmp_abs( const mbedtls_mpi *X, const mbedtls_mpi *Y )
 {
     size_t i, j;
 
@@ -802,7 +802,7 @@
 /*
  * Compare signed values
  */
-int mpi_cmp_mpi( const mpi *X, const mpi *Y )
+int mbedtls_mpi_cmp_mpi( const mbedtls_mpi *X, const mbedtls_mpi *Y )
 {
     size_t i, j;
 
@@ -835,35 +835,35 @@
 /*
  * Compare signed values
  */
-int mpi_cmp_int( const mpi *X, t_sint z )
+int mbedtls_mpi_cmp_int( const mbedtls_mpi *X, mbedtls_mpi_sint z )
 {
-    mpi Y;
-    t_uint p[1];
+    mbedtls_mpi Y;
+    mbedtls_mpi_uint p[1];
 
     *p  = ( z < 0 ) ? -z : z;
     Y.s = ( z < 0 ) ? -1 : 1;
     Y.n = 1;
     Y.p = p;
 
-    return( mpi_cmp_mpi( X, &Y ) );
+    return( mbedtls_mpi_cmp_mpi( X, &Y ) );
 }
 
 /*
  * Unsigned addition: X = |A| + |B|  (HAC 14.7)
  */
-int mpi_add_abs( mpi *X, const mpi *A, const mpi *B )
+int mbedtls_mpi_add_abs( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
 {
     int ret;
     size_t i, j;
-    t_uint *o, *p, c;
+    mbedtls_mpi_uint *o, *p, c;
 
     if( X == B )
     {
-        const mpi *T = A; A = X; B = T;
+        const mbedtls_mpi *T = A; A = X; B = T;
     }
 
     if( X != A )
-        MPI_CHK( mpi_copy( X, A ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, A ) );
 
     /*
      * X should always be positive as a result of unsigned additions.
@@ -874,7 +874,7 @@
         if( B->p[j - 1] != 0 )
             break;
 
-    MPI_CHK( mpi_grow( X, j ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, j ) );
 
     o = B->p; p = X->p; c = 0;
 
@@ -888,7 +888,7 @@
     {
         if( i >= X->n )
         {
-            MPI_CHK( mpi_grow( X, i + 1 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, i + 1 ) );
             p = X->p + i;
         }
 
@@ -901,12 +901,12 @@
 }
 
 /*
- * Helper for mpi subtraction
+ * Helper for mbedtls_mpi subtraction
  */
-static void mpi_sub_hlp( size_t n, t_uint *s, t_uint *d )
+static void mpi_sub_hlp( size_t n, mbedtls_mpi_uint *s, mbedtls_mpi_uint *d )
 {
     size_t i;
-    t_uint c, z;
+    mbedtls_mpi_uint c, z;
 
     for( i = c = 0; i < n; i++, s++, d++ )
     {
@@ -924,25 +924,25 @@
 /*
  * Unsigned subtraction: X = |A| - |B|  (HAC 14.9)
  */
-int mpi_sub_abs( mpi *X, const mpi *A, const mpi *B )
+int mbedtls_mpi_sub_abs( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
 {
-    mpi TB;
+    mbedtls_mpi TB;
     int ret;
     size_t n;
 
-    if( mpi_cmp_abs( A, B ) < 0 )
-        return( POLARSSL_ERR_MPI_NEGATIVE_VALUE );
+    if( mbedtls_mpi_cmp_abs( A, B ) < 0 )
+        return( MBEDTLS_ERR_MPI_NEGATIVE_VALUE );
 
-    mpi_init( &TB );
+    mbedtls_mpi_init( &TB );
 
     if( X == B )
     {
-        MPI_CHK( mpi_copy( &TB, B ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, B ) );
         B = &TB;
     }
 
     if( X != A )
-        MPI_CHK( mpi_copy( X, A ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, A ) );
 
     /*
      * X should always be positive as a result of unsigned subtractions.
@@ -959,7 +959,7 @@
 
 cleanup:
 
-    mpi_free( &TB );
+    mbedtls_mpi_free( &TB );
 
     return( ret );
 }
@@ -967,26 +967,26 @@
 /*
  * Signed addition: X = A + B
  */
-int mpi_add_mpi( mpi *X, const mpi *A, const mpi *B )
+int mbedtls_mpi_add_mpi( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
 {
     int ret, s = A->s;
 
     if( A->s * B->s < 0 )
     {
-        if( mpi_cmp_abs( A, B ) >= 0 )
+        if( mbedtls_mpi_cmp_abs( A, B ) >= 0 )
         {
-            MPI_CHK( mpi_sub_abs( X, A, B ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, A, B ) );
             X->s =  s;
         }
         else
         {
-            MPI_CHK( mpi_sub_abs( X, B, A ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, B, A ) );
             X->s = -s;
         }
     }
     else
     {
-        MPI_CHK( mpi_add_abs( X, A, B ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_add_abs( X, A, B ) );
         X->s = s;
     }
 
@@ -998,26 +998,26 @@
 /*
  * Signed subtraction: X = A - B
  */
-int mpi_sub_mpi( mpi *X, const mpi *A, const mpi *B )
+int mbedtls_mpi_sub_mpi( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
 {
     int ret, s = A->s;
 
     if( A->s * B->s > 0 )
     {
-        if( mpi_cmp_abs( A, B ) >= 0 )
+        if( mbedtls_mpi_cmp_abs( A, B ) >= 0 )
         {
-            MPI_CHK( mpi_sub_abs( X, A, B ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, A, B ) );
             X->s =  s;
         }
         else
         {
-            MPI_CHK( mpi_sub_abs( X, B, A ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, B, A ) );
             X->s = -s;
         }
     }
     else
     {
-        MPI_CHK( mpi_add_abs( X, A, B ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_add_abs( X, A, B ) );
         X->s = s;
     }
 
@@ -1029,37 +1029,37 @@
 /*
  * Signed addition: X = A + b
  */
-int mpi_add_int( mpi *X, const mpi *A, t_sint b )
+int mbedtls_mpi_add_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b )
 {
-    mpi _B;
-    t_uint p[1];
+    mbedtls_mpi _B;
+    mbedtls_mpi_uint p[1];
 
     p[0] = ( b < 0 ) ? -b : b;
     _B.s = ( b < 0 ) ? -1 : 1;
     _B.n = 1;
     _B.p = p;
 
-    return( mpi_add_mpi( X, A, &_B ) );
+    return( mbedtls_mpi_add_mpi( X, A, &_B ) );
 }
 
 /*
  * Signed subtraction: X = A - b
  */
-int mpi_sub_int( mpi *X, const mpi *A, t_sint b )
+int mbedtls_mpi_sub_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b )
 {
-    mpi _B;
-    t_uint p[1];
+    mbedtls_mpi _B;
+    mbedtls_mpi_uint p[1];
 
     p[0] = ( b < 0 ) ? -b : b;
     _B.s = ( b < 0 ) ? -1 : 1;
     _B.n = 1;
     _B.p = p;
 
-    return( mpi_sub_mpi( X, A, &_B ) );
+    return( mbedtls_mpi_sub_mpi( X, A, &_B ) );
 }
 
 /*
- * Helper for mpi multiplication
+ * Helper for mbedtls_mpi multiplication
  */
 static
 #if defined(__APPLE__) && defined(__arm__)
@@ -1069,9 +1069,9 @@
  */
 __attribute__ ((noinline))
 #endif
-void mpi_mul_hlp( size_t i, t_uint *s, t_uint *d, t_uint b )
+void mpi_mul_hlp( size_t i, mbedtls_mpi_uint *s, mbedtls_mpi_uint *d, mbedtls_mpi_uint b )
 {
-    t_uint c = 0, t = 0;
+    mbedtls_mpi_uint c = 0, t = 0;
 
 #if defined(MULADDC_HUIT)
     for( ; i >= 8; i -= 8 )
@@ -1133,16 +1133,16 @@
 /*
  * Baseline multiplication: X = A * B  (HAC 14.12)
  */
-int mpi_mul_mpi( mpi *X, const mpi *A, const mpi *B )
+int mbedtls_mpi_mul_mpi( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
 {
     int ret;
     size_t i, j;
-    mpi TA, TB;
+    mbedtls_mpi TA, TB;
 
-    mpi_init( &TA ); mpi_init( &TB );
+    mbedtls_mpi_init( &TA ); mbedtls_mpi_init( &TB );
 
-    if( X == A ) { MPI_CHK( mpi_copy( &TA, A ) ); A = &TA; }
-    if( X == B ) { MPI_CHK( mpi_copy( &TB, B ) ); B = &TB; }
+    if( X == A ) { MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TA, A ) ); A = &TA; }
+    if( X == B ) { MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, B ) ); B = &TB; }
 
     for( i = A->n; i > 0; i-- )
         if( A->p[i - 1] != 0 )
@@ -1152,8 +1152,8 @@
         if( B->p[j - 1] != 0 )
             break;
 
-    MPI_CHK( mpi_grow( X, i + j ) );
-    MPI_CHK( mpi_lset( X, 0 ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, i + j ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_lset( X, 0 ) );
 
     for( i++; j > 0; j-- )
         mpi_mul_hlp( i - 1, A->p, X->p + j - 1, B->p[j - 1] );
@@ -1162,7 +1162,7 @@
 
 cleanup:
 
-    mpi_free( &TB ); mpi_free( &TA );
+    mbedtls_mpi_free( &TB ); mbedtls_mpi_free( &TA );
 
     return( ret );
 }
@@ -1170,69 +1170,69 @@
 /*
  * Baseline multiplication: X = A * b
  */
-int mpi_mul_int( mpi *X, const mpi *A, t_uint b )
+int mbedtls_mpi_mul_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_uint b )
 {
-    mpi _B;
-    t_uint p[1];
+    mbedtls_mpi _B;
+    mbedtls_mpi_uint p[1];
 
     _B.s = 1;
     _B.n = 1;
     _B.p = p;
     p[0] = b;
 
-    return( mpi_mul_mpi( X, A, &_B ) );
+    return( mbedtls_mpi_mul_mpi( X, A, &_B ) );
 }
 
 /*
- * Division by mpi: A = Q * B + R  (HAC 14.20)
+ * Division by mbedtls_mpi: A = Q * B + R  (HAC 14.20)
  */
-int mpi_div_mpi( mpi *Q, mpi *R, const mpi *A, const mpi *B )
+int mbedtls_mpi_div_mpi( mbedtls_mpi *Q, mbedtls_mpi *R, const mbedtls_mpi *A, const mbedtls_mpi *B )
 {
     int ret;
     size_t i, n, t, k;
-    mpi X, Y, Z, T1, T2;
+    mbedtls_mpi X, Y, Z, T1, T2;
 
-    if( mpi_cmp_int( B, 0 ) == 0 )
-        return( POLARSSL_ERR_MPI_DIVISION_BY_ZERO );
+    if( mbedtls_mpi_cmp_int( B, 0 ) == 0 )
+        return( MBEDTLS_ERR_MPI_DIVISION_BY_ZERO );
 
-    mpi_init( &X ); mpi_init( &Y ); mpi_init( &Z );
-    mpi_init( &T1 ); mpi_init( &T2 );
+    mbedtls_mpi_init( &X ); mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &Z );
+    mbedtls_mpi_init( &T1 ); mbedtls_mpi_init( &T2 );
 
-    if( mpi_cmp_abs( A, B ) < 0 )
+    if( mbedtls_mpi_cmp_abs( A, B ) < 0 )
     {
-        if( Q != NULL ) MPI_CHK( mpi_lset( Q, 0 ) );
-        if( R != NULL ) MPI_CHK( mpi_copy( R, A ) );
+        if( Q != NULL ) MBEDTLS_MPI_CHK( mbedtls_mpi_lset( Q, 0 ) );
+        if( R != NULL ) MBEDTLS_MPI_CHK( mbedtls_mpi_copy( R, A ) );
         return( 0 );
     }
 
-    MPI_CHK( mpi_copy( &X, A ) );
-    MPI_CHK( mpi_copy( &Y, B ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &X, A ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Y, B ) );
     X.s = Y.s = 1;
 
-    MPI_CHK( mpi_grow( &Z, A->n + 2 ) );
-    MPI_CHK( mpi_lset( &Z,  0 ) );
-    MPI_CHK( mpi_grow( &T1, 2 ) );
-    MPI_CHK( mpi_grow( &T2, 3 ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &Z, A->n + 2 ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &Z,  0 ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &T1, 2 ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &T2, 3 ) );
 
-    k = mpi_msb( &Y ) % biL;
+    k = mbedtls_mpi_msb( &Y ) % biL;
     if( k < biL - 1 )
     {
         k = biL - 1 - k;
-        MPI_CHK( mpi_shift_l( &X, k ) );
-        MPI_CHK( mpi_shift_l( &Y, k ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &X, k ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &Y, k ) );
     }
     else k = 0;
 
     n = X.n - 1;
     t = Y.n - 1;
-    MPI_CHK( mpi_shift_l( &Y, biL * ( n - t ) ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &Y, biL * ( n - t ) ) );
 
-    while( mpi_cmp_mpi( &X, &Y ) >= 0 )
+    while( mbedtls_mpi_cmp_mpi( &X, &Y ) >= 0 )
     {
         Z.p[n - t]++;
-        MPI_CHK( mpi_sub_mpi( &X, &X, &Y ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &X, &X, &Y ) );
     }
-    MPI_CHK( mpi_shift_r( &Y, biL * ( n - t ) ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &Y, biL * ( n - t ) ) );
 
     for( i = n; i > t ; i-- )
     {
@@ -1240,22 +1240,22 @@
             Z.p[i - t - 1] = ~0;
         else
         {
-#if defined(POLARSSL_HAVE_UDBL)
-            t_udbl r;
+#if defined(MBEDTLS_HAVE_UDBL)
+            mbedtls_t_udbl r;
 
-            r  = (t_udbl) X.p[i] << biL;
-            r |= (t_udbl) X.p[i - 1];
+            r  = (mbedtls_t_udbl) X.p[i] << biL;
+            r |= (mbedtls_t_udbl) X.p[i - 1];
             r /= Y.p[t];
-            if( r > ( (t_udbl) 1 << biL ) - 1 )
-                r = ( (t_udbl) 1 << biL ) - 1;
+            if( r > ( (mbedtls_t_udbl) 1 << biL ) - 1 )
+                r = ( (mbedtls_t_udbl) 1 << biL ) - 1;
 
-            Z.p[i - t - 1] = (t_uint) r;
+            Z.p[i - t - 1] = (mbedtls_mpi_uint) r;
 #else
             /*
              * __udiv_qrnnd_c, from gmp/longlong.h
              */
-            t_uint q0, q1, r0, r1;
-            t_uint d0, d1, d, m;
+            mbedtls_mpi_uint q0, q1, r0, r1;
+            mbedtls_mpi_uint d0, d1, d, m;
 
             d  = Y.p[t];
             d0 = ( d << biH ) >> biH;
@@ -1290,7 +1290,7 @@
             r0 -= m;
 
             Z.p[i - t - 1] = ( q1 << biH ) | q0;
-#endif /* POLARSSL_HAVE_UDBL && !64-bit Apple with Clang 5.0 */
+#endif /* MBEDTLS_HAVE_UDBL && !64-bit Apple with Clang 5.0 */
         }
 
         Z.p[i - t - 1]++;
@@ -1298,51 +1298,51 @@
         {
             Z.p[i - t - 1]--;
 
-            MPI_CHK( mpi_lset( &T1, 0 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &T1, 0 ) );
             T1.p[0] = ( t < 1 ) ? 0 : Y.p[t - 1];
             T1.p[1] = Y.p[t];
-            MPI_CHK( mpi_mul_int( &T1, &T1, Z.p[i - t - 1] ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T1, &T1, Z.p[i - t - 1] ) );
 
-            MPI_CHK( mpi_lset( &T2, 0 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &T2, 0 ) );
             T2.p[0] = ( i < 2 ) ? 0 : X.p[i - 2];
             T2.p[1] = ( i < 1 ) ? 0 : X.p[i - 1];
             T2.p[2] = X.p[i];
         }
-        while( mpi_cmp_mpi( &T1, &T2 ) > 0 );
+        while( mbedtls_mpi_cmp_mpi( &T1, &T2 ) > 0 );
 
-        MPI_CHK( mpi_mul_int( &T1, &Y, Z.p[i - t - 1] ) );
-        MPI_CHK( mpi_shift_l( &T1,  biL * ( i - t - 1 ) ) );
-        MPI_CHK( mpi_sub_mpi( &X, &X, &T1 ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_mul_int( &T1, &Y, Z.p[i - t - 1] ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &T1,  biL * ( i - t - 1 ) ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &X, &X, &T1 ) );
 
-        if( mpi_cmp_int( &X, 0 ) < 0 )
+        if( mbedtls_mpi_cmp_int( &X, 0 ) < 0 )
         {
-            MPI_CHK( mpi_copy( &T1, &Y ) );
-            MPI_CHK( mpi_shift_l( &T1, biL * ( i - t - 1 ) ) );
-            MPI_CHK( mpi_add_mpi( &X, &X, &T1 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &T1, &Y ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &T1, biL * ( i - t - 1 ) ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &X, &X, &T1 ) );
             Z.p[i - t - 1]--;
         }
     }
 
     if( Q != NULL )
     {
-        MPI_CHK( mpi_copy( Q, &Z ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( Q, &Z ) );
         Q->s = A->s * B->s;
     }
 
     if( R != NULL )
     {
-        MPI_CHK( mpi_shift_r( &X, k ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &X, k ) );
         X.s = A->s;
-        MPI_CHK( mpi_copy( R, &X ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( R, &X ) );
 
-        if( mpi_cmp_int( R, 0 ) == 0 )
+        if( mbedtls_mpi_cmp_int( R, 0 ) == 0 )
             R->s = 1;
     }
 
 cleanup:
 
-    mpi_free( &X ); mpi_free( &Y ); mpi_free( &Z );
-    mpi_free( &T1 ); mpi_free( &T2 );
+    mbedtls_mpi_free( &X ); mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &Z );
+    mbedtls_mpi_free( &T1 ); mbedtls_mpi_free( &T2 );
 
     return( ret );
 }
@@ -1350,36 +1350,36 @@
 /*
  * Division by int: A = Q * b + R
  */
-int mpi_div_int( mpi *Q, mpi *R, const mpi *A, t_sint b )
+int mbedtls_mpi_div_int( mbedtls_mpi *Q, mbedtls_mpi *R, const mbedtls_mpi *A, mbedtls_mpi_sint b )
 {
-    mpi _B;
-    t_uint p[1];
+    mbedtls_mpi _B;
+    mbedtls_mpi_uint p[1];
 
     p[0] = ( b < 0 ) ? -b : b;
     _B.s = ( b < 0 ) ? -1 : 1;
     _B.n = 1;
     _B.p = p;
 
-    return( mpi_div_mpi( Q, R, A, &_B ) );
+    return( mbedtls_mpi_div_mpi( Q, R, A, &_B ) );
 }
 
 /*
  * Modulo: R = A mod B
  */
-int mpi_mod_mpi( mpi *R, const mpi *A, const mpi *B )
+int mbedtls_mpi_mod_mpi( mbedtls_mpi *R, const mbedtls_mpi *A, const mbedtls_mpi *B )
 {
     int ret;
 
-    if( mpi_cmp_int( B, 0 ) < 0 )
-        return( POLARSSL_ERR_MPI_NEGATIVE_VALUE );
+    if( mbedtls_mpi_cmp_int( B, 0 ) < 0 )
+        return( MBEDTLS_ERR_MPI_NEGATIVE_VALUE );
 
-    MPI_CHK( mpi_div_mpi( NULL, R, A, B ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_div_mpi( NULL, R, A, B ) );
 
-    while( mpi_cmp_int( R, 0 ) < 0 )
-      MPI_CHK( mpi_add_mpi( R, R, B ) );
+    while( mbedtls_mpi_cmp_int( R, 0 ) < 0 )
+      MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( R, R, B ) );
 
-    while( mpi_cmp_mpi( R, B ) >= 0 )
-      MPI_CHK( mpi_sub_mpi( R, R, B ) );
+    while( mbedtls_mpi_cmp_mpi( R, B ) >= 0 )
+      MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( R, R, B ) );
 
 cleanup:
 
@@ -1389,16 +1389,16 @@
 /*
  * Modulo: r = A mod b
  */
-int mpi_mod_int( t_uint *r, const mpi *A, t_sint b )
+int mbedtls_mpi_mod_int( mbedtls_mpi_uint *r, const mbedtls_mpi *A, mbedtls_mpi_sint b )
 {
     size_t i;
-    t_uint x, y, z;
+    mbedtls_mpi_uint x, y, z;
 
     if( b == 0 )
-        return( POLARSSL_ERR_MPI_DIVISION_BY_ZERO );
+        return( MBEDTLS_ERR_MPI_DIVISION_BY_ZERO );
 
     if( b < 0 )
-        return( POLARSSL_ERR_MPI_NEGATIVE_VALUE );
+        return( MBEDTLS_ERR_MPI_NEGATIVE_VALUE );
 
     /*
      * handle trivial cases
@@ -1446,9 +1446,9 @@
 /*
  * Fast Montgomery initialization (thanks to Tom St Denis)
  */
-static void mpi_montg_init( t_uint *mm, const mpi *N )
+static void mpi_montg_init( mbedtls_mpi_uint *mm, const mbedtls_mpi *N )
 {
-    t_uint x, m0 = N->p[0];
+    mbedtls_mpi_uint x, m0 = N->p[0];
     unsigned int i;
 
     x  = m0;
@@ -1463,11 +1463,11 @@
 /*
  * Montgomery multiplication: A = A * B * R^-1 mod N  (HAC 14.36)
  */
-static void mpi_montmul( mpi *A, const mpi *B, const mpi *N, t_uint mm,
-                         const mpi *T )
+static void mpi_montmul( mbedtls_mpi *A, const mbedtls_mpi *B, const mbedtls_mpi *N, mbedtls_mpi_uint mm,
+                         const mbedtls_mpi *T )
 {
     size_t i, n, m;
-    t_uint u0, u1, *d;
+    mbedtls_mpi_uint u0, u1, *d;
 
     memset( T->p, 0, T->n * ciL );
 
@@ -1491,7 +1491,7 @@
 
     memcpy( A->p, d, ( n + 1 ) * ciL );
 
-    if( mpi_cmp_abs( A, N ) >= 0 )
+    if( mbedtls_mpi_cmp_abs( A, N ) >= 0 )
         mpi_sub_hlp( n, N->p, A->p );
     else
         /* prevent timing attacks */
@@ -1501,10 +1501,10 @@
 /*
  * Montgomery reduction: A = A * R^-1 mod N
  */
-static void mpi_montred( mpi *A, const mpi *N, t_uint mm, const mpi *T )
+static void mpi_montred( mbedtls_mpi *A, const mbedtls_mpi *N, mbedtls_mpi_uint mm, const mbedtls_mpi *T )
 {
-    t_uint z = 1;
-    mpi U;
+    mbedtls_mpi_uint z = 1;
+    mbedtls_mpi U;
 
     U.n = U.s = (int) z;
     U.p = &z;
@@ -1515,42 +1515,42 @@
 /*
  * Sliding-window exponentiation: X = A^E mod N  (HAC 14.85)
  */
-int mpi_exp_mod( mpi *X, const mpi *A, const mpi *E, const mpi *N, mpi *_RR )
+int mbedtls_mpi_exp_mod( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *E, const mbedtls_mpi *N, mbedtls_mpi *_RR )
 {
     int ret;
     size_t wbits, wsize, one = 1;
     size_t i, j, nblimbs;
     size_t bufsize, nbits;
-    t_uint ei, mm, state;
-    mpi RR, T, W[ 2 << POLARSSL_MPI_WINDOW_SIZE ], Apos;
+    mbedtls_mpi_uint ei, mm, state;
+    mbedtls_mpi RR, T, W[ 2 << MBEDTLS_MPI_WINDOW_SIZE ], Apos;
     int neg;
 
-    if( mpi_cmp_int( N, 0 ) < 0 || ( N->p[0] & 1 ) == 0 )
-        return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+    if( mbedtls_mpi_cmp_int( N, 0 ) < 0 || ( N->p[0] & 1 ) == 0 )
+        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
 
-    if( mpi_cmp_int( E, 0 ) < 0 )
-        return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+    if( mbedtls_mpi_cmp_int( E, 0 ) < 0 )
+        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
 
     /*
      * Init temps and window size
      */
     mpi_montg_init( &mm, N );
-    mpi_init( &RR ); mpi_init( &T );
-    mpi_init( &Apos );
+    mbedtls_mpi_init( &RR ); mbedtls_mpi_init( &T );
+    mbedtls_mpi_init( &Apos );
     memset( W, 0, sizeof( W ) );
 
-    i = mpi_msb( E );
+    i = mbedtls_mpi_msb( E );
 
     wsize = ( i > 671 ) ? 6 : ( i > 239 ) ? 5 :
             ( i >  79 ) ? 4 : ( i >  23 ) ? 3 : 1;
 
-    if( wsize > POLARSSL_MPI_WINDOW_SIZE )
-        wsize = POLARSSL_MPI_WINDOW_SIZE;
+    if( wsize > MBEDTLS_MPI_WINDOW_SIZE )
+        wsize = MBEDTLS_MPI_WINDOW_SIZE;
 
     j = N->n + 1;
-    MPI_CHK( mpi_grow( X, j ) );
-    MPI_CHK( mpi_grow( &W[1],  j ) );
-    MPI_CHK( mpi_grow( &T, j * 2 ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( X, j ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &W[1],  j ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &T, j * 2 ) );
 
     /*
      * Compensate for negative A (and correct at the end)
@@ -1558,7 +1558,7 @@
     neg = ( A->s == -1 );
     if( neg )
     {
-        MPI_CHK( mpi_copy( &Apos, A ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Apos, A ) );
         Apos.s = 1;
         A = &Apos;
     }
@@ -1568,30 +1568,30 @@
      */
     if( _RR == NULL || _RR->p == NULL )
     {
-        MPI_CHK( mpi_lset( &RR, 1 ) );
-        MPI_CHK( mpi_shift_l( &RR, N->n * 2 * biL ) );
-        MPI_CHK( mpi_mod_mpi( &RR, &RR, N ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &RR, 1 ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &RR, N->n * 2 * biL ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &RR, &RR, N ) );
 
         if( _RR != NULL )
-            memcpy( _RR, &RR, sizeof( mpi ) );
+            memcpy( _RR, &RR, sizeof( mbedtls_mpi ) );
     }
     else
-        memcpy( &RR, _RR, sizeof( mpi ) );
+        memcpy( &RR, _RR, sizeof( mbedtls_mpi ) );
 
     /*
      * W[1] = A * R^2 * R^-1 mod N = A * R mod N
      */
-    if( mpi_cmp_mpi( A, N ) >= 0 )
-        MPI_CHK( mpi_mod_mpi( &W[1], A, N ) );
+    if( mbedtls_mpi_cmp_mpi( A, N ) >= 0 )
+        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &W[1], A, N ) );
     else
-        MPI_CHK( mpi_copy( &W[1], A ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &W[1], A ) );
 
     mpi_montmul( &W[1], &RR, N, mm, &T );
 
     /*
      * X = R^2 * R^-1 mod N = R mod N
      */
-    MPI_CHK( mpi_copy( X, &RR ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, &RR ) );
     mpi_montred( X, N, mm, &T );
 
     if( wsize > 1 )
@@ -1601,8 +1601,8 @@
          */
         j =  one << ( wsize - 1 );
 
-        MPI_CHK( mpi_grow( &W[j], N->n + 1 ) );
-        MPI_CHK( mpi_copy( &W[j], &W[1]    ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &W[j], N->n + 1 ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &W[j], &W[1]    ) );
 
         for( i = 0; i < wsize - 1; i++ )
             mpi_montmul( &W[j], &W[j], N, mm, &T );
@@ -1612,8 +1612,8 @@
          */
         for( i = j + 1; i < ( one << wsize ); i++ )
         {
-            MPI_CHK( mpi_grow( &W[i], N->n + 1 ) );
-            MPI_CHK( mpi_copy( &W[i], &W[i - 1] ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_grow( &W[i], N->n + 1 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &W[i], &W[i - 1] ) );
 
             mpi_montmul( &W[i], &W[1], N, mm, &T );
         }
@@ -1634,7 +1634,7 @@
 
             nblimbs--;
 
-            bufsize = sizeof( t_uint ) << 3;
+            bufsize = sizeof( mbedtls_mpi_uint ) << 3;
         }
 
         bufsize--;
@@ -1704,18 +1704,18 @@
     if( neg )
     {
         X->s = -1;
-        MPI_CHK( mpi_add_mpi( X, N, X ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( X, N, X ) );
     }
 
 cleanup:
 
     for( i = ( one << ( wsize - 1 ) ); i < ( one << wsize ); i++ )
-        mpi_free( &W[i] );
+        mbedtls_mpi_free( &W[i] );
 
-    mpi_free( &W[1] ); mpi_free( &T ); mpi_free( &Apos );
+    mbedtls_mpi_free( &W[1] ); mbedtls_mpi_free( &T ); mbedtls_mpi_free( &Apos );
 
     if( _RR == NULL || _RR->p == NULL )
-        mpi_free( &RR );
+        mbedtls_mpi_free( &RR );
 
     return( ret );
 }
@@ -1723,51 +1723,51 @@
 /*
  * Greatest common divisor: G = gcd(A, B)  (HAC 14.54)
  */
-int mpi_gcd( mpi *G, const mpi *A, const mpi *B )
+int mbedtls_mpi_gcd( mbedtls_mpi *G, const mbedtls_mpi *A, const mbedtls_mpi *B )
 {
     int ret;
     size_t lz, lzt;
-    mpi TG, TA, TB;
+    mbedtls_mpi TG, TA, TB;
 
-    mpi_init( &TG ); mpi_init( &TA ); mpi_init( &TB );
+    mbedtls_mpi_init( &TG ); mbedtls_mpi_init( &TA ); mbedtls_mpi_init( &TB );
 
-    MPI_CHK( mpi_copy( &TA, A ) );
-    MPI_CHK( mpi_copy( &TB, B ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TA, A ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, B ) );
 
-    lz = mpi_lsb( &TA );
-    lzt = mpi_lsb( &TB );
+    lz = mbedtls_mpi_lsb( &TA );
+    lzt = mbedtls_mpi_lsb( &TB );
 
     if( lzt < lz )
         lz = lzt;
 
-    MPI_CHK( mpi_shift_r( &TA, lz ) );
-    MPI_CHK( mpi_shift_r( &TB, lz ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TA, lz ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TB, lz ) );
 
     TA.s = TB.s = 1;
 
-    while( mpi_cmp_int( &TA, 0 ) != 0 )
+    while( mbedtls_mpi_cmp_int( &TA, 0 ) != 0 )
     {
-        MPI_CHK( mpi_shift_r( &TA, mpi_lsb( &TA ) ) );
-        MPI_CHK( mpi_shift_r( &TB, mpi_lsb( &TB ) ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TA, mbedtls_mpi_lsb( &TA ) ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TB, mbedtls_mpi_lsb( &TB ) ) );
 
-        if( mpi_cmp_mpi( &TA, &TB ) >= 0 )
+        if( mbedtls_mpi_cmp_mpi( &TA, &TB ) >= 0 )
         {
-            MPI_CHK( mpi_sub_abs( &TA, &TA, &TB ) );
-            MPI_CHK( mpi_shift_r( &TA, 1 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( &TA, &TA, &TB ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TA, 1 ) );
         }
         else
         {
-            MPI_CHK( mpi_sub_abs( &TB, &TB, &TA ) );
-            MPI_CHK( mpi_shift_r( &TB, 1 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( &TB, &TB, &TA ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TB, 1 ) );
         }
     }
 
-    MPI_CHK( mpi_shift_l( &TB, lz ) );
-    MPI_CHK( mpi_copy( G, &TB ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( &TB, lz ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( G, &TB ) );
 
 cleanup:
 
-    mpi_free( &TG ); mpi_free( &TA ); mpi_free( &TB );
+    mbedtls_mpi_free( &TG ); mbedtls_mpi_free( &TA ); mbedtls_mpi_free( &TB );
 
     return( ret );
 }
@@ -1779,18 +1779,18 @@
  * regardless of the platform endianness (useful when f_rng is actually
  * deterministic, eg for tests).
  */
-int mpi_fill_random( mpi *X, size_t size,
+int mbedtls_mpi_fill_random( mbedtls_mpi *X, size_t size,
                      int (*f_rng)(void *, unsigned char *, size_t),
                      void *p_rng )
 {
     int ret;
-    unsigned char buf[POLARSSL_MPI_MAX_SIZE];
+    unsigned char buf[MBEDTLS_MPI_MAX_SIZE];
 
-    if( size > POLARSSL_MPI_MAX_SIZE )
-        return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+    if( size > MBEDTLS_MPI_MAX_SIZE )
+        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
 
-    MPI_CHK( f_rng( p_rng, buf, size ) );
-    MPI_CHK( mpi_read_binary( X, buf, size ) );
+    MBEDTLS_MPI_CHK( f_rng( p_rng, buf, size ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( X, buf, size ) );
 
 cleanup:
     return( ret );
@@ -1799,99 +1799,99 @@
 /*
  * Modular inverse: X = A^-1 mod N  (HAC 14.61 / 14.64)
  */
-int mpi_inv_mod( mpi *X, const mpi *A, const mpi *N )
+int mbedtls_mpi_inv_mod( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *N )
 {
     int ret;
-    mpi G, TA, TU, U1, U2, TB, TV, V1, V2;
+    mbedtls_mpi G, TA, TU, U1, U2, TB, TV, V1, V2;
 
-    if( mpi_cmp_int( N, 0 ) <= 0 )
-        return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+    if( mbedtls_mpi_cmp_int( N, 0 ) <= 0 )
+        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
 
-    mpi_init( &TA ); mpi_init( &TU ); mpi_init( &U1 ); mpi_init( &U2 );
-    mpi_init( &G ); mpi_init( &TB ); mpi_init( &TV );
-    mpi_init( &V1 ); mpi_init( &V2 );
+    mbedtls_mpi_init( &TA ); mbedtls_mpi_init( &TU ); mbedtls_mpi_init( &U1 ); mbedtls_mpi_init( &U2 );
+    mbedtls_mpi_init( &G ); mbedtls_mpi_init( &TB ); mbedtls_mpi_init( &TV );
+    mbedtls_mpi_init( &V1 ); mbedtls_mpi_init( &V2 );
 
-    MPI_CHK( mpi_gcd( &G, A, N ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( &G, A, N ) );
 
-    if( mpi_cmp_int( &G, 1 ) != 0 )
+    if( mbedtls_mpi_cmp_int( &G, 1 ) != 0 )
     {
-        ret = POLARSSL_ERR_MPI_NOT_ACCEPTABLE;
+        ret = MBEDTLS_ERR_MPI_NOT_ACCEPTABLE;
         goto cleanup;
     }
 
-    MPI_CHK( mpi_mod_mpi( &TA, A, N ) );
-    MPI_CHK( mpi_copy( &TU, &TA ) );
-    MPI_CHK( mpi_copy( &TB, N ) );
-    MPI_CHK( mpi_copy( &TV, N ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &TA, A, N ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TU, &TA ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TB, N ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &TV, N ) );
 
-    MPI_CHK( mpi_lset( &U1, 1 ) );
-    MPI_CHK( mpi_lset( &U2, 0 ) );
-    MPI_CHK( mpi_lset( &V1, 0 ) );
-    MPI_CHK( mpi_lset( &V2, 1 ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &U1, 1 ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &U2, 0 ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &V1, 0 ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &V2, 1 ) );
 
     do
     {
         while( ( TU.p[0] & 1 ) == 0 )
         {
-            MPI_CHK( mpi_shift_r( &TU, 1 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TU, 1 ) );
 
             if( ( U1.p[0] & 1 ) != 0 || ( U2.p[0] & 1 ) != 0 )
             {
-                MPI_CHK( mpi_add_mpi( &U1, &U1, &TB ) );
-                MPI_CHK( mpi_sub_mpi( &U2, &U2, &TA ) );
+                MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &U1, &U1, &TB ) );
+                MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &U2, &U2, &TA ) );
             }
 
-            MPI_CHK( mpi_shift_r( &U1, 1 ) );
-            MPI_CHK( mpi_shift_r( &U2, 1 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &U1, 1 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &U2, 1 ) );
         }
 
         while( ( TV.p[0] & 1 ) == 0 )
         {
-            MPI_CHK( mpi_shift_r( &TV, 1 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &TV, 1 ) );
 
             if( ( V1.p[0] & 1 ) != 0 || ( V2.p[0] & 1 ) != 0 )
             {
-                MPI_CHK( mpi_add_mpi( &V1, &V1, &TB ) );
-                MPI_CHK( mpi_sub_mpi( &V2, &V2, &TA ) );
+                MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &V1, &V1, &TB ) );
+                MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &V2, &V2, &TA ) );
             }
 
-            MPI_CHK( mpi_shift_r( &V1, 1 ) );
-            MPI_CHK( mpi_shift_r( &V2, 1 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &V1, 1 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &V2, 1 ) );
         }
 
-        if( mpi_cmp_mpi( &TU, &TV ) >= 0 )
+        if( mbedtls_mpi_cmp_mpi( &TU, &TV ) >= 0 )
         {
-            MPI_CHK( mpi_sub_mpi( &TU, &TU, &TV ) );
-            MPI_CHK( mpi_sub_mpi( &U1, &U1, &V1 ) );
-            MPI_CHK( mpi_sub_mpi( &U2, &U2, &V2 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &TU, &TU, &TV ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &U1, &U1, &V1 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &U2, &U2, &V2 ) );
         }
         else
         {
-            MPI_CHK( mpi_sub_mpi( &TV, &TV, &TU ) );
-            MPI_CHK( mpi_sub_mpi( &V1, &V1, &U1 ) );
-            MPI_CHK( mpi_sub_mpi( &V2, &V2, &U2 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &TV, &TV, &TU ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &V1, &V1, &U1 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &V2, &V2, &U2 ) );
         }
     }
-    while( mpi_cmp_int( &TU, 0 ) != 0 );
+    while( mbedtls_mpi_cmp_int( &TU, 0 ) != 0 );
 
-    while( mpi_cmp_int( &V1, 0 ) < 0 )
-        MPI_CHK( mpi_add_mpi( &V1, &V1, N ) );
+    while( mbedtls_mpi_cmp_int( &V1, 0 ) < 0 )
+        MBEDTLS_MPI_CHK( mbedtls_mpi_add_mpi( &V1, &V1, N ) );
 
-    while( mpi_cmp_mpi( &V1, N ) >= 0 )
-        MPI_CHK( mpi_sub_mpi( &V1, &V1, N ) );
+    while( mbedtls_mpi_cmp_mpi( &V1, N ) >= 0 )
+        MBEDTLS_MPI_CHK( mbedtls_mpi_sub_mpi( &V1, &V1, N ) );
 
-    MPI_CHK( mpi_copy( X, &V1 ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( X, &V1 ) );
 
 cleanup:
 
-    mpi_free( &TA ); mpi_free( &TU ); mpi_free( &U1 ); mpi_free( &U2 );
-    mpi_free( &G ); mpi_free( &TB ); mpi_free( &TV );
-    mpi_free( &V1 ); mpi_free( &V2 );
+    mbedtls_mpi_free( &TA ); mbedtls_mpi_free( &TU ); mbedtls_mpi_free( &U1 ); mbedtls_mpi_free( &U2 );
+    mbedtls_mpi_free( &G ); mbedtls_mpi_free( &TB ); mbedtls_mpi_free( &TV );
+    mbedtls_mpi_free( &V1 ); mbedtls_mpi_free( &V2 );
 
     return( ret );
 }
 
-#if defined(POLARSSL_GENPRIME)
+#if defined(MBEDTLS_GENPRIME)
 
 static const int small_prime[] =
 {
@@ -1924,27 +1924,27 @@
  * Return values:
  * 0: no small factor (possible prime, more tests needed)
  * 1: certain prime
- * POLARSSL_ERR_MPI_NOT_ACCEPTABLE: certain non-prime
+ * MBEDTLS_ERR_MPI_NOT_ACCEPTABLE: certain non-prime
  * other negative: error
  */
-static int mpi_check_small_factors( const mpi *X )
+static int mpi_check_small_factors( const mbedtls_mpi *X )
 {
     int ret = 0;
     size_t i;
-    t_uint r;
+    mbedtls_mpi_uint r;
 
     if( ( X->p[0] & 1 ) == 0 )
-        return( POLARSSL_ERR_MPI_NOT_ACCEPTABLE );
+        return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
 
     for( i = 0; small_prime[i] > 0; i++ )
     {
-        if( mpi_cmp_int( X, small_prime[i] ) <= 0 )
+        if( mbedtls_mpi_cmp_int( X, small_prime[i] ) <= 0 )
             return( 1 );
 
-        MPI_CHK( mpi_mod_int( &r, X, small_prime[i] ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, small_prime[i] ) );
 
         if( r == 0 )
-            return( POLARSSL_ERR_MPI_NOT_ACCEPTABLE );
+            return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
     }
 
 cleanup:
@@ -1954,27 +1954,27 @@
 /*
  * Miller-Rabin pseudo-primality test  (HAC 4.24)
  */
-static int mpi_miller_rabin( const mpi *X,
+static int mpi_miller_rabin( const mbedtls_mpi *X,
                              int (*f_rng)(void *, unsigned char *, size_t),
                              void *p_rng )
 {
     int ret;
     size_t i, j, n, s;
-    mpi W, R, T, A, RR;
+    mbedtls_mpi W, R, T, A, RR;
 
-    mpi_init( &W ); mpi_init( &R ); mpi_init( &T ); mpi_init( &A );
-    mpi_init( &RR );
+    mbedtls_mpi_init( &W ); mbedtls_mpi_init( &R ); mbedtls_mpi_init( &T ); mbedtls_mpi_init( &A );
+    mbedtls_mpi_init( &RR );
 
     /*
      * W = |X| - 1
      * R = W >> lsb( W )
      */
-    MPI_CHK( mpi_sub_int( &W, X, 1 ) );
-    s = mpi_lsb( &W );
-    MPI_CHK( mpi_copy( &R, &W ) );
-    MPI_CHK( mpi_shift_r( &R, s ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_sub_int( &W, X, 1 ) );
+    s = mbedtls_mpi_lsb( &W );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &R, &W ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &R, s ) );
 
-    i = mpi_msb( X );
+    i = mbedtls_mpi_msb( X );
     /*
      * HAC, table 4.4
      */
@@ -1987,34 +1987,34 @@
         /*
          * pick a random A, 1 < A < |X| - 1
          */
-        MPI_CHK( mpi_fill_random( &A, X->n * ciL, f_rng, p_rng ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( &A, X->n * ciL, f_rng, p_rng ) );
 
-        if( mpi_cmp_mpi( &A, &W ) >= 0 )
+        if( mbedtls_mpi_cmp_mpi( &A, &W ) >= 0 )
         {
-            j = mpi_msb( &A ) - mpi_msb( &W );
-            MPI_CHK( mpi_shift_r( &A, j + 1 ) );
+            j = mbedtls_mpi_msb( &A ) - mbedtls_mpi_msb( &W );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &A, j + 1 ) );
         }
         A.p[0] |= 3;
 
         /*
          * A = A^R mod |X|
          */
-        MPI_CHK( mpi_exp_mod( &A, &A, &R, X, &RR ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &A, &A, &R, X, &RR ) );
 
-        if( mpi_cmp_mpi( &A, &W ) == 0 ||
-            mpi_cmp_int( &A,  1 ) == 0 )
+        if( mbedtls_mpi_cmp_mpi( &A, &W ) == 0 ||
+            mbedtls_mpi_cmp_int( &A,  1 ) == 0 )
             continue;
 
         j = 1;
-        while( j < s && mpi_cmp_mpi( &A, &W ) != 0 )
+        while( j < s && mbedtls_mpi_cmp_mpi( &A, &W ) != 0 )
         {
             /*
              * A = A * A mod |X|
              */
-            MPI_CHK( mpi_mul_mpi( &T, &A, &A ) );
-            MPI_CHK( mpi_mod_mpi( &A, &T, X  ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &T, &A, &A ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_mod_mpi( &A, &T, X  ) );
 
-            if( mpi_cmp_int( &A, 1 ) == 0 )
+            if( mbedtls_mpi_cmp_int( &A, 1 ) == 0 )
                 break;
 
             j++;
@@ -2023,17 +2023,17 @@
         /*
          * not prime if A != |X| - 1 or A == 1
          */
-        if( mpi_cmp_mpi( &A, &W ) != 0 ||
-            mpi_cmp_int( &A,  1 ) == 0 )
+        if( mbedtls_mpi_cmp_mpi( &A, &W ) != 0 ||
+            mbedtls_mpi_cmp_int( &A,  1 ) == 0 )
         {
-            ret = POLARSSL_ERR_MPI_NOT_ACCEPTABLE;
+            ret = MBEDTLS_ERR_MPI_NOT_ACCEPTABLE;
             break;
         }
     }
 
 cleanup:
-    mpi_free( &W ); mpi_free( &R ); mpi_free( &T ); mpi_free( &A );
-    mpi_free( &RR );
+    mbedtls_mpi_free( &W ); mbedtls_mpi_free( &R ); mbedtls_mpi_free( &T ); mbedtls_mpi_free( &A );
+    mbedtls_mpi_free( &RR );
 
     return( ret );
 }
@@ -2041,22 +2041,22 @@
 /*
  * Pseudo-primality test: small factors, then Miller-Rabin
  */
-int mpi_is_prime( const mpi *X,
+int mbedtls_mpi_is_prime( const mbedtls_mpi *X,
                   int (*f_rng)(void *, unsigned char *, size_t),
                   void *p_rng )
 {
     int ret;
-    mpi XX;
+    mbedtls_mpi XX;
 
     XX.s = 1;
     XX.n = X->n;
     XX.p = X->p;
 
-    if( mpi_cmp_int( &XX, 0 ) == 0 ||
-        mpi_cmp_int( &XX, 1 ) == 0 )
-        return( POLARSSL_ERR_MPI_NOT_ACCEPTABLE );
+    if( mbedtls_mpi_cmp_int( &XX, 0 ) == 0 ||
+        mbedtls_mpi_cmp_int( &XX, 1 ) == 0 )
+        return( MBEDTLS_ERR_MPI_NOT_ACCEPTABLE );
 
-    if( mpi_cmp_int( &XX, 2 ) == 0 )
+    if( mbedtls_mpi_cmp_int( &XX, 2 ) == 0 )
         return( 0 );
 
     if( ( ret = mpi_check_small_factors( &XX ) ) != 0 )
@@ -2073,38 +2073,38 @@
 /*
  * Prime number generation
  */
-int mpi_gen_prime( mpi *X, size_t nbits, int dh_flag,
+int mbedtls_mpi_gen_prime( mbedtls_mpi *X, size_t nbits, int dh_flag,
                    int (*f_rng)(void *, unsigned char *, size_t),
                    void *p_rng )
 {
     int ret;
     size_t k, n;
-    t_uint r;
-    mpi Y;
+    mbedtls_mpi_uint r;
+    mbedtls_mpi Y;
 
-    if( nbits < 3 || nbits > POLARSSL_MPI_MAX_BITS )
-        return( POLARSSL_ERR_MPI_BAD_INPUT_DATA );
+    if( nbits < 3 || nbits > MBEDTLS_MPI_MAX_BITS )
+        return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
 
-    mpi_init( &Y );
+    mbedtls_mpi_init( &Y );
 
     n = BITS_TO_LIMBS( nbits );
 
-    MPI_CHK( mpi_fill_random( X, n * ciL, f_rng, p_rng ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_fill_random( X, n * ciL, f_rng, p_rng ) );
 
-    k = mpi_msb( X );
-    if( k < nbits ) MPI_CHK( mpi_shift_l( X, nbits - k ) );
-    if( k > nbits ) MPI_CHK( mpi_shift_r( X, k - nbits ) );
+    k = mbedtls_mpi_msb( X );
+    if( k < nbits ) MBEDTLS_MPI_CHK( mbedtls_mpi_shift_l( X, nbits - k ) );
+    if( k > nbits ) MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( X, k - nbits ) );
 
     X->p[0] |= 3;
 
     if( dh_flag == 0 )
     {
-        while( ( ret = mpi_is_prime( X, f_rng, p_rng ) ) != 0 )
+        while( ( ret = mbedtls_mpi_is_prime( X, f_rng, p_rng ) ) != 0 )
         {
-            if( ret != POLARSSL_ERR_MPI_NOT_ACCEPTABLE )
+            if( ret != MBEDTLS_ERR_MPI_NOT_ACCEPTABLE )
                 goto cleanup;
 
-            MPI_CHK( mpi_add_int( X, X, 2 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 2 ) );
         }
     }
     else
@@ -2114,15 +2114,15 @@
          * is X = 2 mod 3 (which is equivalent to Y = 2 mod 3).
          * Make sure it is satisfied, while keeping X = 3 mod 4
          */
-        MPI_CHK( mpi_mod_int( &r, X, 3 ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_mod_int( &r, X, 3 ) );
         if( r == 0 )
-            MPI_CHK( mpi_add_int( X, X, 8 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 8 ) );
         else if( r == 1 )
-            MPI_CHK( mpi_add_int( X, X, 4 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( X, X, 4 ) );
 
         /* Set Y = (X-1) / 2, which is X / 2 because X is odd */
-        MPI_CHK( mpi_copy( &Y, X ) );
-        MPI_CHK( mpi_shift_r( &Y, 1 ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_copy( &Y, X ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_shift_r( &Y, 1 ) );
 
         while( 1 )
         {
@@ -2138,7 +2138,7 @@
                 break;
             }
 
-            if( ret != POLARSSL_ERR_MPI_NOT_ACCEPTABLE )
+            if( ret != MBEDTLS_ERR_MPI_NOT_ACCEPTABLE )
                 goto cleanup;
 
             /*
@@ -2146,21 +2146,21 @@
              * Y = 1 mod 2 and Y = 2 mod 3 (eq X = 3 mod 4 and X = 2 mod 3)
              * so up Y by 6 and X by 12.
              */
-            MPI_CHK( mpi_add_int(  X,  X, 12 ) );
-            MPI_CHK( mpi_add_int( &Y, &Y, 6  ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_add_int(  X,  X, 12 ) );
+            MBEDTLS_MPI_CHK( mbedtls_mpi_add_int( &Y, &Y, 6  ) );
         }
     }
 
 cleanup:
 
-    mpi_free( &Y );
+    mbedtls_mpi_free( &Y );
 
     return( ret );
 }
 
-#endif /* POLARSSL_GENPRIME */
+#endif /* MBEDTLS_GENPRIME */
 
-#if defined(POLARSSL_SELF_TEST)
+#if defined(MBEDTLS_SELF_TEST)
 
 #define GCD_PAIR_COUNT  3
 
@@ -2174,34 +2174,34 @@
 /*
  * Checkup routine
  */
-int mpi_self_test( int verbose )
+int mbedtls_mpi_self_test( int verbose )
 {
     int ret, i;
-    mpi A, E, N, X, Y, U, V;
+    mbedtls_mpi A, E, N, X, Y, U, V;
 
-    mpi_init( &A ); mpi_init( &E ); mpi_init( &N ); mpi_init( &X );
-    mpi_init( &Y ); mpi_init( &U ); mpi_init( &V );
+    mbedtls_mpi_init( &A ); mbedtls_mpi_init( &E ); mbedtls_mpi_init( &N ); mbedtls_mpi_init( &X );
+    mbedtls_mpi_init( &Y ); mbedtls_mpi_init( &U ); mbedtls_mpi_init( &V );
 
-    MPI_CHK( mpi_read_string( &A, 16,
+    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &A, 16,
         "EFE021C2645FD1DC586E69184AF4A31E" \
         "D5F53E93B5F123FA41680867BA110131" \
         "944FE7952E2517337780CB0DB80E61AA" \
         "E7C8DDC6C5C6AADEB34EB38A2F40D5E6" ) );
 
-    MPI_CHK( mpi_read_string( &E, 16,
+    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &E, 16,
         "B2E7EFD37075B9F03FF989C7C5051C20" \
         "34D2A323810251127E7BF8625A4F49A5" \
         "F3E27F4DA8BD59C47D6DAABA4C8127BD" \
         "5B5C25763222FEFCCFC38B832366C29E" ) );
 
-    MPI_CHK( mpi_read_string( &N, 16,
+    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &N, 16,
         "0066A198186C18C10B2F5ED9B522752A" \
         "9830B69916E535C8F047518A889A43A5" \
         "94B6BED27A168D31D4A52F88925AA8F5" ) );
 
-    MPI_CHK( mpi_mul_mpi( &X, &A, &N ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_mul_mpi( &X, &A, &N ) );
 
-    MPI_CHK( mpi_read_string( &U, 16,
+    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &U, 16,
         "602AB7ECA597A3D6B56FF9829A5E8B85" \
         "9E857EA95A03512E2BAE7391688D264A" \
         "A5663B0341DB9CCFD2C4C5F421FEC814" \
@@ -2211,104 +2211,104 @@
         "30879B56C61DE584A0F53A2447A51E" ) );
 
     if( verbose != 0 )
-        polarssl_printf( "  MPI test #1 (mul_mpi): " );
+        mbedtls_printf( "  MPI test #1 (mul_mpi): " );
 
-    if( mpi_cmp_mpi( &X, &U ) != 0 )
+    if( mbedtls_mpi_cmp_mpi( &X, &U ) != 0 )
     {
         if( verbose != 0 )
-            polarssl_printf( "failed\n" );
+            mbedtls_printf( "failed\n" );
 
         ret = 1;
         goto cleanup;
     }
 
     if( verbose != 0 )
-        polarssl_printf( "passed\n" );
+        mbedtls_printf( "passed\n" );
 
-    MPI_CHK( mpi_div_mpi( &X, &Y, &A, &N ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_div_mpi( &X, &Y, &A, &N ) );
 
-    MPI_CHK( mpi_read_string( &U, 16,
+    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &U, 16,
         "256567336059E52CAE22925474705F39A94" ) );
 
-    MPI_CHK( mpi_read_string( &V, 16,
+    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &V, 16,
         "6613F26162223DF488E9CD48CC132C7A" \
         "0AC93C701B001B092E4E5B9F73BCD27B" \
         "9EE50D0657C77F374E903CDFA4C642" ) );
 
     if( verbose != 0 )
-        polarssl_printf( "  MPI test #2 (div_mpi): " );
+        mbedtls_printf( "  MPI test #2 (div_mpi): " );
 
-    if( mpi_cmp_mpi( &X, &U ) != 0 ||
-        mpi_cmp_mpi( &Y, &V ) != 0 )
+    if( mbedtls_mpi_cmp_mpi( &X, &U ) != 0 ||
+        mbedtls_mpi_cmp_mpi( &Y, &V ) != 0 )
     {
         if( verbose != 0 )
-            polarssl_printf( "failed\n" );
+            mbedtls_printf( "failed\n" );
 
         ret = 1;
         goto cleanup;
     }
 
     if( verbose != 0 )
-        polarssl_printf( "passed\n" );
+        mbedtls_printf( "passed\n" );
 
-    MPI_CHK( mpi_exp_mod( &X, &A, &E, &N, NULL ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_exp_mod( &X, &A, &E, &N, NULL ) );
 
-    MPI_CHK( mpi_read_string( &U, 16,
+    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &U, 16,
         "36E139AEA55215609D2816998ED020BB" \
         "BD96C37890F65171D948E9BC7CBAA4D9" \
         "325D24D6A3C12710F10A09FA08AB87" ) );
 
     if( verbose != 0 )
-        polarssl_printf( "  MPI test #3 (exp_mod): " );
+        mbedtls_printf( "  MPI test #3 (exp_mod): " );
 
-    if( mpi_cmp_mpi( &X, &U ) != 0 )
+    if( mbedtls_mpi_cmp_mpi( &X, &U ) != 0 )
     {
         if( verbose != 0 )
-            polarssl_printf( "failed\n" );
+            mbedtls_printf( "failed\n" );
 
         ret = 1;
         goto cleanup;
     }
 
     if( verbose != 0 )
-        polarssl_printf( "passed\n" );
+        mbedtls_printf( "passed\n" );
 
-    MPI_CHK( mpi_inv_mod( &X, &A, &N ) );
+    MBEDTLS_MPI_CHK( mbedtls_mpi_inv_mod( &X, &A, &N ) );
 
-    MPI_CHK( mpi_read_string( &U, 16,
+    MBEDTLS_MPI_CHK( mbedtls_mpi_read_string( &U, 16,
         "003A0AAEDD7E784FC07D8F9EC6E3BFD5" \
         "C3DBA76456363A10869622EAC2DD84EC" \
         "C5B8A74DAC4D09E03B5E0BE779F2DF61" ) );
 
     if( verbose != 0 )
-        polarssl_printf( "  MPI test #4 (inv_mod): " );
+        mbedtls_printf( "  MPI test #4 (inv_mod): " );
 
-    if( mpi_cmp_mpi( &X, &U ) != 0 )
+    if( mbedtls_mpi_cmp_mpi( &X, &U ) != 0 )
     {
         if( verbose != 0 )
-            polarssl_printf( "failed\n" );
+            mbedtls_printf( "failed\n" );
 
         ret = 1;
         goto cleanup;
     }
 
     if( verbose != 0 )
-        polarssl_printf( "passed\n" );
+        mbedtls_printf( "passed\n" );
 
     if( verbose != 0 )
-        polarssl_printf( "  MPI test #5 (simple gcd): " );
+        mbedtls_printf( "  MPI test #5 (simple gcd): " );
 
     for( i = 0; i < GCD_PAIR_COUNT; i++ )
     {
-        MPI_CHK( mpi_lset( &X, gcd_pairs[i][0] ) );
-        MPI_CHK( mpi_lset( &Y, gcd_pairs[i][1] ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &X, gcd_pairs[i][0] ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &Y, gcd_pairs[i][1] ) );
 
-        MPI_CHK( mpi_gcd( &A, &X, &Y ) );
+        MBEDTLS_MPI_CHK( mbedtls_mpi_gcd( &A, &X, &Y ) );
 
-        if( mpi_cmp_int( &A, gcd_pairs[i][2] ) != 0 )
+        if( mbedtls_mpi_cmp_int( &A, gcd_pairs[i][2] ) != 0 )
         {
             if( verbose != 0 )
-                polarssl_printf( "failed at %d\n", i );
+                mbedtls_printf( "failed at %d\n", i );
 
             ret = 1;
             goto cleanup;
@@ -2316,22 +2316,22 @@
     }
 
     if( verbose != 0 )
-        polarssl_printf( "passed\n" );
+        mbedtls_printf( "passed\n" );
 
 cleanup:
 
     if( ret != 0 && verbose != 0 )
-        polarssl_printf( "Unexpected error, return code = %08X\n", ret );
+        mbedtls_printf( "Unexpected error, return code = %08X\n", ret );
 
-    mpi_free( &A ); mpi_free( &E ); mpi_free( &N ); mpi_free( &X );
-    mpi_free( &Y ); mpi_free( &U ); mpi_free( &V );
+    mbedtls_mpi_free( &A ); mbedtls_mpi_free( &E ); mbedtls_mpi_free( &N ); mbedtls_mpi_free( &X );
+    mbedtls_mpi_free( &Y ); mbedtls_mpi_free( &U ); mbedtls_mpi_free( &V );
 
     if( verbose != 0 )
-        polarssl_printf( "\n" );
+        mbedtls_printf( "\n" );
 
     return( ret );
 }
 
-#endif /* POLARSSL_SELF_TEST */
+#endif /* MBEDTLS_SELF_TEST */
 
-#endif /* POLARSSL_BIGNUM_C */
+#endif /* MBEDTLS_BIGNUM_C */