Merge lp:~linuxjedi/libdrizzle/5.1-better-realloc into lp:libdrizzle

[Andrew Hutchings]

* Makes a few reallocs safer
* Removes reallocs where they aren't needed

=== modified file 'libdrizzle/conn.cc'
--- libdrizzle/conn.cc	2013-01-13 18:54:59 +0000
+++ libdrizzle/conn.cc	2013-01-15 13:40:33 +0000
@@ -1165,7 +1165,13 @@
         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);
+      unsigned char *realloc_buffer= (unsigned char*)realloc(con->buffer, con->buffer_allocation);
+      if (realloc_buffer == NULL)
+      {
+        drizzle_set_error(con, __func__, "realloc failure");
+        return DRIZZLE_RETURN_MEMORY;
+      }
+      con->buffer= realloc_buffer;
       drizzle_log_debug(con, "buffer resized to: %zu", con->buffer_allocation);
       con->buffer_ptr= con->buffer;
       available_buffer= con->buffer_allocation - con->buffer_size;

=== modified file 'libdrizzle/field.cc'
--- libdrizzle/field.cc	2013-01-13 17:40:00 +0000
+++ libdrizzle/field.cc	2013-01-15 13:40:33 +0000
@@ -143,7 +143,7 @@
 
   if (result->field_buffer == NULL)
   {
-    result->field_buffer= (drizzle_field_t)realloc(NULL, (*total) +1);
+    result->field_buffer= new (std::nothrow) char[(*total) + 1];
     if (result->field_buffer == NULL)
     {
       drizzle_set_error(result->con, __func__, "Failed to allocate.");
@@ -176,7 +176,7 @@
 {
   if (field)
   {
-    free(field);
+    delete[] field;
   }
 }
 

=== modified file 'libdrizzle/result.cc'
--- libdrizzle/result.cc	2013-01-13 22:31:54 +0000
+++ libdrizzle/result.cc	2013-01-15 13:40:33 +0000
@@ -327,9 +327,15 @@
       }
       if (result->binary_rows)
       {
-        result->null_bitmap_list= (uint8_t**)realloc(result->null_bitmap_list, sizeof(uint8_t*) * ((size_t)(result->row_list_size) + DRIZZLE_ROW_GROW_SIZE));
+        uint8_t **null_bitmap_list= (uint8_t**)realloc(result->null_bitmap_list, sizeof(uint8_t*) * ((size_t)(result->row_list_size) + DRIZZLE_ROW_GROW_SIZE));
+        if (null_bitmap_list == NULL)
+        {
+          drizzle_row_free(result, row);
+          drizzle_set_error(result->con, __func__, "Failed to realloc null_bitmap_list.");
+          return DRIZZLE_RETURN_MEMORY;
+        }
+        result->null_bitmap_list= null_bitmap_list;
       }
-
       result->row_list= row_list;
 
       field_sizes_list= (size_t **)realloc(result->field_sizes_list, sizeof(size_t *) * ((size_t)(result->row_list_size) + DRIZZLE_ROW_GROW_SIZE));

=== modified file 'libdrizzle/row.cc'
--- libdrizzle/row.cc	2012-12-23 01:05:57 +0000
+++ libdrizzle/row.cc	2013-01-15 13:40:33 +0000
@@ -105,7 +105,7 @@
       return NULL;
     }
 
-    result->row= (drizzle_row_t)realloc(NULL, (sizeof(drizzle_field_t) + sizeof(size_t)) * result->column_count);
+    result->row= new (std::nothrow) drizzle_field_t[sizeof(size_t) * result->column_count];
     if (result->row == NULL)
     {
       drizzle_set_error(result->con, __func__, "Failed to allocate.");
@@ -126,7 +126,7 @@
     {
       if (*ret_ptr != DRIZZLE_RETURN_IO_WAIT)
       {
-        free(result->row);
+        delete[] result->row;
         result->row= NULL;
         result->field_sizes= NULL;
       }
@@ -159,7 +159,7 @@
     drizzle_field_free(row[x]);
   }
 
-  free(row);
+  delete[] row;
 }
 
 size_t *drizzle_row_field_sizes(drizzle_result_st *result)

