[prev in list] [next in list] [prev in thread] [next in thread]
List: pecl-cvs
Subject: [PECL-CVS] com =?UTF-8?Q?pecl/database/mysql=5Fxdevapi=3A=20orabug=20=23=33=30=31=33?= =?UTF-8?Q?=34
From: hery ramilison <mysqlre () php ! net>
Date: 2020-08-26 17:47:49
Message-ID: php-mail-99284806e4e415e313679ae4e7c396b7741832788 () git ! php ! net
[Download RAW message or body]
Commit: 478b595862381d466b75445922919acd60f026a2
Author: Darek Slusarczyk <dariusz.slusarczyk@oracle.com> Wed, 26 Aug 2020 \
19:47:49 +0200
Parents: 273abde1fe5b539d64784bc193fe162da6a149ff
Branches: release/8.0.23
Link: http://git.php.net/?p=pecl/database/mysql_xdevapi.git;a=commitdiff;h=478b595862381d466b75445922919acd60f026a2
Log:
orabug #30134451: mysqlndx replace raw zval with improved zvalue where possible
refactorings in:
- capabilities (wireprotocol, session / compression setup)
- util::zvalue - better support for std::initializer_list input
Bugs:
https://bugs.php.net/30134451
Changed paths:
M util/value.cc
M util/value.h
M util/value.inl
M xmysqlnd/xmysqlnd_compression_setup.cc
M xmysqlnd/xmysqlnd_crud_table_commands.cc
M xmysqlnd/xmysqlnd_session.cc
M xmysqlnd/xmysqlnd_session.h
M xmysqlnd/xmysqlnd_wireprotocol.cc
M xmysqlnd/xmysqlnd_wireprotocol.h
["diff_478b595862381d466b75445922919acd60f026a2.txt" (text/plain)]
diff --git a/util/value.cc b/util/value.cc
index 970757b1..25d0d7e9 100644
--- a/util/value.cc
+++ b/util/value.cc
@@ -203,9 +203,10 @@ zvalue::zvalue(const char* value, std::size_t length)
assign(value, length);
}
-zvalue::zvalue(std::initializer_list<std::pair<const char*, zvalue>> values)
+zvalue::zvalue(std::initializer_list<std::pair<string_view, zvalue>> values)
{
ZVAL_UNDEF(&zv);
+ reserve(values.size());
insert(values);
}
@@ -370,7 +371,6 @@ zvalue& zvalue::operator=(const char* value)
return *this;
}
-
zvalue& zvalue::operator=(const arg_string& value)
{
assign(value.c_str(), value.length());
@@ -384,8 +384,10 @@ void zvalue::assign(const char* value, std::size_t length)
ZVAL_STRINGL(&zv, value, length);
}
-zvalue& zvalue::operator=(std::initializer_list<std::pair<const char*, zvalue>> \
values) +zvalue& zvalue::operator=(std::initializer_list<std::pair<string_view, \
zvalue>> values) {
+ reset();
+ reserve(values.size());
insert(values);
return *this;
}
diff --git a/util/value.h b/util/value.h
index c010b39a..5c1b3585 100644
--- a/util/value.h
+++ b/util/value.h
@@ -74,7 +74,7 @@ class zvalue
zvalue(const arg_string& value);
zvalue(const char* value, std::size_t length);
- zvalue(std::initializer_list<std::pair<const char*, zvalue>> values);
+ zvalue(std::initializer_list<std::pair<string_view, zvalue>> values);
template<typename T>
zvalue(std::initializer_list<T> values);
@@ -123,7 +123,7 @@ class zvalue
void assign(const char* value, std::size_t length);
- zvalue& operator=(std::initializer_list<std::pair<const char*, zvalue>> values);
+ zvalue& operator=(std::initializer_list<std::pair<string_view, zvalue>> values);
template<typename T>
zvalue& operator=(std::initializer_list<T> values);
@@ -348,10 +348,8 @@ class zvalue
template<typename Key, typename Value>
void insert(const std::pair<Key, Value>& key_value);
- void insert(std::initializer_list<std::pair<const char*, zvalue>> values);
-
template<typename Key, typename Value>
- void append(std::initializer_list<std::pair<Key, Value>> values);
+ void insert(std::initializer_list<std::pair<Key, Value>> values);
// adds new item at the next free index
void push_back(const zvalue& value);
diff --git a/util/value.inl b/util/value.inl
index 9ca983ac..ca3a75e0 100644
--- a/util/value.inl
+++ b/util/value.inl
@@ -23,6 +23,7 @@ template<typename T>
zvalue::zvalue(std::initializer_list<T> values)
{
ZVAL_UNDEF(&zv);
+ reserve(values.size());
push_back(values);
}
@@ -75,6 +76,8 @@ zvalue::zvalue(const map<Key, Value>& values)
template<typename T>
zvalue& zvalue::operator=(std::initializer_list<T> values)
{
+ reset();
+ reserve(values.size());
push_back(values);
return *this;
}
@@ -82,6 +85,7 @@ zvalue& zvalue::operator=(std::initializer_list<T> values)
template<typename T>
zvalue& zvalue::operator=(const vector<T>& values)
{
+ reset();
reserve(values.size());
for (const auto& value : values) {
push_back(value);
@@ -92,6 +96,7 @@ zvalue& zvalue::operator=(const vector<T>& values)
template<typename T>
zvalue& zvalue::operator=(const set<T>& values)
{
+ reset();
reserve(values.size());
for (const auto& value : values) {
push_back(value);
@@ -102,6 +107,7 @@ zvalue& zvalue::operator=(const set<T>& values)
template<typename Key, typename Value>
zvalue& zvalue::operator=(const map<Key, Value>& values)
{
+ reset();
reserve(values.size());
for (const auto& value : values) {
insert(value.first, value.second);
@@ -771,15 +777,9 @@ void zvalue::insert(const std::pair<Key, Value>& key_value)
insert(key_value.first, key_value.second);
}
-inline void zvalue::insert(std::initializer_list<std::pair<const char*, zvalue>> \
values)
-{
- append(values);
-}
-
template<typename Key, typename Value>
-void zvalue::append(std::initializer_list<std::pair<Key, Value>> values)
+void zvalue::insert(std::initializer_list<std::pair<Key, Value>> values)
{
- reserve(values.size());
for_each(
values.begin(),
values.end(),
@@ -792,7 +792,6 @@ void zvalue::append(std::initializer_list<std::pair<Key, Value>> \
values) template<typename T>
void zvalue::push_back(std::initializer_list<T> values)
{
- reserve(values.size());
for (const auto& value : values) {
push_back(value);
}
diff --git a/xmysqlnd/xmysqlnd_compression_setup.cc \
b/xmysqlnd/xmysqlnd_compression_setup.cc index 7119a2e3..1bbae778 100644
--- a/xmysqlnd/xmysqlnd_compression_setup.cc
+++ b/xmysqlnd/xmysqlnd_compression_setup.cc
@@ -188,7 +188,7 @@ bool Negotiate::run(const Configuration& config)
"compression":{"algorithm": "deflate_stream", "server_max_combine_messages" : 10 \
}) "compression":{"algorithm": "lz4_message", "server_combine_mixed_messages" : true \
})
*/
- util::zvalue cap_compression_name("compression");
+ constexpr util::string_view cap_compression_name("compression");
util::zvalue cap_compression_value(util::zvalue::create_object());
cap_compression_value.set_property(PROPERTY_ALGORITHM, \
to_string(config.algorithm)); if (config.combine_mixed_messages) {
@@ -199,9 +199,8 @@ bool Negotiate::run(const Configuration& config)
}
st_xmysqlnd_msg__capabilities_set caps_set{ \
msg_factory.get__capabilities_set(&msg_factory) };
- zval* cap_names[]{cap_compression_name.ptr()};
- zval* cap_values[]{cap_compression_value.ptr()};
- if (caps_set.send_request(&caps_set, 1, cap_names, cap_values) != PASS) {
+ const util::zvalue capabilities = { {cap_compression_name, cap_compression_value} \
}; + if (caps_set.send_request(&caps_set, capabilities) != PASS) {
return false;
}
diff --git a/xmysqlnd/xmysqlnd_crud_table_commands.cc \
b/xmysqlnd/xmysqlnd_crud_table_commands.cc index bd17ad4a..31616eec 100644
--- a/xmysqlnd/xmysqlnd_crud_table_commands.cc
+++ b/xmysqlnd/xmysqlnd_crud_table_commands.cc
@@ -481,7 +481,7 @@ xmysqlnd_crud_table_update__add_operation(XMYSQLND_CRUD_TABLE_OP__UPDATE \
* obj, {
DBG_ENTER("xmysqlnd_crud_table_update__add_operation");
DBG_INF_FMT("operation=%s", \
Mysqlx::Crud::UpdateOperation::UpdateType_Name(op_type).c_str());
- DBG_INF_FMT("path=%*s value=%p is_expr=%u is_document=%u validate_array=%u", \
path.length(), path.data(), value, is_expression, is_document, validate_array); \
+ DBG_INF_FMT("path=%*s value=%p is_expr=%u is_document=%u validate_array=%u", \
path.length(), path.data(), value.ptr(), is_expression, is_document, validate_array); \
DBG_INF_FMT("value_type=%u", value.type());
switch (value.type()) {
diff --git a/xmysqlnd/xmysqlnd_session.cc b/xmysqlnd/xmysqlnd_session.cc
index 6235112d..6ab761da 100644
--- a/xmysqlnd/xmysqlnd_session.cc
+++ b/xmysqlnd/xmysqlnd_session.cc
@@ -99,23 +99,6 @@ inline bool is_tlsv13_supported() {
}
-zend_bool
-xmysqlnd_is_capability_present(
- const zval* capabilities,
- const std::string& cap_name,
- zend_bool* found
-)
-{
- zval* zv = zend_hash_str_find(Z_ARRVAL_P(capabilities), cap_name.c_str(), \
cap_name.length());
- if (!zv || Z_TYPE_P(zv) == IS_UNDEF) {
- *found = FALSE;
- return FALSE;
- }
- *found = TRUE;
- convert_to_boolean(zv);
- return Z_TYPE_P(zv) == IS_TRUE? TRUE:FALSE;
-}
-
} // anonymous namespace
bool set_connection_timeout(
@@ -215,39 +198,24 @@ xmysqlnd_session_data::get_scheme(
Mysqlx::Datatypes::Object*
xmysqlnd_session_data::prepare_client_attr_object()
{
- const std::size_t capa_count{ connection_attribs.size()};
Mysqlx::Datatypes::Object* values = new (std::nothrow) \
Mysqlx::Datatypes::Object; if(values){
- std::size_t idx{ 0 };
- for( ; idx < capa_count; ++idx) {
- std::unique_ptr<Mysqlx::Datatypes::Scalar> scalar{nullptr};
- std::unique_ptr<Mysqlx::Datatypes::Scalar_String> string_value{nullptr};
- std::unique_ptr<Mysqlx::Datatypes::Any> any{nullptr};
-
- const auto& connection_attrib = connection_attribs[idx];
+ for(const auto& [connection_attrib_key, connection_attrib_value] : \
connection_attribs) { Mysqlx::Datatypes::Object_ObjectField* field = \
values->add_fld();
-
- const auto& connection_attrib_key = connection_attrib.first;
field->set_key(connection_attrib_key.c_str(), connection_attrib_key.length());
- scalar.reset(new Mysqlx::Datatypes::Scalar);
- string_value.reset(new Mysqlx::Datatypes::Scalar_String);
- any.reset(new Mysqlx::Datatypes::Any);
-
- const auto& connection_attrib_value = connection_attrib.second;
+ std::unique_ptr string_value{ \
std::make_unique<Mysqlx::Datatypes::Scalar_String>() }; \
string_value->set_value(connection_attrib_value.c_str(), \
connection_attrib_value.length()); +
+ std::unique_ptr scalar{ std::make_unique<Mysqlx::Datatypes::Scalar>() };
scalar->set_type(Mysqlx::Datatypes::Scalar_Type_V_STRING);
scalar->set_allocated_v_string(string_value.release());
+ std::unique_ptr any{ std::make_unique<Mysqlx::Datatypes::Any>() };
any->set_allocated_scalar(scalar.release());
any->set_type( Mysqlx::Datatypes::Any_Type::Any_Type_SCALAR );
field->set_allocated_value(any.release());
}
-
- if( idx < capa_count ) {
- delete values;
- values = nullptr;
- }
}
return values;
}
@@ -265,49 +233,35 @@ xmysqlnd_session_data::send_client_attributes()
st_xmysqlnd_msg__capabilities_set caps_set{ \
msg_factory.get__capabilities_set(&msg_factory) }; st_xmysqlnd_msg__capabilities_get \
caps_get{ msg_factory.get__capabilities_get(&msg_factory) };
- zval ** capability_names = static_cast<zval**>( mnd_ecalloc(1 , sizeof(zval*)));
- zval ** capability_values = static_cast<zval**>( mnd_ecalloc(1, sizeof(zval*)));
-
- if( capability_names && capability_values ) {
- Mysqlx::Datatypes::Object* values = prepare_client_attr_object();
-
- if( values ) {
- Mysqlx::Datatypes::Any final_any;
- final_any.set_allocated_obj(values);
- final_any.set_type( Mysqlx::Datatypes::Any_Type::Any_Type_OBJECT );
-
- util::zvalue name("session_connect_attrs");
-
- util::zvalue value = any2zval(final_any);
- capability_names[0] = name.ptr();
- capability_values[0] = value.ptr();
-
- const st_xmysqlnd_on_error_bind on_error =
- { xmysqlnd_session_data_handler_on_error, (void*) this };
-
- if( PASS == caps_set.send_request(&caps_set,
- 1, //session_connect_attrs
- capability_names,
- capability_values) ) {
- DBG_INF_FMT("Successfully submitted the connection attributes to the server.");
- util::zvalue zvalue;
- caps_get.init_read(&caps_get, on_error);
- ret = caps_get.read_response(&caps_get,
- zvalue.ptr());
- if( ret == PASS ) {
- DBG_INF_FMT("Server response OK for the submitted connection attributes.");
- } else {
- DBG_ERR_FMT("Negative response from the server for the submitted connection \
attributes");
- }
+ Mysqlx::Datatypes::Object* values = prepare_client_attr_object();
+
+ if( values ) {
+ Mysqlx::Datatypes::Any final_any;
+ final_any.set_allocated_obj(values);
+ final_any.set_type( Mysqlx::Datatypes::Any_Type::Any_Type_OBJECT );
+
+ constexpr util::string_view name("session_connect_attrs");
+ util::zvalue value = any2zval(final_any);
+ util::zvalue capabilities = { {name, value} };
+
+ const st_xmysqlnd_on_error_bind on_error =
+ { xmysqlnd_session_data_handler_on_error, (void*) this };
+
+ if( PASS == caps_set.send_request(&caps_set, capabilities) ) {
+ DBG_INF_FMT("Successfully submitted the connection attributes to the server.");
+ util::zvalue capabilities;
+ caps_get.init_read(&caps_get, on_error);
+ ret = caps_get.read_response(&caps_get, &capabilities);
+ if( ret == PASS ) {
+ DBG_INF_FMT("Server response OK for the submitted connection attributes.");
+ } else {
+ DBG_ERR_FMT("Negative response from the server for the submitted connection \
attributes"); }
}
}
else {
DBG_ERR_FMT("Unable to allocate the memory for the capability objects");
}
-
- mnd_efree(capability_names);
- mnd_efree(capability_values);
}
DBG_RETURN(ret);
}
@@ -974,24 +928,12 @@ enum_func_status try_setup_crypto_connection(
//Attempt to set the TLS capa. flag.
st_xmysqlnd_msg__capabilities_set \
caps_set{ msg_factory.get__capabilities_set(&msg_factory) };
- zval ** capability_names = (zval **) mnd_ecalloc(2, sizeof(zval*));
- zval ** capability_values = (zval **) mnd_ecalloc(2, sizeof(zval*));
- constexpr util::string_view cstr_name("tls");
- util::zvalue name(cstr_name);
- util::zvalue value(true);
-
- capability_names[0] = name.ptr();
- capability_values[0] = value.ptr();
- if( PASS == caps_set.send_request(&caps_set,
- 1,
- capability_names,
- capability_values))
- {
+ const util::zvalue capabilities = { {"tls", true} };
+ if( PASS == caps_set.send_request(&caps_set, capabilities)) {
DBG_INF_FMT("Cap. send request with tls=true success, reading response..!");
util::zvalue zvalue;
caps_get.init_read(&caps_get, on_error);
- ret = caps_get.read_response(&caps_get,
- zvalue.ptr());
+ ret = caps_get.read_response(&caps_get, &zvalue);
if( ret == PASS ) {
DBG_INF_FMT("Cap. response OK, setting up TLS options.!");
php_stream_context * context = php_stream_context_alloc();
@@ -1016,14 +958,6 @@ enum_func_status try_setup_crypto_connection(
util::set_error_info(util::xdevapi_exception::Code::cannot_setup_tls, \
session->error_info); }
}
-
- //Cleanup
- if( capability_names ) {
- mnd_efree(capability_names);
- }
- if( capability_values ) {
- mnd_efree(capability_values);
- }
DBG_RETURN(ret);
}
@@ -1545,7 +1479,7 @@ util::strings to_auth_mech_names(const Auth_mechanisms& \
auth_mechanisms)
Gather_auth_mechanisms::Gather_auth_mechanisms(
const Session_auth_data* auth,
- const zval* capabilities,
+ const util::zvalue& capabilities,
Auth_mechanisms* auth_mechanisms)
: auth(auth)
, capabilities(capabilities)
@@ -1592,7 +1526,6 @@ Authenticate::Authenticate(
, msg_factory(session->create_message_factory())
, auth(session->auth.get())
{
- ZVAL_NULL(&capabilities);
}
Authenticate::~Authenticate()
@@ -1632,7 +1565,6 @@ bool Authenticate::init_capabilities()
caps_get = msg_factory.get__capabilities_get(&msg_factory);
if (caps_get.send_request(&caps_get) != PASS) return false;
- ZVAL_NULL(&capabilities);
const st_xmysqlnd_on_error_bind on_error{
xmysqlnd_session_data_handler_on_error,
session
@@ -1658,9 +1590,8 @@ void Authenticate::setup_compression()
bool Authenticate::init_connection()
{
- const std::string capability_tls{ "tls" };
- zend_bool tls_set{FALSE};
- xmysqlnd_is_capability_present(&capabilities, capability_tls, &tls_set);
+ constexpr std::string_view Capability_tls{ "tls" };
+ const bool tls_set = capabilities.contains(Capability_tls);
if (auth->ssl_mode == SSL_mode::disabled) return true;
@@ -1672,14 +1603,14 @@ bool Authenticate::init_connection()
}
}
-zval Authenticate::get_capabilities()
+util::zvalue Authenticate::get_capabilities()
{
return capabilities;
}
bool Authenticate::gather_auth_mechanisms()
{
- Gather_auth_mechanisms gather_auth_mechanisms(auth, &capabilities, \
&auth_mechanisms); + Gather_auth_mechanisms gather_auth_mechanisms(auth, \
capabilities, &auth_mechanisms); return gather_auth_mechanisms.run();
}
@@ -1780,19 +1711,18 @@ bool Gather_auth_mechanisms::is_tls_enabled() const
bool Gather_auth_mechanisms::is_auth_mechanism_supported(Auth_mechanism \
auth_mechanism) const {
- zval* entry{nullptr};
- const zval* auth_mechs = zend_hash_str_find(Z_ARRVAL_P(capabilities),
- "authentication.mechanisms", sizeof("authentication.mechanisms") - 1);
- if (!capabilities || Z_TYPE_P(auth_mechs) != IS_ARRAY) {
+ constexpr util::string_view Auth_mechanisms = "authentication.mechanisms";
+ const util::zvalue auth_mechs = capabilities.find(Auth_mechanisms);
+ if (!auth_mechs.is_array()) {
return false;
}
const util::string& auth_mech_name{ auth_mechanism_to_str(auth_mechanism) };
- MYSQLX_HASH_FOREACH_VAL(Z_ARRVAL_P(auth_mechs), entry) {
- if (!strcasecmp(Z_STRVAL_P(entry), auth_mech_name.c_str())) {
+ for (const auto& auth_mech : auth_mechs.values()) {
+ if (auth_mech.is_string() && boost::iequals(auth_mech.to_string_view(), \
auth_mech_name)) { return true;
}
- } ZEND_HASH_FOREACH_END();
+ }
return false;
}
diff --git a/xmysqlnd/xmysqlnd_session.h b/xmysqlnd/xmysqlnd_session.h
index b56769ee..ddbfcbb6 100644
--- a/xmysqlnd/xmysqlnd_session.h
+++ b/xmysqlnd/xmysqlnd_session.h
@@ -343,7 +343,7 @@ public:
~Authenticate();
bool run(bool re_auth = false);
- zval get_capabilities();
+ util::zvalue get_capabilities();
private:
bool run_auth();
bool run_re_auth();
@@ -365,7 +365,7 @@ private:
st_xmysqlnd_msg__capabilities_get caps_get;
const Session_auth_data* auth;
- zval capabilities;
+ util::zvalue capabilities;
Auth_mechanisms auth_mechanisms;
@@ -393,7 +393,7 @@ class Gather_auth_mechanisms
public:
Gather_auth_mechanisms(
const Session_auth_data* auth,
- const zval* capabilities,
+ const util::zvalue& capabilities,
Auth_mechanisms* auth_mechanisms);
bool run();
@@ -406,7 +406,7 @@ private:
private:
const Session_auth_data* auth;
- const zval* capabilities;
+ const util::zvalue& capabilities;
Auth_mechanisms& auth_mechanisms;
};
diff --git a/xmysqlnd/xmysqlnd_wireprotocol.cc b/xmysqlnd/xmysqlnd_wireprotocol.cc
index 645550c2..6eeeab2c 100644
--- a/xmysqlnd/xmysqlnd_wireprotocol.cc
+++ b/xmysqlnd/xmysqlnd_wireprotocol.cc
@@ -667,17 +667,16 @@ on_ERROR(const Mysqlx::Error & error, const \
st_xmysqlnd_on_error_bind on_error) }
/************************************** CAPABILITIES GET \
**************************************************/
-static void
-capabilities_to_zval(const Mysqlx::Connection::Capabilities & message, zval* \
return_value) +static util::zvalue
+capabilities_to_zval(const Mysqlx::Connection::Capabilities& message)
{
- DBG_ENTER("capabilities_to_zv");
+ DBG_ENTER("capabilities_to_zval");
util::zvalue capabilities(util::zvalue::create_array(message.capabilities_size()));
for (int i{0}; i < message.capabilities_size(); ++i) {
const auto& capability{ message.capabilities(i) };
capabilities.insert(capability.name(), any2zval(capability.value()));
}
- capabilities.move_to(return_value);
- DBG_VOID_RETURN;
+ DBG_RETURN(capabilities);
}
static const enum_hnd_func_status
@@ -693,8 +692,8 @@ capabilities_get_on_ERROR(const Mysqlx::Error & error, void * \
context) static const enum_hnd_func_status
capabilities_get_on_CAPABILITIES(const Mysqlx::Connection::Capabilities& message, \
void* context) {
- st_xmysqlnd_msg__capabilities_get* const ctx = \
static_cast<st_xmysqlnd_msg__capabilities_get* >(context);
- capabilities_to_zval(message, ctx->capabilities_zval);
+ st_xmysqlnd_msg__capabilities_get* const ctx = \
static_cast<st_xmysqlnd_msg__capabilities_get*>(context); + *ctx->capabilities = \
capabilities_to_zval(message); return HND_PASS;
}
@@ -725,10 +724,10 @@ static st_xmysqlnd_server_messages_handlers \
capabilities_get_handlers =
enum_func_status
-xmysqlnd_capabilities_get__read_response(st_xmysqlnd_msg__capabilities_get* msg, \
zval * capabilities) \
+xmysqlnd_capabilities_get__read_response(st_xmysqlnd_msg__capabilities_get* msg, \
util::zvalue* capabilities) {
DBG_ENTER("xmysqlnd_capabilities_get__read_response");
- msg->capabilities_zval = capabilities;
+ msg->capabilities = capabilities;
const enum_func_status ret = xmysqlnd_receive_message(&capabilities_get_handlers,
msg,
msg->msg_ctx);
@@ -824,20 +823,17 @@ \
xmysqlnd_capabilities_set__read_response(st_xmysqlnd_msg__capabilities_set* msg,
enum_func_status
xmysqlnd_capabilities_set__send_request(st_xmysqlnd_msg__capabilities_set* msg,
- const size_t cap_count,
- zval ** capabilities_names,
- zval ** capabilities_values)
+ const util::zvalue& capabilities)
{
- size_t bytes_sent;
Mysqlx::Connection::CapabilitiesSet message;
- for (unsigned i{0}; i < cap_count; ++i) {
+ for (const auto& [cap_name, cap_value] : capabilities) {
Mysqlx::Connection::Capability * capability = \
message.mutable_capabilities()->add_capabilities();
- capability->set_name(Z_STRVAL_P(capabilities_names[i]),
- Z_STRLEN_P(capabilities_names[i]));
+ capability->set_name(cap_name.c_str(), cap_name.length());
Mysqlx::Datatypes::Any any_entry;
- zval2any(capabilities_values[i], any_entry);
+ zval2any(cap_value, any_entry);
capability->mutable_value()->CopyFrom(any_entry);
}
+ size_t bytes_sent = 0;
return xmysqlnd_send_message(COM_CAPABILITIES_SET, message, msg->msg_ctx, \
&bytes_sent); }
diff --git a/xmysqlnd/xmysqlnd_wireprotocol.h b/xmysqlnd/xmysqlnd_wireprotocol.h
index ce226ab9..676041a6 100644
--- a/xmysqlnd/xmysqlnd_wireprotocol.h
+++ b/xmysqlnd/xmysqlnd_wireprotocol.h
@@ -27,6 +27,7 @@
#include "proto_gen/mysqlx_expect.pb.h"
#include "util/strings.h"
+#include "util/value.h"
#include <optional>
@@ -76,27 +77,26 @@ struct st_xmysqlnd_on_session_var_change_bind
void * ctx;
};
-
struct st_xmysqlnd_msg__capabilities_get
{
enum_func_status (*send_request)(st_xmysqlnd_msg__capabilities_get* msg);
enum_func_status (*read_response)(st_xmysqlnd_msg__capabilities_get* msg,
- zval * capabilities);
+ util::zvalue* capabilities);
enum_func_status (*init_read)(st_xmysqlnd_msg__capabilities_get* const msg,
const st_xmysqlnd_on_error_bind on_error);
Message_context msg_ctx;
st_xmysqlnd_on_error_bind on_error;
- zval* capabilities_zval;
+ util::zvalue* capabilities;
};
struct st_xmysqlnd_msg__capabilities_set
{
enum_func_status (*send_request)(st_xmysqlnd_msg__capabilities_set* msg,
- const size_t cap_count, zval ** capabilities_names, zval ** \
capabilities_values); + const util::zvalue& capabilities);
enum_func_status (*read_response)(st_xmysqlnd_msg__capabilities_set* msg,
zval* return_value);
--
PECL CVS Mailing List
To unsubscribe, visit: http://www.php.net/unsub.php
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic