mysqlnd_connection.c

/*
  +----------------------------------------------------------------------+
  | Copyright (c) The PHP Group                                          |
  +----------------------------------------------------------------------+
  | This source file is subject to version 3.01 of the PHP license,      |
  | that is bundled with this package in the file LICENSE, and is        |
  | available through the world-wide-web at the following url:           |
  | https://www.php.net/license/3_01.txt                                 |
  | If you did not receive a copy of the PHP license and are unable to   |
  | obtain it through the world-wide-web, please send a note to          |
  | license@php.net so we can mail you a copy immediately.               |
  +----------------------------------------------------------------------+
  | Authors: Andrey Hristov <andrey@php.net>                             |
  |          Ulf Wendel <uw@php.net>                                     |
  +----------------------------------------------------------------------+
*/

#include "php.h"
#include "mysqlnd.h"
#include "mysqlnd_connection.h"
#include "mysqlnd_vio.h"
#include "mysqlnd_protocol_frame_codec.h"
#include "mysqlnd_auth.h"
#include "mysqlnd_wireprotocol.h"
#include "mysqlnd_priv.h"
#include "mysqlnd_result.h"
#include "mysqlnd_statistics.h"
#include "mysqlnd_charset.h"
#include "mysqlnd_debug.h"
#include "mysqlnd_ext_plugin.h"
#include "zend_smart_str.h"


extern MYSQLND_CHARSET *mysqlnd_charsets;

PHPAPI const char * const mysqlnd_server_gone = "MySQL server has gone away";
PHPAPI const char * const mysqlnd_out_of_sync = "Commands out of sync; you can't run this command now";
PHPAPI const char * const mysqlnd_out_of_memory = "Out of memory";

PHPAPI MYSQLND_STATS * mysqlnd_global_stats = NULL;


/* {{{ mysqlnd_upsert_status::reset */
void
MYSQLND_METHOD(mysqlnd_upsert_status, reset)(MYSQLND_UPSERT_STATUS * const upsert_status)
{
	upsert_status->warning_count = 0;
	upsert_status->server_status = 0;
	upsert_status->affected_rows = 0;
	upsert_status->last_insert_id = 0;
}
/* }}} */


/* {{{ mysqlnd_upsert_status::set_affected_rows_to_error */
void
MYSQLND_METHOD(mysqlnd_upsert_status, set_affected_rows_to_error)(MYSQLND_UPSERT_STATUS * upsert_status)
{
	upsert_status->affected_rows = (uint64_t) ~0;
}
/* }}} */


MYSQLND_CLASS_METHODS_START(mysqlnd_upsert_status)
	MYSQLND_METHOD(mysqlnd_upsert_status, reset),
	MYSQLND_METHOD(mysqlnd_upsert_status, set_affected_rows_to_error),
MYSQLND_CLASS_METHODS_END;


/* {{{ mysqlnd_upsert_status_init */
void
mysqlnd_upsert_status_init(MYSQLND_UPSERT_STATUS * const upsert_status)
{
	upsert_status->m = &MYSQLND_CLASS_METHOD_TABLE_NAME(mysqlnd_upsert_status);
	upsert_status->m->reset(upsert_status);
}
/* }}} */


/* {{{ mysqlnd_error_list_pdtor */
static void
mysqlnd_error_list_pdtor(void * pDest)
{
	MYSQLND_ERROR_LIST_ELEMENT * element = (MYSQLND_ERROR_LIST_ELEMENT *) pDest;

	DBG_ENTER("mysqlnd_error_list_pdtor");
	if (element->error) {
		mnd_pefree(element->error, TRUE);
	}
	DBG_VOID_RETURN;
}
/* }}} */


/* {{{ mysqlnd_error_info::reset */
static void
MYSQLND_METHOD(mysqlnd_error_info, reset)(MYSQLND_ERROR_INFO * const info)
{
	DBG_ENTER("mysqlnd_error_info::reset");

	info->error_no = 0;
	info->error[0] = '\0';
	memset(&info->sqlstate, 0, sizeof(info->sqlstate));
	zend_llist_clean(&info->error_list);

	DBG_VOID_RETURN;
}
/* }}} */


/* {{{ mysqlnd_error_info::set_client_error */
static void
MYSQLND_METHOD(mysqlnd_error_info, set_client_error)(MYSQLND_ERROR_INFO * const info,
													 const unsigned int err_no,
													 const char * const sqlstate,
													 const char * const error)
{
	DBG_ENTER("mysqlnd_error_info::set_client_error");
	if (err_no) {
		MYSQLND_ERROR_LIST_ELEMENT error_for_the_list = {0};

		info->error_no = err_no;
		strlcpy(info->sqlstate, sqlstate, sizeof(info->sqlstate));
		strlcpy(info->error, error, sizeof(info->error));

		error_for_the_list.error_no = err_no;
		strlcpy(error_for_the_list.sqlstate, sqlstate, sizeof(error_for_the_list.sqlstate));
		error_for_the_list.error = mnd_pestrdup(error, TRUE);
		if (error_for_the_list.error) {
			DBG_INF_FMT("adding error [%s] to the list", error_for_the_list.error);
			zend_llist_add_element(&info->error_list, &error_for_the_list);
		}
	} else {
		info->m->reset(info);
	}
	DBG_VOID_RETURN;
}
/* }}} */


