Merge lp:~linuxjedi/libdrizzle/5.1-malloc-replace into lp:libdrizzle

[Andrew Hutchings]

* Switches malloc for new/delete
* Make structs initialize (for new)
* Change fixed 32K net buffer to an auto-growing variable net buffer 1MB -> 1GB
  o Starts at 1MB
  o If packet > buffer size (buffer is full) double buffer size
  o If buffer size >= 1GB bail with error (instead of trying to recv 0 bytes as before)

[lp:~linuxjedi/libdrizzle/5.1-malloc-replace]

94. By Andrew Hutchings on 2013-01-13

Get rid of vector include (no longer needed)

=== modified file 'libdrizzle-5.1/constants.h'
--- libdrizzle-5.1/constants.h	2012-12-30 20:08:04 +0000
+++ libdrizzle-5.1/constants.h	2013-01-13 19:37:21 +0000
@@ -78,7 +78,8 @@
 #define DRIZZLE_MAX_COLUMN_NAME_SIZE     2048
 #define DRIZZLE_MAX_DEFAULT_VALUE_SIZE   2048
 #define DRIZZLE_MAX_PACKET_SIZE          UINT32_MAX
-#define DRIZZLE_MAX_BUFFER_SIZE          32768
+#define DRIZZLE_MAX_BUFFER_SIZE          1024*1024*1024
+#define DRIZZLE_DEFAULT_BUFFER_SIZE      1024*1024
 #define DRIZZLE_BUFFER_COPY_THRESHOLD    8192
 #define DRIZZLE_MAX_SERVER_VERSION_SIZE  32
 #define DRIZZLE_MAX_SERVER_EXTRA_SIZE    32
@@ -86,8 +87,8 @@
 #define DRIZZLE_STATE_STACK_SIZE         8
 #define DRIZZLE_ROW_GROW_SIZE            8192
 #define DRIZZLE_DEFAULT_SOCKET_TIMEOUT   10
-#define DRIZZLE_DEFAULT_SOCKET_SEND_SIZE 32768
-#define DRIZZLE_DEFAULT_SOCKET_RECV_SIZE 32768
+#define DRIZZLE_DEFAULT_SOCKET_SEND_SIZE DRIZZLE_DEFAULT_BUFFER_SIZE
+#define DRIZZLE_DEFAULT_SOCKET_RECV_SIZE DRIZZLE_DEFAULT_BUFFER_SIZE
 #define DRIZZLE_MYSQL_PASSWORD_HASH      41
 #define DRIZZLE_BINLOG_CRC32_LEN         4
 // If this version or higher then we are doing checksums

=== modified file 'libdrizzle/binlog.cc'
--- libdrizzle/binlog.cc	2013-01-12 14:14:18 +0000
+++ libdrizzle/binlog.cc	2013-01-13 19:37:21 +0000
@@ -221,7 +221,7 @@
 
   if (con->result->binlog_event == NULL)
   {
-    con->result->binlog_event= (drizzle_binlog_st*)malloc(sizeof(drizzle_binlog_st));
+    con->result->binlog_event= new (std::nothrow) drizzle_binlog_st;
     con->result->binlog_event->data= NULL;
   }
   binlog_event= con->result->binlog_event;

=== modified file 'libdrizzle/column.cc'
--- libdrizzle/column.cc	2013-01-05 10:27:32 +0000
+++ libdrizzle/column.cc	2013-01-13 19:37:21 +0000
@@ -56,32 +56,13 @@
     return NULL;
   }
 
-  column= (drizzle_column_st*)malloc(sizeof(drizzle_column_st));
+  column= new (std::nothrow) drizzle_column_st;
   if (column == NULL)
   {
     drizzle_set_error(result->con, __func__, "Failed to allocate.");
     return NULL;
   }
 
-  column->result = result;
-  column->options= DRIZZLE_COLUMN_UNUSED;
-  /* SET BELOW: column->next */
-  column->prev = NULL;
-  column->catalog[0] = '\0';
-  column->db[0] = '\0';
-  column->table[0] = '\0';
-  column->orig_table[0] = '\0';
-  column->name[0] = '\0';
-  column->orig_name[0] = '\0';
-  column->charset = DRIZZLE_CHARSET_NONE;
-  column->size = 0;
-  column->max_size = 0;
-  column->type= (drizzle_column_type_t)0;
-  column->flags = 0;
-  column->decimals = 0;
-  /* UNSET: column->default_value */
-  column->default_value_size = 0;
-
   column->result= result;
 
   if (result->column_list)
