Merge lp:~linuxjedi/libdrizzle/5.1-con-opts2 into lp:libdrizzle

[Andrew Hutchings]

Split out con options into state and options

[lp:~linuxjedi/libdrizzle/5.1-con-opts2]

97. By Andrew Hutchings on 2013-01-26

Make con options safer

=== modified file 'libdrizzle-5.1/conn.h'
--- libdrizzle-5.1/conn.h	2013-01-05 10:27:32 +0000
+++ libdrizzle-5.1/conn.h	2013-01-26 23:33:19 +0000
@@ -134,48 +134,47 @@
 DRIZZLE_API
 const char *drizzle_sqlstate(const drizzle_st *con);
 
-/**
- * Get options for a connection.
- *
- * @param[in] con Connection structure previously initialized with
- *  drizzle_create(), drizzle_clone(), or related functions.
- * @return Options set for the connection structure.
- */
-DRIZZLE_API
-drizzle_options_t drizzle_options(const drizzle_st *con);
-
-/**
- * Set options for a connection.
- *
- * @param[in] con Connection structure previously initialized with
- *  drizzle_create(), drizzle_clone(), or related functions.
- * @param[in] options Available options for connection structure to set.
- */
-DRIZZLE_API
-void drizzle_set_options(drizzle_st *con,
-                             drizzle_options_t options);
-
-/**
- * Add options for a connection.
- *
- * @param[in] con Connection structure previously initialized with
- *  drizzle_create(), drizzle_clone(), or related functions.
- * @param[in] options Available options for connection structure to set.
- */
-DRIZZLE_API
-void drizzle_add_options(drizzle_st *con,
-                             drizzle_options_t options);
-
-/**
- * Remove options for a connection.
- *
- * @param[in] con Connection structure previously initialized with
- *  drizzle_create(), drizzle_clone(), or related functions.
- * @param[in] options Available options for connection structure to remove.
- */
-DRIZZLE_API
-void drizzle_remove_options(drizzle_st *con,
-                                drizzle_options_t options);
+DRIZZLE_API
+drizzle_options_st *drizzle_options_create(void);
+
+DRIZZLE_API
+void drizzle_options_destroy(drizzle_options_st *options);
+
+DRIZZLE_API
+void drizzle_options_set_non_blocking(drizzle_options_st *options, bool state);
+
+DRIZZLE_API
+bool drizzle_options_get_non_blocking(drizzle_options_st *options);
+
+DRIZZLE_API
+void drizzle_options_set_raw_scramble(drizzle_options_st *options, bool state);
+
+DRIZZLE_API
+bool drizzle_options_get_raw_scramble(drizzle_options_st *options);
+
+DRIZZLE_API
+void drizzle_options_set_found_rows(drizzle_options_st *options, bool state);
+
+DRIZZLE_API
+bool drizzle_options_get_found_rows(drizzle_options_st *options);
+
+DRIZZLE_API
+void drizzle_options_set_interactive(drizzle_options_st *options, bool state);
+
+DRIZZLE_API
+bool drizzle_options_get_interactive(drizzle_options_st *option);
+
+DRIZZLE_API
+void drizzle_options_set_multi_statements(drizzle_options_st *options, bool state);
+
+DRIZZLE_API
+bool drizzle_options_get_multi_statements(drizzle_options_st *options);
+
+DRIZZLE_API
+void drizzle_options_set_auth_plugin(drizzle_options_st *options, bool state);
+
+DRIZZLE_API
+bool drizzle_options_get_auth_plugin(drizzle_options_st *options);
 
 /**
  * Get TCP host for a connection.

=== modified file 'libdrizzle-5.1/constants.h'
--- libdrizzle-5.1/constants.h	2013-01-13 19:26:36 +0000
+++ libdrizzle-5.1/constants.h	2013-01-26 23:33:19 +0000
@@ -98,29 +98,6 @@
 
 /** @} */
 
-/**
- * @ingroup drizzle_con
- * Options for drizzle_st.
- */
-enum drizzle_options_t
-{
-  DRIZZLE_CON_NONE=                 0,
-  DRIZZLE_CON_OPTIONS_NON_BLOCKING= (1 << 0),
-  DRIZZLE_CON_RAW_PACKET=           (1 << 2),
-  DRIZZLE_CON_RAW_SCRAMBLE=         (1 << 3),
-  DRIZZLE_CON_READY=                (1 << 4),
-  DRIZZLE_CON_NO_RESULT_READ=       (1 << 5),
-  DRIZZLE_CON_IO_READY=             (1 << 6),
-  DRIZZLE_CON_FOUND_ROWS=           (1 << 9),
-  DRIZZLE_CON_INTERACTIVE=          (1 << 11),
-  DRIZZLE_CON_MULTI_STATEMENTS=     (1 << 12),
-  DRIZZLE_CON_AUTH_PLUGIN=          (1 << 13)
-};
-
-#ifndef __cplusplus
-typedef enum drizzle_options_t drizzle_options_t;
-#endif
-
 #ifndef __cplusplus
 typedef enum drizzle_socket_t drizzle_socket_t;
 #endif
@@ -583,6 +560,7 @@
 typedef struct drizzle_tcp_st drizzle_tcp_st;
 typedef struct drizzle_uds_st drizzle_uds_st;
 typedef struct drizzle_st drizzle_st;
+typedef struct drizzle_options_st drizzle_options_st;
 typedef struct drizzle_result_st drizzle_result_st;
 typedef struct drizzle_column_st drizzle_column_st;
 typedef struct drizzle_binlog_st drizzle_binlog_st;

=== modified file 'libdrizzle-5.1/drizzle_client.h'
--- libdrizzle-5.1/drizzle_client.h	2013-01-05 15:46:05 +0000
+++ libdrizzle-5.1/drizzle_client.h	2013-01-26 23:33:19 +0000
@@ -98,7 +98,7 @@
 drizzle_st *drizzle_create_tcp(const char *host, in_port_t port,
                                     const char *user, const char *password,
                                     const char *db,
-                                    drizzle_options_t options);
+                                    drizzle_options_st *options);
 
 /**
  * Add unix domain socket connection with common arguments.
@@ -113,7 +113,7 @@
 DRIZZLE_API
 drizzle_st *drizzle_create_uds(const char *uds, const char *user,
                                     const char *password, const char *db,
-                                    drizzle_options_t options);
+                                    drizzle_options_st *options);
 
 /** @} */
 

