Added new API function mysql_get_info/mysql_get_infov which retrieves

global or connection dependent information:

mysql_get_infov(MYSQL *mysql, enum mariadb_value value, void *arg, ...)

the following value types are supported:
    MARIADB_CHARSET_ID (requires numeric 4th parameter)
    MARIADB_CHARSET_INFO (requires string 4th parameter)
    MARIADB_CHARSET_NAME
    MARIADB_CLIENT_ERRORS
    MARIADB_CLIENT_VERSION
    MARIADB_CLIENT_VERSION_ID
    MARIADB_CONNECTION_ASYNC_TIMEOUT
    MARIADB_CONNECTION_ASYNC_TIMEOUT_MS
    MARIADB_CONNECTION_HOST
    MARIADB_CONNECTION_INFO
    MARIADB_CONNECTION_PORT
    MARIADB_CONNECTION_PROTOCOL_VERSION_ID
    MARIADB_CONNECTION_PVIO_TYPE
    MARIADB_CONNECTION_SCHEMA
    MARIADB_CONNECTION_SERVER_TYPE
    MARIADB_CONNECTION_SERVER_VERSION
    MARIADB_CONNECTION_SERVER_VERSION_ID
    MARIADB_CONNECTION_SOCKET
    MARIADB_CONNECTION_SSL_CIPHER
    MARIADB_CONNECTION_SSL_VERSION
    MARIADB_CONNECTION_SSL_VERSION_ID
    MARIADB_CONNECTION_TYPE
    MARIADB_CONNECTION_UNIX_SOCKET
    MARIADB_CONNECTION_USER
    MARIADB_MAX_ALLOWED_PACKET
    MARIADB_NET_BUFFER_LENGTH

MARIADB_CONNECTION prefix indicates that a valid connection handle has
to be passed as first parameter.

include/ma_ssl.h

@@ -16,6 +16,11 @@ typedef struct st_ma_pvio_ssl {
   void *ssl;
 } MARIADB_SSL;
 
+struct st_ssl_version {
+  unsigned int iversion;
+  char *cversion;
+};
+
 /* Function prototypes */
 
 /* ma_ssl_start
@@ -124,6 +129,17 @@ const char *ma_ssl_get_cipher(MARIADB_SSL *ssl);
 */
 unsigned int ma_ssl_get_finger_print(MARIADB_SSL *cssl, unsigned char *fp, unsigned int fp_len);
 
+/* ma_ssl_get_protocol_version 
+   returns protocol version in use
+   Parameter:
+     MARIADB_SSL    MariaDB SSL container
+     version        pointer to ssl version info
+   Returns:
+     0              success
+     1              error
+*/
+my_bool ma_ssl_get_protocol_version(MARIADB_SSL *cssl, struct st_ssl_version *version);
+
 /* Function prototypes */
 MARIADB_SSL *ma_pvio_ssl_init(MYSQL *mysql);
 my_bool ma_pvio_ssl_connect(MARIADB_SSL *cssl);
@@ -134,5 +150,6 @@ int ma_pvio_ssl_verify_server_cert(MARIADB_SSL *cssl);
 const char *ma_pvio_ssl_cipher(MARIADB_SSL *cssl);
 my_bool ma_pvio_ssl_check_fp(MARIADB_SSL *cssl, const char *fp, const char *fp_list);
 my_bool ma_pvio_start_ssl(MARIADB_PVIO *pvio);
+my_bool ma_pvio_ssl_get_protocol_version(MARIADB_SSL *cssl, struct st_ssl_version *version);
 
 #endif /* _ma_ssl_h_ */

include/mysql.h

@@ -216,7 +216,36 @@ extern unsigned int mariadb_deinitialize_ssl;
     MARIADB_OPT_SSL_PASSWORD,       /* password for encrypted certificates */
     MARIADB_OPT_CONNECTION_READ_ONLY,
     MYSQL_OPT_CONNECT_ATTRS,        /* for mysql_get_optionv */