MYSQLND_CLASS_METHODS_START(mysqlnd_error_info)
	MYSQLND_METHOD(mysqlnd_error_info, reset),
	MYSQLND_METHOD(mysqlnd_error_info, set_client_error),
MYSQLND_CLASS_METHODS_END;



/* {{{ mysqlnd_error_info_init */
PHPAPI void
mysqlnd_error_info_init(MYSQLND_ERROR_INFO * const info, const bool persistent)
{
	DBG_ENTER("mysqlnd_error_info_init");
	info->m = mysqlnd_error_info_get_methods();
	info->m->reset(info);

	zend_llist_init(&info->error_list, sizeof(MYSQLND_ERROR_LIST_ELEMENT), (llist_dtor_func_t) mysqlnd_error_list_pdtor, persistent);
	info->persistent = persistent;
	DBG_VOID_RETURN;
}
/* }}} */


/* {{{ mysqlnd_error_info_free_contents */
PHPAPI void
mysqlnd_error_info_free_contents(MYSQLND_ERROR_INFO * const info)
{
	DBG_ENTER("mysqlnd_error_info_free_contents");
	info->m->reset(info);
	DBG_VOID_RETURN;
}
/* }}} */




/* {{{ mysqlnd_connection_state::get */
static enum mysqlnd_connection_state
MYSQLND_METHOD(mysqlnd_connection_state, get)(const struct st_mysqlnd_connection_state * const state_struct)
{
	DBG_ENTER("mysqlnd_connection_state::get");
	DBG_INF_FMT("State=%u", state_struct->state);
	DBG_RETURN(state_struct->state);
}
/* }}} */


/* {{{ mysqlnd_connection_state::set */
static void
MYSQLND_METHOD(mysqlnd_connection_state, set)(struct st_mysqlnd_connection_state * const state_struct, const enum mysqlnd_connection_state state)
{
	DBG_ENTER("mysqlnd_connection_state::set");
	DBG_INF_FMT("New state=%u", state);
	state_struct->state = state;
	DBG_VOID_RETURN;
}
/* }}} */


MYSQLND_CLASS_METHODS_START(mysqlnd_connection_state)
	MYSQLND_METHOD(mysqlnd_connection_state, get),
	MYSQLND_METHOD(mysqlnd_connection_state, set),
MYSQLND_CLASS_METHODS_END;


/* {{{ mysqlnd_connection_state_init */
PHPAPI void
mysqlnd_connection_state_init(struct st_mysqlnd_connection_state * const state)
{
	DBG_ENTER("mysqlnd_connection_state_init");
	state->m = &MYSQLND_CLASS_METHOD_TABLE_NAME(mysqlnd_connection_state);
	state->state = CONN_ALLOCED;
	DBG_VOID_RETURN;
}
/* }}} */



/* {{{ mysqlnd_conn_data::free_options */
static void
MYSQLND_METHOD(mysqlnd_conn_data, free_options)(MYSQLND_CONN_DATA * conn)
{
	bool pers = conn->persistent;

	if (conn->options->charset_name) {
		mnd_pefree(conn->options->charset_name, pers);
		conn->options->charset_name = NULL;
	}
	if (conn->options->auth_protocol) {
		mnd_pefree(conn->options->auth_protocol, pers);
		conn->options->auth_protocol = NULL;
	}
	if (conn->options->num_commands) {
		unsigned int i;
		for (i = 0; i < conn->options->num_commands; i++) {
			/* allocated with pestrdup */
			mnd_pefree(conn->options->init_commands[i], pers);
		}
		mnd_pefree(conn->options->init_commands, pers);
		conn->options->init_commands = NULL;
	}
	if (conn->options->cfg_file) {
		mnd_pefree(conn->options->cfg_file, pers);
		conn->options->cfg_file = NULL;
	}
	if (conn->options->cfg_section) {
		mnd_pefree(conn->options->cfg_section, pers);
		conn->options->cfg_section = NULL;
	}
	if (conn->options->connect_attr) {
		zend_hash_destroy(conn->options->connect_attr);
		mnd_pefree(conn->options->connect_attr, pers);
		conn->options->connect_attr = NULL;
	}
	if (conn->options->local_infile_directory) {
		mnd_pefree(conn->options->local_infile_directory, pers);
		conn->options->local_infile_directory = NULL;
	}
}
/* }}} */