@@ -109,7 +90,7 @@
   if (column->next)
     column->next->prev= column->prev;
 
-  free(column);
+  delete column;
 }
 
 drizzle_result_st *drizzle_column_drizzle_result(drizzle_column_st *column)
@@ -341,7 +322,7 @@
       return DRIZZLE_RETURN_OK;
     }
 
-    result->column_buffer= (drizzle_column_st*)calloc(result->column_count, sizeof(drizzle_column_st));
+    result->column_buffer= new (std::nothrow) drizzle_column_st[result->column_count];
     if (result->column_buffer == NULL)
     {
       drizzle_set_error(result->con, __func__, "Failed to allocate.");

=== modified file 'libdrizzle/command.cc'
--- libdrizzle/command.cc	2013-01-05 10:27:32 +0000
+++ libdrizzle/command.cc	2013-01-13 19:37:21 +0000
@@ -91,7 +91,7 @@
                     + strlen(con->db) + 1;
 
     /* Flush buffer if there is not enough room. */
-    free_size= (size_t)DRIZZLE_MAX_BUFFER_SIZE - (size_t)(start - con->buffer);
+    free_size= con->buffer_allocation - (size_t)(start - con->buffer);
     if (free_size < con->packet_size)
     {
       drizzle_state_push(con, drizzle_state_write);

=== modified file 'libdrizzle/common.h'
--- libdrizzle/common.h	2013-01-10 12:04:23 +0000
+++ libdrizzle/common.h	2013-01-13 19:37:21 +0000
@@ -44,6 +44,7 @@
 #include <libdrizzle-5.1/drizzle_client.h>
 
 #include <cassert>
+#include <new>
 
 #ifdef HAVE_FCNTL_H
 # include <fcntl.h>

=== modified file 'libdrizzle/conn.cc'
--- libdrizzle/conn.cc	2013-01-12 13:36:22 +0000
+++ libdrizzle/conn.cc	2013-01-13 19:37:21 +0000
@@ -1126,7 +1126,7 @@
   {
     con->buffer_ptr= con->buffer;
   }
-  else if ((con->buffer_ptr - con->buffer) > (DRIZZLE_MAX_BUFFER_SIZE / 2))
+  else if ((size_t)(con->buffer_ptr - con->buffer) > (con->buffer_allocation / 2))
   {
     memmove(con->buffer, con->buffer_ptr, con->buffer_size);
     con->buffer_ptr= con->buffer;
@@ -1149,7 +1149,27 @@
 
   while (1)
   {
-    size_t available_buffer= (size_t)DRIZZLE_MAX_BUFFER_SIZE - ((size_t)(con->buffer_ptr - con->buffer) + con->buffer_size);
+    size_t available_buffer= con->buffer_allocation - ((size_t)(con->buffer_ptr - con->buffer) + con->buffer_size);
+    if (available_buffer == 0)
+    {
+      if (con->buffer_allocation >= DRIZZLE_MAX_BUFFER_SIZE)
+      {
+        drizzle_set_error(con, __func__,
+                          "buffer too small:%zu", con->packet_size + 4);
+        return DRIZZLE_RETURN_INTERNAL_ERROR;
+      }
+      // Shift data to beginning of the buffer then resize
+      // This means that buffer_ptr isn't screwed up by realloc pointer move
+      if (con->buffer_ptr != con->buffer)
+      {
+        memmove(con->buffer, con->buffer_ptr, con->buffer_size);
+      }
+      con->buffer_allocation= con->buffer_allocation * 2;
+      con->buffer= (unsigned char*)realloc(con->buffer, con->buffer_allocation);
+      drizzle_log_debug(con, "buffer resized to: %zu", con->buffer_allocation);
+      con->buffer_ptr= con->buffer;
+      available_buffer= con->buffer_allocation - con->buffer_size;
+    }
 
 #ifdef USE_OPENSSL
     if (con->ssl_state == DRIZZLE_SSL_STATE_HANDSHAKE_COMPLETE)
@@ -1166,8 +1186,8 @@
     errno= translate_windows_error();
 #endif // defined _WIN32 || defined __CYGWIN__
 
-    drizzle_log_crazy(con, "read fd=%d recv=%zd ssl= %d errno=%s",
-                      con->fd, read_size, 
+    drizzle_log_crazy(con, "read fd=%d avail= %zd recv=%zd ssl= %d errno=%s",
+                      con->fd, available_buffer, read_size, 
                       (con->ssl_state == DRIZZLE_SSL_STATE_HANDSHAKE_COMPLETE) ? 1 : 0,
                       strerror(errno));
 

=== modified file 'libdrizzle/drizzle.cc'
--- libdrizzle/drizzle.cc	2013-01-12 13:36:22 +0000
+++ libdrizzle/drizzle.cc	2013-01-13 19:37:21 +0000
@@ -169,61 +169,12 @@
 {
   drizzle_st *con;
 
-  con= (drizzle_st*)malloc(sizeof(drizzle_st));
+  con= new (std::nothrow) drizzle_st;
   if (con == NULL)
   {
     return NULL;
   }
 
-  con->flags.is_shutdown= false;
-  con->options= DRIZZLE_CON_NONE;
-  con->packet_number= 0;
-  con->protocol_version= 0;
-  con->state_current= 0;
-  con->events= 0;
-  con->revents= 0;
-  con->capabilities= DRIZZLE_CAPABILITIES_NONE;
-  con->charset= DRIZZLE_CHARSET_NONE;
-  con->command= DRIZZLE_COMMAND_SLEEP;
-  con->socket_type= DRIZZLE_CON_SOCKET_TCP;
-  con->status= DRIZZLE_CON_STATUS_NONE;
-  con->max_packet_size= DRIZZLE_MAX_PACKET_SIZE;
-  con->result_count= 0;
-  con->thread_id= 0;
-  con->backlog= DRIZZLE_DEFAULT_BACKLOG;
-  con->fd= -1;
-  con->buffer_size= 0;
-  con->command_offset= 0;
-  con->command_size= 0;
-  con->command_total= 0;
-  con->packet_size= 0;
-  con->addrinfo_next= NULL;
-  con->buffer_ptr= con->buffer;
-  con->command_buffer= NULL;
-  con->command_data= NULL;
-  con->context= NULL;
-  con->context_free_fn= NULL;
-  con->result_list= NULL;
-  con->scramble= NULL;
-  /* con->buffer doesn't need to be set */
-  con->db[0]= 0;
-  con->password[0]= 0;
-  /* con->scramble_buffer doesn't need to be set */
-  con->server_version[0]= 0;
-  /* con->state_stack doesn't need to be set */
-  con->user[0]= 0;
-  con->ssl_context= NULL;
-  con->ssl= NULL;
-  con->ssl_state= DRIZZLE_SSL_STATE_NONE;
-  con->error_code= 0;
-  con->verbose= DRIZZLE_VERBOSE_NEVER;
-  con->last_errno= 0;
-  con->timeout= -1;
-  con->log_fn= NULL;
-  con->log_context= NULL;
-  con->sqlstate[0]= '\0';
-  con->last_error[0]= '\0';
-
   return con;
 }
 
@@ -256,7 +207,8 @@
     SSL_CTX_free(con->ssl_context);
 #endif
 
-  free(con);
+  free(con->buffer);
+  delete con;
 }
 
 drizzle_return_t drizzle_wait(drizzle_st *con)

=== modified file 'libdrizzle/field.cc'
--- libdrizzle/field.cc	2012-12-29 20:26:36 +0000
+++ libdrizzle/field.cc	2013-01-13 19:37:21 +0000
@@ -305,7 +305,7 @@
 drizzle_return_t drizzle_state_binary_null_read(drizzle_st *con)
 {
   con->result->null_bitmap_length= (con->result->column_count+7+2)/8;
-  con->result->null_bitmap= (uint8_t*)malloc(con->result->null_bitmap_length);
+  con->result->null_bitmap= new uint8_t[con->result->null_bitmap_length];
   con->buffer_ptr++;
 
   memcpy(con->result->null_bitmap, con->buffer_ptr, con->result->null_bitmap_length);

=== modified file 'libdrizzle/handshake.cc'
--- libdrizzle/handshake.cc	2013-01-05 10:27:32 +0000
+++ libdrizzle/handshake.cc	2013-01-13 19:37:21 +0000
@@ -240,7 +240,7 @@
                   + 1;  /* NULL */
 
   /* Assume the entire handshake packet will fit in the buffer. */
-  if ((con->packet_size + 4) > DRIZZLE_MAX_BUFFER_SIZE)
+  if ((con->packet_size + 4) > con->buffer_allocation)
   {
     drizzle_set_error(con, "drizzle_state_handshake_server_write",
                       "buffer too small:%zu", con->packet_size + 4);
@@ -548,7 +548,7 @@
                   + strlen(con->db) + 1;
 
   /* Assume the entire handshake packet will fit in the buffer. */
-  if ((con->packet_size + 4) > DRIZZLE_MAX_BUFFER_SIZE)
+  if ((con->packet_size + 4) > con->buffer_allocation)
   {
     drizzle_set_error(con, "drizzle_state_handshake_client_write",
                       "buffer too small:%zu", con->packet_size + 4);

=== modified file 'libdrizzle/result.cc'
--- libdrizzle/result.cc	2012-12-29 16:29:59 +0000
+++ libdrizzle/result.cc	2013-01-13 19:37:21 +0000
@@ -55,45 +55,13 @@
     return NULL;
   }
 
-  result= (drizzle_result_st*)malloc(sizeof(drizzle_result_st));
+  result= new (std::nothrow) drizzle_result_st;
   if (result == NULL)
   {
     drizzle_set_error(con, __func__, "Failed to allocate.");
     return NULL;
   }
 
-  result->binlog_checksums= false;
-  result->binlog_event= NULL;
-  result->column_list= NULL;
-  result->options= DRIZZLE_RESULT_NONE;
-  result->prev= NULL;
-  result->column_buffer= NULL;
-  result->row= NULL;
-  result->error_code= 0;
-  result->insert_id= 0;
-  result->warning_count= 0;
-  result->affected_rows= 0;
-  result->column_count= 0;
-  result->column_current= 0;
-  result->column= NULL;
-  result->row_count= 0;
-  result->row_current= 0;
-  result->field_current= 0;
-  result->field_total= 0;
-  result->field_offset= 0;
-  result->field_size= 0;
-  result->field= NULL;
-  result->field_buffer= NULL;
-  result->row_list_size= 0;
-  result->row_list= NULL;
-  result->field_sizes= NULL;
-  result->field_sizes_list= NULL;
-  result->info[0]= '\0';
-  result->sqlstate[0]= '\0';
-  result->null_bitmap_list= NULL;
-  result->null_bitmap= NULL;
-  result->binary_rows= false;
-
   result->con= con;
   con->result= result;
 
@@ -118,7 +86,7 @@
   if (result->binlog_event != NULL)
   {
     free(result->binlog_event->data);
-    free(result->binlog_event);
+    delete result->binlog_event;
   }
 
   for (column= result->column_list; column != NULL; column= result->column_list)
@@ -126,7 +94,7 @@
     drizzle_column_free(column);
   }
 
-  free(result->column_buffer);
+  delete[] result->column_buffer;
 
   if (result->options & DRIZZLE_RESULT_BUFFER_ROW)
   {
@@ -136,7 +104,7 @@
       drizzle_row_free(result, result->row_list[x]);
       if (result->null_bitmap_list != NULL)
       {
-        free(result->null_bitmap_list[x]);
+        delete[] result->null_bitmap_list[x];
       }
     }
     if (result->null_bitmap_list != NULL)
@@ -163,7 +131,7 @@
     result->next->prev= result->prev;
   }
 
-  free(result);
+  delete result;
 }
 
 void drizzle_result_free_all(drizzle_st *con)

=== modified file 'libdrizzle/statement.cc'
--- libdrizzle/statement.cc	2013-01-12 14:14:18 +0000
+++ libdrizzle/statement.cc	2013-01-13 19:37:21 +0000
@@ -40,21 +40,13 @@
 
 drizzle_stmt_st *drizzle_stmt_prepare(drizzle_st *con, const char *statement, size_t size, drizzle_return_t *ret_ptr)
 {
-  drizzle_stmt_st *stmt= (drizzle_stmt_st*)malloc(sizeof(drizzle_stmt_st));
+  drizzle_stmt_st *stmt= new (std::nothrow) drizzle_stmt_st;
   if (stmt == NULL)
   {
     *ret_ptr= DRIZZLE_RETURN_MEMORY;
-    drizzle_set_error(con, __func__, "malloc");
+    drizzle_set_error(con, __func__, "new");
     return NULL;
   }
-  stmt->execute_result= NULL;
-  stmt->param_count= 0;
-  stmt->id= 0;
-  stmt->query_params= NULL;
-  stmt->result_params= NULL;
-  stmt->null_bitmap_length= 0;
-  stmt->null_bitmap= NULL;
-  stmt->new_bind= true;
   con->stmt= stmt;
   stmt->con= con;
 
@@ -62,7 +54,7 @@
                                       statement, size, size, ret_ptr);
   if (*ret_ptr != DRIZZLE_RETURN_OK)
   {
-    free(stmt);
+    delete stmt;
     con->stmt= NULL;
     return NULL;
   }
@@ -77,7 +69,7 @@
       *ret_ptr= drizzle_column_skip(stmt->prepare_result);
       if ((*ret_ptr != DRIZZLE_RETURN_OK) && (*ret_ptr != DRIZZLE_RETURN_EOF))
       {
-        free(stmt);
+        delete stmt;
         return NULL;
       }
     }
@@ -93,17 +85,17 @@
    * bitmap mask */
 
   stmt->null_bitmap_length= (stmt->param_count + 7) / 8;
-  stmt->null_bitmap= (uint8_t*)calloc(stmt->null_bitmap_length, 1);
+  stmt->null_bitmap= new (std::nothrow) uint8_t[stmt->null_bitmap_length]();
   if (stmt->null_bitmap == NULL)
   {
-    free(stmt);
+    delete stmt;
     *ret_ptr= DRIZZLE_RETURN_MEMORY;
-    drizzle_set_error(con, __func__, "malloc");
+    drizzle_set_error(con, __func__, "new");
     return NULL;
   }
 
   /* Also use the parameter count to allocate the parameters */
-  stmt->query_params= (drizzle_bind_st*)calloc(stmt->param_count, sizeof(drizzle_bind_st));
+  stmt->query_params= new (std::nothrow) drizzle_bind_st[stmt->param_count];
   stmt->state= DRIZZLE_STMT_PREPARED;
   stmt->fields= stmt->prepare_result->column_buffer;
 
@@ -141,10 +133,10 @@
              + (stmt->param_count * 2) /* Parameter type data */
              + param_lengths; /* Parameter data */
 
-  buffer = (unsigned char*)malloc(buffer_size);
+  buffer = new (std::nothrow) unsigned char[buffer_size];
   if (buffer == NULL)
   {
-    drizzle_set_error(stmt->con, __func__, "malloc");
+    drizzle_set_error(stmt->con, __func__, "new");
     return DRIZZLE_RETURN_MEMORY;
   }
   buffer_pos= buffer;
@@ -274,7 +266,7 @@
       case DRIZZLE_COLUMN_TYPE_TIME2:
       default:
         drizzle_set_error(stmt->con, __func__, "unknown type when filling buffer");
-        free(buffer);
+        delete[] buffer;
         return DRIZZLE_RETURN_UNEXPECTED_DATA;
         break;
     }
@@ -296,7 +288,7 @@
   }
   else
   {
-    free(buffer);
+    delete[] buffer;
     return ret;
   }
 
