Merge branch 'master' into serg-integr

CMakeLists.txt

@@ -135,7 +135,7 @@ SET(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -DDBUG_OFF")
 SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -DDBUG_OFF")
 
 IF(CMAKE_COMPILER_IS_GNUCC)
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wunused -Wno-uninitialized")
+  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wunused -Wno-uninitialized  -Wall -Wextra -Wformat-security -Wno-init-self -Wvla -Wwrite-strings -Wdeclaration-after-statement")
 ENDIF()
 
 # If the build type isn't specified, set to Relwithdebinfo as default.

include/ma_global.h

@@ -711,6 +711,7 @@ typedef char		*my_string; /* String of characters */
 typedef unsigned long	size_s; /* Size of strings (In string-funcs) */
 typedef int		myf;	/* Type of MyFlags in my_funcs */
 typedef char		my_bool; /* Small bool */
+typedef unsigned long long my_ulonglong;
 #if !defined(bool) && !defined(bool_defined) && (!defined(HAVE_BOOL) || !defined(__cplusplus))
 typedef char		bool;	/* Ordinary boolean values 0 1 */
 #endif

include/ma_hash.h

@@ -54,8 +54,8 @@ my_bool _hash_init(HASH *hash,uint default_array_elements, uint key_offset,
 		  void (*free_element)(void*), uint flags CALLER_INFO_PROTO);
 void hash_free(HASH *tree);
 uchar *hash_element(HASH *hash,uint idx);
-gptr hash_search(HASH *info,const uchar *key,uint length);
+void * hash_search(HASH *info,const uchar *key,uint length);
-gptr hash_next(HASH *info,const uchar *key,uint length);
+void * hash_next(HASH *info,const uchar *key,uint length);
 my_bool hash_insert(HASH *info,const uchar *data);
 my_bool hash_delete(HASH *hash,uchar *record);
 my_bool hash_update(HASH *hash,uchar *record,uchar *old_key,uint old_key_length);

include/ma_pvio.h

@@ -55,6 +55,8 @@ enum enum_pvio_operation {
   PVIO_WRITE=1
 };
 
+#define SHM_DEFAULT_NAME "MYSQL"
+
 struct st_pvio_callback;
 
 typedef struct st_pvio_callback {
@@ -75,7 +77,7 @@ struct st_ma_pvio {
   MYSQL *mysql;
   PVIO_METHODS *methods;
   void (*set_error)(MYSQL *mysql, unsigned int error_nr, const char *sqlstate, const char *format, ...);
-  void (*callback)(MARIADB_PVIO *pvio, my_bool is_read, const char *buffer, size_t length);
+  void (*callback)(MARIADB_PVIO *pvio, my_bool is_read, const uchar *buffer, size_t length);
 };
 
 typedef struct st_ma_pvio_cinfo

include/ma_sys.h

@@ -368,12 +368,12 @@ typedef struct st_ma_mem_root {
 
 	/* Prototypes for mysys and my_func functions */
 
-extern gptr _mymalloc(size_t uSize,const char *sFile,
+extern void * _mymalloc(size_t uSize,const char *sFile,
 		      uint uLine, myf MyFlag);
-extern gptr _myrealloc(gptr pPtr,size_t uSize,const char *sFile,
+extern void * _myrealloc(void * pPtr,size_t uSize,const char *sFile,
 		       uint uLine, myf MyFlag);
 extern void *ma_multi_malloc(myf MyFlags, ...);
-extern void _myfree(gptr pPtr,const char *sFile,uint uLine, myf MyFlag);
+extern void _myfree(void * pPtr,const char *sFile,uint uLine, myf MyFlag);
 extern int _sanity(const char *sFile,unsigned int uLine);
 #ifndef TERMINATE
 extern void TERMINATE(FILE *file);
@@ -507,11 +507,11 @@ File create_temp_file(char *to, const char *dir, const char *pfx,
 extern my_bool ma_init_dynamic_array(DYNAMIC_ARRAY *array,uint element_size,
 	  uint init_alloc,uint alloc_increment CALLER_INFO_PROTO);
 #define ma_init_dynamic_array_ci(A,B,C,D) ma_init_dynamic_array(A,B,C,D ORIG_CALLER_INFO)
-extern my_bool ma_insert_dynamic(DYNAMIC_ARRAY *array,gptr element);
+extern my_bool ma_insert_dynamic(DYNAMIC_ARRAY *array,void * element);
 extern unsigned char *ma_alloc_dynamic(DYNAMIC_ARRAY *array);
 extern unsigned char *ma_pop_dynamic(DYNAMIC_ARRAY*);
-extern my_bool ma_set_dynamic(DYNAMIC_ARRAY *array,gptr element,uint array_index);
+extern my_bool ma_set_dynamic(DYNAMIC_ARRAY *array,void * element,uint array_index);
-extern void ma_get_dynamic(DYNAMIC_ARRAY *array,gptr element,uint array_index);
+extern void ma_get_dynamic(DYNAMIC_ARRAY *array,void * element,uint array_index);
 extern void ma_delete_dynamic(DYNAMIC_ARRAY *array);
 extern void ma_delete_dynamic_element(DYNAMIC_ARRAY *array, uint array_index);
 extern void ma_freeze_size(DYNAMIC_ARRAY *array);

include/ma_tls.h

@@ -127,7 +127,7 @@ const char *ma_tls_get_cipher(MARIADB_TLS *ssl);
    Returns:
      actual size of finger print
 */
-unsigned int ma_tls_get_finger_print(MARIADB_TLS *ctls, unsigned char *fp, unsigned int fp_len);
+unsigned int ma_tls_get_finger_print(MARIADB_TLS *ctls, char *fp, unsigned int fp_len);
 
 /* ma_tls_get_protocol_version 
    returns protocol version in use

include/mariadb_ctype.h

@@ -41,11 +41,11 @@ typedef struct ma_charset_info_st
 {
   unsigned int	nr; /* so far only 1 byte for charset */
   unsigned int  state;
-  char	*csname;
+  const char	*csname;
-  char	*name;
+  const char	*name;
-  char  *dir;
+  const char  *dir;
   unsigned int codepage;
-  char  *encoding;
+  const char  *encoding;
   unsigned int	char_minlen;
   unsigned int	char_maxlen;
   unsigned int 	(*mb_charlen)(unsigned int c);
@@ -64,7 +64,7 @@ MARIADB_CHARSET_INFO *find_compiled_charset_by_name(const char *name);
 
 size_t mysql_cset_escape_quotes(const MARIADB_CHARSET_INFO *cset, char *newstr,  const char *escapestr, size_t escapestr_len);
 size_t mysql_cset_escape_slashes(const MARIADB_CHARSET_INFO *cset, char *newstr, const char *escapestr, size_t escapestr_len);
-char* madb_get_os_character_set(void);
+const char* madb_get_os_character_set(void);
 #ifdef _WIN32
 int madb_get_windows_cp(const char *charset);
 #endif

include/mariadb_stmt.h

@@ -101,7 +101,7 @@ typedef struct st_mysql_bind
   my_bool        *error;
   union {
     unsigned char *row_ptr;        /* for the current data position */
-    unsigned char *indicator;      /* indicator variable */
+    char *indicator;               /* indicator variable */
   } u;
   void (*store_param_func)(NET *net, struct st_mysql_bind *param);
   void (*fetch_result)(struct st_mysql_bind *, MYSQL_FIELD *,

include/mysql.h

@@ -37,6 +37,7 @@ extern "C" {
 #if !defined (_global_h) && !defined (MY_GLOBAL_INCLUDED) /* If not standard header */
 #include <sys/types.h>
 typedef char my_bool;
+typedef unsigned long long my_ulonglong;
 
 #if !defined(_WIN32)
 #define STDCALL
@@ -467,7 +468,7 @@ void my_set_error(MYSQL *mysql, unsigned int error_nr,
 /* Functions to get information from the MYSQL and MYSQL_RES structures */
 /* Should definitely be used if one uses shared libraries */
 
-unsigned long long STDCALL mysql_num_rows(MYSQL_RES *res);
+my_ulonglong STDCALL mysql_num_rows(MYSQL_RES *res);
 unsigned int STDCALL mysql_num_fields(MYSQL_RES *res);
 my_bool STDCALL mysql_eof(MYSQL_RES *res);
 MYSQL_FIELD *STDCALL mysql_fetch_field_direct(MYSQL_RES *res,
@@ -479,11 +480,11 @@ unsigned int STDCALL mysql_field_tell(MYSQL_RES *res);
 unsigned int STDCALL mysql_field_count(MYSQL *mysql);
 my_bool STDCALL mysql_more_results(MYSQL *mysql);
 int STDCALL mysql_next_result(MYSQL *mysql);
-unsigned long long STDCALL mysql_affected_rows(MYSQL *mysql);
+my_ulonglong STDCALL mysql_affected_rows(MYSQL *mysql);
 my_bool STDCALL mysql_autocommit(MYSQL *mysql, my_bool mode);
 my_bool STDCALL mysql_commit(MYSQL *mysql);
 my_bool STDCALL mysql_rollback(MYSQL *mysql);
-unsigned long long STDCALL mysql_insert_id(MYSQL *mysql);
+my_ulonglong STDCALL mysql_insert_id(MYSQL *mysql);
 unsigned int STDCALL mysql_errno(MYSQL *mysql);
 char * STDCALL mysql_error(MYSQL *mysql);
 char * STDCALL mysql_info(MYSQL *mysql);

libmariadb/ma_array.c

@@ -55,9 +55,9 @@ my_bool ma_init_dynamic_array(DYNAMIC_ARRAY *array, uint element_size,
 }
 
 
-my_bool ma_insert_dynamic(DYNAMIC_ARRAY *array, gptr element)
+my_bool ma_insert_dynamic(DYNAMIC_ARRAY *array, void *element)
 {
-  gptr buffer;
+  void *buffer;
   if (array->elements == array->max_element)
   {						/* Call only when nessesary */
     if (!(buffer=ma_alloc_dynamic(array)))
@@ -87,7 +87,7 @@ unsigned char *ma_alloc_dynamic(DYNAMIC_ARRAY *array)
     array->buffer=new_ptr;
     array->max_element+=array->alloc_increment;
   }
-  return array->buffer+(array->elements++ * array->size_of_element);
+  return (unsigned char *)array->buffer+(array->elements++ * array->size_of_element);
 }
 
 
@@ -96,12 +96,12 @@ unsigned char *ma_alloc_dynamic(DYNAMIC_ARRAY *array)
 unsigned char *ma_pop_dynamic(DYNAMIC_ARRAY *array)
 {
   if (array->elements)
-    return array->buffer+(--array->elements * array->size_of_element);
+    return (unsigned char *)array->buffer+(--array->elements * array->size_of_element);
   return 0;
 }
 
 
-my_bool ma_set_dynamic(DYNAMIC_ARRAY *array, gptr element, uint idx)
+my_bool ma_set_dynamic(DYNAMIC_ARRAY *array, void * element, uint idx)
 {
   if (idx >= array->elements)
   {
@@ -127,7 +127,7 @@ my_bool ma_set_dynamic(DYNAMIC_ARRAY *array, gptr element, uint idx)
 }
 
 
-void ma_get_dynamic(DYNAMIC_ARRAY *array, gptr element, uint idx)
+void ma_get_dynamic(DYNAMIC_ARRAY *array, void * element, uint idx)
 {
   if (idx >= array->elements)
   {

libmariadb/ma_charset.c

@@ -696,7 +696,7 @@ const MARIADB_CHARSET_INFO * mysql_find_charset_nr(unsigned int charsetnr)
 MARIADB_CHARSET_INFO * mysql_find_charset_name(const char *name)
 {
   MARIADB_CHARSET_INFO *c = (MARIADB_CHARSET_INFO *)mariadb_compiled_charsets;
-  char *csname;
+  const char *csname;
 
   if (!strcasecmp(name, MADB_AUTODETECT_CHARSET_NAME))
     csname= madb_get_os_character_set();
@@ -844,10 +844,10 @@ size_t mysql_cset_escape_slashes(const MARIADB_CHARSET_INFO * cset, char *newstr
 
 /* {{{ MADB_OS_CHARSET */
 struct st_madb_os_charset {
-  char *identifier;
+  const char *identifier;
-  char *description;
+  const char *description;
-  char *charset;
+  const char *charset;
-  char *iconv_cs;
+  const char *iconv_cs;
   unsigned char supported;
 };
 
@@ -1086,7 +1086,7 @@ struct st_madb_os_charset MADB_OS_CHARSET[]=
 /* }}} */
 
 /* {{{ madb_get_os_character_set */
-char *madb_get_os_character_set()
+const char *madb_get_os_character_set()
 {
   unsigned int i= 0;
   char *p= NULL;
@@ -1195,7 +1195,7 @@ size_t STDCALL mariadb_convert_string(const char *from, size_t *from_len, MARIAD
     *errorcode= errno;
     goto error;
   }
-  if ((rc= iconv(conv, (char **)&from, from_len, &to, to_len)) == -1)
+  if ((rc= iconv(conv, (char **)&from, from_len, &to, to_len)) == (size_t)-1)
   {
     *errorcode= errno;
     goto error;

libmariadb/ma_hash.c

@@ -95,9 +95,9 @@ static inline char*
 hash_key(HASH *hash,const uchar *record,uint *length,my_bool first)
 {
   if (hash->get_key)
-    return (*hash->get_key)(record,(uint *)length,first);
+    return (char *)(*hash->get_key)(record,(uint *)length,first);
   *length=hash->key_length;
-  return (uchar*) record+hash->key_offset;
+  return (char*) record+hash->key_offset;
 }
 
 	/* Calculate pos according to keys */
@@ -202,7 +202,7 @@ unsigned int rec_hashnr(HASH *hash,const uchar *record)
 	/* Search after a record based on a key */
 	/* Sets info->current_ptr to found record */
 
-gptr hash_search(HASH *hash,const uchar *key,uint length)
+void* hash_search(HASH *hash,const uchar *key,uint length)
 {
   HASH_LINK *pos;
   uint flag,idx;
@@ -237,7 +237,7 @@ gptr hash_search(HASH *hash,const uchar *key,uint length)
 	/* Get next record with identical key */
 	/* Can only be called if previous calls was hash_search */
 
-gptr hash_next(HASH *hash,const uchar *key,uint length)
+void *hash_next(HASH *hash,const uchar *key,uint length)
 {
   HASH_LINK *pos;
   uint idx;

libmariadb/ma_init.c

@@ -57,7 +57,7 @@ void ma_init(void)
 
 
 
-void ma_end(int infoflag)
+void ma_end(int infoflag __attribute__((unused)))
 {
 #ifdef _WIN32
   WSACleanup( );

libmariadb/ma_loaddata.c

@@ -109,7 +109,7 @@ int mysql_local_infile_read(void *ptr, char * buf, unsigned int buf_len)
 
   count= ma_read((void *)buf, 1, (size_t)buf_len, info->fp);
 
-  if (count < 0)
+  if (count == (size_t)-1)
   {
     info->error_no = errno;
     snprintf((char *)info->error_msg, sizeof(info->error_msg), 
@@ -202,7 +202,7 @@ my_bool mysql_handle_local_infile(MYSQL *conn, const char *filename)
   if (!(conn->options.client_flag & CLIENT_LOCAL_FILES)) {
     my_set_error(conn, CR_UNKNOWN_ERROR, SQLSTATE_UNKNOWN, "Load data local infile forbidden");
     /* write empty packet to server */
-    ma_net_write(&conn->net, "", 0);
+    ma_net_write(&conn->net, (unsigned char *)"", 0);
     ma_net_flush(&conn->net);
     goto infile_error;
   }
@@ -219,7 +219,7 @@ my_bool mysql_handle_local_infile(MYSQL *conn, const char *filename)
 
     tmp_errno= conn->options.local_infile_error(info, tmp_buf, sizeof(tmp_buf));
     my_set_error(conn, tmp_errno, SQLSTATE_UNKNOWN, tmp_buf);
-    ma_net_write(&conn->net, "", 0);
+    ma_net_write(&conn->net, (unsigned char *)"", 0);
     ma_net_flush(&conn->net);
     goto infile_error;
   }
@@ -227,7 +227,7 @@ my_bool mysql_handle_local_infile(MYSQL *conn, const char *filename)
   /* read data */
   while ((bufread= conn->options.local_infile_read(info, (char *)buf, buflen)) > 0)
   {
-    if (ma_net_write(&conn->net, (char *)buf, bufread))
+    if (ma_net_write(&conn->net, (unsigned char *)buf, bufread))
     {
       my_set_error(conn, CR_SERVER_LOST, SQLSTATE_UNKNOWN, NULL);
       goto infile_error;
@@ -235,7 +235,8 @@ my_bool mysql_handle_local_infile(MYSQL *conn, const char *filename)
   }
 
   /* send empty packet for eof */
-  if (ma_net_write(&conn->net, "", 0) || ma_net_flush(&conn->net))
+  if (ma_net_write(&conn->net, (unsigned char *)"", 0) || 
+      ma_net_flush(&conn->net))
   {
     my_set_error(conn, CR_SERVER_LOST, SQLSTATE_UNKNOWN, NULL);
     goto infile_error;

libmariadb/ma_net.c

@@ -207,7 +207,7 @@ ma_net_write(NET *net, const uchar *packet, size_t len)
     int3store(buff,max_len);
     buff[3]= (uchar)net->pkt_nr++;
     if (ma_net_write_buff(net,(char*) buff,NET_HEADER_SIZE) ||
-        ma_net_write_buff(net, packet, max_len))
+        ma_net_write_buff(net, (char *)packet, max_len))
       return 1;
     packet+= max_len;
     len-= max_len;
@@ -216,7 +216,7 @@ ma_net_write(NET *net, const uchar *packet, size_t len)
   int3store(buff, len);
   buff[3]= (uchar)net->pkt_nr++;
   if (ma_net_write_buff(net,(char*) buff,NET_HEADER_SIZE) ||
-      ma_net_write_buff(net, packet, len))
+      ma_net_write_buff(net, (char *)packet, len))
     return 1;
   return 0;
 }
@@ -304,19 +304,22 @@ ma_net_write_buff(NET *net,const char *packet, size_t len)
   return 0;
 }
 
+unsigned char *mysql_net_store_length(unsigned char *packet, size_t length);
+
 int net_add_multi_command(NET *net, uchar command, const uchar *packet,
                           size_t length)
 {
   size_t left_length;
   size_t required_length, current_length;
-  required_length= length + 1 + COMP_HEADER_SIZE + NET_HEADER_SIZE;
+  /* 9 - maximum possible length of data stored in net length format */
+  required_length= length + 1 + COMP_HEADER_SIZE + NET_HEADER_SIZE + 9;
 
   /* We didn't allocate memory in ma_net_init since it was too early to
    * detect if the server supports COM_MULTI command */
   if (!net->extension->mbuff)
   {
     size_t alloc_size= (required_length + IO_SIZE - 1) & ~(IO_SIZE - 1);
-    if (!(net->extension->mbuff= (char *)malloc(alloc_size)))
+    if (!(net->extension->mbuff= (unsigned char *)malloc(alloc_size)))
     {
       net->last_errno=ER_OUT_OF_RESOURCES;
       net->error=2;
@@ -337,8 +340,8 @@ int net_add_multi_command(NET *net, uchar command, const uchar *packet,
       goto error;
     net->extension->mbuff_pos = net->extension->mbuff + current_length;
   }
-  int3store(net->extension->mbuff_pos, length + 1);
+  net->extension->mbuff_pos= mysql_net_store_length(net->extension->mbuff_pos,
-  net->extension->mbuff_pos+= 3;
+                                                    length + 1);
   *net->extension->mbuff_pos= command;
   net->extension->mbuff_pos++;
   memcpy(net->extension->mbuff_pos, packet, length);
@@ -396,7 +399,7 @@ ma_net_real_write(NET *net,const char *packet,size_t  len)
   pos=(char*) packet; end=pos+len;
   while (pos != end)
   {
-    if ((ssize_t) (length=ma_pvio_write(net->pvio,pos,(size_t) (end-pos))) <= 0)
+    if ((ssize_t) (length=ma_pvio_write(net->pvio,(uchar *)pos,(size_t) (end-pos))) <= 0)
     {
       net->error=2;				/* Close socket */
       net->last_errno= ER_NET_ERROR_ON_WRITE;
@@ -435,7 +438,7 @@ ma_real_read(NET *net, size_t *complen)
       while (remain > 0)
       {
 	/* First read is done with non blocking mode */
-        if ((ssize_t) (length=ma_pvio_cache_read(net->pvio,(char*) pos,remain)) <= 0L)
+        if ((ssize_t) (length=ma_pvio_cache_read(net->pvio, pos,remain)) <= 0L)
         {
 	  len= packet_error;
 	  net->error=2;				/* Close socket */

libmariadb/ma_pvio.c

@@ -70,7 +70,7 @@ MARIADB_PVIO *ma_pvio_init(MA_PVIO_CINFO *cinfo)
    *   pvio_namedpipe
    *   pvio_sharedmed
    */
-  char *pvio_plugins[] = {"pvio_socket", "pvio_npipe", "pvio_shmem"};
+  const char *pvio_plugins[] = {"pvio_socket", "pvio_npipe", "pvio_shmem"};
   int type;
   MARIADB_PVIO_PLUGIN *pvio_plugin;
   MARIADB_PVIO *pvio= NULL;
@@ -139,9 +139,11 @@ MARIADB_PVIO *ma_pvio_init(MA_PVIO_CINFO *cinfo)
 /* {{{ my_bool ma_pvio_is_alive */
 my_bool ma_pvio_is_alive(MARIADB_PVIO *pvio)
 {
+  if (!pvio)
+    return FALSE;
   if (pvio->methods->is_alive)
     return pvio->methods->is_alive(pvio);
-  return FALSE;
+  return TRUE;
 }
 /* }}} */
 
@@ -311,8 +313,7 @@ static size_t ma_pvio_write_async(MARIADB_PVIO *pvio, const uchar *buffer, size_
 
   for (;;)
   {
-    if (pvio->methods->async_write)
+    res= pvio->methods->async_write(pvio, buffer, length);
-      res= pvio->methods->async_write(pvio, buffer, length);
     if (res >= 0 || IS_BLOCKING_ERROR())
       return res;
     b->events_to_wait_for= MYSQL_WAIT_WRITE;
@@ -521,8 +522,8 @@ my_bool ma_pvio_start_ssl(MARIADB_PVIO *pvio)
     return 1;
 
   if (pvio->mysql->options.extension &&
-      (pvio->mysql->options.extension->tls_fp && pvio->mysql->options.extension->tls_fp[0]) ||
+      ((pvio->mysql->options.extension->tls_fp && pvio->mysql->options.extension->tls_fp[0]) ||
-      (pvio->mysql->options.extension->tls_fp_list && pvio->mysql->options.extension->tls_fp_list[0]))
+      (pvio->mysql->options.extension->tls_fp_list && pvio->mysql->options.extension->tls_fp_list[0])))
   {
 
     if (ma_pvio_tls_check_fp(pvio->ctls, 

libmariadb/ma_stmt_codec.c

@@ -402,7 +402,9 @@ static void convert_from_long(MYSQL_BIND *r_param, const MYSQL_FIELD *field, lon
 
 /* {{{ ps_fetch_null */
 static
-void ps_fetch_null(MYSQL_BIND *r_param, const MYSQL_FIELD * field, unsigned char **row)
+void ps_fetch_null(MYSQL_BIND *r_param __attribute__((unused)),
+                   const MYSQL_FIELD * field __attribute__((unused)),
+                   unsigned char **row __attribute__((unused)))
 {
   /* do nothing */
 }
@@ -509,7 +511,7 @@ void ps_fetch_int64(MYSQL_BIND *r_param, const MYSQL_FIELD * const field,
     default:
     {
       longlong sval= (longlong)sint8korr(*row);
-      longlong lval= field->flags & UNSIGNED_FLAG ? (ulonglong) sval : (longlong)sval;
+      longlong lval= field->flags & UNSIGNED_FLAG ? (longlong)(ulonglong) sval : (longlong)sval;
       convert_from_long(r_param, field, lval, field->flags & UNSIGNED_FLAG);
       (*row) += 8;
     }
@@ -518,7 +520,7 @@ void ps_fetch_int64(MYSQL_BIND *r_param, const MYSQL_FIELD * const field,
 }
 /* }}} */
 
-static void convert_from_float(MYSQL_BIND *r_param, const MYSQL_FIELD *field, float val, int size)
+static void convert_from_float(MYSQL_BIND *r_param, const MYSQL_FIELD *field, float val, int size __attribute__((unused)))
 {
   double check_trunc_val= (val > 0) ? floor(val) : -floor(-val);
   char *buf= (char *)r_param->buffer;
@@ -616,7 +618,7 @@ static void convert_from_float(MYSQL_BIND *r_param, const MYSQL_FIELD *field, fl
   } 
 }
 
-static void convert_from_double(MYSQL_BIND *r_param, const MYSQL_FIELD *field, double val, int size)
+static void convert_from_double(MYSQL_BIND *r_param, const MYSQL_FIELD *field, double val, int size __attribute__((unused)))
 {
   double check_trunc_val= (val > 0) ? floor(val) : -floor(-val);
   char *buf= (char *)r_param->buffer;
@@ -902,8 +904,9 @@ void ps_fetch_datetime(MYSQL_BIND *r_param, const MYSQL_FIELD * field,
 
 /* {{{ ps_fetch_string */
 static
-void ps_fetch_string(MYSQL_BIND *r_param, const MYSQL_FIELD *field,
+void ps_fetch_string(MYSQL_BIND *r_param,
-             unsigned char **row)
+                     const MYSQL_FIELD *field __attribute__((unused)),
+                     unsigned char **row)
 {
   /* C-API differs from PHP. While PHP just converts string to string,
      C-API needs to convert the string to the defined type with in 
@@ -918,50 +921,32 @@ void ps_fetch_string(MYSQL_BIND *r_param, const MYSQL_FIELD *field,
 
 /* {{{ ps_fetch_bin */
 static
-void ps_fetch_bin(MYSQL_BIND *r_param, const MYSQL_FIELD *field,
+void ps_fetch_bin(MYSQL_BIND *r_param, 
+             const MYSQL_FIELD *field __attribute__((unused)),
              unsigned char **row)
 {
-  /* If r_praram->buffer_type is not a binary type or binary_flag isn't set,
+  ulong field_length= *r_param->length= net_field_length(row);
-     we do conversion from string */
+  uchar *current_pos= (*row) + r_param->offset,
-  if (!(field->flags & BINARY_FLAG) || 
+        *end= (*row) + field_length;
-         (r_param->buffer_type != MYSQL_TYPE_NEWDECIMAL &&
+  size_t copylen= 0;
-          r_param->buffer_type != MYSQL_TYPE_DECIMAL &&
-          r_param->buffer_type != MYSQL_TYPE_GEOMETRY &&
-          r_param->buffer_type != MYSQL_TYPE_ENUM &&
-          r_param->buffer_type != MYSQL_TYPE_SET &&
-          r_param->buffer_type != MYSQL_TYPE_TINY_BLOB &&
-          r_param->buffer_type != MYSQL_TYPE_MEDIUM_BLOB &&
-          r_param->buffer_type != MYSQL_TYPE_LONG_BLOB &&
-          r_param->buffer_type != MYSQL_TYPE_BLOB))
-  {
-    ps_fetch_string(r_param, field, row);
-    return;
-  }
-  else
-  {
-    ulong field_length= *r_param->length= net_field_length(row);
-    uchar *current_pos= (*row) + r_param->offset,
-          *end= (*row) + field_length;
-    size_t copylen= 0;
 
-    if (current_pos < end)
+  if (current_pos < end)
+  {
+    copylen= end - current_pos;
+    if (r_param->buffer_length)
     {
-      copylen= end - current_pos;
+      memcpy(r_param->buffer, current_pos, MIN(copylen, r_param->buffer_length));
-      if (r_param->buffer_length)
+      if (copylen < r_param->buffer_length &&
-      {
+          r_param->buffer_type == MYSQL_TYPE_STRING)
-        memcpy(r_param->buffer, current_pos, MIN(copylen, r_param->buffer_length));
+        ((char *)r_param->buffer)[copylen]= 0;
-        if (copylen < r_param->buffer_length &&
-            r_param->buffer_type == MYSQL_TYPE_STRING)
-          ((char *)r_param->buffer)[copylen]= 0;
-      }
     }
-    *r_param->error= copylen > r_param->buffer_length;
-    /* don't count trailing zero if we fetch into string */
-    if (r_param->buffer_type == MYSQL_TYPE_STRING &&
-      !*r_param->error)
-      field_length--;
-    (*row)+= field_length;
   }
+  *r_param->error= copylen > r_param->buffer_length;
+  /* don't count trailing zero if we fetch into string */
+  if (r_param->buffer_type == MYSQL_TYPE_STRING &&
+    !*r_param->error)
+    field_length--;
+  (*row)+= field_length;
 }
 /* }}} */
 

libmariadb/ma_tls.c

@@ -51,7 +51,7 @@
 my_bool ma_tls_initialized= FALSE;
 unsigned int mariadb_deinitialize_ssl= 1;
 
-char *ssl_protocol_version[5]= {"TLS1.0", "TLS1.1", "TLS1.2"};
+const char *ssl_protocol_version[5]= {"TLS1.0", "TLS1.1", "TLS1.2"};
 
 MARIADB_TLS *ma_pvio_tls_init(MYSQL *mysql)
 {
@@ -119,11 +119,14 @@ my_bool ma_pvio_tls_get_protocol_version(MARIADB_TLS *ctls, struct st_ssl_versio
   return ma_tls_get_protocol_version(ctls, version);
 }
 
-static my_bool ma_pvio_tls_compare_fp(char *fp1, unsigned int fp1_len,
+static my_bool ma_pvio_tls_compare_fp(const char *fp1, unsigned int fp1_len,
-                                   char *fp2, unsigned int fp2_len)
+                                   const char *fp2, unsigned int fp2_len)
 {
   char hexstr[64];
 
+  if (fp1_len != fp2_len)
+    return 1;
+
   fp1_len= (unsigned int)mysql_hex_string(hexstr, fp1, fp1_len);
 #ifdef WIN32
   if (strnicmp(hexstr, fp2, fp1_len) != 0)
@@ -137,14 +140,14 @@ static my_bool ma_pvio_tls_compare_fp(char *fp1, unsigned int fp1_len,
 my_bool ma_pvio_tls_check_fp(MARIADB_TLS *ctls, const char *fp, const char *fp_list)
 {
   unsigned int cert_fp_len= 64;
-  unsigned char cert_fp[64];
+  char cert_fp[64];
   my_bool rc=1;
   MYSQL *mysql= ctls->pvio->mysql;
 
   if ((cert_fp_len= ma_tls_get_finger_print(ctls, cert_fp, cert_fp_len)) < 1)
     goto end;
   if (fp)
-    rc= ma_pvio_tls_compare_fp(cert_fp, cert_fp_len, (char *)fp, (unsigned int)strlen(fp));
+    rc= ma_pvio_tls_compare_fp(cert_fp, cert_fp_len, fp, (unsigned int)strlen(fp));
   else if (fp_list)
   {
     MA_FILE *fp;

libmariadb/mariadb_async.c

@@ -14,6 +14,7 @@
    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+*/
 
 /*
   MySQL non-blocking client library functions.

libmariadb/mariadb_charset.c

@@ -38,7 +38,7 @@ MARIADB_CHARSET_INFO * STDCALL mysql_get_charset_by_nr(uint cs_number)
   return (mariadb_compiled_charsets[i].nr) ? (MARIADB_CHARSET_INFO *)&mariadb_compiled_charsets[i] : NULL;
 }
 
-my_bool set_default_charset(uint cs, myf flags)
+my_bool set_default_charset(uint cs, myf flags __attribute__((unused)))
 {
   MARIADB_CHARSET_INFO *new_charset;
   new_charset = mysql_get_charset_by_nr(cs);
@@ -60,7 +60,7 @@ MARIADB_CHARSET_INFO * STDCALL mysql_get_charset_by_name(const char *cs_name)
   return (mariadb_compiled_charsets[i].nr) ? (MARIADB_CHARSET_INFO *)&mariadb_compiled_charsets[i] : NULL;
 }
 
-my_bool set_default_charset_by_name(const char *cs_name, myf flags)
+my_bool set_default_charset_by_name(const char *cs_name, myf flags __attribute__((unused)))
 {
   MARIADB_CHARSET_INFO *new_charset;
   new_charset = mysql_get_charset_by_name(cs_name);

libmariadb/mariadb_dyncol.c

@@ -1004,6 +1004,8 @@ dynamic_column_value_len(DYNAMIC_COLUMN_VALUE *value,
       return 3;
   case DYN_COL_DYNCOL:
     return value->x.string.value.length;
+  default:
+    break;  
   }
   DBUG_ASSERT(0);
   return 0;
@@ -1592,6 +1594,8 @@ data_store(DYNAMIC_COLUMN *str, DYNAMIC_COLUMN_VALUE *value,
     return dynamic_column_dyncol_store(str, &value->x.string.value);
   case DYN_COL_NULL:
     break;                                      /* Impossible */
+  default:
+    break;
   }
   DBUG_ASSERT(0);
   return ER_DYNCOL_OK;                          /* Impossible */

libmariadb/mariadb_lib.c

@@ -362,7 +362,7 @@ mthd_my_send_cmd(MYSQL *mysql,enum enum_server_command command, const char *arg,
   if (multi == MARIADB_COM_MULTI_BEGIN)
   {
     /* todo: error handling */
-    return(net_add_multi_command(&mysql->net, command, arg, length));
+    return(net_add_multi_command(&mysql->net, command, (uchar *)arg, length));
   }
 
   if (mysql->net.pvio == 0)
@@ -556,7 +556,7 @@ enum enum_option_type {
 struct st_default_options {
   enum mysql_option option;
   enum enum_option_type type;
-  char *conf_key;
+  const char *conf_key;
 };
 
 struct st_default_options mariadb_defaults[] =
@@ -715,7 +715,7 @@ static size_t rset_field_offsets[]= {
 
 MYSQL_FIELD *
 unpack_fields(MYSQL_DATA *data,MA_MEM_ROOT *alloc,uint fields,
-	      my_bool default_value, my_bool long_flag_protocol)
+	      my_bool default_value, my_bool long_flag_protocol __attribute__((unused)))
 {
   MYSQL_ROWS	*row;
   MYSQL_FIELD	*field,*result;
@@ -1005,11 +1005,11 @@ mysql_get_ssl_cipher(MYSQL *mysql)
 ** NB! Errors are not reported until you do mysql_real_connect.
 **************************************************************************/
 
-uchar *ma_send_connect_attr(MYSQL *mysql, uchar *buffer)
+char *ma_send_connect_attr(MYSQL *mysql, unsigned char *buffer)
 {
   if (mysql->server_capabilities & CLIENT_CONNECT_ATTRS)
   {
-    buffer= mysql_net_store_length((unsigned char *)buffer, (mysql->options.extension) ?
+    buffer= (unsigned char *)mysql_net_store_length((unsigned char *)buffer, (mysql->options.extension) ?
                              mysql->options.extension->connect_attrs_len : 0);
     if (mysql->options.extension &&
         hash_inited(&mysql->options.extension->connect_attrs))
@@ -1025,14 +1025,14 @@ uchar *ma_send_connect_attr(MYSQL *mysql, uchar *buffer)
         memcpy(buffer, p, len);
         buffer+= (len);
         p+= (len + 1);
-        len= strlen(p);
+        len= strlen((char *)p);
         buffer= mysql_net_store_length(buffer, len);
         memcpy(buffer, p, len);
         buffer+= len;
       }
     }
   }
-  return buffer;
+  return (char *)buffer;
 }
 
 /** set some default attributes */
@@ -1223,8 +1223,15 @@ MYSQL *mthd_my_real_connect(MYSQL *mysql, const char *host, const char *user,
   else
 #endif
 #else
+  if (mysql->options.protocol == MYSQL_PROTOCOL_MEMORY ||
+      mysql->options.shared_memory_base_name)
+  {
+    cinfo.host= mysql->options.shared_memory_base_name;
+    cinfo.type= PVIO_TYPE_SHAREDMEM;
+    sprintf(host_info=buff,ER(CR_SHARED_MEMORY_CONNECTION), cinfo.host ? cinfo.host : SHM_DEFAULT_NAME);
+  }
    /* named pipe */
-  if (mysql->options.protocol == MYSQL_PROTOCOL_PIPE ||
+  else if (mysql->options.protocol == MYSQL_PROTOCOL_PIPE ||
 	  (host && strcmp(host,LOCAL_HOST_NAMEDPIPE) == 0))
   {
     cinfo.type= PVIO_TYPE_NAMEDPIPE;
@@ -2095,7 +2102,7 @@ mysql_real_query(MYSQL *mysql, const char *query, size_t length)
 
   if (OPT_HAS_EXT_VAL(mysql, multi_command))
     is_multi= mysql->options.extension->multi_command;
-  if (length == -1)
+  if (length == (size_t)-1)
     length= strlen(query);
 
   free_old_query(mysql);
@@ -2541,7 +2548,7 @@ uchar *ma_get_hash_keyval(const uchar *hash_entry,
              key_length + 1  value (\0 terminated)
   */
   uchar *p= (uchar *)hash_entry;
-  size_t len= strlen(p);
+  size_t len= strlen((char *)p);
   *length= (unsigned int)len;
   return p;
 }
@@ -2556,20 +2563,23 @@ int mariadb_flush_multi_command(MYSQL *mysql)
   int rc;
   size_t length= mysql->net.extension->mbuff_pos - mysql->net.extension->mbuff;
 
-  rc= ma_simple_command(mysql, COM_MULTI, mysql->net.extension->mbuff,
+  rc= ma_simple_command(mysql, COM_MULTI, (char *)mysql->net.extension->mbuff,
                      length, 1, 0);
   /* reset multi_buff */
   mysql->net.extension->mbuff_pos= mysql->net.extension->mbuff;
 
   /* don't read result for mysql_stmt_execute_direct() */
   if (!rc)
-    if (mysql->net.extension->mbuff && length > 3 &&
+  {
-        (mysql->net.extension->mbuff[3] == COM_STMT_PREPARE ||
+    uchar *p= (uchar *)mysql->net.extension->mbuff;
-         mysql->net.extension->mbuff[3] == COM_STMT_EXECUTE ||
+    unsigned long len= net_field_length(&p);
-         mysql->net.extension->mbuff[3] == COM_STMT_CLOSE))
+    if (len && (*p == COM_STMT_PREPARE ||
+                *p == COM_STMT_EXECUTE ||
+                *p == COM_STMT_CLOSE))
       return rc;
     else
       return mysql->methods->db_read_query_result(mysql);
+  }
   return rc;
 }
 
@@ -2623,6 +2633,11 @@ mysql_optionsv(MYSQL *mysql,enum mysql_option option, ...)
   case MYSQL_OPT_PROTOCOL:
     mysql->options.protocol= *((uint *)arg1);
     break;
+#ifdef _WIN32
+  case MYSQL_SHARED_MEMORY_BASE_NAME:
+    OPT_SET_VALUE_STR(&mysql->options, shared_memory_base_name, arg1);
+    break;
+#endif
   case MYSQL_OPT_READ_TIMEOUT:
     mysql->options.read_timeout= *(uint *)arg1;
     break;
@@ -2732,10 +2747,10 @@ mysql_optionsv(MYSQL *mysql,enum mysql_option option, ...)
                       arg1 ? (uint)strlen((char *)arg1) : 0)))
       {
         uchar *p= h;
-        size_t key_len= strlen(p);
+        size_t key_len= strlen((char *)p);
         mysql->options.extension->connect_attrs_len-= key_len + get_store_length(key_len);
         p+= key_len + 1;
-        key_len= strlen(p);
+        key_len= strlen((char *)p);
         mysql->options.extension->connect_attrs_len-= key_len + get_store_length(key_len);
         hash_delete(&mysql->options.extension->connect_attrs, h);
       }
@@ -2808,8 +2823,10 @@ mysql_optionsv(MYSQL *mysql,enum mysql_option option, ...)
         }
       }
       /* check if key is already in buffer */
-      if (p= (uchar *)hash_search(&mysql->options.extension->userdata, (uchar *)key,
+      p= (uchar *)hash_search(&mysql->options.extension->userdata, 
-                      (uint)strlen((char *)key)))
+                              (uchar *)key,
+                              (uint)strlen(key));
+      if (p)
       {
         p+= strlen(key) + 1;
         memcpy(p, &data, sizeof(void *));
@@ -2823,7 +2840,7 @@ mysql_optionsv(MYSQL *mysql,enum mysql_option option, ...)
       }
 
       p= buffer;
-      strcpy(p, key);
+      strcpy((char *)p, key);
       p+= strlen(key) + 1;
       memcpy(p, &data, sizeof(void *));
 
@@ -2870,10 +2887,10 @@ mysql_optionsv(MYSQL *mysql,enum mysql_option option, ...)
       if ((buffer= (uchar *)malloc(key_len + value_len)))
       {
         uchar *p= buffer;
-        strcpy(p, arg1);
+        strcpy((char *)p, arg1);
         p+= (strlen(arg1) + 1);
         if (arg2)
-          strcpy(p, arg2);
+          strcpy((char *)p, arg2);
 
         if (hash_insert(&mysql->options.extension->connect_attrs, buffer))
         {
@@ -3003,7 +3020,7 @@ mysql_get_optionv(MYSQL *mysql, enum mysql_option option, void *arg, ...)
     break;
   case MYSQL_SET_CHARSET_NAME:
     if (mysql->charset)
-      *((char **)arg)= mysql->charset->csname;
+      *((const char **)arg)= mysql->charset->csname;
     else
       *((char **)arg)= mysql->options.charset_name;
     break;
@@ -3074,7 +3091,7 @@ mysql_get_optionv(MYSQL *mysql, enum mysql_option option, void *arg, ...)
   case MYSQL_OPT_CONNECT_ATTRS:
     /* mysql_get_optionsv(mysql, MYSQL_OPT_CONNECT_ATTRS, keys, vals, elements) */
     {
-      int i, *elements;
+      unsigned int i, *elements;
       char **key= NULL;
       void *arg1;
       char **val= NULL;
@@ -3106,10 +3123,10 @@ mysql_get_optionv(MYSQL *mysql, enum mysql_option option, void *arg, ...)
         {
           uchar *p= hash_element(&mysql->options.extension->connect_attrs, i);
           if (key)
-            key[i]= p;
+            key[i]= (char *)p;
-          p+= strlen(p) + 1;
+          p+= strlen((char *)p) + 1;
           if (val)
-            val[i]= p;
+            val[i]= (char *)p;
         }
       }
     }
@@ -3198,7 +3215,7 @@ mysql_options4(MYSQL *mysql,enum mysql_option option, const void *arg1, const vo
 ****************************************************************************/
 
 /* MYSQL_RES */
-unsigned long long STDCALL mysql_num_rows(MYSQL_RES *res)
+my_ulonglong STDCALL mysql_num_rows(MYSQL_RES *res)
 {
   return res->row_count;
 }
@@ -3241,7 +3258,7 @@ unsigned int STDCALL mysql_field_count(MYSQL *mysql)
   return mysql->field_count;
 }
 
-unsigned long long STDCALL mysql_affected_rows(MYSQL *mysql)
+my_ulonglong STDCALL mysql_affected_rows(MYSQL *mysql)
 {
   return (mysql)->affected_rows;
 }
@@ -3262,7 +3279,7 @@ my_bool STDCALL mysql_rollback(MYSQL *mysql)
   return((my_bool)mysql_real_query(mysql, "ROLLBACK", sizeof("ROLLBACK")));
 }
 
-unsigned long long STDCALL mysql_insert_id(MYSQL *mysql)
+my_ulonglong STDCALL mysql_insert_id(MYSQL *mysql)
 {
   return (mysql)->insert_id;
 }
@@ -3274,7 +3291,7 @@ uint STDCALL mysql_errno(MYSQL *mysql)
 
 char * STDCALL mysql_error(MYSQL *mysql)
 {
-  return mysql ? (mysql)->net.last_error : "";
+  return mysql ? (mysql)->net.last_error : (char *)"";
 }
 
 char *STDCALL mysql_info(MYSQL *mysql)
@@ -3655,18 +3672,18 @@ my_bool STDCALL mariadb_get_infov(MYSQL *mysql, enum mariadb_value value, void *
   case MARIADB_TLS_LIBRARY:
 #ifdef HAVE_TLS
 #ifdef HAVE_GNUTLS
-    *((char **)arg)= "GNUTLS";
+    *((const char **)arg)= "GNUTLS";
 #elif HAVE_OPENSSL
-    *((char **)arg)= "OPENSSL";
+    *((const char **)arg)= "OPENSSL";
 #elif HAVE_SCHANNEL
-    *((char **)arg)= "SCHANNEL";
+    *((const char **)arg)= "SCHANNEL";
 #endif
 #else
     *((char **)arg)= "OFF";
 #endif
     break;
   case MARIADB_CLIENT_VERSION:
-    *((char **)arg)= MARIADB_CLIENT_VERSION_STR;
+    *((const char **)arg)= MARIADB_CLIENT_VERSION_STR;
     break;
   case MARIADB_CLIENT_VERSION_ID:
     *((size_t *)arg)= MARIADB_VERSION_ID;
@@ -3679,7 +3696,7 @@ my_bool STDCALL mariadb_get_infov(MYSQL *mysql, enum mariadb_value value, void *
     break;
   case MARIADB_CONNECTION_SERVER_TYPE:
     if (mysql)
-      *((char **)arg)= mariadb_connection(mysql) ? "MariaDB" : "MySQL";
+      *((const char **)arg)= mariadb_connection(mysql) ? "MariaDB" : "MySQL";
     else
       goto error;
     break;

libmariadb/mariadb_stmt.c

@@ -79,6 +79,23 @@ MYSQL_FIELD * unpack_fields(MYSQL_DATA *data,MA_MEM_ROOT *alloc,uint fields, my_
 static my_bool is_not_null= 0;
 static my_bool is_null= 1;
 
+void stmt_set_error(MYSQL_STMT *stmt,
+                  unsigned int error_nr,
+                  const char *sqlstate,
+                  const char *format,
+                  ...)
+{
+  va_list ap;
+
+  stmt->last_errno= error_nr;
+  ma_strmake(stmt->sqlstate, sqlstate, SQLSTATE_LENGTH);
+  va_start(ap, format);
+  vsnprintf(stmt->last_error, MYSQL_ERRMSG_SIZE,
+            format ? format : ER(error_nr), ap);
+  va_end(ap);
+  return;
+}
+
 my_bool mthd_supported_buffer_type(enum enum_field_types type)
 {
   switch (type) {
@@ -116,7 +133,8 @@ my_bool mthd_supported_buffer_type(enum enum_field_types type)
 
 static my_bool madb_reset_stmt(MYSQL_STMT *stmt, unsigned int flags);
 static my_bool mysql_stmt_internal_reset(MYSQL_STMT *stmt, my_bool is_close);
-static int stmt_unbuffered_eof(MYSQL_STMT *stmt, uchar **row)
+static int stmt_unbuffered_eof(MYSQL_STMT *stmt __attribute__((unused)),
+                               uchar **row __attribute__((unused)))
 {
   return MYSQL_NO_DATA;
 }
@@ -501,7 +519,7 @@ int store_param(MYSQL_STMT *stmt, int column, unsigned char **p, unsigned long r
     MYSQL_TIME *t= (MYSQL_TIME *)ma_get_buffer_offset(stmt, stmt->params[column].buffer_type,
                                                       stmt->params[column].buffer, row_nr);
     char t_buffer[MAX_DATETIME_STR_LEN];
-    uint len;
+    uint len= 0;
 
     int2store(t_buffer + 1, t->year);
     t_buffer[3]= (char) t->month;
@@ -512,7 +530,7 @@ int store_param(MYSQL_STMT *stmt, int column, unsigned char **p, unsigned long r
     if (t->second_part)
     {
       int4store(t_buffer + 8, t->second_part);
-      len= 12;
+      len= 11;
     }
     else if (t->hour || t->minute || t->second)
       len= 7;
@@ -603,6 +621,13 @@ unsigned char* mysql_stmt_execute_generate_request(MYSQL_STMT *stmt, size_t *req
 
   uchar *start= NULL, *p;
 
+  if (!bulk_supported && stmt->array_size > 0)
+  {
+    stmt_set_error(stmt, CR_FUNCTION_NOT_SUPPORTED, SQLSTATE_UNKNOWN,
+                   CER(CR_FUNCTION_NOT_SUPPORTED), "Bulk operation");
+    return NULL;
+  }
+
 
   /* preallocate length bytes */
   /* check: gr */
@@ -677,12 +702,12 @@ unsigned char* mysql_stmt_execute_generate_request(MYSQL_STMT *stmt, size_t *req
       {
         ulong size= 0;
         my_bool has_data= TRUE;
-        uchar indicator= 0;
+        char indicator= 0;
 
         if (bulk_supported && stmt->params[i].u.indicator)
         {
           if (stmt->row_size)
-            indicator= *(uchar *)(stmt->params[i].u.indicator + j * stmt->row_size);
+            indicator= *(char *)(stmt->params[i].u.indicator + j * stmt->row_size);
           else
             indicator= stmt->params[i].u.indicator[j];
           /* check if we need to send data */
@@ -720,8 +745,11 @@ unsigned char* mysql_stmt_execute_generate_request(MYSQL_STMT *stmt, size_t *req
           case MYSQL_TYPE_BIT:
           case MYSQL_TYPE_SET:
             size+= 5; /* max 8 bytes for size */
-            if (indicator == STMT_INDICATOR_NTS || (!stmt->row_size && stmt->params[i].length[j] == -1))
+            if (indicator == STMT_INDICATOR_NTS || 
-              size+= strlen(ma_get_buffer_offset(stmt, stmt->params[i].buffer_type, stmt->params[i].buffer,j));
+              (!stmt->row_size && stmt->params[i].length[j] == (unsigned long)-1))
+                size+= strlen(ma_get_buffer_offset(stmt, 
+                                                   stmt->params[i].buffer_type,
+                                                   stmt->params[i].buffer,j));
             else
               if (!stmt->row_size)
                 size+= (size_t)stmt->params[i].length[j];
@@ -1327,7 +1355,7 @@ int STDCALL mysql_stmt_prepare(MYSQL_STMT *stmt, const char *query, size_t lengt
     return(1);
   }
 
-  if (length == -1)
+  if (length == (size_t) -1)
     length= strlen(query);
 
   mysql_get_optionv(mysql, MARIADB_OPT_COM_MULTI, &multi);
@@ -1718,6 +1746,9 @@ int STDCALL mysql_stmt_execute(MYSQL_STMT *stmt)
   }
   request= (char *)mysql_stmt_execute_generate_request(stmt, &request_len);
 
+  if (!request)
+    return 1;
+
   ret= stmt->mysql->methods->db_command(mysql, COM_STMT_EXECUTE, request,
                                              request_len, 1, stmt);
 
@@ -1967,7 +1998,7 @@ unsigned long long STDCALL mysql_stmt_num_rows(MYSQL_STMT *stmt)
   return stmt->result.rows;
 }
 
-MYSQL_RES* STDCALL mysql_stmt_param_metadata(MYSQL_STMT *stmt)
+MYSQL_RES* STDCALL mysql_stmt_param_metadata(MYSQL_STMT *stmt __attribute__((unused)))
 {
   /* server doesn't deliver any information yet,
      so we just return NULL
@@ -2061,7 +2092,7 @@ int STDCALL mariadb_stmt_execute_direct(MYSQL_STMT *stmt,
     return(1);
   }
 
-  if (length == -1)
+  if (length == (size_t) -1)
     length= strlen(stmt_str);
 
   mysql_get_optionv(mysql, MARIADB_OPT_COM_MULTI, &multi);

libmariadb/secure/gnutls.c

@@ -39,6 +39,91 @@ extern unsigned int mariadb_deinitialize_ssl;
 
 static int my_verify_callback(gnutls_session_t ssl);
 
+struct st_cipher_map {
+  const char *openssl_name;
+  const char *priority;
+  gnutls_kx_algorithm_t kx;
+  gnutls_cipher_algorithm_t cipher;
+  gnutls_mac_algorithm_t mac;
+};
+
+const struct st_cipher_map gtls_ciphers[]=
+{
+  {"DHE-RSA-AES256-GCM-SHA384", ":+AEAD:+DHE-RSA:+AES-256-GCM",
+   GNUTLS_KX_DHE_RSA, GNUTLS_CIPHER_AES_256_GCM, GNUTLS_MAC_AEAD},
+  {"DHE-RSA-AES256-SHA256", ":+SHA256:+DHE-RSA:+AES-256-CBC",
+   GNUTLS_KX_DHE_RSA, GNUTLS_CIPHER_AES_256_CBC, GNUTLS_MAC_SHA256},
+  {"DHE-RSA-AES256-SHA", ":+SHA1:+DHE-RSA:+AES-256-CBC",
+   GNUTLS_KX_DHE_RSA, GNUTLS_CIPHER_AES_256_CBC, GNUTLS_MAC_SHA1},
+  {"DHE-RSA-CAMELLIA256-SHA", ":+SHA1:+DHE-RSA:+CAMELLIA-256-CBC",
+   GNUTLS_KX_DHE_RSA, GNUTLS_CIPHER_CAMELLIA_256_CBC, GNUTLS_MAC_SHA1},
+  {"AES256-GCM-SHA384", ":+AEAD:+RSA:+AES-256-GCM",
+   GNUTLS_KX_RSA, GNUTLS_CIPHER_AES_256_GCM, GNUTLS_MAC_AEAD},
+  {"AES256-SHA256", ":+SHA256:+RSA:+AES-256-CBC",
+   GNUTLS_KX_RSA, GNUTLS_CIPHER_AES_256_CBC, GNUTLS_MAC_SHA256},
+  {"AES256-SHA", ":+SHA1:+RSA:+AES-256-CBC",
+   GNUTLS_KX_RSA, GNUTLS_CIPHER_AES_256_CBC, GNUTLS_MAC_SHA1},
+  {"CAMELLIA256-SHA", ":+SHA1:+RSA:+CAMELLIA-256-CBC",
+   GNUTLS_KX_RSA, GNUTLS_CIPHER_CAMELLIA_256_CBC, GNUTLS_MAC_SHA1},
+  {"DHE-RSA-AES128-GCM-SHA256", ":+AEAD:+DHE-RSA:+AES-128-GCM",
+   GNUTLS_KX_DHE_RSA, GNUTLS_CIPHER_AES_128_GCM, GNUTLS_MAC_AEAD},
+  {"DHE-RSA-AES128-SHA256", ":+SHA256:+DHE-RSA:+AES-128-CBC",
+   GNUTLS_KX_DHE_RSA, GNUTLS_CIPHER_AES_128_CBC, GNUTLS_MAC_SHA256},
+  {"DHE-RSA-AES128-SHA", ":+SHA1:+DHE-RSA:+AES-128-CBC",
+   GNUTLS_KX_DHE_RSA, GNUTLS_CIPHER_AES_128_CBC, GNUTLS_MAC_SHA1},
+  {"DHE-RSA-CAMELLIA128-SHA", ":+SHA1:+DHE-RSA:+CAMELLIA-128-CBC",
+   GNUTLS_KX_DHE_RSA, GNUTLS_CIPHER_CAMELLIA_128_CBC, GNUTLS_MAC_SHA1},
+  {"AES128-GCM-SHA256", ":+AEAD:+RSA:+AES-128-GCM",
+   GNUTLS_KX_RSA, GNUTLS_CIPHER_AES_128_GCM, GNUTLS_MAC_AEAD},
+  {"AES128-SHA256", ":+SHA256:+RSA:+AES-128-CBC",
+   GNUTLS_KX_RSA, GNUTLS_CIPHER_AES_128_CBC, GNUTLS_MAC_SHA256},
+  {"AES128-SHA", ":+SHA1:+RSA:+AES-128-CBC",
+   GNUTLS_KX_RSA, GNUTLS_CIPHER_AES_128_CBC, GNUTLS_MAC_SHA1},
+  {"CAMELLIA128-SHA", ":+SHA1:+RSA:+CAMELLIA-128-CBC",
+   GNUTLS_KX_RSA, GNUTLS_CIPHER_CAMELLIA_128_CBC, GNUTLS_MAC_SHA1},
+  {"EDH-RSA-DES-CBC3-SHA", ":+SHA1:+DHE-RSA:+3DES-CBC",
+   GNUTLS_KX_DHE_RSA, GNUTLS_CIPHER_3DES_CBC, GNUTLS_MAC_SHA1},
+  {"DES-CBC3-SHA", ":+SHA1:+RSA:+3DES-CBC",
+   GNUTLS_KX_RSA, GNUTLS_CIPHER_3DES_CBC, GNUTLS_MAC_SHA1},
+  {"DHE-RSA-AES256-SHA", ":+SHA1:+DHE-RSA:+AES-256-CBC",
+   GNUTLS_KX_DHE_RSA, GNUTLS_CIPHER_AES_256_CBC, GNUTLS_MAC_SHA1},
+  {"DHE-RSA-CAMELLIA256-SHA", ":+SHA1:+DHE-RSA:+CAMELLIA-256-CBC",
+   GNUTLS_KX_DHE_RSA, GNUTLS_CIPHER_CAMELLIA_256_CBC, GNUTLS_MAC_SHA1},
+  {"AES256-SHA", ":+SHA1:+RSA:+AES-256-CBC",
+   GNUTLS_KX_RSA, GNUTLS_CIPHER_AES_256_CBC, GNUTLS_MAC_SHA1},
+  {"CAMELLIA256-SHA", ":+SHA1:+RSA:+CAMELLIA-256-CBC:",
+   GNUTLS_KX_RSA, GNUTLS_CIPHER_CAMELLIA_256_CBC, GNUTLS_MAC_SHA1},
+  {NULL, NULL, 0, 0, 0}
+};
+
+static const char *openssl_cipher_name(gnutls_kx_algorithm_t kx,
+                                       gnutls_cipher_algorithm_t cipher,
+                                       gnutls_mac_algorithm_t mac)
+{
+  unsigned int i=0;
+  while (gtls_ciphers[i].openssl_name)
+  {
+    if (gtls_ciphers[i].kx == kx &&
+        gtls_ciphers[i].cipher == cipher &&
+        gtls_ciphers[i].mac == mac)
+      return gtls_ciphers[i].openssl_name;
+    i++;
+  }
+  return NULL;
+}
+
+static const char *get_priority(const char *cipher_name)
+{
+  unsigned int i= 0;
+  while (gtls_ciphers[i].openssl_name)
+  {
+    if (strcmp(gtls_ciphers[i].openssl_name, cipher_name) == 0)
+      return gtls_ciphers[i].priority;
+    i++;
+  }
+  return NULL;
+}
+
 #define MAX_SSL_ERR_LEN 100
 
 static void ma_tls_set_error(MYSQL *mysql, int ssl_errno)
@@ -58,7 +143,7 @@ static void ma_tls_set_error(MYSQL *mysql, int ssl_errno)
                    ssl_error_reason);
     return;
   }
-  snprintf(ssl_error, MAX_SSL_ERR_LEN, "SSL errno=%lu", ssl_errno, mysql->charset);
+  snprintf(ssl_error, MAX_SSL_ERR_LEN, "SSL errno=%d", ssl_errno);
   pvio->set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN, 
                  ssl_error);
 }
@@ -78,7 +163,7 @@ static void ma_tls_get_error(char *errmsg, size_t length, int ssl_errno)
     strncpy(errmsg, ssl_error_reason, length);
     return;
   }
-  snprintf(errmsg, length, "SSL errno=%lu", ssl_errno);
+  snprintf(errmsg, length, "SSL errno=%d", ssl_errno);
 }
 
 /*
@@ -147,11 +232,42 @@ void ma_tls_end()
   return;
 }
 
+static int ma_gnutls_set_ciphers(gnutls_session_t ssl, char *cipher_str)
+{
+  const char *err;
+  char *token;
+#define PRIO_SIZE 1024  
+  char prio[PRIO_SIZE];
+
+  if (!cipher_str)
+    return gnutls_priority_set_direct(ssl, "NORMAL", &err);
+
+  token= strtok(cipher_str, ":");
+
+  strcpy(prio, "NONE:+VERS-TLS-ALL:+SIGN-ALL:+COMP-NULL");
+
+  while (token)
+  {
+    const char *p= get_priority(token);
+    /* if cipher was not found, we pass the original token to
+        the priority string, this will allow to specify gnutls
+        specific settings via cipher */
+    if (!p)
+    {
+      strncat(prio, ":", PRIO_SIZE - strlen(prio) - 1);
+      strncat(prio, token, PRIO_SIZE - strlen(prio) - 1);
+    }
+    else 
+      strncat(prio, p, PRIO_SIZE - strlen(prio) - 1);
+    token = strtok(NULL, ":");
+  }
+  return gnutls_priority_set_direct(ssl, prio , &err);
+}
+
 static int ma_tls_set_certs(MYSQL *mysql)
 {
   char *certfile= mysql->options.ssl_cert,
        *keyfile= mysql->options.ssl_key;
-  char *cipher= NULL;
   int  ssl_error= 0;
 
   if (mysql->options.ssl_ca)
@@ -177,17 +293,14 @@ static int ma_tls_set_certs(MYSQL *mysql)
   if (certfile || keyfile)
   {
     if ((ssl_error= gnutls_certificate_set_x509_key_file2(GNUTLS_xcred,
-                                                         certfile, keyfile,
+                      certfile, keyfile, GNUTLS_X509_FMT_PEM,
-                                                         GNUTLS_X509_FMT_PEM,
+                      OPT_HAS_EXT_VAL(mysql, tls_pw) ? mysql->options.extension->tls_pw : NULL,
-                                                         OPT_HAS_EXT_VAL(mysql, tls_pw) ? mysql->options.extension->tls_pw : NULL,
+                      0)) < 0)
-                                                         0)) < 0)
       goto error;
   }
   return 1;
 
 error:
-  if (cipher)
-    free(cipher);
   return ssl_error;
 }
 
@@ -195,7 +308,6 @@ void *ma_tls_init(MYSQL *mysql)
 {
   gnutls_session_t ssl= NULL;
   int ssl_error= 0;
-  const char *err;
 
   pthread_mutex_lock(&LOCK_gnutls_config);
 
@@ -205,8 +317,8 @@ void *ma_tls_init(MYSQL *mysql)
   if ((ssl_error = gnutls_init(&ssl, GNUTLS_CLIENT & GNUTLS_NONBLOCK)) < 0)
     goto error;
   gnutls_session_set_ptr(ssl, (void *)mysql);
-
+ 
-  ssl_error= gnutls_priority_set_direct(ssl, "NORMAL", &err);
+  ssl_error= ma_gnutls_set_ciphers(ssl, mysql->options.ssl_cipher);
   if (ssl_error < 0)
     goto error;
 
@@ -276,6 +388,8 @@ my_bool ma_tls_connect(MARIADB_TLS *ctls)
   {
     ma_tls_set_error(mysql, ret);
     /* restore blocking mode */
+    gnutls_deinit((gnutls_session_t )ctls->ssl);
+    ctls->ssl= NULL;
     if (!blocking)
       pvio->methods->blocking(pvio, FALSE, 0);
     return 1;
@@ -297,14 +411,16 @@ size_t ma_tls_write(MARIADB_TLS *ctls, const uchar* buffer, size_t length)
 
 my_bool ma_tls_close(MARIADB_TLS *ctls)
 {
-  gnutls_bye((gnutls_session_t )ctls->ssl, GNUTLS_SHUT_WR);
+  if (ctls->ssl)
-  gnutls_deinit((gnutls_session_t )ctls->ssl);
+  {
-  ctls->ssl= NULL;
+    gnutls_bye((gnutls_session_t )ctls->ssl, GNUTLS_SHUT_WR);
-
+    gnutls_deinit((gnutls_session_t )ctls->ssl);
+    ctls->ssl= NULL;
+  }
   return 0;
 }
 
-int ma_tls_verify_server_cert(MARIADB_TLS *ctls)
+int ma_tls_verify_server_cert(MARIADB_TLS *ctls __attribute__((unused)))
 {
   /* server verification is already handled before */
   return 0;
@@ -312,9 +428,17 @@ int ma_tls_verify_server_cert(MARIADB_TLS *ctls)
 
 const char *ma_tls_get_cipher(MARIADB_TLS *ctls)
 {
+  gnutls_kx_algorithm_t kx;
+  gnutls_cipher_algorithm_t cipher;
+  gnutls_mac_algorithm_t mac;
+
   if (!ctls || !ctls->ssl)
     return NULL;
-  return gnutls_cipher_get_name (gnutls_cipher_get((gnutls_session_t )ctls->ssl));
+
+  mac= gnutls_mac_get((gnutls_session_t)ctls->ssl);
+  cipher= gnutls_cipher_get((gnutls_session_t)ctls->ssl);
+  kx= gnutls_kx_get((gnutls_session_t)ctls->ssl);
+  return openssl_cipher_name(kx, cipher, mac);
 }
 
 static int my_verify_callback(gnutls_session_t ssl)
@@ -388,7 +512,7 @@ static int my_verify_callback(gnutls_session_t ssl)
   return 0;
 }
 
-unsigned int ma_tls_get_finger_print(MARIADB_TLS *ctls, unsigned char *fp, unsigned int len)
+unsigned int ma_tls_get_finger_print(MARIADB_TLS *ctls, char *fp, unsigned int len)
 {
   MYSQL *mysql;
   size_t fp_len= len;

libmariadb/secure/ma_cipher.h

@@ -1,186 +0,0 @@
-#ifdef _WIN32
-  #define SCHANNEL_CIPHER(a,b,c,d,e) ,a,b,c,d,e
-#else
-  #define SCHANNEL_CIPHER(a,b,c,d,e)
-#endif
-
-
-struct st_cipher_suite {
-  const char *rfc_name;
-  const char *openssl_name;
-  const char *gnutls_name;
-  const char *nss_name;
-#ifdef _WIN32  
-  ALG_ID exch;
-  ALG_ID encrypt;
-  ALG_ID hash;
-  ALG_ID sign;
-  int strength;
-#endif
-};
-
-const struct st_cipher_suite tls_ciphers[] =
-{
-  { /* RFC cipher ID 0x000013 */
-    "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA",
-    "DHE-DSS-DES-CBC3-SHA",
-    "TLS_DHE_DSS_3DES_EDE_CBC_SHA1",
-    "TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA"
-    SCHANNEL_CIPHER(CALG_DH_EPHEM, CALG_3DES, CALG_SHA1, CALG_DSS_SIGN, 0)
-  },
-  { "TLS_DHE_DSS_WITH_AES_128_CBC_SHA",
-    "DHE-DSS-AES128-SHA",
-    "TLS_DHE_DSS_AES_128_CBC_SHA1",
-    "TLS_DHE_DSS_WITH_AES_128_CBC_SHA"
-    SCHANNEL_CIPHER(CALG_DH_EPHEM, CALG_AES_128, CALG_SHA1,CALG_DSS_SIGN, 0)
-  },
-  { "TLS_DHE_DSS_WITH_AES_256_CBC_SHA",
-    "DHE-DSS-AES256-SHA",
-    "TLS_DHE_DSS_AES_256_CBC_SHA1",
-    "TLS_DHE_DSS_WITH_AES_256_CBC_SHA"
-    SCHANNEL_CIPHER(CALG_DH_EPHEM, CALG_AES_256, CALG_SHA1, CALG_DSS_SIGN, 0)
-  },
-  { "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256",
-    "DHE-DSS-AES256-SHA256",
-    "TLS_DHE_DSS_AES_256_CBC_SHA256",
-    "TLS_DHE_DSS_WITH_AES_256_CBC_SHA256"
-    SCHANNEL_CIPHER(CALG_DH_EPHEM, CALG_AES_256, CALG_SHA_256, CALG_DSS_SIGN, 0)
-  },
-  { "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256",
-    "DHE-RSA-AES128-GCM-SHA256",
-    "TLS_DHE_RSA_AES_128_GCM_SHA256",
-    "TLS_DHE_RSA_WITH_AES_128_GCM_SHA256"
-    SCHANNEL_CIPHER(CALG_DH_EPHEM, CALG_AES_128, CALG_SHA_128, 0, 0
-  )},
-  { "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384",
-    "DHE-RSA-AES256-GCM-SHA384",
-    "TLS_DHE_RSA_AES_256_GCM_SHA384",
-    NULL
-    SCHANNEL_CIPHER(CALG_DH_EPHEM, CALG_AES_256, CALG_SHA384, 0, 0)
-  },
-  { "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA",
-    "ECDHE-ECDSA-AES128-SHA",
-    "TLS_ECDHE_ECDSA_AES_128_CBC_SHA1",
-    "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA"
-    SCHANNEL_CIPHER(CALG_ECDSA, CALG_AES128, CALG_SHA1, 0, 0)
-  },
-  { "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
-    "ECDHE-ECDSA-AES128-GCM-SHA256",
-    "TLS_ECDHE_ECDSA_AES_128_GCM_SHA256",
-    "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"
-    SCHANNEL_CIPHER(CALG_ECDSA, CALG_AES128, CALG_SHA256, 0, 0)
-  },
-  { "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA384",
-    NULL,
-    NULL,
-    NULL
-    SCHANNEL_CIPHER(CALG_ECDSA, CALG_AES128, CALG_SHA384, 0, 0)
-  },
-  { "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA",
-    "ECDHE-ECDSA-AES256-SHA",
-    "TLS_ECDHE_ECDSA_AES_256_CBC_SHA1",
-    "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA"
-    SCHANNEL_CIPHER(CALG_ECDSA, CALG_AES256, CALG_SHA1, 0, 0)
-  },
-  { "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384",
-    "ECDHE-ECDSA-AES256-SHA384",
-    "TLS_ECDHE_ECDSA_AES_256_CBC_SHA384",
-    NULL
-    SCHANNEL_CIPHER(CALG_ECDSA, CALG_AES256, CALG_SHA384, 0, 0)
-  },
-  { "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA",
-    "ECDHE-RSA-AES128-SHA",
-    "TLS_ECDHE_RSA_AES_128_CBC_SHA1",
-    "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"
-    SCHANNEL_CIPHER(0xAE06, CALG_AES128, CALG_SHA1, 0, 0)
-  }, 
-  { "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
-    "ECDHE-RSA-AES128-SHA256",
-    "TLS_ECDHE_RSA_AES_128_CBC_SHA256",
-    "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256"
-    SCHANNEL_CIPHER(0xAE06, CALG_AES128, CALG_SHA256, 0, 0)
-  }, 
-  { "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA256",
-    NULL,
-    NULL,
-    NULL
-    SCHANNEL_CIPHER(0xAE06, CALG_AES256, CALG_SHA256, 0, 0)
-  }, 
-  { "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384",
-    "ECDHE-RSA-AES256-SHA384",
-    "TLS_ECDHE_RSA_AES_256_CBC_SHA384",
-    NULL
-    SCHANNEL_CIPHER(0xAE06, CALG_AES256, CALG_SHA384, 0, 0)
-  }, 
-  { "TLS_RSA_EXPORT_WITH_DES40_CBC_SHA",
-    NULL,
-    NULL,
-    "TLS_RSA_EXPORT_WITH_DES40_CBC_SHA"
-    SCHANNEL_CIPHER(CALG_RSA_KEYX, CALG_3DES, CALG_SHA1, 0, 0)
-  },
-  { "TLS_RSA_WITH_3DES_EDE_CBC_SHA",
-    NULL,
-    "TLS_RSA_3DES_EDE_CBC_SHA1",
-    "TLS_RSA_WITH_3DES_EDE_CBC_SHA"
-    SCHANNEL_CIPHER(CALG_RSA_KEYX, CALG_3DES,  CALG_SHA1, 0, 0)
-  },
-  { "TLS_RSA_WITH_AES_128_CBC_SHA",
-    "AES128-SHA",
-    "TLS_RSA_AES_128_CBC_SHA1",
-    "TLS_RSA_WITH_AES_128_CBC_SHA"
-    SCHANNEL_CIPHER(CALG_RSA_KEYX, CALG_AES_128, CALG_SHA1, 0, 0)
-  },
-  { "TLS_RSA_WITH_AES_128_CBC_SHA256",
-    "AES128-SHA256",
-    "TLS_RSA_AES_128_CBC_SHA256",
-    "TLS_RSA_WITH_AES_128_CBC_SHA256"
-    SCHANNEL_CIPHER(CALG_RSA_KEYX, CALG_AES_128, CALG_SHA256, 0, 0)
-  },
-  { "TLS_RSA_WITH_AES_128_GCM_SHA256",
-    "AES128-GCM-SHA256",
-    "TLS_RSA_AES_128_GCM_SHA256",
-    "TLS_RSA_WITH_AES_128_GCM_SHA256"
-    SCHANNEL_CIPHER(CALG_RSA_KEYX, CALG_AES_128, CALG_SHA256, 0, 0)
-  },
-  { "TLS_RSA_WITH_AES_256_CBC_SHA",
-    "AES256-SHA",
-    "TLS_RSA_AES_256_CBC_SHA1",
-    "TLS_RSA_WITH_AES_256_CBC_SHA"
-    SCHANNEL_CIPHER(CALG_RSA_KEYX, CALG_AES_256, CALG_SHA1, 0, 0)
-  },
-  { "TLS_RSA_WITH_AES_256_CBC_SHA256",
-    "AES256-SHA256",
-    "TLS_RSA_AES_256_CBC_SHA256",
-    "TLS_RSA_WITH_AES_256_CBC_SHA256"
-    SCHANNEL_CIPHER(CALG_RSA_KEYX, CALG_AES_256, CALG_SHA_256,0, 0)
-  },
-  { "TLS_RSA_WITH_AES_256_GCM_SHA384",
-    "AES256-GCM-SHA384",
-    "TLS_RSA_AES_256_GCM_SHA384",
-    NULL
-    SCHANNEL_CIPHER(CALG_RSA_KEYX, CALG_AES_256, CALG_SHA384, 0, 0)
-  },
-  { "TLS_RSA_WITH_NULL_SHA256",
-    "NULL-SHA256",
-    "TLS_RSA_NULL_SHA256",
-    "TLS_RSA_WITH_NULL_SHA256"
-    SCHANNEL_CIPHER(CALG_RSA_KEYX, 0, CALG_SHA_256, 0, 0)
-  },
-  { "TLS_RSA_WITH_RC4_128_MD5",
-    NULL,
-    "TLS_RSA_ARCFOUR_128_MD5",
-    "TLS_RSA_WITH_RC4_128_MD5"
-    SCHANNEL_CIPHER(CALG_RSA_KEYX, CALG_RC4, CALG_MD5, 0, 0)
-  },
-  { "TLS_RSA_WITH_RC4_128_SHA",
-    NULL,
-    "TLS_RSA_ARCFOUR_128_SHA1",
-    "TLS_RSA_WITH_RC4_128_SHA"
-    SCHANNEL_CIPHER(CALG_RSA_KEYX, CALG_RC4, CALG_SHA1,0, 0)
-  },
-  { NULL,
-    NULL,
-    NULL,
-    NULL
-    SCHANNEL_CIPHER(0, 0, 0, 0, 0)}
-};

libmariadb/secure/openssl.c

@@ -127,14 +127,14 @@ typedef struct st_ma_tls_session {
 } MA_SSL_SESSION;
 
 MA_SSL_SESSION *ma_tls_sessions= NULL;
-unsigned int ma_tls_session_cache_size= 128;
+int ma_tls_session_cache_size= 128;
 
 static char *ma_md4_hash(const char *host, const char *user, unsigned int port, char *md4)
 {
   char buffer[195]; /* MAX_USERNAME_LEN + MAX_HOST_NAME_LEN + 2 + 5 */
   snprintf(buffer, 194, "%s@%s:%d", user ? user : "", host, port);
   buffer[194]= 0;
-  MD4(buffer, strlen(buffer), md4);
+  MD4((unsigned char *)buffer, strlen(buffer), (unsigned char *)md4);
   return md4;
 }
 
@@ -209,7 +209,8 @@ static int ma_tls_session_cb(SSL *ssl, SSL_SESSION *session)
   return 0;
 }
 
-static void ma_tls_remove_session_cb(SSL_CTX* ctx, SSL_SESSION* session)
+static void ma_tls_remove_session_cb(SSL_CTX* ctx __attribute__((unused)), 
+                                     SSL_SESSION* session)
 {
   int i;
   for (i=0; i < ma_tls_session_cache_size; i++)
@@ -223,7 +224,9 @@ static void ma_tls_remove_session_cb(SSL_CTX* ctx, SSL_SESSION* session)
 #endif
 
 #if OPENSSL_VERSION_NUMBER < 0x10100000L
-static void my_cb_locking(int mode, int n, const char *file, int line)
+static void my_cb_locking(int mode, int n, 
+                          const char *file __attribute__((unused)),
+                          int line __attribute__((unused)))
 {
   if (mode & CRYPTO_LOCK)
     pthread_mutex_lock(&LOCK_crypto[n]);
@@ -397,7 +400,9 @@ void ma_tls_end()
   return;
 }
 
-int ma_tls_get_password(char *buf, int size, int rwflag, void *userdata)
+int ma_tls_get_password(char *buf, int size,
+                        int rwflag __attribute__((unused)),
+                        void *userdata)
 {
   memset(buf, 0, size);
   if (userdata)
@@ -696,7 +701,7 @@ const char *ma_tls_get_cipher(MARIADB_TLS *ctls)
   return SSL_get_cipher_name(ctls->ssl);
 }
 
-unsigned int ma_tls_get_finger_print(MARIADB_TLS *ctls, unsigned char *fp, unsigned int len)
+unsigned int ma_tls_get_finger_print(MARIADB_TLS *ctls, char *fp, unsigned int len)
 {
   EVP_MD *digest= (EVP_MD *)EVP_sha1();
   X509 *cert;
@@ -724,7 +729,7 @@ unsigned int ma_tls_get_finger_print(MARIADB_TLS *ctls, unsigned char *fp, unsig
     return 0;
   }
   fp_len= len;
-  if (!X509_digest(cert, digest, fp, &fp_len))
+  if (!X509_digest(cert, digest, (unsigned char *)fp, &fp_len))
   {
     ma_free(fp);
     my_set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,

libmariadb/secure/schannel.c

@@ -536,7 +536,7 @@ const char *ma_tls_get_cipher(MARIADB_TLS *ctls)
   return NULL;
 }
 
-unsigned int ma_tls_get_finger_print(MARIADB_TLS *ctls, unsigned char *fp, unsigned int len)
+unsigned int ma_tls_get_finger_print(MARIADB_TLS *ctls, char *fp, unsigned int len)
 {
   SC_CTX *sctx= (SC_CTX *)ctls->ssl;
   PCCERT_CONTEXT pRemoteCertContext = NULL;

mariadb_config/mariadb_config.c.in

@@ -13,7 +13,7 @@ static char *mariadb_progname;
 #define CFLAGS  INCLUDE " @CMAKE_C_FLAGS@"
 #define VERSION "@MARIADB_CLIENT_VERSION@"
 #define PLUGIN_DIR "@PREFIX_INSTALL_DIR@/@SUFFIX_INSTALL_DIR@/@PLUGIN_INSTALL_DIR@"
-#define SOCKET  "@MARIADBL_UNIX_ADDR@"
+#define SOCKET  "@MARIADB_UNIX_ADDR@"
 #define PORT "@MARIADB_PORT@"
 
 static struct option long_options[]=
@@ -31,7 +31,7 @@ static struct option long_options[]=
   {NULL, 0, 0, 0}
 };
 
-static char *values[]=
+static const char *values[]=
 {
   CFLAGS,
   NULL,

plugins/auth/dialog.c

@@ -79,7 +79,7 @@ struct st_mysql_client_plugin_AUTHENTICATION _mysql_client_plugin_declaration_ =
   RETURNS
     Input buffer
 */
-static char *auth_dialog_native_prompt(MYSQL *mysql,
+static char *auth_dialog_native_prompt(MYSQL *mysql __attribute__((unused)),
                                        int type,
                                        const char *prompt,
                                        char *buffer,
@@ -103,7 +103,7 @@ static char *auth_dialog_native_prompt(MYSQL *mysql,
   }
   else
   {
-    get_tty_password("", buffer, buffer_len - 1);
+    get_tty_password((char *)"", buffer, buffer_len - 1);
   }
   return buffer;
 }
@@ -138,7 +138,7 @@ static int auth_dialog_open(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql)
   my_bool first_loop= TRUE;
 
   do {
-    if ((packet_length= vio->read_packet(vio, &packet)) < 0)
+    if ((packet_length= vio->read_packet(vio, &packet)) == (size_t)-1)
       /* read error */
       return CR_ERROR;
 
@@ -167,7 +167,7 @@ static int auth_dialog_open(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql)
       response= mysql->passwd;
     }
     if (!response ||
-        vio->write_packet(vio, response, (int)strlen(response) + 1))
+        vio->write_packet(vio, (uchar *)response, (int)strlen(response) + 1))
       return CR_ERROR;
 
     first_loop= FALSE;

plugins/auth/my_auth.c

@@ -9,7 +9,7 @@ typedef struct st_mysql_client_plugin_AUTHENTICATION auth_plugin_t;
 static int client_mpvio_write_packet(struct st_plugin_vio*, const uchar*, size_t);
 static int native_password_auth_client(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql);
 extern void read_user_name(char *name);
-extern uchar *ma_send_connect_attr(MYSQL *mysql, uchar *buffer);
+extern char *ma_send_connect_attr(MYSQL *mysql, unsigned char *buffer);
 
 typedef struct {
   int (*read_packet)(struct st_plugin_vio *vio, uchar **buf);
@@ -141,7 +141,7 @@ static int send_change_user_packet(MCPVIO_EXT *mpvio,
   if (mysql->server_capabilities & CLIENT_PLUGIN_AUTH)
     end= ma_strmake(end, mpvio->plugin->name, NAME_LEN) + 1;
 
-  end= ma_send_connect_attr(mysql, end);
+  end= ma_send_connect_attr(mysql, (unsigned char *)end);
 
   res= ma_simple_command(mysql, COM_CHANGE_USER,
                       buff, (ulong)(end-buff), 1, NULL);
@@ -249,7 +249,7 @@ static int send_client_reply_packet(MCPVIO_EXT *mpvio,
       Send mysql->client_flag, max_packet_size - unencrypted otherwise
       the server does not know we want to do SSL
     */
-    if (ma_net_write(net, (char*)buff, (size_t) (end-buff)) || ma_net_flush(net))
+    if (ma_net_write(net, (unsigned char *)buff, (size_t) (end-buff)) || ma_net_flush(net))
     {
       my_set_error(mysql, CR_SERVER_LOST, SQLSTATE_UNKNOWN,
                           ER(CR_SERVER_LOST_EXTENDED),
@@ -298,10 +298,10 @@ static int send_client_reply_packet(MCPVIO_EXT *mpvio,
   if (mysql->server_capabilities & CLIENT_PLUGIN_AUTH)
     end= ma_strmake(end, mpvio->plugin->name, NAME_LEN) + 1;
 
-  end= ma_send_connect_attr(mysql, end);
+  end= ma_send_connect_attr(mysql, (unsigned char *)end);
 
   /* Write authentication package */
-  if (ma_net_write(net, buff, (size_t) (end-buff)) || ma_net_flush(net))
+  if (ma_net_write(net, (unsigned char *)buff, (size_t) (end-buff)) || ma_net_flush(net))
   {
     my_set_error(mysql, CR_SERVER_LOST, SQLSTATE_UNKNOWN,
                         ER(CR_SERVER_LOST_EXTENDED),
@@ -405,7 +405,7 @@ static int client_mpvio_write_packet(struct st_plugin_vio *mpv,
     if (mpvio->mysql->thd)
       res= 1; /* no chit-chat in embedded */
     else
-      res= ma_net_write(net, (char *)pkt, pkt_len) || ma_net_flush(net);
+      res= ma_net_write(net, (unsigned char *)pkt, pkt_len) || ma_net_flush(net);
     if (res)
       my_set_error(mpvio->mysql, CR_SERVER_LOST, SQLSTATE_UNKNOWN,
                                  ER(CR_SERVER_LOST_EXTENDED),

plugins/connection/aurora.c

@@ -36,7 +36,8 @@
 #endif
 
 /* function prototypes */
-int aurora_init(char *errormsg, size_t errormsg_size,
+int aurora_init(char *errormsg __attribute__((unused)),
+    size_t errormsg_size __attribute__((unused)),
     int unused  __attribute__((unused)), 
     va_list unused1 __attribute__((unused)));
 
@@ -82,7 +83,7 @@ struct st_mariadb_api *mariadb_api= NULL;
 
 typedef struct st_aurora_instance {
   char *host;
-  int  port;
+  unsigned int  port;
   time_t blacklisted;
   int type;
 } AURORA_INSTANCE;
@@ -132,7 +133,8 @@ my_bool aurora_switch_connection(MYSQL *mysql, AURORA *aurora, int type)
  *
  *     plugin initialization function
  */
-int aurora_init(char *errormsg, size_t errormsg_size,
+int aurora_init(char *errormsg __attribute__((unused)),
+    size_t errormsg_size __attribute__((unused)),
     int unused  __attribute__((unused)), 
     va_list unused1 __attribute__((unused)))
 {
@@ -247,7 +249,7 @@ int aurora_get_instance_type(MYSQL *mysql)
   int rc= -1;
   MA_CONNECTION_HANDLER *save_hdlr= mysql->extension->conn_hdlr;
 
-  char *query= "select variable_value from information_schema.global_variables where variable_name='INNODB_READ_ONLY' AND variable_value='OFF'";
+  const char *query= "select variable_value from information_schema.global_variables where variable_name='INNODB_READ_ONLY' AND variable_value='OFF'";
 
   if (!mysql)
     return -1;
@@ -519,7 +521,7 @@ my_bool aurora_find_primary(AURORA *aurora)
 
 /* {{{ MYSQL *aurora_connect */
 MYSQL *aurora_connect(MYSQL *mysql, const char *host, const char *user, const char *passwd,
-    const char *db, unsigned int port, const char *unix_socket, unsigned long client_flag)
+    const char *db, unsigned int port, const char *unix_socket __attribute__((unused)), unsigned long client_flag)
 {
   AURORA *aurora= NULL;
   MA_CONNECTION_HANDLER *save_hdlr= mysql->extension->conn_hdlr;
@@ -716,7 +718,7 @@ my_bool is_replica_stmt(MYSQL *mysql, const char *buffer)
 
 /* {{{ int aurora_command */
 int aurora_command(MYSQL *mysql,enum enum_server_command command, const char *arg,
-    size_t length, my_bool skipp_check, void *opt_arg)
+    size_t length __attribute__((unused)), my_bool skipp_check __attribute__((unused)), void *opt_arg __attribute__((unused)))
 {
   MA_CONNECTION_HANDLER *save_hdlr= mysql->extension->conn_hdlr;
   AURORA *aurora= (AURORA *)save_hdlr->data;

plugins/connection/replication.c

@@ -79,7 +79,7 @@ typedef struct st_conn_repl {
   my_bool round_robin;
   char *url;
   char *host[2];
-  int port[2];
+  unsigned int port[2];
   unsigned int current_type;
 } REPL_DATA;
 
@@ -298,7 +298,9 @@ static my_bool is_slave_stmt(MYSQL *mysql, const char *buffer)
 
 
 int repl_command(MYSQL *mysql,enum enum_server_command command, const char *arg,
-                     size_t length, my_bool skipp_check, void *opt_arg)
+                     size_t length, 
+                     my_bool skipp_check __attribute__((unused)), 
+                     void *opt_arg __attribute__((unused)))
 {
   REPL_DATA *data= (REPL_DATA *)mysql->extension->conn_hdlr->data; 
 

plugins/pvio/pvio_npipe.c

@@ -46,6 +46,7 @@ int pvio_npipe_keepalive(MARIADB_PVIO *pvio);
 my_bool pvio_npipe_get_handle(MARIADB_PVIO *pvio, void *handle);
 my_bool pvio_npipe_is_blocking(MARIADB_PVIO *pvio);
 int pvio_npipe_shutdown(MARIADB_PVIO *pvio);
+my_bool pvio_npipe_is_alive(MARIADB_PVIO *pvio);
 
 struct st_ma_pvio_methods pvio_npipe_methods= {
   pvio_npipe_set_timeout,
@@ -62,7 +63,7 @@ struct st_ma_pvio_methods pvio_npipe_methods= {
   pvio_npipe_keepalive,
   pvio_npipe_get_handle,
   pvio_npipe_is_blocking,
-  NULL,
+  pvio_npipe_is_alive,
   NULL,
   pvio_npipe_shutdown
 };
@@ -367,4 +368,16 @@ int pvio_npipe_shutdown(MARIADB_PVIO *pvio)
   }
   return 1;
 }
+
+my_bool pvio_npipe_is_alive(MARIADB_PVIO *pvio)
+{
+  HANDLE handle;
+  if (!pvio || !pvio->data)
+    return FALSE;
+    handle= ((struct st_pvio_npipe *)pvio->data)->pipe;
+  /* Copy data fron named pipe without removing it */
+  if (PeekNamedPipe(handle, NULL, 0, NULL, NULL, NULL))
+    return TRUE;
+  return test(GetLastError() != ERROR_BROKEN_PIPE);
+}
 #endif

plugins/pvio/pvio_shmem.c

@@ -29,7 +29,6 @@
 #include <string.h>
 #include <ma_string.h>
 
-#define SHM_DEFAULT_NAME "MYSQL"
 #define PVIO_SHM_BUFFER_SIZE 16000 + 4
 
 my_bool pvio_shm_set_timeout(MARIADB_PVIO *pvio, enum enum_pvio_timeout type, int timeout);
@@ -41,6 +40,8 @@ my_bool pvio_shm_blocking(MARIADB_PVIO *pvio, my_bool value, my_bool *old_value)
 my_bool pvio_shm_connect(MARIADB_PVIO *pvio, MA_PVIO_CINFO *cinfo);
 my_bool pvio_shm_close(MARIADB_PVIO *pvio);
 int pvio_shm_shutdown(MARIADB_PVIO *pvio);
+my_bool pvio_shm_is_alive(MARIADB_PVIO *pvio);
+my_bool pvio_shm_get_handle(MARIADB_PVIO *pvio, void *handle);
 
 struct st_ma_pvio_methods pvio_shm_methods= {
   pvio_shm_set_timeout,
@@ -55,9 +56,9 @@ struct st_ma_pvio_methods pvio_shm_methods= {
   pvio_shm_close,
   NULL,
   NULL,
+  pvio_shm_get_handle,
   NULL,
-  NULL,
+  pvio_shm_is_alive,
-  NULL,
   NULL,
   pvio_shm_shutdown
 };
@@ -262,9 +263,7 @@ my_bool pvio_shm_connect(MARIADB_PVIO *pvio, MA_PVIO_CINFO *cinfo)
    */
  
 
-  base_memory_name= (cinfo->mysql->options.shared_memory_base_name) ?
+  base_memory_name= (cinfo->host) ? cinfo->host : SHM_DEFAULT_NAME;
-                     cinfo->mysql->options.shared_memory_base_name : SHM_DEFAULT_NAME;
-  
 
   if (!(shm_name= (char *)LocalAlloc(LMEM_ZEROINIT, strlen(base_memory_name) + 40)))
   {
@@ -447,5 +446,24 @@ int pvio_shm_shutdown(MARIADB_PVIO *pvio)
     return (SetEvent(pvio_shm->event[PVIO_SHM_CONNECTION_CLOSED]) ? 0 : 1);
   return 1;
 }
+
+my_bool pvio_shm_is_alive(MARIADB_PVIO *pvio)
+{
+  PVIO_SHM *pvio_shm;
+  if (!pvio || !pvio->data)
+    return FALSE;
+  pvio_shm= (PVIO_SHM *)pvio->data;
+  return WaitForSingleObject(pvio_shm->event[PVIO_SHM_CONNECTION_CLOSED], 0);
+}
+
+my_bool pvio_shm_get_handle(MARIADB_PVIO *pvio, void *handle)
+{
+  PVIO_SHM *pvio_shm;
+  *(HANDLE **)handle= 0;
+  if (!pvio || !pvio->data)
+    return FALSE;
+  *(HANDLE **)handle= (HANDLE **)((PVIO_SHM*)pvio->data)->event;
+  return TRUE;
+}
 #endif
 

plugins/pvio/pvio_socket.c

@@ -136,10 +136,10 @@ struct st_pvio_socket {
 
 static my_bool pvio_socket_initialized= FALSE;
 
-static int pvio_socket_init(char *errmsg,
+static int pvio_socket_init(char *errmsg __attribute__((unused)),
-                           size_t errmsg_length, 
+                           size_t errmsg_length __attribute__((unused)), 
-                           int unused, 
+                           int unused __attribute__((unused)), 
-                           va_list va)
+                           va_list va __attribute__((unused)))
 {
   pvio_socket_initialized= TRUE;
   return 0;
@@ -390,13 +390,13 @@ ssize_t ma_send(int socket, const uchar *buffer, size_t length, int flags)
 size_t pvio_socket_async_write(MARIADB_PVIO *pvio, const uchar *buffer, size_t length)
 {
   ssize_t r= -1;
+  struct st_pvio_socket *csock= NULL;
 #ifndef _WIN32
   int write_flags= MSG_DONTWAIT;
 #ifdef MSG_NOSIGNAL
   write_flags|= MSG_NOSIGNAL;
 #endif
 #endif
-  struct st_pvio_socket *csock= NULL;
 
   if (!pvio || !pvio->data)
     return -1;
@@ -439,13 +439,13 @@ size_t pvio_socket_async_write(MARIADB_PVIO *pvio, const uchar *buffer, size_t l
 size_t pvio_socket_write(MARIADB_PVIO *pvio, const uchar *buffer, size_t length)
 {
   ssize_t r= -1;
+  struct st_pvio_socket *csock= NULL;
 #ifndef _WIN32
   int send_flags= MSG_DONTWAIT;
 #ifdef MSG_NOSIGNAL
   send_flags|= MSG_NOSIGNAL;
 #endif
 #endif
-  struct st_pvio_socket *csock= NULL;
   if (!pvio || !pvio->data)
     return -1;
 

plugins/trace/trace_example.c

@@ -63,7 +63,7 @@ struct st_mysql_client_plugin _mysql_client_plugin_declaration_ =
   NULL
 };
 
-static char *commands[]= {
+static const char *commands[]= {
   "COM_SLEEP",
   "COM_QUIT",
   "COM_INIT_DB",
@@ -279,7 +279,7 @@ void trace_callback(int mode, MYSQL *mysql, const uchar *buffer, size_t length)
   {
     char *p= (char *)buffer;
     p+= 4; /* packet length */
-    if (*p != 0xFF) /* protocol version 0xFF indicates error */
+    if ((uchar)*p != 0xFF) /* protocol version 0xFF indicates error */
     {
       p+= strlen(p + 1) + 2;
       thread_id= uint4korr(p);
@@ -329,7 +329,7 @@ void trace_callback(int mode, MYSQL *mysql, const uchar *buffer, size_t length)
       else
       {
         p++;
-        if (*p == 0xFF)
+        if ((uchar)*p == 0xFF)
           printf("%8lu: CONNECT_ERROR(%d)\n", info->thread_id, uint4korr(p+1));
         else
           printf("%8lu: CONNECT_SUCCESS(host=%s,user=%s,db=%s)\n", info->thread_id, 
@@ -395,7 +395,7 @@ void trace_callback(int mode, MYSQL *mysql, const uchar *buffer, size_t length)
         len= uint3korr(p);
         p+= 4;
 
-        is_error= ((unsigned int)len == -1);
+        is_error= (len == -1);
 
         switch(info->last_command) {
         case COM_STMT_EXECUTE:

unittest/libmariadb/async.c

@@ -132,7 +132,7 @@ wait_for_mysql(MYSQL *mysql, int status)
 #endif
 }
 
-static int async1(MYSQL *my)
+static int async1(MYSQL *unused __attribute__((unused)))
 {
   int err= 0, rc;
   MYSQL mysql, *ret;
@@ -211,7 +211,7 @@ static int async1(MYSQL *my)
   return OK;
 }
 
-static int test_conc131(MYSQL *my)
+static int test_conc131(MYSQL *unused __attribute__((unused)))
 {
   int rc;
   /* this test needs to run under valgrind */
@@ -227,7 +227,7 @@ static int test_conc131(MYSQL *my)
   return OK;
 }
 
-static int test_conc129(MYSQL *my)
+static int test_conc129(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql;
   

unittest/libmariadb/basic-t.c

@@ -40,7 +40,7 @@ static int test_conc75(MYSQL *my)
   mysql= mysql_init(NULL);
 
   mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
-  mysql_real_connect(mysql, hostname, username, password, schema, port, socketname, 0| CLIENT_MULTI_RESULTS | CLIENT_REMEMBER_OPTIONS);
+  my_test_connect(mysql, hostname, username, password, schema, port, socketname, 0| CLIENT_MULTI_RESULTS | CLIENT_REMEMBER_OPTIONS);
 
   rc= mysql_query(mysql, "DROP TABLE IF EXISTS a");
   check_mysql_rc(rc, mysql);
@@ -72,7 +72,7 @@ static int test_conc75(MYSQL *my)
 }
 
 
-static int test_conc74(MYSQL *my)
+static int test_conc74(MYSQL *unused __attribute__((unused)))
 {
   int rc;
   MYSQL *mysql;
@@ -80,7 +80,7 @@ static int test_conc74(MYSQL *my)
   mysql= mysql_init(NULL);
 
 
-  if (!mysql_real_connect(mysql, hostname, username, password, schema, port, socketname, 0| CLIENT_MULTI_RESULTS | CLIENT_REMEMBER_OPTIONS))
+  if (!my_test_connect(mysql, hostname, username, password, schema, port, socketname, 0| CLIENT_MULTI_RESULTS | CLIENT_REMEMBER_OPTIONS))
   {
     diag("Error: %s", mysql_error(mysql));
     mysql_close(mysql);
@@ -119,7 +119,7 @@ static int test_conc71(MYSQL *my)
   mysql_options(mysql, MYSQL_INIT_COMMAND, "/*!40101 SET SQL_MODE='' */");
   mysql_options(mysql, MYSQL_INIT_COMMAND, "/*!40101 set @@session.wait_timeout=28800 */");
 
-  FAIL_IF(!mysql_real_connect(mysql, hostname, username, password, schema,
+  FAIL_IF(!my_test_connect(mysql, hostname, username, password, schema,
                          port, socketname, 0), mysql_error(my));
 
   diag("kill server");
@@ -149,7 +149,7 @@ static int test_conc70(MYSQL *my)
   mysql_query(my, "SET global max_allowed_packet=1024*1024*22");
 
   mysql_options(mysql, MYSQL_OPT_COMPRESS, (void *)1);
-  FAIL_IF(!mysql_real_connect(mysql, hostname, username, password, schema,
+  FAIL_IF(!my_test_connect(mysql, hostname, username, password, schema,
                          port, socketname, 0), mysql_error(my));
 
   rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
@@ -207,7 +207,7 @@ static int test_conc68(MYSQL *my)
 
   mysql_query(my, "SET global max_allowed_packet=1024*1024*22");
 
-  FAIL_IF(!mysql_real_connect(mysql, hostname, username, password, schema,
+  FAIL_IF(!my_test_connect(mysql, hostname, username, password, schema,
                          port, socketname, 0), mysql_error(my));
 
   rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
@@ -247,7 +247,7 @@ static int test_conc68(MYSQL *my)
 }
 
 
-static int basic_connect(MYSQL *mysql)
+static int basic_connect(MYSQL *unused __attribute__((unused)))
 {
   MYSQL_ROW row;
   MYSQL_RES *res;
@@ -257,7 +257,7 @@ static int basic_connect(MYSQL *mysql)
   MYSQL *my= mysql_init(NULL);
   FAIL_IF(!my, "mysql_init() failed");
 
-  FAIL_IF(!mysql_real_connect(my, hostname, username, password, schema,
+  FAIL_IF(!my_test_connect(my, hostname, username, password, schema,
                          port, socketname, 0), mysql_error(my));
 
   rc= mysql_query(my, "SELECT @@version");
@@ -371,7 +371,7 @@ static int test_bug12001(MYSQL *mysql)
 
 /* connection options */
 struct my_option_st opt_utf8[] = {
-  {MYSQL_SET_CHARSET_NAME, "utf8"},
+  {MYSQL_SET_CHARSET_NAME, (char *)"utf8"},
   {0, NULL}
 };
 
@@ -647,7 +647,7 @@ static int test_status(MYSQL *mysql)
 
 static int bug_conc1(MYSQL *mysql)
 {
-  mysql_real_connect(mysql, hostname, username, password, schema,
+  my_test_connect(mysql, hostname, username, password, schema,
                      port, socketname, 0);
   diag("errno: %d", mysql_errno(mysql));
   FAIL_IF(mysql_errno(mysql) != CR_ALREADY_CONNECTED,
@@ -655,7 +655,7 @@ static int bug_conc1(MYSQL *mysql)
   return OK;
 }
 
-static int test_options_initcmd(MYSQL *my)
+static int test_options_initcmd(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql= mysql_init(NULL);
   MYSQL_RES *res;
@@ -663,7 +663,7 @@ static int test_options_initcmd(MYSQL *my)
 
   mysql_options(mysql, MYSQL_INIT_COMMAND, "DROP TABLE IF EXISTS t1; CREATE TABLE t1 (a int)");
   mysql_options(mysql, MYSQL_INIT_COMMAND, "INSERT INTO t1 VALUES (1),(2),(3)");
-  FAIL_IF(!mysql_real_connect(mysql, hostname, username, password, schema,
+  FAIL_IF(!my_test_connect(mysql, hostname, username, password, schema,
                               port, socketname, 
                               CLIENT_MULTI_STATEMENTS | CLIENT_MULTI_RESULTS), mysql_error(mysql));
 
@@ -678,7 +678,7 @@ static int test_options_initcmd(MYSQL *my)
   return OK;
 }
 
-static int test_extended_init_values(MYSQL *my)
+static int test_extended_init_values(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql= mysql_init(NULL);
 
@@ -692,7 +692,7 @@ static int test_extended_init_values(MYSQL *my)
   return OK;
 }
 
-static int test_reconnect_maxpackage(MYSQL *my)
+static int test_reconnect_maxpackage(MYSQL *unused __attribute__((unused)))
 {
   int rc;
   ulong max_packet= 0;
@@ -708,7 +708,7 @@ static int test_reconnect_maxpackage(MYSQL *my)
   SKIP_CONNECTION_HANDLER;
   mysql= mysql_init(NULL);
 
-  FAIL_IF(!mysql_real_connect(mysql, hostname, username, password, schema,
+  FAIL_IF(!my_test_connect(mysql, hostname, username, password, schema,
                               port, socketname, 
                               CLIENT_MULTI_STATEMENTS | CLIENT_MULTI_RESULTS), mysql_error(mysql));
   mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
@@ -752,7 +752,7 @@ static int test_reconnect_maxpackage(MYSQL *my)
   return OK;
 }
 
-static int test_compressed(MYSQL *my)
+static int test_compressed(MYSQL *unused __attribute__((unused)))
 {
   int rc;
   MYSQL *mysql= mysql_init(NULL);
@@ -760,7 +760,7 @@ static int test_compressed(MYSQL *my)
   my_bool reconnect= 1;
 
   mysql_options(mysql, MYSQL_OPT_COMPRESS, (void *)1);
-  FAIL_IF(!mysql_real_connect(mysql, hostname, username, password, schema,
+  FAIL_IF(!my_test_connect(mysql, hostname, username, password, schema,
                               port, socketname, 
                               CLIENT_MULTI_STATEMENTS | CLIENT_MULTI_RESULTS), mysql_error(mysql));
   mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);

unittest/libmariadb/bulk1.c

@@ -20,7 +20,7 @@
 #define TEST_ARRAY_SIZE 1024
 
 char *rand_str(size_t length) {
-    char charset[] = "0123456789"
+    const char charset[] = "0123456789"
                      "abcdefghijklmnopqrstuvwxyz"
                      "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     char *dest= (char *)malloc(length+1);
@@ -36,17 +36,17 @@ char *rand_str(size_t length) {
 static int bulk1(MYSQL *mysql)
 {
   MYSQL_STMT *stmt= mysql_stmt_init(mysql);
-  char *stmt_str= "INSERT INTO bulk1 VALUES (?,?)";
+  const char *stmt_str= "INSERT INTO bulk1 VALUES (?,?)";
-  unsigned long array_size= TEST_ARRAY_SIZE;
+  unsigned int array_size= TEST_ARRAY_SIZE;
   int rc;
-  int i;
+  unsigned int i;
   char **buffer;
   unsigned long *lengths;
   unsigned int *vals;
   MYSQL_BIND bind[2];
   MYSQL_RES *res;
   MYSQL_ROW row;
-  int intval;
+  unsigned int intval;
 
   rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk1");
   check_mysql_rc(rc, mysql);
@@ -60,7 +60,7 @@ static int bulk1(MYSQL *mysql)
   /* allocate memory */
   buffer= calloc(TEST_ARRAY_SIZE, sizeof(char *));
   lengths= (unsigned long *)calloc(sizeof(long), TEST_ARRAY_SIZE);
-  vals= (int *)calloc(sizeof(int), TEST_ARRAY_SIZE);
+  vals= (unsigned int *)calloc(sizeof(int), TEST_ARRAY_SIZE);
 
   for (i=0; i < TEST_ARRAY_SIZE; i++)
   {
@@ -74,7 +74,7 @@ static int bulk1(MYSQL *mysql)
   bind[0].buffer= (int *)&vals[0];
   bind[1].buffer_type= MYSQL_TYPE_STRING;
   bind[1].buffer= (void *)buffer;
-  bind[1].length= (long *)lengths;
+  bind[1].length= (unsigned long *)lengths;
 
   rc= mysql_stmt_attr_set(stmt, STMT_ATTR_ARRAY_SIZE, &array_size);
   check_stmt_rc(rc, stmt);
@@ -130,9 +130,9 @@ static int bulk2(MYSQL *mysql)
   MYSQL_STMT *stmt= mysql_stmt_init(mysql);
   int rc;
   MYSQL_BIND bind;
-  int i;
+  unsigned int i;
-  unsigned long array_size=1024;
+  unsigned int array_size=1024;
-  uchar indicator[1024];
+  char indicator[1024];
   rc= mysql_query(mysql, "DROP TABLE IF EXISTS bulk2");
   check_mysql_rc(rc, mysql);
 
@@ -159,6 +159,8 @@ static int bulk2(MYSQL *mysql)
   rc= mysql_stmt_execute(stmt);
   check_stmt_rc(rc, stmt);
 
+  mysql_stmt_close(stmt);
+
   return OK;
 }
 

unittest/libmariadb/charset.c

@@ -37,7 +37,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 /* set connection options */
 struct my_option_st opt_bug8378[] = {
-  {MYSQL_SET_CHARSET_NAME, "gbk"},
+  {MYSQL_SET_CHARSET_NAME, (char *) "gbk"},
   {0, NULL}
 };
 
@@ -120,7 +120,7 @@ int test_escaping(MYSQL *mysql)
 {
   int i= 0, rc, len;
   char out[20];
-  char *escape_chars[] = {"'", "\x0", "\n", "\r", "\\", "\0", NULL};
+  const char *escape_chars[] = {"'", "\x0", "\n", "\r", "\\", "\0", NULL};
 
   /* reset sql_mode, mysql_change_user call doesn't reset it */
   rc= mysql_query(mysql, "SET sql_mode=''");
@@ -659,9 +659,9 @@ static int test_bug_54100(MYSQL *mysql)
 
 /* We need this internal function for the test */
 
-static int test_utf16_utf32_noboms(MYSQL *mysql)
+static int test_utf16_utf32_noboms(MYSQL *mysql __attribute__((unused)))
 {
-  char          *csname[]= {"utf16", "utf16le", "utf32", "utf8"};
+  const char *csname[]= {"utf16", "utf16le", "utf32", "utf8"};
   MARIADB_CHARSET_INFO  *csinfo[sizeof(csname)/sizeof(char*)];
 
   const int     UTF8= sizeof(csname)/sizeof(char*) - 1;
@@ -676,7 +676,7 @@ static int test_utf16_utf32_noboms(MYSQL *mysql)
   int    i, error;
   size_t rc, in_len, out_len;
 
-  for (i= 0; i < sizeof(csname)/sizeof(char*); ++i)
+  for (i= 0; i < (int)(sizeof(csname)/sizeof(char*)); ++i)
   {
     csinfo[i]= mariadb_get_charset_by_name(csname[i]);
 
@@ -693,9 +693,9 @@ static int test_utf16_utf32_noboms(MYSQL *mysql)
     out_len= sizeof(buffer);
 
     diag("Converting %s->%s", csname[i], csname[UTF8]);
-    rc= mariadb_convert_string(in_string[i], &in_len, csinfo[i], buffer, &out_len, csinfo[UTF8], &error);
+    rc= mariadb_convert_string((char *)in_string[i], &in_len, csinfo[i], buffer, &out_len, csinfo[UTF8], &error);
 
-    FAIL_IF(rc == -1, "Conversion failed");
+    FAIL_IF(rc == (size_t)-1, "Conversion failed");
     FAIL_IF(rc != in_oct_len[UTF8], "Incorrect number of written bytes");
 
     if (memcmp(buffer, in_string[UTF8], rc) != 0)
@@ -709,9 +709,9 @@ static int test_utf16_utf32_noboms(MYSQL *mysql)
     out_len= sizeof(buffer);
 
     diag("Converting %s->%s", csname[UTF8], csname[i]);
-    rc= mariadb_convert_string(in_string[UTF8], &in_len, csinfo[UTF8], buffer, &out_len, csinfo[i], &error);
+    rc= mariadb_convert_string((char *)in_string[UTF8], &in_len, csinfo[UTF8], buffer, &out_len, csinfo[i], &error);
 
-    FAIL_IF(rc==-1, "Conversion failed");
+    FAIL_IF(rc == (size_t)-1, "Conversion failed");
     diag("rc=%lu oct_len: %lu", rc, in_oct_len[i]);
     FAIL_IF(rc != in_oct_len[i], "Incorrect number of written bytes");
 
@@ -726,10 +726,10 @@ static int test_utf16_utf32_noboms(MYSQL *mysql)
   return OK;
 }
 
-static int charset_auto(MYSQL *my)
+static int charset_auto(MYSQL *my __attribute__((unused)))
 {
   const char *csname1, *csname2;
-  char *osname;
+  const char *osname;
   MYSQL *mysql= mysql_init(NULL);
   int rc;
 
@@ -737,7 +737,7 @@ static int charset_auto(MYSQL *my)
 
   mysql_options(mysql, MYSQL_SET_CHARSET_NAME, "auto");
 
-  FAIL_IF(!mysql_real_connect(mysql, hostname, username,
+  FAIL_IF(!my_test_connect(mysql, hostname, username,
                              password, schema, port, socketname, 0), 
          mysql_error(mysql));
 

unittest/libmariadb/connection.c

@@ -57,7 +57,7 @@ static int test_conc66(MYSQL *my)
   check_mysql_rc(rc, my);
   rc= mysql_query(my, "FLUSH PRIVILEGES");
   check_mysql_rc(rc, my);
-  if (!mysql_real_connect(mysql, hostname, NULL,
+  if (!my_test_connect(mysql, hostname, NULL,
                              NULL, schema, port, socketname, 0))
   {
     diag("Error: %s", mysql_error(mysql));
@@ -441,13 +441,13 @@ static int test_bug31669(MYSQL *mysql)
 }
 
 /**
-     Bug# 33831 mysql_real_connect() should fail if
+     Bug# 33831 my_test_connect() should fail if
      given an already connected MYSQL handle.
 */
 
 static int test_bug33831(MYSQL *mysql)
 {
-  FAIL_IF(mysql_real_connect(mysql, hostname, username,
+  FAIL_IF(my_test_connect(mysql, hostname, username,
                              password, schema, port, socketname, 0), 
          "Error expected");
   
@@ -476,7 +476,7 @@ static int test_opt_reconnect(MYSQL *mysql)
   mysql_get_option(mysql, MYSQL_OPT_RECONNECT, &reconnect);
   FAIL_UNLESS(reconnect == 1, "reconnect != 1");
 
-  if (!(mysql_real_connect(mysql, hostname, username,
+  if (!(my_test_connect(mysql, hostname, username,
                            password, schema, port,
                            socketname, 0)))
   {
@@ -496,7 +496,7 @@ static int test_opt_reconnect(MYSQL *mysql)
   mysql_get_option(mysql, MYSQL_OPT_RECONNECT, &reconnect);
   FAIL_UNLESS(reconnect == 0, "reconnect != 0");
 
-  if (!(mysql_real_connect(mysql, hostname, username,
+  if (!(my_test_connect(mysql, hostname, username,
                            password, schema, port,
                            socketname, 0)))
   {
@@ -527,7 +527,7 @@ static int test_compress(MYSQL *mysql)
 
 
 
-  if (!(mysql_real_connect(mysql, hostname, username,
+  if (!(my_test_connect(mysql, hostname, username,
                            password, schema, port,
                            socketname, 0)))
   {
@@ -565,7 +565,7 @@ static int test_reconnect(MYSQL *mysql)
   mysql_get_option(mysql1, MYSQL_OPT_RECONNECT, &reconnect);
   FAIL_UNLESS(reconnect == 1, "reconnect != 1");
 
-  if (!(mysql_real_connect(mysql1, hostname, username,
+  if (!(my_test_connect(mysql1, hostname, username,
                            password, schema, port,
                            socketname, 0)))
   {
@@ -599,7 +599,7 @@ int test_conc21(MYSQL *mysql)
   MYSQL_RES *res= NULL;
   MYSQL_ROW row;
   char tmp[256];
-  int check_server_version= 0;
+  unsigned int check_server_version= 0;
   int major=0, minor= 0, patch=0;
 
   rc= mysql_query(mysql, "SELECT @@version");
@@ -621,12 +621,12 @@ int test_conc21(MYSQL *mysql)
   return OK;
 }
 
-int test_conc26(MYSQL *my)
+int test_conc26(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql= mysql_init(NULL);
   mysql_options(mysql, MYSQL_SET_CHARSET_NAME, "utf8");
 
-  FAIL_IF(mysql_real_connect(mysql, hostname, "notexistinguser", "password", schema, port, NULL, CLIENT_REMEMBER_OPTIONS), 
+  FAIL_IF(my_test_connect(mysql, hostname, "notexistinguser", "password", schema, port, NULL, CLIENT_REMEMBER_OPTIONS), 
           "Error expected");
 
   FAIL_IF(!mysql->options.charset_name || strcmp(mysql->options.charset_name, "utf8") != 0, 
@@ -634,7 +634,7 @@ int test_conc26(MYSQL *my)
   mysql_close(mysql);
 
   mysql= mysql_init(NULL);
-  FAIL_IF(mysql_real_connect(mysql, hostname, "notexistinguser", "password", schema, port, NULL, 0), 
+  FAIL_IF(my_test_connect(mysql, hostname, "notexistinguser", "password", schema, port, NULL, 0), 
           "Error expected");
   FAIL_IF(mysql->options.charset_name, "Error: options not freed");
   mysql_close(mysql);
@@ -642,14 +642,14 @@ int test_conc26(MYSQL *my)
   return OK;
 }
 
-int test_connection_timeout(MYSQL *my)
+int test_connection_timeout(MYSQL *unused __attribute__((unused)))
 {
   unsigned int timeout= 5;
   time_t start, elapsed;
   MYSQL *mysql= mysql_init(NULL);
   mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, (unsigned int *)&timeout);
   start= time(NULL);
-  if (mysql_real_connect(mysql, "192.168.1.101", "notexistinguser", "password", schema, port, NULL, CLIENT_REMEMBER_OPTIONS))
+  if (my_test_connect(mysql, "192.168.1.101", "notexistinguser", "password", schema, port, NULL, CLIENT_REMEMBER_OPTIONS))
   {
     diag("Error expected - maybe you have to change hostname");
     return FAIL;
@@ -661,7 +661,7 @@ int test_connection_timeout(MYSQL *my)
   return OK;
 }
 
-int test_connection_timeout2(MYSQL *my)
+int test_connection_timeout2(MYSQL *unused __attribute__((unused)))
 {
   unsigned int timeout= 5;
   time_t start, elapsed;
@@ -669,7 +669,7 @@ int test_connection_timeout2(MYSQL *my)
   mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, (unsigned int *)&timeout);
   mysql_options(mysql, MYSQL_INIT_COMMAND, "set @a:=SLEEP(6)");
   start= time(NULL);
-  if (mysql_real_connect(mysql, hostname, username, password, schema, port, NULL, CLIENT_REMEMBER_OPTIONS))
+  if (my_test_connect(mysql, hostname, username, password, schema, port, NULL, CLIENT_REMEMBER_OPTIONS))
   {
     diag("timeout error expected");
     return FAIL;
@@ -681,7 +681,7 @@ int test_connection_timeout2(MYSQL *my)
   return OK;
 }
 
-int test_connection_timeout3(MYSQL *my)
+int test_connection_timeout3(MYSQL *unused __attribute__((unused)))
 {
   unsigned int timeout= 5;
   unsigned int read_write_timeout= 10;
@@ -693,7 +693,7 @@ int test_connection_timeout3(MYSQL *my)
   mysql_options(mysql, MYSQL_OPT_WRITE_TIMEOUT, (unsigned int *)&read_write_timeout);
   mysql_options(mysql, MYSQL_INIT_COMMAND, "set @a:=SLEEP(6)");
   start= time(NULL);
-  if (mysql_real_connect(mysql, hostname, username, password, schema, port, NULL, CLIENT_REMEMBER_OPTIONS))
+  if (my_test_connect(mysql, hostname, username, password, schema, port, NULL, CLIENT_REMEMBER_OPTIONS))
   {
     diag("timeout error expected");
     elapsed= time(NULL) - start;
@@ -710,7 +710,7 @@ int test_connection_timeout3(MYSQL *my)
   mysql_options(mysql, MYSQL_OPT_READ_TIMEOUT, (unsigned int *)&read_write_timeout);
   mysql_options(mysql, MYSQL_OPT_WRITE_TIMEOUT, (unsigned int *)&read_write_timeout);
 
-  if (!mysql_real_connect(mysql, hostname, username, password, schema, port, NULL, CLIENT_REMEMBER_OPTIONS))
+  if (!my_test_connect(mysql, hostname, username, password, schema, port, NULL, CLIENT_REMEMBER_OPTIONS))
   {
     diag("Error: %s", mysql_error(mysql));
     return FAIL;
@@ -756,9 +756,9 @@ static int test_conc118(MYSQL *mysql)
   return OK;
 }
 
-static int test_wrong_bind_address(MYSQL *my)
+static int test_wrong_bind_address(MYSQL *unused __attribute__((unused)))
 {
-  char *bind_addr= "100.188.111.112";
+  const char *bind_addr= "100.188.111.112";
   MYSQL *mysql;
 
   if (!hostname || !strcmp(hostname, "localhost"))
@@ -770,7 +770,7 @@ static int test_wrong_bind_address(MYSQL *my)
   mysql=  mysql_init(NULL);
 
   mysql_options(mysql, MYSQL_OPT_BIND, bind_addr);
-  if (mysql_real_connect(mysql, hostname, username,
+  if (my_test_connect(mysql, hostname, username,
                              password, schema, port, socketname, 0))
   {
     diag("Error expected");
@@ -815,7 +815,7 @@ static int test_bind_address(MYSQL *my)
   mysql= mysql_init(NULL);
   mysql_options(mysql, MYSQL_OPT_BIND, bind_addr);
 
-  if (!mysql_real_connect(mysql, bind_addr, username,
+  if (!my_test_connect(mysql, bind_addr, username,
                              password, schema, port, socketname, 0))
   {
     diag("Error: %s\n", mysql_error(mysql));
@@ -827,7 +827,7 @@ static int test_bind_address(MYSQL *my)
   return OK;
 }
 
-static int test_get_options(MYSQL *my)
+static int test_get_options(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql= mysql_init(NULL);
   int options_int[]= {MYSQL_OPT_CONNECT_TIMEOUT, MYSQL_OPT_LOCAL_INFILE,
@@ -843,18 +843,19 @@ static int test_get_options(MYSQL *my)
                        MYSQL_OPT_SSL_CIPHER, MYSQL_OPT_BIND, MARIADB_OPT_SSL_FP, MARIADB_OPT_SSL_FP_LIST,
                        MARIADB_OPT_TLS_PASSPHRASE, 0};
 
-  char *init_command[3]= {"SET @a:=1", "SET @b:=2", "SET @c:=3"};
+  const char *init_command[3]= {"SET @a:=1", "SET @b:=2", "SET @c:=3"};
   int elements= 0;
   char **command;
 
 
   int intval[2]= {1, 0};
   my_bool boolval[2]= {1, 0};
-  char *char1= "test", *char2;
+  const char *char1= "test";
+  char *char2;
   int i;
   MYSQL *userdata;
-  char *attr_key[] = {"foo1", "foo2", "foo3"};
+  const char *attr_key[] = {"foo1", "foo2", "foo3"};
-  char *attr_val[] = {"bar1", "bar2", "bar3"};
+  const char *attr_val[] = {"bar1", "bar2", "bar3"};
   char **key, **val;
 
   for (i=0; options_int[i]; i++)
@@ -906,7 +907,7 @@ static int test_get_options(MYSQL *my)
   free(val);
 
   mysql_optionsv(mysql, MARIADB_OPT_USERDATA, "my_app", (void *)mysql);
-  mysql_get_optionv(mysql, MARIADB_OPT_USERDATA, "my_app", &userdata);
+  mysql_get_optionv(mysql, MARIADB_OPT_USERDATA, (char *)"my_app", &userdata);
 
   FAIL_IF(mysql != userdata, "wrong userdata");
   mysql_close(mysql);
@@ -941,13 +942,15 @@ static int test_sess_track_db(MYSQL *mysql)
           "session_track_get_first failed");
   FAIL_IF(strncmp(data, "testc", len), "Expected new schema 'testc'");
 
+  diag("charset: %s", mysql->charset->csname);
   rc= mysql_query(mysql, "SET NAMES utf8");
   check_mysql_rc(rc, mysql);
-  FAIL_IF(strcmp(mysql->charset->csname, "utf8"), "Expected charset 'utf8'");
   if (!mysql_session_track_get_first(mysql, SESSION_TRACK_SYSTEM_VARIABLES, &data, &len))
   do {
     printf("# SESSION_TRACK_VARIABLES: %*.*s\n", (int)len, (int)len, data);
   } while (!mysql_session_track_get_next(mysql, SESSION_TRACK_SYSTEM_VARIABLES, &data, &len));
+  diag("charset: %s", mysql->charset->csname);
+  FAIL_IF(strcmp(mysql->charset->csname, "utf8"), "Expected charset 'utf8'");
 
   rc= mysql_query(mysql, "SET NAMES latin1");
   check_mysql_rc(rc, mysql);

unittest/libmariadb/dyncol.c

@@ -24,11 +24,21 @@ static int create_dyncol_named(MYSQL *mysql)
   DYNAMIC_COLUMN_VALUE *vals;
   uint i, column_count= 6;
   int rc;
-  char *strval[]= {"Val1", "Val2", "Val3", "Val4", "Val5", "Val6"};
+  const char *strval[]= {"Val1", "Val2", "Val3", "Val4", "Val5", "Val6"};
-  MYSQL_LEX_STRING keys1[]= {{"key1", 4}, {"key2", 4}, {"key3", 4}, {"key4", 4}, {"key5", 4}, {"key6", 4}},
+  MYSQL_LEX_STRING keys1[]= {{(char *)"key1", 4}, {(char *)"key2", 4},
-                   keys2[]= {{"key1", 4}, {"key1", 4}, {"key3", 4}, {"key4", 4}, {"key5", 4}, {"key6", 4}},
+                             {(char *)"key3", 4}, {(char *)"key4", 4},
-                   keys3[]= {{"\x70\x61\x72\x61\x00\x30", 6}, {"\x70\x61\x72\x61\x00\x31", 6}, {"\x70\x61\x72\x61\x00\x32", 6},
+                             {(char *)"key5", 4}, {(char *)"key6", 4}},
-                             {"\x70\x61\x72\x61\x00\x33", 6}, {"\x70\x61\x72\x61\x00\x34", 6}, {"\x70\x61\x72\x61\x00\x35", 6}};
+
+                   keys2[]= {{(char *)"key1", 4}, {(char *)"key1", 4},
+                             {(char *)"key3", 4}, {(char *)"key4", 4},
+                             {(char *)"key5", 4}, {(char *)"key6", 4}},
+
+                   keys3[]= {{(char *)"\x70\x61\x72\x61\x00\x30", 6}, 
+                             {(char *)"\x70\x61\x72\x61\x00\x31", 6},
+                             {(char *)"\x70\x61\x72\x61\x00\x32", 6},
+                             {(char *)"\x70\x61\x72\x61\x00\x33", 6},
+                             {(char *)"\x70\x61\x72\x61\x00\x34", 6},
+                             {(char *)"\x70\x61\x72\x61\x00\x35", 6}};
   MYSQL_LEX_STRING *my_keys;
   uint my_count;
 
@@ -37,7 +47,7 @@ static int create_dyncol_named(MYSQL *mysql)
   for (i=0; i < column_count; i++)
   {
     vals[i].type= DYN_COL_STRING;
-    vals[i].x.string.value.str= strval[i];
+    vals[i].x.string.value.str= (char *)strval[i];
     vals[i].x.string.value.length= strlen(strval[i]);
     vals[i].x.string.charset= (MARIADB_CHARSET_INFO *)mysql->charset;
     diag("%s", keys3[i].str);
@@ -87,7 +97,7 @@ static int create_dyncol_named(MYSQL *mysql)
   FAIL_IF(rc < 0, "update failed");
   mariadb_dyncol_free(&dyncol);
 
-  keys3[0].str= "test";
+  keys3[0].str= (char *)"test";
   for (i=0; i < column_count; i++)
     diag("%s", my_keys[i].str);
 
@@ -96,7 +106,7 @@ static int create_dyncol_named(MYSQL *mysql)
   return OK; 
 }
 
-static int mdev_4994(MYSQL *mysql)
+static int mdev_4994(MYSQL *unused __attribute__((unused)))
 {
   DYNAMIC_COLUMN dyncol;
   uint key= 1;
@@ -121,22 +131,22 @@ static int create_dyncol_num(MYSQL *mysql)
   MYSQL_LEX_STRING *my_keys;
   DYNAMIC_COLUMN_VALUE *my_vals;
   int rc;
-  char *strval[]= {"Val1", "Val2", "Val3", "Val4", "Val5"};
+  const char *strval[]= {"Val1", "Val2", "Val3", "Val4", "Val5"};
 
   uint keys1[5]= {1,2,3,4,5},
        keys2[5]= {1,2,2,4,5};
-  MYSQL_LEX_STRING key1= {"1",1};
+  MYSQL_LEX_STRING key1= {(char *)"1",1};
 
   for (i=0; i < column_count; i++)
   {
     vals[i].type= DYN_COL_STRING;
-    vals[i].x.string.value.str= strval[i];
+    vals[i].x.string.value.str= (char *)strval[i];
     vals[i].x.string.value.length= strlen(strval[i]);
     vals[i].x.string.charset= (MARIADB_CHARSET_INFO *)mysql->charset;
   }
   FAIL_IF(mariadb_dyncol_create_many_num(&dyncol, column_count, keys1, vals, 1) <0, "Error (keys1)");
 
-  vals[0].x.string.value.str= strval[1];
+  vals[0].x.string.value.str= (char *)strval[1];
   rc= mariadb_dyncol_update_many_named(&dyncol,1, &key1, vals);
   diag("update: %d", rc);
 
@@ -163,10 +173,10 @@ static int mdev_x1(MYSQL *mysql)
   int rc;
   uint i;
   uint num_keys[5]= {1,2,3,4,5};
-  char *strval[]= {"Val1", "Val2", "Val3", "Val4", "Val5"};
+  const char *strval[]= {"Val1", "Val2", "Val3", "Val4", "Val5"};
   DYNAMIC_COLUMN_VALUE vals[5];
   DYNAMIC_COLUMN dynstr;
-  MYSQL_LEX_STRING my_key= {"1", 2};
+  MYSQL_LEX_STRING my_key= {(char *)"1", 2};
   uint unpack_columns;
   MYSQL_LEX_STRING *unpack_keys;
   DYNAMIC_COLUMN_VALUE *unpack_vals;
@@ -174,7 +184,7 @@ static int mdev_x1(MYSQL *mysql)
   for (i=0; i < 5; i++)
   {
     vals[i].type= DYN_COL_STRING;
-    vals[i].x.string.value.str= strval[i];
+    vals[i].x.string.value.str= (char *)strval[i];
     vals[i].x.string.value.length= strlen(strval[i]);
     vals[i].x.string.charset= (MARIADB_CHARSET_INFO *)mysql->charset;
   }
@@ -233,7 +243,7 @@ static int mdev_x1(MYSQL *mysql)
   return OK;
 }
 
-static int dyncol_column_count(MYSQL *mysql)
+static int dyncol_column_count(MYSQL *unused __attribute__((unused)))
 {
   DYNAMIC_COLUMN dyncol;
   uint column_count= 5;

unittest/libmariadb/errors.c

@@ -44,7 +44,7 @@ static int test_ps_client_warnings(MYSQL *mysql)
 {
   int        rc;
   MYSQL_STMT *stmt;
-  char       *query= "DROP TABLE IF EXISTS test_non_exists";
+  const char *query= "DROP TABLE IF EXISTS test_non_exists";
 
   rc= mysql_query(mysql, "DROP TABLE if exists test_non_exists");
   check_mysql_rc(rc, mysql); 
@@ -109,7 +109,7 @@ static int test_ps_client_errors(MYSQL *mysql)
 {
   int rc;
   MYSQL_STMT *stmt;
-  char *query= "DROP TABLE test_non_exists";
+  const char *query= "DROP TABLE test_non_exists";
 
   rc= mysql_query(mysql, "DROP TABLE if exists test_non_exists");
   check_mysql_rc(rc, mysql);

unittest/libmariadb/features-10_2.c

@@ -175,7 +175,7 @@ static int com_multi_ps2(MYSQL *mysql)
   MYSQL_BIND bind[2];
   int intval= 3, rc;
   int i;
-  char *varval= "com_multi_ps2";
+  const char *varval= "com_multi_ps2";
   unsigned int param_count= 2;
 
   if (!have_com_multi)
@@ -189,7 +189,7 @@ static int com_multi_ps2(MYSQL *mysql)
   bind[0].buffer_type= MYSQL_TYPE_SHORT;
   bind[0].buffer= &intval;
   bind[1].buffer_type= MYSQL_TYPE_STRING;
-  bind[1].buffer= varval;
+  bind[1].buffer= (char *)varval;
   bind[1].buffer_length= strlen(varval);
 
   stmt= mysql_stmt_init(mysql);
@@ -271,7 +271,7 @@ static int execute_direct_example(MYSQL *mysql)
   MYSQL_BIND bind[2];
   int intval= 1;
   int param_count= 2;
-  char *strval= "execute_direct_example";
+  const char *strval= "execute_direct_example";
 
   /* Direct execution without parameters */
   if (mariadb_stmt_execute_direct(stmt, "DROP TABLE IF EXISTS execute_direct", -1))
@@ -283,7 +283,7 @@ static int execute_direct_example(MYSQL *mysql)
   bind[0].buffer_type= MYSQL_TYPE_SHORT;
   bind[0].buffer= &intval;
   bind[1].buffer_type= MYSQL_TYPE_STRING;
-  bind[1].buffer= strval;
+  bind[1].buffer= (char *)strval;
   bind[1].buffer_length= strlen(strval);
 
   /* set number of parameters */

unittest/libmariadb/fetch.c

@@ -187,7 +187,7 @@ static int test_fetch_seek(MYSQL *mysql)
   int        rc;
   int32      c1;
   char       c2[11], c3[20];
-  char       *query = "SELECT * FROM t1";
+  const char *query = "SELECT * FROM t1";
 
   rc= mysql_query(mysql, "drop table if exists t1");
   check_mysql_rc(rc, mysql);
@@ -273,7 +273,7 @@ static int test_fetch_offset(MYSQL *mysql)
   ulong      length[2];
   int        rc;
   my_bool    is_null[2];
-  char       *query = "SELECT * FROM t1";
+  const char *query = "SELECT * FROM t1";
 
 
   rc= mysql_query(mysql, "drop table if exists t1");
@@ -396,7 +396,7 @@ static int test_fetch_column(MYSQL *mysql)
   char       c2[20], bc2[20];
   ulong      l1, l2, bl1, bl2;
   int        rc, c1, bc1;
-  char       *query= "SELECT * FROM t1 ORDER BY c2 DESC";
+  const char *query= "SELECT * FROM t1 ORDER BY c2 DESC";
 
   rc= mysql_query(mysql, "drop table if exists t1");
   check_mysql_rc(rc, mysql);
@@ -516,7 +516,7 @@ static int test_fetch_nobuffs(MYSQL *mysql)
   MYSQL_BIND my_bind[4];
   char       str[4][50];
   int        rc;
-  char       *query = "SELECT DATABASE(), CURRENT_USER(), \
+  const char  *query = "SELECT DATABASE(), CURRENT_USER(), \
                        CURRENT_DATE(), CURRENT_TIME()";
 
   stmt = mysql_stmt_init(mysql);
@@ -653,7 +653,7 @@ static int test_fetch_date(MYSQL *mysql)
   MYSQL_BIND my_bind[8];
   my_bool    is_null[8];
   ulong      length[8];
-  char	     *query= "SELECT * FROM test_bind_result";
+  const char *query= "SELECT * FROM test_bind_result";
 
   rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bind_result");
   check_mysql_rc(rc, mysql);

unittest/libmariadb/misc.c

@@ -164,7 +164,7 @@ static int bug31418_impl()
   return OK;
 }
 
-static int test_bug31418(MYSQL *mysql)
+static int test_bug31418(MYSQL *unused __attribute__((unused)))
 {
  int i;
   /* Run test case for BUG#31418 for three different connections. */
@@ -312,7 +312,7 @@ static int test_wl4166_1(MYSQL *mysql)
   ulong      length[7];
   my_bool    is_null[7];
   MYSQL_BIND my_bind[7];
-  static char *query;
+  const char *query;
   int rc;
   int i;
 
@@ -910,7 +910,7 @@ static int test_connect_attrs(MYSQL *my)
   mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD, "foo1", "bar1");
   mysql_options4(mysql, MYSQL_OPT_CONNECT_ATTR_ADD, "foo2", "bar2");
 
-  FAIL_IF(!mysql_real_connect(mysql, hostname, username, password, schema,
+  FAIL_IF(!my_test_connect(mysql, hostname, username, password, schema,
                          port, socketname, 0), mysql_error(my));
 
   if (!(mysql->server_capabilities & CLIENT_CONNECT_ATTRS))
@@ -955,11 +955,11 @@ static int test_conc_114(MYSQL *mysql)
 }
 
 /* run with valgrind */
-static int test_conc117(MYSQL *mysql)
+static int test_conc117(MYSQL *unused __attribute__((unused)))
 {
   my_bool reconnect= 1;
   MYSQL *my= mysql_init(NULL);
-  FAIL_IF(!mysql_real_connect(my, hostname, username, password, schema,
+  FAIL_IF(!my_test_connect(my, hostname, username, password, schema,
                          port, socketname, 0), mysql_error(my));
   
   mysql_kill(my, mysql_thread_id(my));
@@ -973,12 +973,12 @@ static int test_conc117(MYSQL *mysql)
   return OK;
 }
 
-static int test_read_timeout(MYSQL *mysql)
+static int test_read_timeout(MYSQL *unused __attribute__((unused)))
 {
   int timeout= 5, rc;
   MYSQL *my= mysql_init(NULL);
   mysql_options(my, MYSQL_OPT_READ_TIMEOUT, &timeout);
-  FAIL_IF(!mysql_real_connect(my, hostname, username, password, schema,
+  FAIL_IF(!my_test_connect(my, hostname, username, password, schema,
                          port, socketname, 0), mysql_error(my));
   
   rc= mysql_query(my, "SELECT SLEEP(50)");
@@ -1034,7 +1034,7 @@ static int test_remote2(MYSQL *my)
 
   mysql_options(mysql, MYSQL_READ_DEFAULT_FILE, "http://localhost/test.cnf");
   mysql_options(mysql, MYSQL_READ_DEFAULT_GROUP, "test");
-  mysql_real_connect(mysql, hostname, username, password, schema,
+  my_test_connect(mysql, hostname, username, password, schema,
                          0, socketname, 0), mysql_error(my);
   diag("port: %d", mysql->port);
   mysql_close(mysql);
@@ -1122,7 +1122,7 @@ static int test_zerofill(MYSQL *mysql)
   rc= mysql_query(mysql, "SELECT a FROM t1");
   check_mysql_rc(rc, mysql);
 
-  if (res= mysql_store_result(mysql))
+  if ((res= mysql_store_result(mysql)))
   {
     row= mysql_fetch_row(res);
     diag("zerofill: %s", row[0]);

unittest/libmariadb/my_test.h

@@ -114,15 +114,25 @@ struct my_tests_st
   int   connection;
   ulong connect_flags;
   struct my_option_st *options;
-  char *skipmsg;
+  const char *skipmsg;
 };
 
-static char *schema = 0;
+MYSQL *my_test_connect(MYSQL *mysql,
+                       const char *host,
+                       const char *user,
+                       const char *passwd,
+                       const char *db,
+                       unsigned int port,
+                       const char *unix_socket,
+                       unsigned long clientflag);
+
+static const char *schema = 0;
 static char *hostname = 0;
 static char *password = 0;
 static unsigned int port = 0;
 static char *socketname = 0;
 static char *username = 0;
+static int force_tls= 0;
 /*
 static struct my_option test_options[] =
 {
@@ -160,11 +170,13 @@ static struct my_option test_options[] =
 int do_verify_prepare_field(MYSQL_RES *result,
                             unsigned int no, const char *name,
                             const char *org_name,
-                            enum enum_field_types type,
+                            enum enum_field_types type __attribute__((unused)),
                             const char *table,
                             const char *org_table, const char *db,
-                            unsigned long length, const char *def,
+                            unsigned long length __attribute__((unused)), 
-                            const char *file, int line)
+                            const char *def __attribute__((unused)),
+                            const char *file __attribute__((unused)),
+                            int line __attribute__((unused)))
 {
   MYSQL_FIELD *field;
 /*  MARIADB_CHARSET_INFO *cs; */
@@ -312,6 +324,7 @@ static void usage()
   printf("-p password\n");
   printf("-d database\n");
   printf("-S socketname\n");
+  printf("-t force use of TLS\n");
   printf("-P port number\n");
   printf("?  displays this help and exits\n");
 }
@@ -320,7 +333,7 @@ void get_options(int argc, char **argv)
 {
   int c= 0;
 
-  while ((c=getopt(argc,argv, "h:u:p:d:P:S:?")) >= 0)
+  while ((c=getopt(argc,argv, "h:u:p:d:w:P:S:t:?")) >= 0)
   {
     switch(c) {
     case 'h':
@@ -341,6 +354,9 @@ void get_options(int argc, char **argv)
     case 'S':
       socketname= optarg;
       break;
+    case 't':
+      force_tls= 1;
+      break;
     case '?':
       usage();
       exit(0);
@@ -354,7 +370,7 @@ void get_options(int argc, char **argv)
 }
 
 
-int check_variable(MYSQL *mysql, char *variable, char *value)
+int check_variable(MYSQL *mysql, const char *variable, const char *value)
 {
   char query[MAX_TEST_QUERY_LENGTH];
   MYSQL_RES *result;
@@ -380,7 +396,8 @@ int check_variable(MYSQL *mysql, char *variable, char *value)
  * returns a new connection. This function will be called, if the test doesn't
  * use default_connection.
  */
-MYSQL *test_connect(struct my_tests_st *test) {
+MYSQL *test_connect(struct my_tests_st *test)
+{
   MYSQL *mysql;
   int i= 0;
   int timeout= 10;
@@ -389,7 +406,6 @@ MYSQL *test_connect(struct my_tests_st *test) {
     diag("%s", "mysql_init failed - exiting");
     return(NULL);
   }
-
   mysql_options(mysql, MYSQL_REPORT_DATA_TRUNCATION, &truncation_report);
   mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, &timeout);
 
@@ -407,7 +423,7 @@ MYSQL *test_connect(struct my_tests_st *test) {
       i++;
     }
   }
-  if (!(mysql_real_connect(mysql, hostname, username, password,
+  if (!(my_test_connect(mysql, hostname, username, password,
                            schema, port, socketname, (test) ? test->connect_flags:0)))
   {
     diag("Couldn't establish connection to server %s. Error (%d): %s", 
@@ -449,10 +465,33 @@ void get_envvars() {
     schema= "testc";
   if (!port && (envvar= getenv("MYSQL_TEST_PORT")))
     port= atoi(envvar);
+  if (!force_tls && (envvar= getenv("MYSQL_TEST_TLS")))
+    force_tls= atoi(envvar);
   if (!socketname && (envvar= getenv("MYSQL_TEST_SOCKET")))
     socketname= envvar;
 }
 
+MYSQL *my_test_connect(MYSQL *mysql,
+                       const char *host,
+                       const char *user,
+                       const char *passwd,
+                       const char *db,
+                       unsigned int port,
+                       const char *unix_socket,
+                       unsigned long clientflag)
+{
+  if (force_tls)
+    mysql_options(mysql, MYSQL_OPT_SSL_ENFORCE, &force_tls);
+  mysql= mysql_real_connect(mysql, host, user, passwd, db, port, unix_socket, clientflag);
+  if (mysql && force_tls && !mysql_get_ssl_cipher(mysql))
+  {
+    diag("Error: TLS connection not established");
+    return NULL;
+  }
+  return mysql;
+}
+
+
 void run_tests(struct my_tests_st *test) {
   int i, rc, total=0;
   MYSQL *mysql, *mysql_default= NULL;  /* default connection */

unittest/libmariadb/performance.c

@@ -27,7 +27,7 @@ static int perf1(MYSQL *mysql)
 {
   int rc;
   MYSQL_STMT *stmt;
-  char *stmtstr= "SELECT s.emp_no, s.salary, e.emp_no, e.first_name, e.last_name, e.gender FROM salaries s, employees e WHERE s.emp_no = e.emp_no";
+  const char *stmtstr= "SELECT s.emp_no, s.salary, e.emp_no, e.first_name, e.last_name, e.gender FROM salaries s, employees e WHERE s.emp_no = e.emp_no";
 
   rc= mysql_select_db(mysql, "employees");
   if (rc)

unittest/libmariadb/ps.c

@@ -47,20 +47,20 @@ static int test_conc97(MYSQL *mysql)
   return OK;
 }
 
-static int test_conc83(MYSQL *my)
+static int test_conc83(MYSQL *unused __attribute__((unused)))
 {
   MYSQL_STMT *stmt;
   int rc;
   MYSQL *mysql= mysql_init(NULL);
   my_bool reconnect= 1;
 
-  char *query= "SELECT 1,2,3 FROM DUAL";
+  const char *query= "SELECT 1,2,3 FROM DUAL";
 
   stmt= mysql_stmt_init(mysql);
 
   mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
-  FAIL_IF(!(mysql_real_connect(mysql, hostname, username, password,
+  FAIL_IF(!(my_test_connect(mysql, hostname, username, password,
-                           schema, port, socketname, 0)), "mysql_real_connect failed");
+                           schema, port, socketname, 0)), "my_test_connect failed");
 
   /* 1. Status is inited, so prepare should work */
 
@@ -91,7 +91,7 @@ static int test_conc60(MYSQL *mysql)
 {
   MYSQL_STMT *stmt;
   int rc;
-  char *query= "SELECT * FROM agendas";
+  const char *query= "SELECT * FROM agendas";
   my_bool x= 1;
 
   stmt= mysql_stmt_init(mysql);
@@ -184,7 +184,6 @@ static int test_bind_date_conv(MYSQL *mysql, uint row_count)
 {
   MYSQL_STMT   *stmt= 0;
   uint         rc, i, count= row_count;
-  ulong        length[4]= {0,0,0,0};
   MYSQL_BIND   my_bind[4];
   my_bool      is_null[4]= {0,0,0,0};
   MYSQL_TIME   tm[4];
@@ -203,7 +202,6 @@ static int test_bind_date_conv(MYSQL *mysql, uint row_count)
     its members.
   */
   memset(my_bind, '\0', sizeof(my_bind));
-  memset(tm,  0, sizeof(tm));
 
   my_bind[0].buffer_type= MYSQL_TYPE_TIMESTAMP;
   my_bind[1].buffer_type= MYSQL_TYPE_TIME;
@@ -214,9 +212,7 @@ static int test_bind_date_conv(MYSQL *mysql, uint row_count)
   {
     my_bind[i].buffer= (void *) &tm[i];
     my_bind[i].is_null= &is_null[i];
-    my_bind[i].length= &length[i];
+    my_bind[i].buffer_length= sizeof(MYSQL_TIME);
-    my_bind[i].buffer_length= 30;
-    length[i]= 20;
   }
 
   second_part= 0;
@@ -236,6 +232,7 @@ static int test_bind_date_conv(MYSQL *mysql, uint row_count)
   {
     for (i= 0; i < (int) array_elements(my_bind); i++)
     {
+      memset(&tm[i],  0, sizeof(MYSQL_TIME));
       tm[i].neg= 0;
       tm[i].second_part= second_part+count;
       if (my_bind[i].buffer_type != MYSQL_TYPE_TIME)
@@ -828,8 +825,8 @@ static int test_prepare_alter(MYSQL *mysql)
  
   mysql_new= mysql_init(NULL);
   FAIL_IF(!mysql_new, "mysql_init failed");
-  FAIL_IF(!(mysql_real_connect(mysql_new, hostname, username, password,
+  FAIL_IF(!(my_test_connect(mysql_new, hostname, username, password,
-                           schema, port, socketname, 0)), "mysql_real_connect failed");
+                           schema, port, socketname, 0)), "my_test_connect failed");
   rc= mysql_query(mysql_new, "ALTER TABLE test_prep_alter change id id_new varchar(20)");
   diag("Error: %d %s", mysql_errno(mysql_new), mysql_error(mysql_new));
   check_mysql_rc(rc, mysql_new);
@@ -3414,7 +3411,6 @@ static int test_double_compare(MYSQL *mysql)
   my_bind[1].buffer= (void *)&real_data;
   my_bind[1].buffer_length= sizeof(real_data);
   my_bind[1].length= &length[1];
-  length[1]= 10;
 
   /* double */
   my_bind[2].buffer_type= MYSQL_TYPE_DOUBLE;
@@ -3422,6 +3418,7 @@ static int test_double_compare(MYSQL *mysql)
 
   tiny_data= 1;
   strcpy(real_data, "10.2");
+  length[1]= strlen(real_data);
   double_data= 34.5;
   rc= mysql_stmt_bind_param(stmt, my_bind);
   check_stmt_rc(rc, stmt);
@@ -3561,7 +3558,7 @@ static int test_multi_stmt(MYSQL *mysql)
   MYSQL_BIND  my_bind[2];
   ulong       length[2];
   my_bool     is_null[2];
-  static      char *query;
+  const char *query;
 
   rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_multi_table");
   check_mysql_rc(rc, mysql);
@@ -3850,7 +3847,7 @@ static int test_order_param(MYSQL *mysql)
 {
   MYSQL_STMT *stmt;
   int rc;
-  static char *query;
+  const char *query;
 
   rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
   check_mysql_rc(rc, mysql);
@@ -4680,7 +4677,7 @@ static int test_long_data1(MYSQL *mysql)
   int        rc;
   MYSQL_BIND bind[1];
   char query[MAX_TEST_QUERY_LENGTH];
-  char *data= "12345";
+  const char *data= "12345";
 
   rc= mysql_autocommit(mysql, TRUE);
   check_mysql_rc(rc, mysql);
@@ -4718,7 +4715,7 @@ int test_blob_9000(MYSQL *mysql)
   MYSQL_STMT *stmt;
   int rc;
   char buffer[9200];
-  char *query= "INSERT INTO tb9000 VALUES (?)";
+  const char *query= "INSERT INTO tb9000 VALUES (?)";
 
   rc= mysql_query(mysql, "DROP TABLE IF EXISTS tb9000");
   check_mysql_rc(rc, mysql);
@@ -4746,7 +4743,7 @@ int test_fracseconds(MYSQL *mysql)
 {
   MYSQL_STMT *stmt;
   int rc;
-  char *str= "SELECT NOW(6)";
+  const char *str= "SELECT NOW(6)";
   char buffer[60], buffer1[60];
   MYSQL_BIND bind[2];
 
@@ -4821,7 +4818,7 @@ int test_notrunc(MYSQL *mysql)
   my_bool error= 0;
   unsigned long len= 1;
 
-  char *query= "SELECT '1234567890', 'foo' FROM DUAL";
+  const char *query= "SELECT '1234567890', 'foo' FROM DUAL";
 
   mysql_options(mysql, MYSQL_REPORT_DATA_TRUNCATION, &trunc);
 
@@ -4860,7 +4857,53 @@ int test_notrunc(MYSQL *mysql)
   return OK;
 }
 
+static int test_bit2tiny(MYSQL *mysql)
+{
+  MYSQL_BIND bind[2];
+  char       data[11];
+  unsigned   long length[2];
+  my_bool    is_null[2], error[2];
+  const char *query = "SELECT val FROM justbit";
+  MYSQL_STMT *stmt;
+  int rc;
+
+  mysql_query(mysql, "DROP TABLE IF EXISTS justbit");
+  mysql_query(mysql, "CREATE TABLE justbit(val bit(1) not null)");
+  mysql_query(mysql, "INSERT INTO justbit values (1)");
+
+  stmt= mysql_stmt_init(mysql);
+  rc= mysql_stmt_prepare(stmt, query, strlen(query));
+  check_stmt_rc(rc, stmt);
+
+  memset(bind, '\0', sizeof(bind));
+
+  bind[0].buffer_type=  MYSQL_TYPE_TINY;
+  bind[0].buffer=       &data[0];
+  bind[0].buffer_length= 1;
+  bind[0].is_null=      &is_null[0];
+  bind[0].length=       &length[0];
+  bind[0].error=        &error[0];
+
+  rc= mysql_stmt_execute(stmt);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_bind_result(stmt, bind);
+  check_stmt_rc(rc, stmt);
+
+  rc= mysql_stmt_store_result(stmt);
+  check_stmt_rc(rc, stmt);
+
+  mysql_stmt_fetch(stmt);
+
+  FAIL_IF(data[0] != 1, "Value should be 1");
+
+  mysql_stmt_free_result(stmt);
+  mysql_stmt_close(stmt);
+  return OK;
+}
+
 struct my_tests_st my_tests[] = {
+  {"test_bit2tiny", test_bit2tiny, TEST_CONNECTION_NEW, 0, NULL, NULL},
   {"test_conc97", test_conc97, TEST_CONNECTION_NEW, 0, NULL, NULL},
   {"test_conc83", test_conc83, TEST_CONNECTION_NONE, 0, NULL, NULL},
   {"test_conc60", test_conc60, TEST_CONNECTION_DEFAULT, 0, NULL, NULL},

unittest/libmariadb/ps_bugs.c

@@ -39,7 +39,7 @@ static int cmp_double(double *a, double *b)
 static int test_conc67(MYSQL *mysql)
 {
   MYSQL_STMT *stmt= mysql_stmt_init(mysql);
-  char *query= "SELECT a,b FROM conc67 WHERE a=?";
+  const char *query= "SELECT a,b FROM conc67 WHERE a=?";
   int rc, i;
   MYSQL_BIND bind[2];
   char val[20];
@@ -545,8 +545,8 @@ static int test_bug1500(MYSQL *mysql)
   MYSQL_BIND my_bind[3];
   int        rc= 0;
   int32 int_data[3]= {2, 3, 4};
-  char *data;
+  const char *data;
-  char *query;
+  const char *query;
 
 
   rc= mysql_query(mysql, "DROP TABLE IF EXISTS test_bg1500");
@@ -3028,7 +3028,7 @@ static int test_bug8330(MYSQL *mysql)
   int i, rc;
   const char *query= "select a,b from t1 where a=?";
   MYSQL_BIND my_bind[2];
-  long lval[2];
+  long lval[2]= {1,2};
 
   stmt_text= "drop table if exists t1";
   /* in case some previos test failed */
@@ -3354,6 +3354,7 @@ static int test_decimal_bug(MYSQL *mysql)
   */
   memset(my_bind, '\0', sizeof(my_bind));
 
+  memset(data, 0, sizeof(data));
   my_bind[0].buffer_type= MYSQL_TYPE_NEWDECIMAL;
   my_bind[0].buffer= (void *)data;
   my_bind[0].buffer_length= 25;
@@ -3748,7 +3749,7 @@ static int test_bug53311(MYSQL *mysql)
   int rc;
   MYSQL_STMT *stmt;
   int i;
-  char *query= "INSERT INTO bug53311 VALUES (1)";
+  const char *query= "INSERT INTO bug53311 VALUES (1)";
 
   rc= mysql_options(mysql, MYSQL_OPT_RECONNECT, "1");
   check_mysql_rc(rc, mysql);
@@ -3836,7 +3837,7 @@ end:
 
 static int test_conc_5(MYSQL *mysql)
 {
-  char *query= "SELECT a FROM t1";
+  const char *query= "SELECT a FROM t1";
   MYSQL_RES *res;
   MYSQL_STMT *stmt;
   MYSQL_FIELD *fields;
@@ -3873,7 +3874,7 @@ static int test_conc_5(MYSQL *mysql)
 static int test_conc141(MYSQL *mysql)
 {
   int rc;
-  char *query= "CALL p_conc141";
+  const char *query= "CALL p_conc141";
   MYSQL_STMT *stmt= mysql_stmt_init(mysql);
 
   rc= mysql_query(mysql, "DROP TABLE IF EXISTS conc141");
@@ -4107,7 +4108,7 @@ static int test_conc167(MYSQL *mysql)
   char buffer[100];
   int bit1=0, bit2=0;
   int rc;
-  char *stmt_str= "SELECT a,b,c FROM conc168";
+  const char *stmt_str= "SELECT a,b,c FROM conc168";
 
   rc= mysql_query(mysql, "DROP TABLE IF EXISTS conc168");
   check_mysql_rc(rc, mysql);
@@ -4153,7 +4154,7 @@ static int test_conc177(MYSQL *mysql)
   MYSQL_STMT *stmt;
   int rc;
   MYSQL_BIND bind[2];
-  char *stmt_str= "SELECT a,b FROM t1";
+  const char *stmt_str= "SELECT a,b FROM t1";
   char buf1[128], buf2[128];
 
   rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
@@ -4228,7 +4229,7 @@ static int test_conc179(MYSQL *mysql)
 {
   MYSQL_STMT *stmt;
   int rc;
-  char *stmtstr= "CREATE TABLE t1 (`blurb_id` int NOT NULL DEFAULT 0, `blurb` text default '', PRIMARY KEY (blurb_id)) ENGINE='FEDERATED' DEFAULT CHARSET=latin1 CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/test/t1'";
+  const char *stmtstr= "CREATE TABLE t1 (`blurb_id` int NOT NULL DEFAULT 0, `blurb` text default '', PRIMARY KEY (blurb_id)) ENGINE='FEDERATED' DEFAULT CHARSET=latin1 CONNECTION='mysql://root@127.0.0.1:$SLAVE_MYPORT/test/t1'";
 
   rc= mysql_query(mysql, "set sql_mode=''");
   check_mysql_rc(rc, mysql);
@@ -4300,7 +4301,7 @@ static int test_conc181(MYSQL *mysql)
   MYSQL_STMT *stmt;
   int rc;
   MYSQL_BIND bind;
-  char *stmt_str= "SELECT a FROM t1";
+  const char *stmt_str= "SELECT a FROM t1";
   float f=1;
   my_bool err= 0;
 

unittest/libmariadb/ps_new.c

@@ -135,7 +135,7 @@ int test_sp_params(MYSQL *mysql)
   MYSQL_STMT *stmt;
   int a[] = {10,20,30};
   MYSQL_BIND bind[3];
-  char *stmtstr= "CALL P1(?,?,?)";
+  const char *stmtstr= "CALL P1(?,?,?)";
   char res[3][20];
 
   rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
@@ -219,7 +219,7 @@ int test_sp_reset(MYSQL *mysql)
   MYSQL_STMT *stmt;
   int a[] = {10,20,30};
   MYSQL_BIND bind[3];
-  char *stmtstr= "CALL P1(?,?,?)";
+  const char *stmtstr= "CALL P1(?,?,?)";
 
   rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
   check_mysql_rc(rc, mysql);
@@ -274,7 +274,7 @@ int test_sp_reset1(MYSQL *mysql)
   MYSQL_BIND bind[1];
 
   char tmp[20];
-  char *stmtstr= "CALL P1(?)";
+  const char *stmtstr= "CALL P1(?)";
 
   rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
   check_mysql_rc(rc, mysql);
@@ -332,7 +332,7 @@ int test_sp_reset2(MYSQL *mysql)
   MYSQL_STMT *stmt;
   MYSQL_BIND bind[4];
   long l[4];
-  char *stmtstr= "CALL P1()";
+  const char *stmtstr= "CALL P1()";
 
   memset(l, 0, sizeof(l));
 
@@ -425,7 +425,7 @@ int test_query(MYSQL *mysql)
   MYSQL_BIND bind[1];
 
   char tmp[20];
-  char *stmtstr= "CALL P1(?)";
+  const char *stmtstr= "CALL P1(?)";
 
   rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
   check_mysql_rc(rc, mysql);

unittest/libmariadb/ssl.c.in

@@ -123,7 +123,7 @@ static int test_ssl(MYSQL *mysql)
     res= mysql_store_result(mysql);
     row= mysql_fetch_row(res);
     diag("user: %s", row[0]);
-    if (p= strchr(row[0], '@'))
+    if ((p= strchr(row[0], '@')))
       strcpy(sslhost, p+1);
     mysql_free_result(res);
   }
@@ -131,7 +131,7 @@ static int test_ssl(MYSQL *mysql)
   return OK;
 }
 
-static int test_ssl_cipher(MYSQL *unused)
+static int test_ssl_cipher(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *my;
   MYSQL_RES *res;
@@ -162,7 +162,7 @@ static int test_ssl_cipher(MYSQL *unused)
   return OK;
 }
 
-static int test_conc95(MYSQL *my)
+static int test_conc95(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql;
 
@@ -180,7 +180,7 @@ static int test_conc95(MYSQL *my)
                 NULL);
 
   if (!mysql_real_connect(mysql, hostname, "ssluser1", sslpw, schema,
-           port, socketname, 0))
+                          port, socketname, 0))
   {
     diag("could not establish x509 connection. Error: %s", mysql_error(mysql));
     mysql_close(mysql);
@@ -190,7 +190,7 @@ static int test_conc95(MYSQL *my)
   return OK;
 }
 
-static int test_multi_ssl_connections(MYSQL *unused)
+static int test_multi_ssl_connections(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql[50], *my;
   int i, rc;
@@ -255,7 +255,7 @@ static int test_multi_ssl_connections(MYSQL *unused)
 }
 
 #ifndef WIN32
-static void ssl_thread(void *dummy)
+static void ssl_thread(void *unused __attribute__((unused)))
 #else
 DWORD WINAPI ssl_thread(void *dummy)
 #endif
@@ -343,7 +343,7 @@ static int test_ssl_threads(MYSQL *mysql)
   return OK;
 }
 
-static int test_phpbug51647(MYSQL *my)
+static int test_phpbug51647(MYSQL *unused __attribute__((unused)))
 {
   MYSQL* mysql;
 
@@ -365,7 +365,7 @@ static int test_phpbug51647(MYSQL *my)
   return OK;
 }
 
-static int test_password_protected(MYSQL *my)
+static int test_password_protected(MYSQL *unused __attribute__((unused)))
 {
   MYSQL* mysql;
 
@@ -390,7 +390,7 @@ static int test_password_protected(MYSQL *my)
 }
 
 
-static int test_conc50(MYSQL *my)
+static int test_conc50(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql;
 
@@ -411,7 +411,7 @@ static int test_conc50(MYSQL *my)
   return OK;
 }
 
-static int test_conc50_1(MYSQL *my)
+static int test_conc50_1(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql;
 
@@ -433,7 +433,7 @@ static int test_conc50_1(MYSQL *my)
   return OK;
 }
 
-static int test_conc50_2(MYSQL *my)
+static int test_conc50_2(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql;
 
@@ -453,10 +453,13 @@ static int test_conc50_2(MYSQL *my)
   return OK;
 }
 
-static int test_conc127(MYSQL *my)
+static int test_conc127(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql;
 
+  diag("test disabled - for testing disable other tests or run this test as first test");
+  return SKIP;
+
   if (check_skip_ssl())
     return SKIP;
 
@@ -474,7 +477,7 @@ static int test_conc127(MYSQL *my)
   return OK;
 }
 
-static int test_conc50_3(MYSQL *my)
+static int test_conc50_3(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql;
 
@@ -507,7 +510,7 @@ static int test_conc50_3(MYSQL *my)
   return OK;
 }
 
-static int test_conc50_4(MYSQL *my)
+static int test_conc50_4(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql;
 
@@ -527,7 +530,7 @@ static int test_conc50_4(MYSQL *my)
   return OK;
 }
 
-static int verify_ssl_server_cert(MYSQL *my)
+static int verify_ssl_server_cert(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql;
   uint verify= 1;
@@ -550,7 +553,7 @@ static int verify_ssl_server_cert(MYSQL *my)
   return OK;
 }
 
-static int test_bug62743(MYSQL *my)
+static int test_bug62743(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql;
 
@@ -638,7 +641,7 @@ DWORD WINAPI thread_conc102(void)
   check_mysql_rc(rc, mysql);
   pthread_mutex_unlock(&LOCK_test);
   check_mysql_rc(rc, mysql);
-  if (res= mysql_store_result(mysql))
+  if ((res= mysql_store_result(mysql)))
     mysql_free_result(res);
 end:
   mysql_close(mysql);
@@ -702,7 +705,7 @@ static int test_conc_102(MYSQL *mysql)
 
 const char *ssl_cert_finger_print= "@SSL_CERT_FINGER_PRINT@";
 
-static int test_ssl_fp(MYSQL *unused)
+static int test_ssl_fp(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *my;
   MYSQL_RES *res;
@@ -741,7 +744,7 @@ static int test_ssl_fp(MYSQL *unused)
   return OK;
 }
 
-static int test_ssl_fp_list(MYSQL *unused)
+static int test_ssl_fp_list(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *my;
   
@@ -763,7 +766,7 @@ static int test_ssl_fp_list(MYSQL *unused)
   return OK;
 }
 
-static int test_ssl_version(MYSQL *mysql)
+static int test_ssl_version(MYSQL *unused __attribute__((unused)))
 {
   unsigned int iversion;
   const char *version, *library;
@@ -794,7 +797,7 @@ static int test_ssl_version(MYSQL *mysql)
 }
 
 #ifdef HAVE_SCHANNEL
-static int test_schannel_cipher(MYSQL *mysql)
+static int test_schannel_cipher(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *my;
   unsigned int cipher_strength= 256;
@@ -819,11 +822,67 @@ static int test_schannel_cipher(MYSQL *mysql)
 }
 
 #endif
-  
+
+#ifdef HAVE_GNUTLS
+
+static int test_cipher_mapping(MYSQL *unused __attribute__((unused)))
+{
+  unsigned int i=0;
+  const char *ciphers[]= { "DHE-RSA-AES256-GCM-SHA384", "DHE-RSA-AES256-SHA256", "DHE-RSA-AES256-SHA",
+                           "DHE-RSA-CAMELLIA256-SHA", "AES256-GCM-SHA384", "AES256-SHA256",
+                           "AES256-SHA", "CAMELLIA256-SHA", "DHE-RSA-AES128-GCM-SHA256",
+                           "DHE-RSA-AES128-SHA256", "DHE-RSA-AES128-SHA", "DHE-RSA-CAMELLIA128-SHA",
+                           "AES128-GCM-SHA256", "AES128-SHA256", "AES128-SHA", "CAMELLIA128-SHA",
+                           "EDH-RSA-DES-CBC3-SHA", "DES-CBC3-SHA", "DHE-RSA-AES256-SHA",
+                           "DHE-RSA-CAMELLIA256-SHA", "AES256-SHA", "CAMELLIA256-SHA",
+                           NULL };
+
+  if (check_skip_ssl())
+    return SKIP;
+
+  while (ciphers[i] != NULL)
+  {
+    MYSQL *mysql= mysql_init(NULL);
+    MYSQL_ROW row;
+    MYSQL_RES *res;
+    char c[100];
+    int rc;
+    mysql_options(mysql, MYSQL_OPT_SSL_CIPHER, ciphers[i]);
+    diag("%s", ciphers[i]);
+    FAIL_IF(!mysql_real_connect(mysql, hostname, username, password, schema,
+                         port, socketname, 0), mysql_error(mysql));
+    if (strcmp(ciphers[i], mysql_get_ssl_cipher(mysql)) != 0)
+    {
+      diag("expected: %s instead of %s", ciphers[i], mysql_get_ssl_cipher(mysql));
+      mysql_close(mysql);
+      return FAIL;
+    }
+    rc= mysql_query(mysql, "SHOW STATUS LIKE 'ssl_cipher'");
+    check_mysql_rc(rc, mysql);
+    res= mysql_store_result(mysql);
+    row= mysql_fetch_row(res);
+    strcpy(c, row[1]);
+    mysql_free_result(res);
+    mysql_close(mysql);
+    if (strcmp(ciphers[i], c) != 0)
+    {
+      diag("expected: %s instead of %s", ciphers[i], c);
+      return FAIL;
+    }
+
+    i++;
+  }
+  return OK;
+}
+
+#endif  
 
 struct my_tests_st my_tests[] = {
   {"test_ssl", test_ssl, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
-//  {"test_conc127", test_conc127, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
+#ifdef HAVE_GNUTLS
+  {"test_cipher_mapping", test_cipher_mapping, TEST_CONNECTION_NONE, 0,  NULL,  NULL},
+#endif
+  {"test_conc127", test_conc127, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
   {"test_ssl_fp", test_ssl_fp, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
   {"test_ssl_fp_list", test_ssl_fp_list, TEST_CONNECTION_NEW, 0,  NULL,  NULL},
   {"test_conc50", test_conc50, TEST_CONNECTION_NEW, 0,  NULL,  NULL},

unittest/libmariadb/t_aurora.c

@@ -4,7 +4,7 @@
 #include "my_test.h"
 #include "ma_pvio.h"
 
-static int aurora1(MYSQL *my)
+static int aurora1(MYSQL *unused __attribute__((unused)))
 {
   int rc;
   my_bool read_only= 1;
@@ -54,7 +54,7 @@ static int aurora1(MYSQL *my)
   return OK;
 }
 
-static int test_wrong_user(MYSQL *my)
+static int test_wrong_user(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql= mysql_init(NULL);
 
@@ -68,7 +68,7 @@ static int test_wrong_user(MYSQL *my)
   return OK;
 }
 
-static int test_reconnect(MYSQL *my)
+static int test_reconnect(MYSQL *unused __attribute__((unused)))
 {
   MYSQL *mysql= mysql_init(NULL);
   MYSQL_RES *res;

unittest/libmariadb/t_conc173.c

@@ -27,7 +27,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include "my_test.h"
 
-static int test_conc_173(MYSQL *my)
+static int test_conc_173(MYSQL *unused __attribute__((unused)))
 {
   MYSQL mysql;
   int arg;

unittest/libmariadb/thread.c

@@ -4,7 +4,7 @@
 #include "my_test.h"
 #include <ma_pthread.h>
 
-static int basic_connect(MYSQL *mysql)
+static int basic_connect(MYSQL *unused __attribute__((unused)))
 {
   MYSQL_ROW row;
   MYSQL_RES *res;
@@ -14,7 +14,7 @@ static int basic_connect(MYSQL *mysql)
   MYSQL *my= mysql_init(NULL);
   FAIL_IF(!my, "mysql_init() failed");
 
-  FAIL_IF(!mysql_real_connect(my, hostname, username, password, schema,
+  FAIL_IF(!my_test_connect(my, hostname, username, password, schema,
                          port, socketname, 0), mysql_error(my));
 
   rc= mysql_query(my, "SELECT @@version");
@@ -123,7 +123,7 @@ DWORD WINAPI thread_conc27(void)
   MYSQL_RES *res;
   mysql_thread_init();
   mysql= mysql_init(NULL);
-  if(!mysql_real_connect(mysql, hostname, username, password, schema,
+  if(!my_test_connect(mysql, hostname, username, password, schema,
           port, socketname, 0))
   {
     diag(">Error: %s", mysql_error(mysql));