/* {{{ mysqlnd_conn_data::free_contents */
static void
MYSQLND_METHOD(mysqlnd_conn_data, free_contents)(MYSQLND_CONN_DATA * conn)
{
	bool pers = conn->persistent;

	DBG_ENTER("mysqlnd_conn_data::free_contents");

	if (conn->current_result) {
		conn->current_result->m.free_result(conn->current_result, TRUE);
		conn->current_result = NULL;
	}

	if (conn->protocol_frame_codec) {
		conn->protocol_frame_codec->data->m.free_contents(conn->protocol_frame_codec);
	}

	if (conn->vio) {
		conn->vio->data->m.free_contents(conn->vio);
	}

	DBG_INF("Freeing memory of members");

	mysqlnd_set_persistent_string(&conn->hostname, NULL, 0, pers);
	mysqlnd_set_persistent_string(&conn->username, NULL, 0, pers);
	mysqlnd_set_persistent_string(&conn->password, NULL, 0, pers);
	mysqlnd_set_persistent_string(&conn->connect_or_select_db, NULL, 0, pers);
	mysqlnd_set_persistent_string(&conn->unix_socket, NULL, 0, pers);
	DBG_INF_FMT("scheme=%s", conn->scheme.s);
	mysqlnd_set_persistent_string(&conn->scheme, NULL, 0, pers);

	if (conn->server_version) {
		mnd_pefree(conn->server_version, pers);
		conn->server_version = NULL;
	}
	if (conn->host_info) {
		mnd_pefree(conn->host_info, pers);
		conn->host_info = NULL;
	}
	mysqlnd_set_persistent_string(&conn->authentication_plugin_data, NULL, 0, pers);
	mysqlnd_set_string(&conn->last_message, NULL, 0);

	conn->charset = NULL;
	conn->greet_charset = NULL;

	DBG_VOID_RETURN;
}
/* }}} */


/* {{{ mysqlnd_conn_data::dtor */
static void
MYSQLND_METHOD_PRIVATE(mysqlnd_conn_data, dtor)(MYSQLND_CONN_DATA * conn)
{
	DBG_ENTER("mysqlnd_conn_data::dtor");
	DBG_INF_FMT("conn=%" PRIu64, conn->thread_id);

	conn->m->free_contents(conn);
	conn->m->free_options(conn);

	if (conn->error_info) {
		mysqlnd_error_info_free_contents(conn->error_info);
		conn->error_info = NULL;
	}

	if (conn->protocol_frame_codec) {
		mysqlnd_pfc_free(conn->protocol_frame_codec, conn->stats, conn->error_info);
		conn->protocol_frame_codec = NULL;
	}

	if (conn->vio) {
		mysqlnd_vio_free(conn->vio, conn->stats, conn->error_info);
		conn->vio = NULL;
	}

	if (conn->payload_decoder_factory) {
		mysqlnd_protocol_payload_decoder_factory_free(conn->payload_decoder_factory);
		conn->payload_decoder_factory = NULL;
	}

	if (conn->stats) {
		mysqlnd_stats_end(conn->stats, conn->persistent);
	}

	mnd_pefree(conn, conn->persistent);

	DBG_VOID_RETURN;
}
/* }}} */


/* {{{ mysqlnd_conn_data::set_server_option */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn_data, set_server_option)(MYSQLND_CONN_DATA * const conn, enum_mysqlnd_server_option option)
{
	DBG_ENTER("mysqlnd_conn_data::set_server_option");
	DBG_RETURN(conn->command->set_option(conn, option));
}
/* }}} */


/* {{{ mysqlnd_conn_data::restart_psession */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn_data, restart_psession)(MYSQLND_CONN_DATA * conn)
{
	DBG_ENTER("mysqlnd_conn_data::restart_psession");
	MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_CONNECT_REUSED);
	conn->current_result = NULL;
	conn->last_message.s = NULL;
	DBG_RETURN(PASS);
}
/* }}} */


/* {{{ mysqlnd_conn_data::end_psession */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn_data, end_psession)(MYSQLND_CONN_DATA * conn)
{
	DBG_ENTER("mysqlnd_conn_data::end_psession");
	/* Free here what should not be seen by the next script */
	if (conn->current_result) {
		conn->current_result->m.free_result(conn->current_result, TRUE);
		conn->current_result = NULL;
	}
	mysqlnd_set_string(&conn->last_message, NULL, 0);
	conn->error_info = &conn->error_info_impl;
	DBG_RETURN(PASS);
}
/* }}} */


/* {{{ mysqlnd_conn_data::fetch_auth_plugin_by_name */
static struct st_mysqlnd_authentication_plugin *
MYSQLND_METHOD(mysqlnd_conn_data, fetch_auth_plugin_by_name)(const char * const requested_protocol)
{
	struct st_mysqlnd_authentication_plugin * auth_plugin;
	char * plugin_name = NULL;
	DBG_ENTER("mysqlnd_conn_data::fetch_auth_plugin_by_name");

	mnd_sprintf(&plugin_name, 0, "auth_plugin_%s", requested_protocol);
	DBG_INF_FMT("looking for %s auth plugin", plugin_name);
	auth_plugin = mysqlnd_plugin_find(plugin_name);
	mnd_sprintf_free(plugin_name);

	DBG_RETURN(auth_plugin);
}
/* }}} */