@@ -309,10 +301,10 @@
   if (stmt->execute_result->column_count > 0)
   {
     ret= drizzle_column_buffer(stmt->execute_result);
-    stmt->result_params= (drizzle_bind_st*)calloc(stmt->execute_result->column_count, sizeof(drizzle_bind_st));
+    stmt->result_params= new (std::nothrow) drizzle_bind_st[stmt->execute_result->column_count];
   }
 
-  free(buffer);
+  delete[] buffer;
   return ret;
 }
 
@@ -336,7 +328,7 @@
   /* TODO: rework drizzle_command_write so we can send a header and we don't
    * need this copy
    * */
-  buffer= (unsigned char*)malloc(len + 6);
+  buffer= new (std::nothrow) unsigned char[len + 6];
 
   drizzle_set_byte4(buffer, stmt->id);
   drizzle_set_byte2(&buffer[4], param_num);
@@ -348,7 +340,7 @@
   stmt->con->options= (drizzle_options_t)((uint8_t)stmt->con->options & (uint8_t)~DRIZZLE_CON_NO_RESULT_READ);
   stmt->query_params[param_num].options.is_long_data= true;
 
-  free(buffer);
+  delete[] buffer;
   return ret;
 }
 
@@ -379,7 +371,7 @@
     stmt->execute_result= NULL;
   }
   stmt->state= DRIZZLE_STMT_PREPARED;