-    MARIADB_OPT_USERDATA,
+    MARIADB_OPT_USERDATA
+  };
+
+  enum mariadb_value {
+    MARIADB_CHARSET_ID,
+    MARIADB_CHARSET_INFO,
+    MARIADB_CHARSET_NAME,
+    MARIADB_CLIENT_ERRORS,
+    MARIADB_CLIENT_VERSION,
+    MARIADB_CLIENT_VERSION_ID,
+    MARIADB_CONNECTION_ASYNC_TIMEOUT,
+    MARIADB_CONNECTION_ASYNC_TIMEOUT_MS,
+    MARIADB_CONNECTION_HOST,
+    MARIADB_CONNECTION_INFO,
+    MARIADB_CONNECTION_PORT,
+    MARIADB_CONNECTION_PROTOCOL_VERSION_ID,
+    MARIADB_CONNECTION_PVIO_TYPE,
+    MARIADB_CONNECTION_SCHEMA,
+    MARIADB_CONNECTION_SERVER_TYPE,
+    MARIADB_CONNECTION_SERVER_VERSION,
+    MARIADB_CONNECTION_SERVER_VERSION_ID,
+    MARIADB_CONNECTION_SOCKET,
+    MARIADB_CONNECTION_SSL_CIPHER,
+    MARIADB_CONNECTION_SSL_VERSION,
+    MARIADB_CONNECTION_SSL_VERSION_ID,
+    MARIADB_CONNECTION_TYPE,
+    MARIADB_CONNECTION_UNIX_SOCKET,
+    MARIADB_CONNECTION_USER,
+    MARIADB_MAX_ALLOWED_PACKET,
+    MARIADB_NET_BUFFER_LENGTH
   };
 
   enum mysql_status { MYSQL_STATUS_READY,
@@ -407,6 +436,8 @@ const char * STDCALL mysql_character_set_name(MYSQL *mysql);
 void STDCALL mysql_get_character_set_info(MYSQL *mysql, MY_CHARSET_INFO *cs);
 int STDCALL mysql_set_character_set(MYSQL *mysql, const char *csname);
 
+my_bool STDCALL mariadb_get_infov(MYSQL *mysql, enum mariadb_value value, void *arg, ...);
+my_bool STDCALL mariadb_get_info(MYSQL *mysql, enum mariadb_value value, void *arg);
 MYSQL *		STDCALL mysql_init(MYSQL *mysql);
 int		STDCALL mysql_ssl_set(MYSQL *mysql, const char *key,
 				      const char *cert, const char *ca,
@@ -493,10 +524,9 @@ int STDCALL mysql_get_optionv(MYSQL *mysql, enum mysql_option option, void *arg,
 int STDCALL mysql_get_option(MYSQL *mysql, enum mysql_option option, void *arg);
 MYSQL_PARAMETERS *STDCALL mysql_get_parameters(void);
 unsigned long STDCALL mysql_hex_string(char *to, const char *from, size_t len);
-my_socket STDCALL mysql_get_socket(const MYSQL *mysql);
+my_socket STDCALL mysql_get_socket(MYSQL *mysql);
 unsigned int STDCALL mysql_get_timeout_value(const MYSQL *mysql);
 unsigned int STDCALL mysql_get_timeout_value_ms(const MYSQL *mysql);
-int STDCALL mariadb_get_connection_type(MYSQL *mysql);
 my_bool STDCALL mysql_reconnect(MYSQL *mysql);
 
 /* Async API */

libmariadb/CMakeLists.txt

@@ -36,7 +36,8 @@ SET(EXPORT_SYMBOLS
  mariadb_dyncol_val_str
  mariadb_get_charset_by_name
  mariadb_get_charset_by_nr
- mariadb_get_connection_type
+ mariadb_get_info
+ mariadb_get_infov
  mysql_affected_rows
  mysql_autocommit
  mysql_autocommit_cont

libmariadb/libmariadb.c

@@ -67,6 +67,9 @@
 #include <poll.h>
 #endif
 #include <ma_pvio.h>
+#ifdef HAVE_SSL
+#include <ma_ssl.h>
+#endif
 #include <ma_dyncol.h>
 #include <mysql/client_plugin.h>
 
@@ -2547,9 +2550,9 @@ mysql_get_server_info(MYSQL *mysql)
   return((char*) mysql->server_version);
 }
 
-unsigned long STDCALL mysql_get_server_version(MYSQL *mysql)
+static size_t mariadb_server_version_id(MYSQL *mysql)
 {
-  long major, minor, patch;
+  size_t major, minor, patch;
   char *p;
 
   if (!(p = mysql->server_version)) {
@@ -2562,7 +2565,12 @@ unsigned long STDCALL mysql_get_server_version(MYSQL *mysql)
   p += 1; /* consume the dot */
   patch = strtol(p, &p, 10);
 
-  return (unsigned long)(major * 10000L + (unsigned long)(minor * 100L + patch));
+  return (major * 10000L + (unsigned long)(minor * 100L + patch));
+}
+
+unsigned long STDCALL mysql_get_server_version(MYSQL *mysql)
+{
+  return (unsigned long)mariadb_server_version_id(mysql);
 }
 
 
@@ -3323,9 +3331,9 @@ mysql_real_escape_string(MYSQL *mysql, char *to,const char *from,
     return (ulong)mysql_cset_escape_slashes(mysql->charset, to, from, length);
 }
 
-void STDCALL mysql_get_character_set_info(MYSQL *mysql, MY_CHARSET_INFO *cs)
+static void mariadb_get_charset_info(MYSQL *mysql, MY_CHARSET_INFO *cs)
 {
-  DBUG_ENTER("mysql_get_character_set_info");
+  DBUG_ENTER("mariadb_get_charset_info");
 
   if (!cs)
     DBUG_VOID_RETURN;
@@ -3342,6 +3350,11 @@ void STDCALL mysql_get_character_set_info(MYSQL *mysql, MY_CHARSET_INFO *cs)
   DBUG_VOID_RETURN;
 }
 
+void STDCALL mysql_get_character_set_info(MYSQL *mysql, MY_CHARSET_INFO *cs)
+{
+  return mariadb_get_charset_info(mysql, cs);
+}
+
 int STDCALL mysql_set_character_set(MYSQL *mysql, const char *csname)
 {
   const CHARSET_INFO *cs;
@@ -3503,8 +3516,7 @@ mysql_get_parameters(void)
   return &mariadb_internal_parameters;
 }
 
-my_socket STDCALL
+static my_socket mariadb_get_socket(MYSQL *mysql)
-mysql_get_socket(const MYSQL *mysql)
 {
   my_socket sock= INVALID_SOCKET;
   if (mysql->net.pvio)
@@ -3523,13 +3535,10 @@ mysql_get_socket(const MYSQL *mysql)
   return sock;
 }
 
-int STDCALL mariadb_get_connection_type(MYSQL *mysql)
+my_socket STDCALL
+mysql_get_socket(MYSQL *mysql)
 {
-  /* check if we are connected */
+  return mariadb_get_socket(mysql);
-  if (!mysql || !mysql->net.pvio)
-    return -1;
-
-  return (int)mysql->net.pvio->type;
 }
 
 CHARSET_INFO * STDCALL mariadb_get_charset_by_name(const char *csname)
@@ -3541,6 +3550,198 @@ CHARSET_INFO * STDCALL mariadb_get_charset_by_nr(unsigned int csnr)
 {
   return (CHARSET_INFO *)mysql_find_charset_nr(csnr);
 }
+
+my_bool STDCALL mariadb_get_infov(MYSQL *mysql, enum mariadb_value value, void *arg, ...)
+{
+  va_list ap;
+
+  DBUG_ENTER("mariadb_get_valuev");
+  DBUG_PRINT("enter",("value: %d",(int) value));
+
+  va_start(ap, arg);
+
+  switch(value) {
+  case MARIADB_MAX_ALLOWED_PACKET:
+    *((size_t *)arg)= (size_t)max_allowed_packet;
+    break;
+  case MARIADB_NET_BUFFER_LENGTH:
+    *((size_t *)arg)= (size_t)net_buffer_length;
+    break;
+  case MARIADB_CONNECTION_SSL_VERSION:
+    #ifdef HAVE_SSL
+    if (mysql && mysql->net.pvio && mysql->net.pvio->cssl)
+    {
+      struct st_ssl_version version;
+      if (!ma_pvio_ssl_get_protocol_version(mysql->net.pvio->cssl, &version))
+      *((char **)arg)= version.cversion;
+    }
+    else
+    #endif
+      goto error;
+    break;
+  case MARIADB_CONNECTION_SSL_VERSION_ID:
+    #ifdef HAVE_SSL
+    if (mysql && mysql->net.pvio && mysql->net.pvio->cssl)
+    {
+      struct st_ssl_version version;
+      if (!ma_pvio_ssl_get_protocol_version(mysql->net.pvio->cssl, &version))
+      *((unsigned int *)arg)= version.iversion;
+    }
+    else
+    #endif
+      goto error;
+    break;
+  case MARIADB_CLIENT_VERSION:
+    *((char **)arg)= MYSQL_CLIENT_VERSION;
+    break;
+  case MARIADB_CLIENT_VERSION_ID:
+    *((size_t *)arg)= MYSQL_VERSION_ID;
+    break;
+  case MARIADB_CONNECTION_SERVER_VERSION:
+    if (mysql)
+      *((char **)arg)= mysql->server_version;
+    else
+      goto error;
+    break;
+  case MARIADB_CONNECTION_SERVER_TYPE:
+    if (mysql)
+      *((char **)arg)= mariadb_connection(mysql) ? "MariaDB" : "MySQL";
+    else
+      goto error;
+    break;
+  case MARIADB_CONNECTION_SERVER_VERSION_ID:
+    if (mysql)
+      *((size_t *)arg)= mariadb_server_version_id(mysql);
+    else
+      goto error;
+    break;
+  case MARIADB_CONNECTION_PROTOCOL_VERSION_ID:
+    if (mysql)
+      *((unsigned int *)arg)= mysql->protocol_version;
+    else
+      goto error;
+    break;
+  case MARIADB_CHARSET_INFO:
+    if (mysql)
+      mariadb_get_charset_info(mysql, (MY_CHARSET_INFO *)arg);
+    else
+      goto error;
+    break;
+  case MARIADB_CONNECTION_SOCKET:
+    if (mysql)
+      *((my_socket *)arg)= mariadb_get_socket(mysql);
+    else
+      goto error;
+    break;
+  case MARIADB_CONNECTION_TYPE:
+    if (mysql  && mysql->net.pvio)
+      *((int *)arg)= (int)mysql->net.pvio->type;
+    else
+      goto error;
+    break;
+  case MARIADB_CONNECTION_ASYNC_TIMEOUT_MS:
+    if (mysql && mysql->options.extension && mysql->options.extension->async_context)
+      *((unsigned int *)arg)= mysql->options.extension->async_context->timeout_value;
+    else
+      goto error;
+    break;
+  case MARIADB_CONNECTION_ASYNC_TIMEOUT:
+    if (mysql && mysql->options.extension && mysql->options.extension->async_context)
+    {
+      unsigned int timeout= mysql->options.extension->async_context->timeout_value;
+      if (timeout > UINT_MAX - 999)
+        *((unsigned int *)arg)= (timeout - 1)/1000 + 1;
+      else
+        *((unsigned int *)arg)= (timeout+999)/1000;
+    }
+    else
+      goto error;
+    break;
+  case MARIADB_CHARSET_NAME:
+    {
+      char *name;
+      name= va_arg(ap, char *);
+      if (name)
+        *((CHARSET_INFO **)arg)= (CHARSET_INFO *)mysql_find_charset_name(name);
+      else
+        goto error;
+    }
+    break;
+  case MARIADB_CHARSET_ID:
+    {
+      unsigned int nr;
+      nr= va_arg(ap, unsigned int);
+      *((CHARSET_INFO **)arg)= (CHARSET_INFO *)mysql_find_charset_nr(nr);
+    }
+    break;
+  case MARIADB_CONNECTION_SSL_CIPHER:
+    #ifdef HAVE_SSL
+    if (mysql && mysql->net.pvio && mysql->net.pvio->cssl)
+      *((char **)arg)= (char *)ma_pvio_ssl_cipher(mysql->net.pvio->cssl);
+    else
+    #endif
+      goto error;
+    break;
+  case MARIADB_CLIENT_ERRORS:
+    *((char ***)arg)= (char **)client_errors;
+    break;
+  case MARIADB_CONNECTION_INFO:
+    if (mysql)
+      *((char **)arg)= (char *)mysql->info;
+    else
+      goto error;
+    break;
+  case MARIADB_CONNECTION_PVIO_TYPE:
+    if (mysql && !mysql->net.pvio)
+      *((unsigned int *)arg)= (unsigned int)mysql->net.pvio->type;
+    else
+      goto error;
+    break;
+  case MARIADB_CONNECTION_SCHEMA:
+    if (mysql)
+      *((char **)arg)= mysql->db;
+    else
+      goto error;
+    break;
+  case MARIADB_CONNECTION_USER:
+    if (mysql)
+      *((char **)arg)= mysql->user;
+    else
+      goto error;
+    break;
+  case MARIADB_CONNECTION_PORT:
+    if (mysql)
+      *((unsigned int *)arg)= mysql->port;
+    else
+      goto error;
+    break;
+  case MARIADB_CONNECTION_UNIX_SOCKET:
+    if (mysql)
+      *((char **)arg)= mysql->unix_socket;
+    else
+      goto error;
+    break;
+  case MARIADB_CONNECTION_HOST:
+    if (mysql)
+      *((char **)arg)= mysql->host;
+    else
+      goto error;
+    break;
+  default:
+    va_end(ap);
+    DBUG_RETURN(-1);
+  }
+  va_end(ap);
+  DBUG_RETURN(0);
+error:
+  va_end(ap);
+  DBUG_RETURN(-1);
+}
+
+my_bool STDCALL mariadb_get_info(MYSQL *mysql, enum mariadb_value value, void *arg)
+{
+  return mariadb_get_infov(mysql, value, arg);
+}
 /*
  * Default methods for a connection. These methods are
  * stored in mysql->methods and can be overwritten by

libmariadb/ma_ssl.c

@@ -51,6 +51,8 @@
 my_bool ma_ssl_initialized= FALSE;
 unsigned int mariadb_deinitialize_ssl= 1;
 
+char *ssl_protocol_version[5]= {"unknown", "SSL3", "TLS1.0", "TLS1.1", "TLS1.2"};
+
 MARIADB_SSL *ma_pvio_ssl_init(MYSQL *mysql)
 {
   MARIADB_SSL *cssl= NULL;
@@ -104,6 +106,11 @@ const char *ma_pvio_ssl_cipher(MARIADB_SSL *cssl)
   return ma_ssl_get_cipher(cssl);
 }
 
+my_bool ma_pvio_ssl_get_protocol_version(MARIADB_SSL *cssl, struct st_ssl_version *version)
+{
+  return ma_ssl_get_protocol_version(cssl, version);
+}
+
 static my_bool ma_pvio_ssl_compare_fp(char *fp1, unsigned int fp1_len,
                                    char *fp2, unsigned int fp2_len)
 {

libmariadb/secure/gnutls.c

@@ -423,5 +423,13 @@ unsigned int ma_ssl_get_finger_print(MARIADB_SSL *cssl, unsigned char *fp, unsig
   }
 }
 
-#endif /* HAVE_GNUTLS */
+my_bool ma_ssl_get_protocol_version(MARIADB_SSL *cssl, struct st_ssl_version *version)
+{
+  if (!cssl || !cssl->ssl)
+    return 1;
 
+  version->iversion= gnutls_protocol_get_version(cssl->ssl);
+  version->cversion= (char *)gnutls_protocol_get_name(version->iversion);
+  return 0;  
+}
+#endif /* HAVE_GNUTLS */

libmariadb/secure/ma_schannel.c

@@ -626,14 +626,6 @@ SECURITY_STATUS ma_schannel_client_handshake(MARIADB_SSL *cssl)
     return sRet;
   }
 
-  /* Allocate IO-Buffer */
-  sctx->IoBufferSize= 2 * net_buffer_length;
-  if (!(sctx->IoBuffer= (PUCHAR)LocalAlloc(LMEM_ZEROINIT, sctx->IoBufferSize)))
-  {
-    sRet= SEC_E_INSUFFICIENT_MEMORY;
-    goto end;
-  }
-  
   /* send client hello packaet */
   if(BuffersOut[0].cbBuffer != 0 && BuffersOut[0].pvBuffer != NULL)
   {  
@@ -646,11 +638,17 @@ SECURITY_STATUS ma_schannel_client_handshake(MARIADB_SSL *cssl)
   }
   sRet= ma_schannel_handshake_loop(pvio, TRUE, &ExtraData);
 
-  /* Reallocate IO-Buffer for write operations: After handshake
+  /* allocate IO-Buffer for write operations: After handshake
   was successfull, we are able now to calculate payload */
-  QueryContextAttributes( &sctx->ctxt, SECPKG_ATTR_STREAM_SIZES, &sctx->Sizes );
+  if ((sRet = QueryContextAttributes(&sctx->ctxt, SECPKG_ATTR_STREAM_SIZES, &sctx->Sizes )))
+    goto end;
+
   sctx->IoBufferSize= SCHANNEL_PAYLOAD(sctx->Sizes);
-  sctx->IoBuffer= LocalReAlloc(sctx->IoBuffer, sctx->IoBufferSize, LMEM_ZEROINIT);
+  if (!(sctx->IoBuffer= (PUCHAR)LocalAlloc(0, sctx->IoBufferSize)))
+  {
+    sRet= SEC_E_INSUFFICIENT_MEMORY;
+    goto end;
+  }
     
   return sRet;
 end:
@@ -776,6 +774,7 @@ SECURITY_STATUS ma_schannel_read_decrypt(MARIADB_PVIO *pvio,
       dwOffset= 0;
   }    
 }
+/* }}} */
 
 my_bool ma_schannel_verify_certs(SC_CTX *sctx, DWORD dwCertFlags)
 {
@@ -897,8 +896,45 @@ size_t ma_schannel_write_encrypt(MARIADB_PVIO *pvio,
     return -1;
   
   if (pvio->methods->write(pvio, sctx->IoBuffer, Buffers[0].cbBuffer + Buffers[1].cbBuffer + Buffers[2].cbBuffer))
-    return payload;
+    return payload; 
   return 0;
 }
 /* }}} */
 
+extern char *ssl_protocol_version[5];
+
+/* {{{ ma_ssl_get_protocol_version(MARIADB_SSL *cssl, struct st_ssl_version *version) */
+my_bool ma_ssl_get_protocol_version(MARIADB_SSL *cssl, struct st_ssl_version *version)
+{
+  SC_CTX *sctx;
+  SecPkgContext_ConnectionInfo ConnectionInfo;
+  if (!cssl->ssl)
+    return 1;
+
+  sctx= (SC_CTX *)cssl->ssl;
+
+  if (QueryContextAttributes(&sctx->ctxt, SECPKG_ATTR_CONNECTION_INFO, &ConnectionInfo) != SEC_E_OK)
+    return 1;
+
+  switch(ConnectionInfo.dwProtocol)
+  {
+  case SP_PROT_SSL3_CLIENT:
+    version->iversion= 1;
+    break;
+  case SP_PROT_TLS1_CLIENT:
+    version->iversion= 2;
+    break;
+  case SP_PROT_TLS1_1_CLIENT:
+    version->iversion= 3;
+    break;
+  case SP_PROT_TLS1_2_CLIENT:
+    version->iversion= 4;
+    break;
+  default:
+    version->iversion= 0;
+    break;
+  }
+  version->cversion= ssl_protocol_version[version->iversion];
+  return 0;
+}
+/* }}} */

libmariadb/secure/openssl.c

@@ -177,8 +177,11 @@ int ma_ssl_start(char *errmsg, size_t errmsg_len)
     SSL_load_error_strings();
     /* digests and ciphers */
     OpenSSL_add_all_algorithms();
-
+#if (OPENSSL_VERSION_NUMBER >= 0x10100000L)
-    if (!(SSL_context= SSL_CTX_new(TLSv1_client_method())))
+    if (!(SSL_context= SSL_CTX_new(TLS_client_method())))
+#else
+    if (!(SSL_context= SSL_CTX_new(SSLv23_client_method())))
+#endif
     {
       ma_ssl_get_error(errmsg, errmsg_len);
       goto end;
@@ -569,3 +572,37 @@ unsigned int ma_ssl_get_finger_print(MARIADB_SSL *cssl, unsigned char *fp, unsig
   }
   return (fp_len);
 }
+
+
+extern char *ssl_protocol_version[5];
+
+my_bool ma_ssl_get_protocol_version(MARIADB_SSL *cssl, struct st_ssl_version *version)
+{
+  SSL *ssl;
+
+  if (!cssl || !cssl->ssl)
+    return 1;
+
+  ssl = (SSL *)cssl->ssl;
+  switch(ssl->version)
+  {
+    case SSL3_VERSION:
+      version->iversion= 1;
+      break;
+    case TLS1_VERSION:
+      version->iversion= 2;
+      break;
+    case TLS1_1_VERSION:
+      version->iversion= 3;
+      break;
+    case TLS1_2_VERSION:
+      version->iversion= 4;
+      break;
+    default:
+      version->iversion= 0;
+      break;
+  }
+  version->cversion= ssl_protocol_version[version->iversion];
+  return 0;  
+}
+

libmariadb/secure/schannel.c

@@ -284,7 +284,7 @@ my_bool ma_ssl_connect(MARIADB_SSL *cssl)
     Cred.cCreds = 1;
     Cred.paCred = &sctx->client_cert_ctx;
   }
-  Cred.grbitEnabledProtocols= SP_PROT_TLS1;
+  Cred.grbitEnabledProtocols= SP_PROT_TLS1_1PLUS;
 
   if ((sRet= AcquireCredentialsHandleA(NULL, UNISP_NAME_A, SECPKG_CRED_OUTBOUND,
  									            NULL, &Cred, NULL, NULL, &sctx->CredHdl, NULL)) != SEC_E_OK)

plugins/connection/CMakeLists.txt

@@ -14,6 +14,9 @@ IF(REPLICATION_PLUGIN_TYPE MATCHES "DYNAMIC")
   ENDIF()
   ADD_DEFINITIONS(-DHAVE_REPLICATION_DYNAMIC=1)
   ADD_LIBRARY(replication SHARED ${replication_RC} replication.c ${EXPORT_FILE})
+  IF(WIN32)
+    TARGET_LINK_LIBRARIES(replication libmariadb)
+  ENDIF()
   SET(INSTALL_LIBS replication)
 ENDIF()
 
@@ -27,6 +30,9 @@ IF(REPLICATION_PLUGIN_TYPE MATCHES "DYNAMIC")
   ENDIF()
   ADD_DEFINITIONS(-DHAVE_AURORA_DYNAMIC=1)
   ADD_LIBRARY(aurora SHARED ${aurora_RC} aurora.c ${EXPORT_FILE})
+  IF(WIN32)
+    TARGET_LINK_LIBRARIES(aurora libmariadb)
+  ENDIF()
   SET(INSTALL_LIBS ${INSTALL_LIBS} aurora)
 ENDIF()
 

plugins/connection/replication.c

@@ -42,13 +42,6 @@ int repl_command(MYSQL *mysql,enum enum_server_command command, const char *arg,
                       size_t length, my_bool skipp_check, void *opt_arg);
 int repl_set_options(MYSQL *msql, enum mysql_option option, void *arg);
 
-#ifdef HAVE_REPLICATION_DYNAMIC
-
-#undef my_free
-#define my_malloc(a,b) malloc(a)
-#define my_free(a) free(a)
-#endif
-
 #define MARIADB_MASTER 0
 #define MARIADB_SLAVE  1
 
@@ -120,7 +113,7 @@ my_bool repl_parse_url(const char *url, REPL_DATA *data)
   memset(data->port, 0, 2 * sizeof(int));
 
   if (!data->url)
-    data->url= my_strdup(url, MYF(0));
+    data->url= strdup(url);
   data->host[MARIADB_MASTER]= p= data->url;
  
   /* get slaves */ 
@@ -188,7 +181,7 @@ MYSQL *repl_connect(MYSQL *mysql, const char *host, const char *user, const char
 
   if ((data= (REPL_DATA *)hdlr->data))
   {
-    ma_pvio_close(data->pvio[MARIADB_MASTER]);
+    data->pvio[MARIADB_MASTER]->methods->close(data->pvio[MARIADB_MASTER]);
     data->pvio[MARIADB_MASTER]= 0;
     repl_close(mysql);
   }
@@ -234,8 +227,8 @@ error:
   if (data)
   {
     if (data->url)
-      my_free(data->url);
+      free(data->url);
-    my_free(data);
+    free(data);
   }
   return NULL;
 }
@@ -259,8 +252,8 @@ void repl_close(MYSQL *mysql)
   }
 
   /* free masrwe information and close connection */
-  my_free(data->url);
+  free(data->url);
-  my_free(data);
+  free(data);
   mysql->net.conn_hdlr->data= NULL;
 }
 