/* {{{ mysqlnd_conn_data::execute_init_commands */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn_data, execute_init_commands)(MYSQLND_CONN_DATA * conn)
{
	enum_func_status ret = PASS;

	DBG_ENTER("mysqlnd_conn_data::execute_init_commands");
	if (conn->options->init_commands) {
		unsigned int current_command = 0;
		for (; current_command < conn->options->num_commands; ++current_command) {
			const char * const command = conn->options->init_commands[current_command];
			if (command) {
				MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_INIT_COMMAND_EXECUTED_COUNT);
				if (PASS != conn->m->query(conn, command, strlen(command))) {
					MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_INIT_COMMAND_FAILED_COUNT);
					ret = FAIL;
					break;
				}
				do {
					if (conn->last_query_type == QUERY_SELECT) {
						MYSQLND_RES * result = conn->m->use_result(conn);
						if (result) {
							result->m.free_result(result, TRUE);
						}
					}
				} while (conn->m->next_result(conn) != FAIL);
			}
		}
	}
	DBG_RETURN(ret);
}
/* }}} */


/* {{{ mysqlnd_conn_data::get_updated_connect_flags */
static unsigned int
MYSQLND_METHOD(mysqlnd_conn_data, get_updated_connect_flags)(MYSQLND_CONN_DATA * conn, unsigned int mysql_flags)
{
#ifdef MYSQLND_COMPRESSION_ENABLED
	MYSQLND_PFC * pfc = conn->protocol_frame_codec;
#endif
	MYSQLND_VIO * vio = conn->vio;

	DBG_ENTER("mysqlnd_conn_data::get_updated_connect_flags");
	/* allow CLIENT_LOCAL_FILES capability, although extensions basing on mysqlnd
		shouldn't allow 'load data local infile' by default due to security issues */
	mysql_flags |= MYSQLND_CAPABILITIES;

	mysql_flags |= conn->options->flags; /* use the flags from set_client_option() */

#ifndef MYSQLND_COMPRESSION_ENABLED
	if (mysql_flags & CLIENT_COMPRESS) {
		mysql_flags &= ~CLIENT_COMPRESS;
	}
#else
	if (pfc && pfc->data->flags & MYSQLND_PROTOCOL_FLAG_USE_COMPRESSION) {
		mysql_flags |= CLIENT_COMPRESS;
	}
#endif
#ifndef MYSQLND_SSL_SUPPORTED
	if (mysql_flags & CLIENT_SSL) {
		mysql_flags &= ~CLIENT_SSL;
	}
#else
	if (vio && (vio->data->options.ssl_key ||
				vio->data->options.ssl_cert ||
				vio->data->options.ssl_ca ||
				vio->data->options.ssl_capath ||
				vio->data->options.ssl_cipher))
	{
		mysql_flags |= CLIENT_SSL;
	}
#endif

	if (conn->options->connect_attr && zend_hash_num_elements(conn->options->connect_attr)) {
		mysql_flags |= CLIENT_CONNECT_ATTRS;
	}

	DBG_RETURN(mysql_flags);
}
/* }}} */


/* {{{ mysqlnd_conn_data::connect_handshake */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn_data, connect_handshake)(MYSQLND_CONN_DATA * conn,
						const MYSQLND_CSTRING * const scheme,
						const MYSQLND_CSTRING * const username,
						const MYSQLND_CSTRING * const password,
						const MYSQLND_CSTRING * const database,
						const unsigned int mysql_flags)
{
	enum_func_status ret = FAIL;
	DBG_ENTER("mysqlnd_conn_data::connect_handshake");

	if (PASS == conn->vio->data->m.connect(conn->vio, *scheme, conn->persistent, conn->stats, conn->error_info) &&
		PASS == conn->protocol_frame_codec->data->m.reset(conn->protocol_frame_codec, conn->stats, conn->error_info))
	{
		size_t client_flags = mysql_flags;

		ret = conn->command->handshake(conn, *username, *password, *database, client_flags);
	}
	DBG_RETURN(ret);
}
/* }}} */