-  free(stmt->result_params);
+  delete[] stmt->result_params;
 
   return ret;
 }
@@ -552,7 +544,7 @@
     return DRIZZLE_RETURN_INVALID_ARGUMENT;
   }
 
-  free(stmt->null_bitmap);
+  delete[] stmt->null_bitmap;
   for (uint16_t x= 0; x < stmt->param_count; x++)
   {
     if (stmt->query_params[x].options.is_allocated)
@@ -560,7 +552,7 @@
       free(stmt->query_params[x].data);
     }
   }
-  free(stmt->query_params);
+  delete[] stmt->query_params;
   if (stmt->execute_result)
   {
     for (uint16_t x= 0; x < stmt->execute_result->column_count; x++)
@@ -568,7 +560,7 @@
       free(stmt->result_params[x].data);
       free(stmt->result_params[x].converted_data);
     }
-    free(stmt->result_params);
+    delete[] stmt->result_params;
     drizzle_result_free(stmt->execute_result);
   }
   if (stmt->prepare_result)
@@ -581,7 +573,7 @@
   drizzle_command_write(stmt->con, NULL, DRIZZLE_COMMAND_STMT_CLOSE, buffer, 4,
                         4, &ret);
   stmt->con->options= (drizzle_options_t)((uint8_t)stmt->con->options & (uint8_t)~DRIZZLE_CON_NO_RESULT_READ);