=== modified file 'libdrizzle/statement.cc'
--- libdrizzle/statement.cc	2013-01-13 19:26:36 +0000
+++ libdrizzle/statement.cc	2013-01-15 13:40:33 +0000
@@ -416,6 +416,7 @@
   while((column= drizzle_column_next(stmt->execute_result)))
   {
     drizzle_bind_st *param= &stmt->result_params[column_counter];
+    param->type= column->type;
     /* if this row is null in the result bitmap */
     if (*stmt->execute_result->null_bitmap & ((column_counter^2) << 2))
     {
@@ -433,9 +434,6 @@
         param->options.is_unsigned= true;
       }
 
-      param->data= realloc(param->data, param->length);
-      param->type= column->type;
-
       switch(column->type)
       {
         case DRIZZLE_COLUMN_TYPE_NULL:
@@ -447,30 +445,37 @@
           break;
         case DRIZZLE_COLUMN_TYPE_SHORT:
         case DRIZZLE_COLUMN_TYPE_YEAR:
+          param->data= param->data_buffer;
           short_data= drizzle_get_byte2(row[column_counter]);
           memcpy(param->data, &short_data, 2);
           break;
         case DRIZZLE_COLUMN_TYPE_INT24:
         case DRIZZLE_COLUMN_TYPE_LONG:
+          param->data= param->data_buffer;
           long_data= drizzle_get_byte4(row[column_counter]);
           memcpy(param->data, &long_data, 4);
           break;
         case DRIZZLE_COLUMN_TYPE_LONGLONG:
+          param->data= param->data_buffer;
           longlong_data= drizzle_get_byte8(row[column_counter]);
           memcpy(param->data, &longlong_data, 8);
           break;
         case DRIZZLE_COLUMN_TYPE_FLOAT:
+          param->data= param->data_buffer;
           memcpy(param->data, row[column_counter], 4);
           break;
         case DRIZZLE_COLUMN_TYPE_DOUBLE:
+          param->data= param->data_buffer;
           memcpy(param->data, row[column_counter], 8);
           break;
         case DRIZZLE_COLUMN_TYPE_TIME:
+          param->data= param->data_buffer;
           drizzle_unpack_time(row[column_counter], param->length, (unsigned char*)param->data);
           break;
         case DRIZZLE_COLUMN_TYPE_DATE:
         case DRIZZLE_COLUMN_TYPE_DATETIME:
         case DRIZZLE_COLUMN_TYPE_TIMESTAMP:
+          param->data= param->data_buffer;
           drizzle_unpack_datetime(row[column_counter], param->length, (unsigned char*)param->data);
           break;
         case DRIZZLE_COLUMN_TYPE_TINY_BLOB:
@@ -483,7 +488,7 @@
         case DRIZZLE_COLUMN_TYPE_DECIMAL:
         case DRIZZLE_COLUMN_TYPE_NEWDECIMAL:
         case DRIZZLE_COLUMN_TYPE_NEWDATE:
-          memcpy(param->data, row[column_counter], param->length);
+          param->data= row[column_counter];
           break;
         /* These types aren't handled yet, most are for older MySQL versions */
         case DRIZZLE_COLUMN_TYPE_VARCHAR:
@@ -547,18 +552,14 @@
   delete[] stmt->null_bitmap;
   for (uint16_t x= 0; x < stmt->param_count; x++)
   {
-    if (stmt->query_params[x].options.is_allocated)
-    {
-      free(stmt->query_params[x].data);
-    }
+    delete[] stmt->query_params[x].data_buffer;
   }
   delete[] stmt->query_params;
   if (stmt->execute_result)
   {
     for (uint16_t x= 0; x < stmt->execute_result->column_count; x++)
     {
-      free(stmt->result_params[x].data);
-      free(stmt->result_params[x].converted_data);
+      delete[] stmt->result_params[x].data_buffer;
     }
     delete[] stmt->result_params;
     drizzle_result_free(stmt->execute_result);

=== modified file 'libdrizzle/statement_local.h'
--- libdrizzle/statement_local.h	2013-01-05 15:56:07 +0000
+++ libdrizzle/statement_local.h	2013-01-15 13:40:33 +0000
@@ -41,7 +41,7 @@
 extern "C" {
 #endif
 
-drizzle_return_t drizzle_stmt_set_param(drizzle_stmt_st *stmt, uint16_t param_num, drizzle_column_type_t type, void *data, uint32_t length, bool is_unsigned, bool is_allocated);
+drizzle_return_t drizzle_stmt_set_param(drizzle_stmt_st *stmt, uint16_t param_num, drizzle_column_type_t type, void *data, uint32_t length, bool is_unsigned);
 
 char *long_to_string(drizzle_bind_st *param, uint32_t val);
 

=== modified file 'libdrizzle/statement_param.cc'
--- libdrizzle/statement_param.cc	2013-01-05 11:25:32 +0000
+++ libdrizzle/statement_param.cc	2013-01-15 13:40:33 +0000
@@ -39,7 +39,7 @@
 #include "libdrizzle/common.h"
 
 /* Internal function */
-drizzle_return_t drizzle_stmt_set_param(drizzle_stmt_st *stmt, uint16_t param_num, drizzle_column_type_t type, void *data, uint32_t length, bool is_unsigned, bool is_allocated)
+drizzle_return_t drizzle_stmt_set_param(drizzle_stmt_st *stmt, uint16_t param_num, drizzle_column_type_t type, void *data, uint32_t length, bool is_unsigned)
 {
   if ((stmt == NULL) || (param_num >= stmt->param_count) || (data == NULL))
   {
@@ -55,7 +55,6 @@
   stmt->query_params[param_num].data= data;
   stmt->query_params[param_num].length= length;
   stmt->query_params[param_num].options.is_unsigned= is_unsigned;
-  stmt->query_params[param_num].options.is_allocated= is_allocated;
   stmt->query_params[param_num].is_bound= true;
 
   return DRIZZLE_RETURN_OK;
@@ -65,77 +64,70 @@
 drizzle_return_t drizzle_stmt_set_tiny(drizzle_stmt_st *stmt, uint16_t param_num, uint8_t value, bool is_unsigned)
 {
   uint8_t *val;
-  stmt->query_params[param_num].data = realloc(stmt->query_params[param_num].data, sizeof(uint8_t));
-  val= (uint8_t*) stmt->query_params[param_num].data;
+  val= (uint8_t*) stmt->query_params[param_num].data_buffer;
   *val= value;
 
-  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_TINY, val, 1, is_unsigned, false);
+  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_TINY, val, 1, is_unsigned);
 }
 drizzle_return_t drizzle_stmt_set_short(drizzle_stmt_st *stmt, uint16_t param_num, uint16_t value, bool is_unsigned)
 {
   uint16_t *val;
-  stmt->query_params[param_num].data = realloc(stmt->query_params[param_num].data, sizeof(uint16_t));
-  val= (uint16_t*) stmt->query_params[param_num].data;
+  val= (uint16_t*) stmt->query_params[param_num].data_buffer;
   *val= value;
 
-  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_SHORT, val, 2, is_unsigned, false);
+  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_SHORT, val, 2, is_unsigned);
 }
 
 drizzle_return_t drizzle_stmt_set_int(drizzle_stmt_st *stmt, uint16_t param_num, uint32_t value, bool is_unsigned)
 {
   uint32_t *val;
-  stmt->query_params[param_num].data = realloc(stmt->query_params[param_num].data, sizeof(uint32_t));
-  val= (uint32_t*) stmt->query_params[param_num].data;
+  val= (uint32_t*) stmt->query_params[param_num].data_buffer;
   *val= value;
 
-  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_LONG, val, 4, is_unsigned, true);
+  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_LONG, val, 4, is_unsigned);
 }
 
 drizzle_return_t drizzle_stmt_set_bigint(drizzle_stmt_st *stmt, uint16_t param_num, uint64_t value, bool is_unsigned)
 {
   uint64_t *val;
-  stmt->query_params[param_num].data = realloc(stmt->query_params[param_num].data, sizeof(uint64_t));
-  val= (uint64_t*) stmt->query_params[param_num].data;
+  val= (uint64_t*) stmt->query_params[param_num].data_buffer;
   *val= value;
 
-  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_LONGLONG, val, 8, is_unsigned, false);
+  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_LONGLONG, val, 8, is_unsigned);
 }
 
 drizzle_return_t drizzle_stmt_set_double(drizzle_stmt_st *stmt, uint16_t param_num, double value)
 {
   double *val;
-  stmt->query_params[param_num].data = realloc(stmt->query_params[param_num].data, sizeof(double));
-  val= (double*) stmt->query_params[param_num].data;
+  val= (double*) stmt->query_params[param_num].data_buffer;
   *val= value;
 
-  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_DOUBLE, val, 8, false, false);
+  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_DOUBLE, val, 8, false);
 }
 
 drizzle_return_t drizzle_stmt_set_float(drizzle_stmt_st *stmt, uint16_t param_num, float value)
 {
   float *val;
-  stmt->query_params[param_num].data = realloc(stmt->query_params[param_num].data, sizeof(float));
-  val= (float*) stmt->query_params[param_num].data;
+  val= (float*) stmt->query_params[param_num].data_buffer;
   *val= value;
 
-  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_FLOAT, val, 4, false, false);
+  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_FLOAT, val, 4, false);
 }
 
 drizzle_return_t drizzle_stmt_set_string(drizzle_stmt_st *stmt, uint16_t param_num, char *value, size_t length)
 {
-  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_STRING, value, length, false, false);
+  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_STRING, value, length, false);
 }
 
 drizzle_return_t drizzle_stmt_set_null(drizzle_stmt_st *stmt, uint16_t param_num)
 {
-  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_NULL, NULL, 0, false, false);
+  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_NULL, NULL, 0, false);
 }
 
 drizzle_return_t drizzle_stmt_set_time(drizzle_stmt_st *stmt, uint16_t param_num, uint32_t days, uint8_t hours, uint8_t minutes, uint8_t seconds, uint32_t microseconds, bool is_negative)
 {
   drizzle_datetime_st *time;
-  stmt->query_params[param_num].data = realloc(stmt->query_params[param_num].data, sizeof(drizzle_datetime_st));
-  time= (drizzle_datetime_st*) stmt->query_params[param_num].data;
+  time= (drizzle_datetime_st*) stmt->query_params[param_num].data_buffer;
 
   time->negative= is_negative;
   time->day= days;
@@ -145,14 +137,13 @@
   time->microsecond= microseconds;
 
   /* Length not important because we will figure that out when packing */
-  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_TIME, time, 0, false, true);
+  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_TIME, time, 0, false);
 }
 
 drizzle_return_t drizzle_stmt_set_timestamp(drizzle_stmt_st *stmt, uint16_t param_num, uint16_t year, uint8_t month, uint8_t day, uint8_t hours, uint8_t minutes, uint8_t seconds, uint32_t microseconds)
 {
   drizzle_datetime_st *timestamp;
-  stmt->query_params[param_num].data = realloc(stmt->query_params[param_num].data, sizeof(drizzle_datetime_st));
-  timestamp= (drizzle_datetime_st*) stmt->query_params[param_num].data;
+  timestamp= (drizzle_datetime_st*) stmt->query_params[param_num].data_buffer;
 
   timestamp->negative= false;
   timestamp->year= year;
@@ -165,7 +156,7 @@
   timestamp->microsecond= microseconds;
 
   /* Length not important because we will figure that out when packing */ 
-  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_TIME, timestamp, 0, false, true);
+  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_TIME, timestamp, 0, false);
 }
 
 bool drizzle_stmt_get_is_null_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr)
@@ -582,70 +573,70 @@
 
 char *long_to_string(drizzle_bind_st *param, uint32_t val)
 {
-  /* Max length is -INT32_MAX + NUL = 12 */
-  param->converted_data= (char*)realloc(param->converted_data, 12);
+  /* Pick an empty point in the buffer to make the str */
+  char* buffer= param->data_buffer + 50;
   if (param->options.is_unsigned)
   {
-    snprintf(param->converted_data, 12, "%"PRIu32, val);
+    snprintf(buffer, 12, "%"PRIu32, val);
   }
   else
   {
-    snprintf(param->converted_data, 12, "%"PRId32, (int32_t)val);
+    snprintf(buffer, 12, "%"PRId32, (int32_t)val);
   }
-  return param->converted_data;
+  return buffer;
 }
 
 char *longlong_to_string(drizzle_bind_st *param, uint64_t val)
 { 
   /* Max length is -INT64_MAX + NUL = 21 */
-  param->converted_data= (char*)realloc(param->converted_data, 21);
+  char* buffer= param->data_buffer + 50;
   if (param->options.is_unsigned)
   { 
-    snprintf(param->converted_data, 21, "%"PRIu64, val);
+    snprintf(buffer, 21, "%"PRIu64, val);
   }
   else
   {
-    snprintf(param->converted_data, 21, "%"PRId64, (int64_t)val);
+    snprintf(buffer, 21, "%"PRId64, (int64_t)val);
   }
-  return param->converted_data;
+  return buffer;
 }
 
 char *double_to_string(drizzle_bind_st *param, double val)
 { 
   /* Max length is 23 */
-  param->converted_data= (char*)realloc(param->converted_data, 23);
-  snprintf(param->converted_data, 23, "%f", val);
-  return param->converted_data;
+  char* buffer= param->data_buffer + 50;
+  snprintf(buffer, 23, "%f", val);
+  return buffer;
 }
 
 char *time_to_string(drizzle_bind_st *param, drizzle_datetime_st *time)
 {
   /* Max time is -HHH:MM:SS.ssssss + NUL = 17 */
-  param->converted_data= (char*)realloc(param->converted_data, 17);
+  char* buffer= param->data_buffer + 50;
   if (time->microsecond == 0)
   {
-    snprintf(param->converted_data, 17, "%s%"PRIu16":%"PRIu8":%"PRIu8, (time->negative) ? "-" : "", time->hour, time->minute, time->second);
+    snprintf(buffer, 17, "%s%"PRIu16":%"PRIu8":%"PRIu8, (time->negative) ? "-" : "", time->hour, time->minute, time->second);
   }
   else
   {
-    snprintf(param->converted_data, 17, "%s%"PRIu16":%"PRIu8":%"PRIu8".%"PRIu32, (time->negative) ? "-" : "", time->hour, time->minute, time->second, time->microsecond);
+    snprintf(buffer, 17, "%s%"PRIu16":%"PRIu8":%"PRIu8".%"PRIu32, (time->negative) ? "-" : "", time->hour, time->minute, time->second, time->microsecond);
   }
-  return param->converted_data;
+  return buffer;
 }
 
 char *timestamp_to_string(drizzle_bind_st *param, drizzle_datetime_st *timestamp)
 {
   /* Max timestamp is YYYY-MM-DD HH:MM:SS.ssssss + NUL = 26 */
-  param->converted_data= (char*)realloc(param->converted_data, 26);
+  char* buffer= param->data_buffer + 50;
   if (timestamp->microsecond == 0)
   {
-    snprintf(param->converted_data, 26, "%"PRIu16"-%"PRIu8"-%"PRIu32" %"PRIu16":%"PRIu8":%"PRIu8, timestamp->year, timestamp->month, timestamp->day, timestamp->hour, timestamp->minute, timestamp->second);
+    snprintf(buffer, 26, "%"PRIu16"-%"PRIu8"-%"PRIu32" %"PRIu16":%"PRIu8":%"PRIu8, timestamp->year, timestamp->month, timestamp->day, timestamp->hour, timestamp->minute, timestamp->second);
   }
   else
   {
-    snprintf(param->converted_data, 26, "%"PRIu16"-%"PRIu8"-%"PRIu32" %"PRIu16":%"PRIu8":%"PRIu8".%"PRIu32, timestamp->year, timestamp->month, timestamp->day, timestamp->hour, timestamp->minute, timestamp->second, timestamp->microsecond);
+    snprintf(buffer, 26, "%"PRIu16"-%"PRIu8"-%"PRIu32" %"PRIu16":%"PRIu8":%"PRIu8".%"PRIu32, timestamp->year, timestamp->month, timestamp->day, timestamp->hour, timestamp->minute, timestamp->second, timestamp->microsecond);
   }
-  return param->converted_data;
+  return buffer;
 }
 
 uint16_t drizzle_stmt_column_lookup(drizzle_result_st *result, const char *column_name, drizzle_return_t *ret_ptr)

=== modified file 'libdrizzle/structs.h'
--- libdrizzle/structs.h	2013-01-13 22:31:54 +0000
+++ libdrizzle/structs.h	2013-01-15 13:40:33 +0000
@@ -456,30 +456,29 @@
 {
   drizzle_column_type_t type;
   void *data;
+  char *data_buffer;
   uint32_t length;
   bool is_bound;
-  char *converted_data;
   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)
+      is_long_data(false)
     { }
   } options;
   drizzle_bind_st() :
     type(DRIZZLE_COLUMN_TYPE_NONE),
     data(NULL),
     length(0),
-    is_bound(false),
-    converted_data(NULL)
-  { }
+    is_bound(false)
+  { 
+    data_buffer= new (std::nothrow) char[128];
+  }
 };
 
 #ifdef __cplusplus