/* {{{ mysqlnd_conn_data::get_scheme */
static MYSQLND_STRING
MYSQLND_METHOD(mysqlnd_conn_data, get_scheme)(MYSQLND_CONN_DATA * conn, MYSQLND_CSTRING hostname, MYSQLND_CSTRING *socket_or_pipe, unsigned int port, bool * unix_socket, bool * named_pipe)
{
	MYSQLND_STRING transport;
	DBG_ENTER("mysqlnd_conn_data::get_scheme");
#ifndef PHP_WIN32
	if (hostname.l == sizeof("localhost") - 1 && !strncasecmp(hostname.s, "localhost", hostname.l)) {
		DBG_INF_FMT("socket=%s", socket_or_pipe->s? socket_or_pipe->s:"n/a");
		if (!socket_or_pipe->s) {
			socket_or_pipe->s = "/tmp/mysql.sock";
			socket_or_pipe->l = strlen(socket_or_pipe->s);
		}
		transport.l = mnd_sprintf(&transport.s, 0, "unix://%s", socket_or_pipe->s);
		*unix_socket = TRUE;
#else
	if (hostname.l == sizeof(".") - 1 && hostname.s[0] == '.') {
		/* named pipe in socket */
		if (!socket_or_pipe->s) {
			socket_or_pipe->s = "\\\\.\\pipe\\MySQL";
			socket_or_pipe->l = strlen(socket_or_pipe->s);
		}
		transport.l = mnd_sprintf(&transport.s, 0, "pipe://%s", socket_or_pipe->s);
		*named_pipe = TRUE;
#endif
	} else {
		if (!port) {
			port = 3306;
		}
		transport.l = mnd_sprintf(&transport.s, 0, "tcp://%s:%u", hostname.s, port);
	}
	DBG_INF_FMT("transport=%s", transport.s? transport.s:"OOM");
	DBG_RETURN(transport);
}
/* }}} */


/* {{{ mysqlnd_conn_data::connect */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn_data, connect)(MYSQLND_CONN_DATA * conn,
						MYSQLND_CSTRING hostname,
						MYSQLND_CSTRING username,
						MYSQLND_CSTRING password,
						MYSQLND_CSTRING database,
						unsigned int port,
						MYSQLND_CSTRING socket_or_pipe,
						unsigned int mysql_flags
					)
{
	bool unix_socket = FALSE;
	bool named_pipe = FALSE;
	bool reconnect = FALSE;
	bool saved_compression = FALSE;
	MYSQLND_PFC * pfc = conn->protocol_frame_codec;
	MYSQLND_STRING transport = { NULL, 0 };

	DBG_ENTER("mysqlnd_conn_data::connect");
	DBG_INF_FMT("conn=%p", conn);

	SET_EMPTY_ERROR(conn->error_info);
	UPSERT_STATUS_SET_AFFECTED_ROWS_TO_ERROR(conn->upsert_status);

	DBG_INF_FMT("host=%s user=%s db=%s port=%u flags=%u persistent=%u state=%u",
				hostname.s?hostname.s:"", username.s?username.s:"", database.s?database.s:"", port, mysql_flags,
				conn? conn->persistent:0, conn? (int)GET_CONNECTION_STATE(&conn->state):-1);

	if (GET_CONNECTION_STATE(&conn->state) > CONN_ALLOCED) {
		DBG_INF("Connecting on a connected handle.");

		if (GET_CONNECTION_STATE(&conn->state) < CONN_QUIT_SENT) {
			MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_CLOSE_IMPLICIT);
			reconnect = TRUE;
			conn->m->send_close(conn);
		}

		conn->m->free_contents(conn);
		/* Now reconnect using the same handle */
		if (pfc->data->compressed) {
			/*
			  we need to save the state. As we will re-connect, pfc->compressed should be off, or
			  we will look for a compression header as part of the greet message, but there will
			  be none.
			*/
			saved_compression = TRUE;
			pfc->data->compressed = FALSE;
		}
		if (pfc->data->ssl) {
			pfc->data->ssl = FALSE;
		}
	} else {
		unsigned int max_allowed_size = MYSQLND_ASSEMBLED_PACKET_MAX_SIZE;
		conn->m->set_client_option(conn, MYSQLND_OPT_MAX_ALLOWED_PACKET, (char *)&max_allowed_size);
	}

	if (!hostname.s || !hostname.s[0]) {
		hostname.s = "localhost";
		hostname.l = strlen(hostname.s);
	}
	if (!username.s) {
		DBG_INF_FMT("no user given, using empty string");
		username.s = "";
		username.l = 0;
	}
	if (!password.s) {
		DBG_INF_FMT("no password given, using empty string");
		password.s = "";
		password.l = 0;
	}
	if (!database.s || !database.s[0]) {
		DBG_INF_FMT("no db given, using empty string");
		database.s = "";
		database.l = 0;
	} else {
		mysql_flags |= CLIENT_CONNECT_WITH_DB;
	}

	transport = conn->m->get_scheme(conn, hostname, &socket_or_pipe, port, &unix_socket, &named_pipe);

	mysql_flags = conn->m->get_updated_connect_flags(conn, mysql_flags);

	{
		const MYSQLND_CSTRING scheme = { transport.s, transport.l };
		if (FAIL == conn->m->connect_handshake(conn, &scheme, &username, &password, &database, mysql_flags)) {
			goto err;
		}
	}

	{
		SET_CONNECTION_STATE(&conn->state, CONN_READY);

		if (saved_compression) {
			pfc->data->compressed = TRUE;
		}
		/*
		  If a connect on a existing handle is performed and mysql_flags is
		  passed which doesn't CLIENT_COMPRESS, then we need to overwrite the value
		  which we set based on saved_compression.
		*/
		pfc->data->compressed = mysql_flags & CLIENT_COMPRESS? TRUE:FALSE;


		mysqlnd_set_persistent_string(&conn->scheme, transport.s, transport.l, conn->persistent);
		if (transport.s) {
			mnd_sprintf_free(transport.s);
			transport.s = NULL;
		}

		if (!conn->scheme.s) {
			goto err; /* OOM */
		}

		mysqlnd_set_persistent_string(&conn->username, username.s, username.l, conn->persistent);
		mysqlnd_set_persistent_string(&conn->password, username.s, password.l, conn->persistent);
		conn->port				= port;
		mysqlnd_set_persistent_string(&conn->connect_or_select_db, database.s, database.l, conn->persistent);

		if (!unix_socket && !named_pipe) {
			mysqlnd_set_persistent_string(&conn->hostname, hostname.s, hostname.l, conn->persistent);
			{
				char *p;
				mnd_sprintf(&p, 0, "%s via TCP/IP", conn->hostname.s);
				if (!p) {
					SET_OOM_ERROR(conn->error_info);
					goto err; /* OOM */
				}
				conn->host_info = mnd_pestrdup(p, conn->persistent);
				mnd_sprintf_free(p);
			}
		} else {
			conn->unix_socket.s = mnd_pestrdup(socket_or_pipe.s, conn->persistent);
			if (unix_socket) {
				conn->host_info = mnd_pestrdup("Localhost via UNIX socket", conn->persistent);
			} else if (named_pipe) {
				char *p;
				mnd_sprintf(&p, 0, "%s via named pipe", conn->unix_socket.s);
				if (!p) {
					SET_OOM_ERROR(conn->error_info);
					goto err; /* OOM */
				}
				conn->host_info = mnd_pestrdup(p, conn->persistent);
				mnd_sprintf_free(p);
			} else {
				php_error_docref(NULL, E_WARNING, "Impossible. Should be either socket or a pipe. Report a bug!");
			}
			if (!conn->unix_socket.s || !conn->host_info) {
				SET_OOM_ERROR(conn->error_info);
				goto err; /* OOM */
			}
			conn->unix_socket.l = strlen(conn->unix_socket.s);
		}

		SET_EMPTY_ERROR(conn->error_info);

		mysqlnd_local_infile_default(conn);

		if (FAIL == conn->m->execute_init_commands(conn)) {
			goto err;
		}

		MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn->stats, STAT_CONNECT_SUCCESS, 1, STAT_OPENED_CONNECTIONS, 1);
		if (reconnect) {
			MYSQLND_INC_GLOBAL_STATISTIC(STAT_RECONNECT);
		}
		if (conn->persistent) {
			MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn->stats, STAT_PCONNECT_SUCCESS, 1, STAT_OPENED_PERSISTENT_CONNECTIONS, 1);
		}

		DBG_INF_FMT("connection_id=%" PRIu64, conn->thread_id);

		DBG_RETURN(PASS);
	}