=== modified file 'libdrizzle/command.cc'
--- libdrizzle/command.cc	2013-01-13 18:54:59 +0000
+++ libdrizzle/command.cc	2013-01-26 23:33:19 +0000
@@ -157,8 +157,7 @@
   {
     drizzle_state_pop(con);
 
-    if (!(con->options & (DRIZZLE_CON_RAW_PACKET |
-                          DRIZZLE_CON_NO_RESULT_READ)) &&
+    if (!(con->state.raw_packet || con->state.no_result_read) &&
         con->command != DRIZZLE_COMMAND_FIELD_LIST)
     {
       drizzle_state_push(con, drizzle_state_result_read);

=== modified file 'libdrizzle/conn.cc'
--- libdrizzle/conn.cc	2013-01-14 21:18:05 +0000
+++ libdrizzle/conn.cc	2013-01-26 23:33:19 +0000
@@ -220,7 +220,7 @@
 
   __closesocket(con->fd);
 
-  con->options = (drizzle_options_t)((int)con->options & (int)~DRIZZLE_CON_READY);
+  con->state.ready= false;
   con->packet_number= 0;
   con->buffer_ptr= con->buffer;
   con->buffer_size= 0;
@@ -250,7 +250,7 @@
   }
 
   if (revents != 0)
-    con->options = (drizzle_options_t)((int)con->options | (int)DRIZZLE_CON_IO_READY);
+    con->state.io_ready= true;
 
   con->revents= revents;
 
@@ -300,47 +300,122 @@
   return con->sqlstate;
 }
 
-drizzle_options_t drizzle_options(const drizzle_st *con)
-{
-  if (con == NULL)
-  {
-    return DRIZZLE_CON_NONE;
-  }
-
-  return drizzle_options_t(con->options);
-}
-
-void drizzle_set_options(drizzle_st *con,
-                             drizzle_options_t options)
-{
-  if (con == NULL)
-  {
-    return;
-  }
-
-  con->options= options;
-}
-
-void drizzle_add_options(drizzle_st *con,
-                             drizzle_options_t options)
-{
-  if (con == NULL)
-  {
-    return;
-  }
-
-  con->options = (drizzle_options_t)((int)con->options | (int)options);
-}
-
-void drizzle_remove_options(drizzle_st *con,
-                                drizzle_options_t options)
-{
-  if (con == NULL)
-  {
-    return;
-  }
-
-  con->options = (drizzle_options_t)((int) con->options & (int)~options);
+drizzle_options_st *drizzle_options_create(void)
+{
+  return new (std::nothrow) drizzle_options_st;
+}
+
+void drizzle_options_destroy(drizzle_options_st *options)
+{
+  delete options;
+}
+
+void drizzle_options_set_non_blocking(drizzle_options_st *options, bool state)
+{
+  if (options == NULL)
+  {
+    return;
+  }
+  options->non_blocking= state;
+}
+
+bool drizzle_options_get_non_blocking(drizzle_options_st *options)
+{
+  if (options == NULL)
+  {
+    return false;
+  }
+  return options->non_blocking;
+}
+
+void drizzle_options_set_raw_scramble(drizzle_options_st *options, bool state)
+{
+  if (options == NULL)
+  {
+    return;
+  }
+  options->raw_scramble= state;
+}
+
+bool drizzle_options_get_raw_scramble(drizzle_options_st *options)
+{
+  if (options == NULL)
+  {
+    return false;
+  }
+  return options->raw_scramble;
+}
+
+void drizzle_options_set_found_rows(drizzle_options_st *options, bool state)
+{
+  if (options == NULL)
+  {
+    return;
+  }
+  options->found_rows= state;
+}
+
+bool drizzle_options_get_found_rows(drizzle_options_st *options)
+{
+  if (options == NULL)
+  {
+    return false;
+  }
+  return options->found_rows;
+}
+
+void drizzle_options_set_interactive(drizzle_options_st *options, bool state)
+{
+  if (options == NULL)
+  {
+    return;
+  }
+  options->interactive= state;
+}
+
+bool drizzle_options_get_interactive(drizzle_options_st *options)
+{
+  if (options == NULL)
+  {
+    return false;
+  }
+  return options->interactive;
+}
+
+void drizzle_options_set_multi_statements(drizzle_options_st *options, bool state)
+{
+  if (options == NULL)
+  {
+    return;
+  }
+  options->multi_statements= state;
+}
+
+bool drizzle_options_get_multi_statements(drizzle_options_st *options)
+{
+  if (options == NULL)
+  {
+    return false;
+  }
+  return options->multi_statements;
+}
+
+void drizzle_options_set_auth_plugin(drizzle_options_st *options, bool state)
+{
+  if (options == NULL)
+  {
+    return;
+  }
+  options->auth_plugin= state;
+}
+
+bool drizzle_options_get_auth_plugin(drizzle_options_st *options)
+{
+  if (options == NULL)
+  {
+    return false;
+  }
+  return options->auth_plugin;
 }
 
 const char *drizzle_host(const drizzle_st *con)
@@ -610,14 +685,14 @@
     return DRIZZLE_RETURN_INVALID_ARGUMENT;
   }
 
-  if (con->options & DRIZZLE_CON_READY)
+  if (con->state.ready)
   {
     return DRIZZLE_RETURN_OK;
   }
 
   if (drizzle_state_none(con))
   {
-    if (!(con->options & DRIZZLE_CON_RAW_PACKET))
+    if (con->state.raw_packet == false)
     {
       drizzle_state_push(con, drizzle_state_handshake_server_read);
       drizzle_state_push(con, drizzle_state_packet_read);
@@ -721,9 +796,9 @@
 
   drizzle_result_st *old_result;
 
-  if (!(con->options & DRIZZLE_CON_READY))
+  if (con->state.ready == false)
   {
-    if (con->options & DRIZZLE_CON_RAW_PACKET)
+    if (con->state.raw_packet)
     {
       drizzle_set_error(con, "drizzle_command_write",
                         "connection not ready");
@@ -740,7 +815,7 @@
 
   if (drizzle_state_none(con))
   {
-    if (con->options & (DRIZZLE_CON_RAW_PACKET | DRIZZLE_CON_NO_RESULT_READ))
+    if (con->state.raw_packet || con->state.no_result_read)
     {
       con->result= NULL;
     }
@@ -1097,7 +1172,7 @@
     }
 
     ret= drizzle_set_events(con, POLLOUT);
-    if (con->options & DRIZZLE_CON_OPTIONS_NON_BLOCKING)
+    if (con->options.non_blocking)
     {
       return DRIZZLE_RETURN_IO_WAIT;
     }
@@ -1133,7 +1208,7 @@
   }
 
   if ((con->revents & POLLIN) == 0 &&
-      (con->options & DRIZZLE_CON_OPTIONS_NON_BLOCKING))
+      (con->options.non_blocking))
   {
     /* non-blocking mode: return IO_WAIT instead of attempting to read. This
      * avoids reading immediately after writing a command, which typically
@@ -1225,7 +1300,7 @@
             return ret;
           }
 
-          if (con->options & DRIZZLE_CON_OPTIONS_NON_BLOCKING)
+          if (con->options.non_blocking)
           {
             return DRIZZLE_RETURN_IO_WAIT;
           }
@@ -1332,7 +1407,7 @@
           return ret;
         }
 
-        if (con->options & DRIZZLE_CON_OPTIONS_NON_BLOCKING)
+        if (con->options.non_blocking)
         {
           return DRIZZLE_RETURN_IO_WAIT;
         }

=== modified file 'libdrizzle/drizzle.cc'
--- libdrizzle/drizzle.cc	2013-01-13 19:26:36 +0000
+++ libdrizzle/drizzle.cc	2013-01-26 23:33:19 +0000
@@ -268,9 +268,9 @@
   /* We can't keep state between calls since connections may be removed during
      processing. If this list ever gets big, we may want something faster. */
 
-  if (con->options & DRIZZLE_CON_IO_READY)
+  if (con->state.io_ready)
   {
-    con->options = (drizzle_options_t)((int)con->options & (int)~DRIZZLE_CON_IO_READY);
+    con->state.io_ready= false;
     return con;
   }
 
@@ -284,7 +284,7 @@
 drizzle_st *drizzle_create_tcp(const char *host, in_port_t port,
                                const char *user, const char *password,
                                const char *db,
-                               drizzle_options_t options)
+                               drizzle_options_st *options)
 {
   drizzle_st *con= drizzle_create();
   if (con == NULL)
@@ -295,14 +295,17 @@
   drizzle_set_tcp(con, host, port);
   drizzle_set_auth(con, user, password);
   drizzle_set_db(con, db);
-  drizzle_add_options(con, options);
+  if (options != NULL)
+  {
+    con->options= *options;
+  }
 
   return con;
 }
 
 drizzle_st *drizzle_create_uds(const char *uds, const char *user,
                                     const char *password, const char *db,
-                                    drizzle_options_t options)
+                                    drizzle_options_st *options)
 {
   drizzle_st *con;
 
@@ -315,7 +318,10 @@
   drizzle_set_uds(con, uds);
   drizzle_set_auth(con, user, password);
   drizzle_set_db(con, db);
-  drizzle_add_options(con, options);
+  if (options != NULL)
+  {
+    con->options= *options;
+  }
 
   return con;
 }

=== modified file 'libdrizzle/field.cc'
--- libdrizzle/field.cc	2013-01-15 13:37:21 +0000
+++ libdrizzle/field.cc	2013-01-26 23:33:19 +0000
@@ -257,7 +257,7 @@
   {
     con->result->field_size= con->packet_size;
 
-    if (con->options & DRIZZLE_CON_RAW_PACKET)
+    if (con->state.raw_packet)
     {
       con->result->options = (drizzle_result_options_t)((int)con->result->options | DRIZZLE_RESULT_ROW_BREAK);
     }

=== modified file 'libdrizzle/handshake.cc'
--- libdrizzle/handshake.cc	2013-01-13 18:54:59 +0000
+++ libdrizzle/handshake.cc	2013-01-26 23:33:19 +0000
@@ -200,7 +200,7 @@
 
   drizzle_state_pop(con);
 
-  if (!(con->options & DRIZZLE_CON_RAW_PACKET))
+  if (con->state.raw_packet == false)
   {
     drizzle_state_push(con, drizzle_state_handshake_result_read);
     drizzle_state_push(con, drizzle_state_packet_read);
@@ -481,20 +481,22 @@
   con->capabilities = (drizzle_capabilities_t)((int)con->capabilities | (int)DRIZZLE_CAPABILITIES_PROTOCOL_41);
 
   capabilities= con->capabilities & DRIZZLE_CAPABILITIES_CLIENT;
-  if (!(con->options & DRIZZLE_CON_FOUND_ROWS))
+  if (con->options.found_rows == false)
+  {
     capabilities&= ~DRIZZLE_CAPABILITIES_FOUND_ROWS;
+  }
 
-  if (con->options & DRIZZLE_CON_INTERACTIVE)
+  if (con->options.interactive)
   {
     capabilities|= DRIZZLE_CAPABILITIES_INTERACTIVE;
   }
 
-  if (con->options & DRIZZLE_CON_MULTI_STATEMENTS)
+  if (con->options.multi_statements)
   {
     capabilities|= DRIZZLE_CAPABILITIES_MULTI_STATEMENTS;
   }
 
-  if (con->options & DRIZZLE_CON_AUTH_PLUGIN)
+  if (con->options.auth_plugin)
   {
     capabilities|= DRIZZLE_CAPABILITIES_PLUGIN_AUTH;
   }
@@ -664,7 +666,7 @@
       }
       else
       {
-        con->options = (drizzle_options_t)((int)con->options | (int)DRIZZLE_CON_READY);
+        con->state.ready= true;
       }
     }
   }

=== modified file 'libdrizzle/pack.cc'
--- libdrizzle/pack.cc	2013-01-05 10:27:32 +0000
+++ libdrizzle/pack.cc	2013-01-26 23:33:19 +0000
@@ -356,7 +356,7 @@
   ptr[0]= 0;
   ptr++;
 
-  if (con->options & DRIZZLE_CON_RAW_SCRAMBLE && con->scramble != NULL)
+  if (con->options.raw_scramble && con->scramble != NULL)
   {
     ptr[0]= DRIZZLE_MAX_SCRAMBLE_SIZE;
     ptr++;
@@ -375,7 +375,7 @@
     ptr[0]= DRIZZLE_MAX_SCRAMBLE_SIZE;
     ptr++;
 
-    if (con->options & DRIZZLE_CON_AUTH_PLUGIN)
+    if (con->options.auth_plugin)
     {
       snprintf((char *)ptr, DRIZZLE_MAX_SCRAMBLE_SIZE, "%s", con->password);
       ptr[DRIZZLE_MAX_SCRAMBLE_SIZE-1]= 0;

=== modified file 'libdrizzle/statement.cc'
--- libdrizzle/statement.cc	2013-01-15 13:37:21 +0000
+++ libdrizzle/statement.cc	2013-01-26 23:33:19 +0000
@@ -334,10 +334,10 @@
   drizzle_set_byte2(&buffer[4], param_num);
   memcpy(&buffer[6], data, len);
 
-  stmt->con->options= (drizzle_options_t)((uint8_t)stmt->con->options | (uint8_t)DRIZZLE_CON_NO_RESULT_READ);
+  stmt->con->state.no_result_read= true;
   drizzle_command_write(stmt->con, NULL, DRIZZLE_COMMAND_STMT_SEND_LONG_DATA,
                         buffer, len+6, len+6, &ret);
-  stmt->con->options= (drizzle_options_t)((uint8_t)stmt->con->options & (uint8_t)~DRIZZLE_CON_NO_RESULT_READ);
+  stmt->con->state.no_result_read= false;
   stmt->query_params[param_num].options.is_long_data= true;
 
   delete[] buffer;
@@ -361,10 +361,10 @@
   }
 
   drizzle_set_byte4(buffer, stmt->id);
-  stmt->con->options= (drizzle_options_t)((uint8_t)stmt->con->options | (uint8_t)DRIZZLE_CON_NO_RESULT_READ);
+  stmt->con->state.no_result_read= true;
   drizzle_command_write(stmt->con, NULL, DRIZZLE_COMMAND_STMT_RESET, buffer, 4,
                         4, &ret);
-  stmt->con->options= (drizzle_options_t)((uint8_t)stmt->con->options & (uint8_t)~DRIZZLE_CON_NO_RESULT_READ);
+  stmt->con->state.no_result_read= false;
   if (stmt->execute_result)
   {
     drizzle_result_free(stmt->execute_result);
@@ -570,10 +570,10 @@
   }
 
   drizzle_set_byte4(buffer, stmt->id);
-  stmt->con->options= (drizzle_options_t)((uint8_t)stmt->con->options | (uint8_t)DRIZZLE_CON_NO_RESULT_READ);
+  stmt->con->state.no_result_read= true;
   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);
+  stmt->con->state.no_result_read= false;
   delete stmt;
   return ret;
 }

=== modified file 'libdrizzle/structs.h'
--- libdrizzle/structs.h	2013-01-15 13:37:21 +0000
+++ libdrizzle/structs.h	2013-01-26 23:33:19 +0000
@@ -147,6 +147,26 @@
 /**
  * @ingroup drizzle_con
  */
+
+struct drizzle_options_st
+{
+  bool non_blocking;
+  bool raw_scramble;
+  bool found_rows;
+  bool interactive;
+  bool multi_statements;
+  bool auth_plugin;
+
+  drizzle_options_st() :
+    non_blocking(false),
+    raw_scramble(false),
+    found_rows(false),
+    interactive(false),
+    multi_statements(false),
+    auth_plugin(false)
+  { }
+};
+
 struct drizzle_st
 {
   struct flags_t{
@@ -164,7 +184,22 @@
   drizzle_capabilities_t capabilities;
   drizzle_charset_t charset;
   drizzle_command_t command;
-  drizzle_options_t options;
+  struct state_t
+  {
+    bool ready;
+    bool no_result_read;
+    bool io_ready;
+    bool raw_packet;
+
+    state_t() :
+      ready(false),
+      no_result_read(false),
+      io_ready(false),
+      raw_packet(false)
+    { }
+  } state;
+  
+  drizzle_options_st options;
   drizzle_socket_t socket_type;
   drizzle_status_t status;
   uint32_t max_packet_size;
@@ -228,7 +263,6 @@
     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),