unittest/libmariadb/CMakeLists.txt

@@ -58,7 +58,7 @@ ENDIF()
 
 FOREACH(API_TEST ${API_TESTS})
   ADD_EXECUTABLE(${API_TEST} ${API_TEST}.c)
-  TARGET_LINK_LIBRARIES(${API_TEST} mytap mariadbclient)
+  TARGET_LINK_LIBRARIES(${API_TEST} mytap libmariadb)
   ADD_TEST(${API_TEST} ${EXECUTABLE_OUTPUT_PATH}/${API_TEST})
   SET_TESTS_PROPERTIES(${API_TEST} PROPERTIES TIMEOUT 120)
 ENDFOREACH(API_TEST)

unittest/libmariadb/async.c

@@ -34,7 +34,8 @@ my_bool skip_async= 0;
 
 static int test_async(MYSQL *mysql)
 {
-  int type= mariadb_get_connection_type(mysql);
+  int type;
+  mariadb_get_info(mysql, MARIADB_CONNECTION_PVIO_TYPE, &type);
   if (type > MARIADB_CONNECTION_TCP)
   {
     skip_async= 1;

unittest/libmariadb/misc.c

@@ -1021,11 +1021,74 @@ static int test_remote2(MYSQL *my)
 }
 #endif
 
+static int test_get_info(MYSQL *mysql)
+{
+  size_t sval;
+  unsigned int ival;
+  char *cval;
+  int rc;
+  MY_CHARSET_INFO cs;
+  CHARSET_INFO *ci;
+  char **errors;
+   
+  rc= mariadb_get_infov(mysql, MARIADB_MAX_ALLOWED_PACKET, &sval);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("max_allowed_packet: %d", sval);
+  rc= mariadb_get_infov(mysql, MARIADB_NET_BUFFER_LENGTH, &sval);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("net_buffer_length: %d", sval);
+  rc= mariadb_get_infov(mysql, MARIADB_CLIENT_VERSION_ID, &sval);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("client_version_id: %d", sval);
+  rc= mariadb_get_infov(mysql, MARIADB_CONNECTION_SERVER_VERSION_ID, &sval);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("server_version_id: %d", sval);
+  rc= mariadb_get_infov(mysql, MARIADB_CHARSET_INFO, &cs);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("charset name: %s", cs.csname);
+  rc= mariadb_get_infov(mysql, MARIADB_CONNECTION_PVIO_TYPE, &ival);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("connection type: %d", ival);
+  rc= mariadb_get_infov(mysql, MARIADB_CONNECTION_PROTOCOL_VERSION_ID, &ival);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("protocol_version: %d", ival);
+  rc= mariadb_get_infov(mysql, MARIADB_CONNECTION_SERVER_TYPE, &cval);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("server_type: %s", cval);
+  rc= mariadb_get_infov(mysql, MARIADB_CONNECTION_SERVER_VERSION, &cval);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("server_version: %s", cval);
+  rc= mariadb_get_infov(mysql, MARIADB_CLIENT_VERSION, &cval);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("client_version: %s", cval);
+  rc= mariadb_get_infov(mysql, MARIADB_CHARSET_NAME, &ci, "utf8");
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("charset_name: %s", ci->csname);
+  diag("charset_nr: %d", ci->nr);
+  rc= mariadb_get_infov(mysql, MARIADB_CHARSET_ID, &ci, 63);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("charset_name: %s", ci->csname);
+  rc= mariadb_get_infov(mysql, MARIADB_CLIENT_ERRORS, &errors);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("error[0]: %s", errors[0]);
+  rc= mysql_query(mysql, "DROP TABLE IF exists t1");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "CREATE TABLE t1 (a int)");
+  check_mysql_rc(rc, mysql);
+  rc= mysql_query(mysql, "INSERT INTO t1 VALUES (1),(2)");
+  check_mysql_rc(rc, mysql);
+  rc= mariadb_get_infov(mysql, MARIADB_CONNECTION_INFO, &cval);
+  FAIL_IF(rc, "mysql_get_info failed");
+  diag("mariadb_info: %s", cval);
+  return OK;
+}
+
 struct my_tests_st my_tests[] = {
 #ifdef HAVE_REMOTEIO
   {"test_remote1", test_remote1, TEST_CONNECTION_NEW, 0, NULL, NULL},
   {"test_remote2", test_remote2, TEST_CONNECTION_NEW, 0, NULL, NULL},
 #endif
+  {"test_get_info", test_get_info, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
   {"test_conc117", test_conc117, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
   {"test_conc_114", test_conc_114, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},
   {"test_connect_attrs", test_connect_attrs, TEST_CONNECTION_DEFAULT, 0,  NULL, NULL},

unittest/libmariadb/ssl.c.in

@@ -51,10 +51,16 @@ static int check_cipher(MYSQL *mysql)
   char *cipher= (char *)mysql_get_ssl_cipher(mysql);
   if (!cipher)
     return 1;
+  diag("cipher: %s", cipher);
+
 #ifdef HAVE_GNUTLS
-  return strcmp(cipher, "AES-128-GCM");
+  {
+    return strcmp(cipher, "AES-128-GCM");
+  }
 #elif HAVE_OPENSSL
-  return strcmp(cipher, "DHE-RSA-AES256-SHA");
+  if (!strcmp(cipher, "DHE-RSA-AES256-SHA") ||
+      !strcmp(cipher, "DHE-RSA-AES256-GCM-SHA384"))
+    return 0;
 #elif HAVE_SCHANNEL
   return strcmp(cipher, "CALG_AES_256");
 #endif
@@ -107,6 +113,14 @@ static int test_ssl(MYSQL *mysql)
   }
   mysql_free_result(res);
 
+#ifdef HAVE_GNUTLS
+  diag("SSL library: GNUTLS");
+#elif HAVE_OPENSSL
+  diag("SSL library: OPENSSL");
+#elif HAVE_SCHANNEL
+  diag("SSL library: SCHANNEL");
+#endif  
+
   sslhost[0]= 0;
 
   if (!skip_ssl)
@@ -129,6 +143,9 @@ static int test_ssl(MYSQL *mysql)
 static int test_ssl_cipher(MYSQL *unused)
 {
   MYSQL *my;
+  MYSQL_RES *res;
+  MYSQL_ROW row;
+  int rc;
   
   if (check_skip_ssl())
     return SKIP;
@@ -141,6 +158,14 @@ static int test_ssl_cipher(MYSQL *unused)
   FAIL_IF(!mysql_real_connect(my, hostname, ssluser, sslpw, schema,
                          port, socketname, 0), mysql_error(my));
 
+  rc= mysql_query(my, "SHOW session status like 'Ssl_version'");
+  check_mysql_rc(rc, my);
+  res= mysql_store_result(my);
+  row= mysql_fetch_row(res);
+  diag("%s: %s", row[0], row[1]);
+  diag("cipher: %s", mysql_get_ssl_cipher(my));
+  mysql_free_result(res);
+
   FAIL_IF(check_cipher(my) != 0, "Invalid cipher");
   mysql_close(my);
   return OK;
@@ -747,7 +772,33 @@ static int test_ssl_fp_list(MYSQL *unused)
   return OK;
 }
 
+static int test_ssl_version(MYSQL *mysql)
+{
+  unsigned int iversion;
+  char *version;
+  MYSQL *my;
 
+  if (check_skip_ssl())
+    return SKIP;
+
+  my= mysql_init(NULL);
+  FAIL_IF(!my, "mysql_init() failed");
+
+  mysql_ssl_set(my,0, 0, "@CMAKE_SOURCE_DIR@/unittest/libmariadb/certs/ca-cert.pem", 0, 0);
+  FAIL_IF(!mysql_real_connect(my, hostname, ssluser, sslpw, schema,
+                         port, socketname, 0), mysql_error(my));
+
+  diag("cipher: %s", mysql_get_ssl_cipher(my));
+  mariadb_get_infov(my, MARIADB_CONNECTION_SSL_VERSION_ID, &iversion);
+  diag("protocol: %d", iversion);
+  mariadb_get_infov(my, MARIADB_CONNECTION_SSL_VERSION, &version);
+  diag("protocol: %s", version);
+
+  mysql_close(my);
+
+  return OK;
+}
+  
 
 struct my_tests_st my_tests[] = {
   {"test_ssl", test_ssl, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
@@ -766,6 +817,7 @@ struct my_tests_st my_tests[] = {
   {"test_ssl_cipher", test_ssl_cipher, TEST_CONNECTION_NONE, 0,  NULL,  NULL},
   {"test_multi_ssl_connections", test_multi_ssl_connections, TEST_CONNECTION_NONE, 0,  NULL,  NULL},
   {"test_conc_102", test_conc_102, TEST_CONNECTION_NEW, 0, NULL, NULL},
+  {"test_ssl_version", test_ssl_version, TEST_CONNECTION_NEW, 0, NULL, NULL},
   {"test_ssl_threads", test_ssl_threads, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
 #ifndef HAVE_SCHANNEL
   {"test_password_protected", test_password_protected, TEST_CONNECTION_NEW, 0,  NULL,  NULL},