err:
	DBG_ERR_FMT("[%u] %.128s (trying to connect via %s)", conn->error_info->error_no, conn->error_info->error, transport.s ? transport.s : conn->scheme.s);
	if (!conn->error_info->error_no) {
		/* There was an unknown error if the connection failed but we have no error number */
		char * msg;
		mnd_sprintf(&msg, 0, "Unknown error while trying to connect via %s", transport.s ? transport.s : conn->scheme.s);
		SET_CLIENT_ERROR(conn->error_info, CR_CONNECTION_ERROR, UNKNOWN_SQLSTATE, msg);
		mnd_sprintf_free(msg);
	}

	if (transport.s) {
		mnd_sprintf_free(transport.s);
		transport.s = NULL;
	}

	conn->m->free_contents(conn);
	MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_CONNECT_FAILURE);
	DBG_RETURN(FAIL);
}
/* }}} */


/* {{{ mysqlnd_conn::connect */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND * conn_handle,
						const MYSQLND_CSTRING hostname,
						const MYSQLND_CSTRING username,
						const MYSQLND_CSTRING password,
						const MYSQLND_CSTRING database,
						unsigned int port,
						const MYSQLND_CSTRING socket_or_pipe,
						unsigned int mysql_flags)
{
	MYSQLND_CONN_DATA * conn = conn_handle->data;

	DBG_ENTER("mysqlnd_conn::connect");

	mysqlnd_options4(conn_handle, MYSQL_OPT_CONNECT_ATTR_ADD, "_client_name", "mysqlnd");
	if (hostname.l > 0) {
		mysqlnd_options4(conn_handle, MYSQL_OPT_CONNECT_ATTR_ADD, "_server_host", hostname.s);
	}
	DBG_RETURN(conn->m->connect(conn, hostname, username, password, database, port, socket_or_pipe, mysql_flags));
}
/* }}} */


/* {{{ mysqlnd_conn_data::query */
/*
  If conn->error_info->error_no is not zero, then we had an error.
  Still the result from the query is PASS
*/
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn_data, query)(MYSQLND_CONN_DATA * conn, const char * const query, const size_t query_len)
{
	enum_func_status ret = FAIL;
	DBG_ENTER("mysqlnd_conn_data::query");
	DBG_INF_FMT("conn=%p conn=%" PRIu64 " query=%s", conn, conn->thread_id, query);

	if (PASS == conn->m->send_query(conn, query, query_len, NULL, NULL) &&
		PASS == conn->m->reap_query(conn))
	{
		ret = PASS;
		if (conn->last_query_type == QUERY_UPSERT && UPSERT_STATUS_GET_AFFECTED_ROWS(conn->upsert_status)) {
			MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn->stats, STAT_ROWS_AFFECTED_NORMAL, UPSERT_STATUS_GET_AFFECTED_ROWS(conn->upsert_status));
		}
	}
	DBG_RETURN(ret);
}
/* }}} */


/* {{{ mysqlnd_conn_data::send_query */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn_data, send_query)(
		MYSQLND_CONN_DATA * conn, const char * const query, const size_t query_len,
		zval *read_cb, zval *err_cb)
{
	DBG_ENTER("mysqlnd_conn_data::send_query");
	DBG_INF_FMT("conn=%" PRIu64 " query=%s", conn->thread_id, query);
	DBG_INF_FMT("conn->server_status=%u", UPSERT_STATUS_GET_SERVER_STATUS(conn->upsert_status));

	const MYSQLND_CSTRING query_string = {query, query_len};
	enum_func_status ret = conn->command->query(conn, query_string);
	DBG_INF_FMT("conn->server_status=%u", UPSERT_STATUS_GET_SERVER_STATUS(conn->upsert_status));
	DBG_RETURN(ret);
}
/* }}} */


/* {{{ mysqlnd_conn_data::reap_query */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn_data, reap_query)(MYSQLND_CONN_DATA * conn)
{
	DBG_ENTER("mysqlnd_conn_data::reap_query");
	DBG_INF_FMT("conn=%" PRIu64, conn->thread_id);

	DBG_INF_FMT("conn->server_status=%u", UPSERT_STATUS_GET_SERVER_STATUS(conn->upsert_status));
	enum_func_status ret = conn->command->reap_result(conn);
	DBG_INF_FMT("conn->server_status=%u", UPSERT_STATUS_GET_SERVER_STATUS(conn->upsert_status));
	DBG_RETURN(ret);
}
/* }}} */


/* {{{ mysqlnd_conn_data::list_method */
MYSQLND_RES *
MYSQLND_METHOD(mysqlnd_conn_data, list_method)(MYSQLND_CONN_DATA * conn, const char * const query, const char * const achtung_wild, const char * const par1)
{
	char * show_query = NULL;
	size_t show_query_len;
	MYSQLND_RES * result = NULL;

	DBG_ENTER("mysqlnd_conn_data::list_method");
	DBG_INF_FMT("conn=%" PRIu64 " query=%s wild=%p", conn->thread_id, query, achtung_wild);

	if (par1) {
		if (achtung_wild) {
			show_query_len = mnd_sprintf(&show_query, 0, query, par1, achtung_wild);
		} else {
			show_query_len = mnd_sprintf(&show_query, 0, query, par1);
		}
	} else {
		if (achtung_wild) {
			show_query_len = mnd_sprintf(&show_query, 0, query, achtung_wild);
		} else {
			show_query_len = strlen(show_query = (char *)query);
		}
	}

	if (PASS == conn->m->query(conn, show_query, show_query_len)) {
		result = conn->m->store_result(conn);
	}
	if (show_query != query) {
		mnd_sprintf_free(show_query);
	}
	DBG_RETURN(result);
}
/* }}} */


/* {{{ mysqlnd_conn_data::err_no */
static unsigned int
MYSQLND_METHOD(mysqlnd_conn_data, err_no)(const MYSQLND_CONN_DATA * const conn)
{
	return conn->error_info->error_no;
}
/* }}} */


/* {{{ mysqlnd_conn_data::error */
static const char *
MYSQLND_METHOD(mysqlnd_conn_data, error)(const MYSQLND_CONN_DATA * const conn)
{
	return conn->error_info->error;
}
/* }}} */