-  free(stmt);
+  delete stmt;
   return ret;
 }
 

=== modified file 'libdrizzle/structs.h'
--- libdrizzle/structs.h	2013-01-05 15:56:07 +0000
+++ libdrizzle/structs.h	2013-01-13 19:37:21 +0000
@@ -149,8 +149,12 @@
  */
 struct drizzle_st
 {
-  struct {
+  struct flags_t{
     bool is_shutdown;
+
+    flags_t() :
+      is_shutdown(false)
+    { }
   } flags;
   uint8_t packet_number;
   uint8_t protocol_version;
@@ -187,7 +191,8 @@
     drizzle_tcp_st tcp;
     drizzle_uds_st uds;
   } socket;
-  unsigned char buffer[DRIZZLE_MAX_BUFFER_SIZE];
+  unsigned char *buffer;
+  size_t buffer_allocation;
   char db[DRIZZLE_MAX_DB_SIZE];
   char password[DRIZZLE_MAX_PASSWORD_SIZE];
   unsigned char scramble_buffer[DRIZZLE_MAX_SCRAMBLE_SIZE];
@@ -213,6 +218,58 @@
   char sqlstate[DRIZZLE_MAX_SQLSTATE_SIZE + 1];
   char last_error[DRIZZLE_MAX_ERROR_SIZE];
   drizzle_stmt_st *stmt;
+
+  drizzle_st() :
+    packet_number(0),
+    protocol_version(0),
+    state_current(0),
+    events(0),
+    revents(0),
+    capabilities(DRIZZLE_CAPABILITIES_NONE),
+    charset(DRIZZLE_CHARSET_NONE),
+    command(DRIZZLE_COMMAND_SLEEP),
+    options(DRIZZLE_CON_NONE),
+    socket_type(DRIZZLE_CON_SOCKET_TCP),
+    status(DRIZZLE_CON_STATUS_NONE),
+    max_packet_size(DRIZZLE_MAX_PACKET_SIZE),
+    result_count(0),
+    thread_id(0),
+    backlog(DRIZZLE_DEFAULT_BACKLOG),
+    fd(-1),
+    buffer_size(0),
+    command_offset(0),
+    command_size(0),
+    command_total(0),
+    packet_size(0),
+    addrinfo_next(NULL),
+    command_buffer(NULL),
+    command_data(NULL),
+    context(NULL),
+    context_free_fn(NULL),
+    result(NULL),
+    result_list(NULL),
+    scramble(NULL),
+    buffer_allocation(DRIZZLE_DEFAULT_BUFFER_SIZE),
+    ssl_context(NULL),
+    ssl(NULL),
+    ssl_state(DRIZZLE_SSL_STATE_NONE),
+    error_code(0),
+    verbose(DRIZZLE_VERBOSE_NEVER),
+    last_errno(0),
+    timeout(-1),
+    log_fn(NULL),
+    log_context(NULL),
+    stmt(NULL)
+  {
+    db[0]= '\0';
+    password[0]= '\0';
+    server_version[0]= '\0';
+    user[0]= '\0';
+    sqlstate[0]= '\0';
+    last_error[0]= '\0';
+    buffer= (unsigned char*)malloc(DRIZZLE_DEFAULT_BUFFER_SIZE);
+    buffer_ptr= buffer;
+  }
 };
 
 /**
@@ -282,10 +339,10 @@
     field_total(0),
     field_offset(0),
     field_size(0),
-    field(),
-    field_buffer(),
+    field(NULL),
+    field_buffer(NULL),
     row_list_size(0),
-    row(),
+    row(NULL),
     row_list(NULL),
     field_sizes(NULL),
     field_sizes_list(NULL),
@@ -296,8 +353,8 @@
     null_bitmap_length(0),
     binary_rows(false)
   {
-    info[0]= 0;
-    sqlstate[0]= 0;
+    info[0]= '\0';
+    sqlstate[0]= '\0';
   }
 
 #endif
@@ -341,6 +398,26 @@
   uint8_t decimals;
   unsigned char default_value[DRIZZLE_MAX_DEFAULT_VALUE_SIZE];
   size_t default_value_size;
+
+  drizzle_column_st() :
+    result(NULL),
+    next(NULL),
+    prev(NULL),
+    options(DRIZZLE_COLUMN_UNUSED),
+    charset(DRIZZLE_CHARSET_NONE),
+    size(0),
+    max_size(0),
+    type(DRIZZLE_COLUMN_TYPE_NONE),
+    flags(DRIZZLE_COLUMN_FLAGS_NONE),
+    decimals(0),
+    default_value_size(0)
+  { 
+    catalog[0]= '\0';
+    db[0]= '\0';
+    table[0]= '\0';
+    orig_table[0] ='\0';
+    name[0]= '\0';
+  }
 };
 
 struct drizzle_stmt_st
@@ -357,6 +434,21 @@
   drizzle_result_st *prepare_result;
   drizzle_result_st *execute_result;
   drizzle_column_st *fields;
+
+  drizzle_stmt_st() :
+    con(NULL),
+    state(DRIZZLE_STMT_NONE),
+    id(0),
+    param_count(0),
+    query_params(NULL),
+    result_params(NULL),
+    null_bitmap_length(0),
+    null_bitmap(NULL),
+    new_bind(true),
+    prepare_result(NULL),
+    execute_result(NULL),
+    fields(NULL)
+  { }
 };
 
 struct drizzle_bind_st
@@ -366,13 +458,27 @@
   uint32_t length;
   bool is_bound;
   char *converted_data;
-  struct
+  struct options_t
   {
     bool is_null;
     bool is_unsigned;
     bool is_long_data;
     bool is_allocated;
+
+    options_t() :
+      is_null(false),
+      is_unsigned(false),
+      is_long_data(false),
+      is_allocated(false)
+    { }
   } options;
+  drizzle_bind_st() :
+    type(DRIZZLE_COLUMN_TYPE_NONE),
+    data(NULL),
+    length(0),
+    is_bound(false),
+    converted_data(NULL)
+  { }
 };
 
 #ifdef __cplusplus