/* {{{ mysqlnd_conn_data::sqlstate */
static const char *
MYSQLND_METHOD(mysqlnd_conn_data, sqlstate)(const MYSQLND_CONN_DATA * const conn)
{
	return conn->error_info->sqlstate[0] ? conn->error_info->sqlstate:MYSQLND_SQLSTATE_NULL;
}
/* }}} */


/* {{{ mysqlnd_old_escape_string */
PHPAPI  zend_ulong
mysqlnd_old_escape_string(char * newstr, const char * escapestr, size_t escapestr_len)
{
	DBG_ENTER("mysqlnd_old_escape_string");
	DBG_RETURN(mysqlnd_cset_escape_slashes(mysqlnd_find_charset_name("latin1"), newstr, escapestr, escapestr_len));
}
/* }}} */


/* {{{ mysqlnd_conn_data::ssl_set */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn_data, ssl_set)(MYSQLND_CONN_DATA * const conn, const char * key, const char * const cert,
									  const char * const ca, const char * const capath, const char * const cipher)
{
	MYSQLND_VIO * vio = conn->vio;
	DBG_ENTER("mysqlnd_conn_data::ssl_set");

	enum_func_status ret = (
		PASS == vio->data->m.set_client_option(vio, MYSQLND_OPT_SSL_KEY, key) &&
		PASS == vio->data->m.set_client_option(vio, MYSQLND_OPT_SSL_CERT, cert) &&
		PASS == vio->data->m.set_client_option(vio, MYSQLND_OPT_SSL_CA, ca) &&
		PASS == vio->data->m.set_client_option(vio, MYSQLND_OPT_SSL_CAPATH, capath) &&
		PASS == vio->data->m.set_client_option(vio, MYSQLND_OPT_SSL_CIPHER, cipher)) ? PASS : FAIL;
	DBG_RETURN(ret);
}
/* }}} */


/* {{{ mysqlnd_conn_data::escape_string */
static zend_ulong
MYSQLND_METHOD(mysqlnd_conn_data, escape_string)(MYSQLND_CONN_DATA * const conn, char * newstr, const char * escapestr, size_t escapestr_len)
{
	zend_ulong ret = FAIL;
	DBG_ENTER("mysqlnd_conn_data::escape_string");
	DBG_INF_FMT("conn=%" PRIu64, conn->thread_id);

	DBG_INF_FMT("server_status=%u", UPSERT_STATUS_GET_SERVER_STATUS(conn->upsert_status));
	if (UPSERT_STATUS_GET_SERVER_STATUS(conn->upsert_status) & SERVER_STATUS_NO_BACKSLASH_ESCAPES) {
		ret = mysqlnd_cset_escape_quotes(conn->charset, newstr, escapestr, escapestr_len);
	} else {
		ret = mysqlnd_cset_escape_slashes(conn->charset, newstr, escapestr, escapestr_len);
	}
	DBG_RETURN(ret);
}
/* }}} */


/* {{{ mysqlnd_conn_data::dump_debug_info */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn_data, dump_debug_info)(MYSQLND_CONN_DATA * const conn)
{
	DBG_ENTER("mysqlnd_conn_data::dump_debug_info");
	DBG_INF_FMT("conn=%" PRIu64, conn->thread_id);
	DBG_RETURN(conn->command->debug(conn));
}
/* }}} */


/* {{{ mysqlnd_conn_data::select_db */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn_data, select_db)(MYSQLND_CONN_DATA * const conn, const char * const db, const size_t db_len)
{
	DBG_ENTER("mysqlnd_conn_data::select_db");
	DBG_INF_FMT("conn=%" PRIu64 " db=%s", conn->thread_id, db);

	const MYSQLND_CSTRING database = {db, db_len};
	DBG_RETURN(conn->command->init_db(conn, database));
}
/* }}} */


/* {{{ mysqlnd_conn_data::ping */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn_data, ping)(MYSQLND_CONN_DATA * const conn)
{
	DBG_ENTER("mysqlnd_conn_data::ping");
	DBG_INF_FMT("conn=%" PRIu64, conn->thread_id);

	enum_func_status ret = conn->command->ping(conn);
	DBG_INF_FMT("ret=%u", ret);
	DBG_RETURN(ret);
}
/* }}} */


/* {{{ mysqlnd_conn_data::statistic */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn_data, statistic)(MYSQLND_CONN_DATA * conn, zend_string **message)
{
	DBG_ENTER("mysqlnd_conn_data::statistic");
	DBG_INF_FMT("conn=%" PRIu64, conn->thread_id);
	DBG_RETURN(conn->command->statistics(conn, message));
}
/* }}} */


/* {{{ mysqlnd_conn_data::kill */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn_data, kill)(MYSQLND_CONN_DATA * conn, unsigned int pid)
{
	DBG_ENTER("mysqlnd_conn_data::kill");
	DBG_INF_FMT("conn=%" PRIu64 " pid=%u", conn->thread_id, pid);

	const unsigned int process_id = pid;
	/* 'unsigned char' is promoted to 'int' when passed through '...' */