diff options
Diffstat (limited to 'ext/mysqlnd/mysqlnd.c')
| -rw-r--r-- | ext/mysqlnd/mysqlnd.c | 2143 |
1 files changed, 1218 insertions, 925 deletions
diff --git a/ext/mysqlnd/mysqlnd.c b/ext/mysqlnd/mysqlnd.c index 7815c6642..c9be18035 100644 --- a/ext/mysqlnd/mysqlnd.c +++ b/ext/mysqlnd/mysqlnd.c @@ -12,9 +12,9 @@ | obtain it through the world-wide-web, please send a note to | | license@php.net so we can mail you a copy immediately. | +----------------------------------------------------------------------+ - | Authors: Georg Richter <georg@mysql.com> | - | Andrey Hristov <andrey@mysql.com> | + | Authors: Andrey Hristov <andrey@mysql.com> | | Ulf Wendel <uwendel@mysql.com> | + | Georg Richter <georg@mysql.com> | +----------------------------------------------------------------------+ */ @@ -27,8 +27,6 @@ #include "mysqlnd_statistics.h" #include "mysqlnd_charset.h" #include "mysqlnd_debug.h" -/* for php_get_current_user() */ -#include "ext/standard/basic_functions.h" /* TODO : @@ -64,60 +62,50 @@ PHPAPI const char * const mysqlnd_out_of_sync = "Commands out of sync; you can't PHPAPI const char * const mysqlnd_out_of_memory = "Out of memory"; PHPAPI MYSQLND_STATS *mysqlnd_global_stats = NULL; -static zend_bool mysqlnd_library_initted = FALSE; -static struct st_mysqlnd_conn_methods *mysqlnd_conn_methods; -/* {{{ mysqlnd_library_end */ -PHPAPI void mysqlnd_library_end(TSRMLS_D) -{ - if (mysqlnd_library_initted == TRUE) { - mysqlnd_stats_end(mysqlnd_global_stats); - mysqlnd_global_stats = NULL; - mysqlnd_library_initted = FALSE; - } -} -/* }}} */ - - -/* {{{ mysqlnd_conn::free_options */ +/* {{{ mysqlnd_conn_data::free_options */ static void -MYSQLND_METHOD(mysqlnd_conn, free_options)(MYSQLND * conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, free_options)(MYSQLND_CONN_DATA * conn TSRMLS_DC) { zend_bool pers = conn->persistent; - if (conn->options.charset_name) { - mnd_pefree(conn->options.charset_name, pers); - conn->options.charset_name = NULL; + 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) { + if (conn->options->num_commands) { unsigned int i; - for (i = 0; i < conn->options.num_commands; 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[i], pers); } - mnd_pefree(conn->options.init_commands, pers); - conn->options.init_commands = NULL; + 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_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->cfg_section) { + mnd_pefree(conn->options->cfg_section, pers); + conn->options->cfg_section = NULL; } } /* }}} */ -/* {{{ mysqlnd_conn::free_contents */ +/* {{{ mysqlnd_conn_data::free_contents */ static void -MYSQLND_METHOD(mysqlnd_conn, free_contents)(MYSQLND * conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, free_contents)(MYSQLND_CONN_DATA * conn TSRMLS_DC) { zend_bool pers = conn->persistent; - DBG_ENTER("mysqlnd_conn::free_contents"); + DBG_ENTER("mysqlnd_conn_data::free_contents"); mysqlnd_local_infile_default(conn); if (conn->current_result) { @@ -132,55 +120,51 @@ MYSQLND_METHOD(mysqlnd_conn, free_contents)(MYSQLND * conn TSRMLS_DC) DBG_INF("Freeing memory of members"); if (conn->host) { - DBG_INF("Freeing host"); mnd_pefree(conn->host, pers); conn->host = NULL; } if (conn->user) { - DBG_INF("Freeing user"); mnd_pefree(conn->user, pers); conn->user = NULL; } if (conn->passwd) { - DBG_INF("Freeing passwd"); mnd_pefree(conn->passwd, pers); conn->passwd = NULL; } if (conn->connect_or_select_db) { - DBG_INF("Freeing connect_or_select_db"); mnd_pefree(conn->connect_or_select_db, pers); conn->connect_or_select_db = NULL; } if (conn->unix_socket) { - DBG_INF("Freeing unix_socket"); mnd_pefree(conn->unix_socket, pers); conn->unix_socket = NULL; } DBG_INF_FMT("scheme=%s", conn->scheme); if (conn->scheme) { - DBG_INF("Freeing scheme"); mnd_pefree(conn->scheme, pers); conn->scheme = NULL; } if (conn->server_version) { - DBG_INF("Freeing server_version"); mnd_pefree(conn->server_version, pers); conn->server_version = NULL; } if (conn->host_info) { - DBG_INF("Freeing host_info"); mnd_pefree(conn->host_info, pers); conn->host_info = NULL; } - if (conn->scramble) { - DBG_INF("Freeing scramble"); - mnd_pefree(conn->scramble, pers); - conn->scramble = NULL; + if (conn->auth_plugin_data) { + mnd_pefree(conn->auth_plugin_data, pers); + conn->auth_plugin_data = NULL; } if (conn->last_message) { mnd_pefree(conn->last_message, pers); conn->last_message = NULL; } + if (conn->error_info->error_list) { + zend_llist_clean(conn->error_info->error_list); + mnd_pefree(conn->error_info->error_list, pers); + conn->error_info->error_list = NULL; + } conn->charset = NULL; conn->greet_charset = NULL; @@ -189,24 +173,22 @@ MYSQLND_METHOD(mysqlnd_conn, free_contents)(MYSQLND * conn TSRMLS_DC) /* }}} */ -/* {{{ mysqlnd_conn::dtor */ +/* {{{ mysqlnd_conn_data::dtor */ static void -MYSQLND_METHOD_PRIVATE(mysqlnd_conn, dtor)(MYSQLND * conn TSRMLS_DC) +MYSQLND_METHOD_PRIVATE(mysqlnd_conn_data, dtor)(MYSQLND_CONN_DATA * conn TSRMLS_DC) { - DBG_ENTER("mysqlnd_conn::dtor"); + DBG_ENTER("mysqlnd_conn_data::dtor"); DBG_INF_FMT("conn=%llu", conn->thread_id); conn->m->free_contents(conn TSRMLS_CC); conn->m->free_options(conn TSRMLS_CC); if (conn->net) { - DBG_INF("Freeing net"); - mysqlnd_net_free(conn->net TSRMLS_CC); + mysqlnd_net_free(conn->net, conn->stats, conn->error_info TSRMLS_CC); conn->net = NULL; } if (conn->protocol) { - DBG_INF("Freeing protocol"); mysqlnd_protocol_free(conn->protocol TSRMLS_CC); conn->protocol = NULL; } @@ -222,22 +204,22 @@ MYSQLND_METHOD_PRIVATE(mysqlnd_conn, dtor)(MYSQLND * conn TSRMLS_DC) /* }}} */ -/* {{{ mysqlnd_conn::simple_command_handle_response */ +/* {{{ mysqlnd_conn_data::simple_command_handle_response */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, simple_command_handle_response)(MYSQLND * conn, enum mysqlnd_packet_type ok_packet, +MYSQLND_METHOD(mysqlnd_conn_data, simple_command_handle_response)(MYSQLND_CONN_DATA * conn, enum mysqlnd_packet_type ok_packet, zend_bool silent, enum php_mysqlnd_server_command command, zend_bool ignore_upsert_status TSRMLS_DC) { enum_func_status ret = FAIL; - DBG_ENTER("mysqlnd_conn::simple_command_handle_response"); + DBG_ENTER("mysqlnd_conn_data::simple_command_handle_response"); DBG_INF_FMT("silent=%u packet=%u command=%s", silent, ok_packet, mysqlnd_command_to_text[command]); switch (ok_packet) { case PROT_OK_PACKET:{ MYSQLND_PACKET_OK * ok_response = conn->protocol->m.get_ok_packet(conn->protocol, FALSE TSRMLS_CC); if (!ok_response) { - SET_OOM_ERROR(conn->error_info); + SET_OOM_ERROR(*conn->error_info); break; } if (FAIL == (ret = PACKET_READ(ok_response, conn))) { @@ -250,7 +232,7 @@ MYSQLND_METHOD(mysqlnd_conn, simple_command_handle_response)(MYSQLND * conn, enu DBG_INF_FMT("OK from server"); if (0xFF == ok_response->field_count) { /* The server signalled error. Set the error */ - SET_CLIENT_ERROR(conn->error_info, ok_response->error_no, ok_response->sqlstate, ok_response->error); + SET_CLIENT_ERROR(*conn->error_info, ok_response->error_no, ok_response->sqlstate, ok_response->error); ret = FAIL; /* Cover a protocol design error: error packet does not @@ -261,7 +243,7 @@ MYSQLND_METHOD(mysqlnd_conn, simple_command_handle_response)(MYSQLND * conn, enu a multi-statement or a stored procedure, so it should be safe to unconditionally turn off the flag here. */ - conn->upsert_status.server_status &= ~SERVER_MORE_RESULTS_EXISTS; + conn->upsert_status->server_status &= ~SERVER_MORE_RESULTS_EXISTS; SET_ERROR_AFF_ROWS(conn); } else { SET_NEW_MESSAGE(conn->last_message, conn->last_message_len, @@ -269,10 +251,10 @@ MYSQLND_METHOD(mysqlnd_conn, simple_command_handle_response)(MYSQLND * conn, enu conn->persistent); if (!ignore_upsert_status) { - conn->upsert_status.warning_count = ok_response->warning_count; - conn->upsert_status.server_status = ok_response->server_status; - conn->upsert_status.affected_rows = ok_response->affected_rows; - conn->upsert_status.last_insert_id = ok_response->last_insert_id; + conn->upsert_status->warning_count = ok_response->warning_count; + conn->upsert_status->server_status = ok_response->server_status; + conn->upsert_status->affected_rows = ok_response->affected_rows; + conn->upsert_status->last_insert_id = ok_response->last_insert_id; } } } @@ -282,11 +264,11 @@ MYSQLND_METHOD(mysqlnd_conn, simple_command_handle_response)(MYSQLND * conn, enu case PROT_EOF_PACKET:{ MYSQLND_PACKET_EOF * ok_response = conn->protocol->m.get_eof_packet(conn->protocol, FALSE TSRMLS_CC); if (!ok_response) { - SET_OOM_ERROR(conn->error_info); + SET_OOM_ERROR(*conn->error_info); break; } if (FAIL == (ret = PACKET_READ(ok_response, conn))) { - SET_CLIENT_ERROR(conn->error_info, CR_MALFORMED_PACKET, UNKNOWN_SQLSTATE, + SET_CLIENT_ERROR(*conn->error_info, CR_MALFORMED_PACKET, UNKNOWN_SQLSTATE, "Malformed packet"); if (!silent) { DBG_ERR_FMT("Error while reading %s's EOF packet", mysqlnd_command_to_text[command]); @@ -295,10 +277,10 @@ MYSQLND_METHOD(mysqlnd_conn, simple_command_handle_response)(MYSQLND * conn, enu } } else if (0xFF == ok_response->field_count) { /* The server signalled error. Set the error */ - SET_CLIENT_ERROR(conn->error_info, ok_response->error_no, ok_response->sqlstate, ok_response->error); + SET_CLIENT_ERROR(*conn->error_info, ok_response->error_no, ok_response->sqlstate, ok_response->error); SET_ERROR_AFF_ROWS(conn); } else if (0xFE != ok_response->field_count) { - SET_CLIENT_ERROR(conn->error_info, CR_MALFORMED_PACKET, UNKNOWN_SQLSTATE, "Malformed packet"); + SET_CLIENT_ERROR(*conn->error_info, CR_MALFORMED_PACKET, UNKNOWN_SQLSTATE, "Malformed packet"); if (!silent) { DBG_ERR_FMT("EOF packet expected, field count wasn't 0xFE but 0x%2X", ok_response->field_count); php_error_docref(NULL TSRMLS_CC, E_WARNING, "EOF packet expected, field count wasn't 0xFE but 0x%2X", @@ -311,7 +293,7 @@ MYSQLND_METHOD(mysqlnd_conn, simple_command_handle_response)(MYSQLND * conn, enu break; } default: - SET_CLIENT_ERROR(conn->error_info, CR_MALFORMED_PACKET, UNKNOWN_SQLSTATE, "Malformed packet"); + SET_CLIENT_ERROR(*conn->error_info, CR_MALFORMED_PACKET, UNKNOWN_SQLSTATE, "Malformed packet"); php_error_docref(NULL TSRMLS_CC, E_ERROR, "Wrong response packet %u passed to the function", ok_packet); break; } @@ -321,41 +303,41 @@ MYSQLND_METHOD(mysqlnd_conn, simple_command_handle_response)(MYSQLND * conn, enu /* }}} */ -/* {{{ mysqlnd_conn::simple_command */ +/* {{{ mysqlnd_conn_data::simple_command */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, simple_command)(MYSQLND * conn, enum php_mysqlnd_server_command command, - const char * const arg, size_t arg_len, enum mysqlnd_packet_type ok_packet, zend_bool silent, +MYSQLND_METHOD(mysqlnd_conn_data, simple_command)(MYSQLND_CONN_DATA * conn, enum php_mysqlnd_server_command command, + const zend_uchar * const arg, size_t arg_len, enum mysqlnd_packet_type ok_packet, zend_bool silent, zend_bool ignore_upsert_status TSRMLS_DC) { enum_func_status ret = PASS; MYSQLND_PACKET_COMMAND * cmd_packet; - DBG_ENTER("mysqlnd_conn::simple_command"); + DBG_ENTER("mysqlnd_conn_data::simple_command"); DBG_INF_FMT("command=%s ok_packet=%u silent=%u", mysqlnd_command_to_text[command], ok_packet, silent); switch (CONN_GET_STATE(conn)) { case CONN_READY: break; case CONN_QUIT_SENT: - SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone); + SET_CLIENT_ERROR(*conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone); DBG_ERR("Server is gone"); DBG_RETURN(FAIL); default: - SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync); + SET_CLIENT_ERROR(*conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync); DBG_ERR_FMT("Command out of sync. State=%u", CONN_GET_STATE(conn)); DBG_RETURN(FAIL); } /* clean UPSERT info */ if (!ignore_upsert_status) { - memset(&conn->upsert_status, 0, sizeof(conn->upsert_status)); + memset(conn->upsert_status, 0, sizeof(*conn->upsert_status)); } SET_ERROR_AFF_ROWS(conn); - SET_EMPTY_ERROR(conn->error_info); + SET_EMPTY_ERROR(*conn->error_info); cmd_packet = conn->protocol->m.get_command_packet(conn->protocol, FALSE TSRMLS_CC); if (!cmd_packet) { - SET_OOM_ERROR(conn->error_info); + SET_OOM_ERROR(*conn->error_info); DBG_RETURN(FAIL); } @@ -372,6 +354,7 @@ MYSQLND_METHOD(mysqlnd_conn, simple_command)(MYSQLND * conn, enum php_mysqlnd_se DBG_ERR_FMT("Error while sending %s packet", mysqlnd_command_to_text[command]); php_error(E_WARNING, "Error while sending %s packet. PID=%d", mysqlnd_command_to_text[command], getpid()); } + CONN_SET_STATE(conn, CONN_QUIT_SENT); DBG_ERR("Server is gone"); ret = FAIL; } else if (ok_packet != PROT_LAST) { @@ -385,26 +368,31 @@ MYSQLND_METHOD(mysqlnd_conn, simple_command)(MYSQLND * conn, enum php_mysqlnd_se /* }}} */ -/* {{{ mysqlnd_conn::set_server_option */ +/* {{{ mysqlnd_conn_data::set_server_option */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, set_server_option)(MYSQLND * const conn, enum_mysqlnd_server_option option TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, set_server_option)(MYSQLND_CONN_DATA * const conn, enum_mysqlnd_server_option option TSRMLS_DC) { - enum_func_status ret; - char buffer[2]; - DBG_ENTER("mysqlnd_conn::set_server_option"); + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, set_server_option); + zend_uchar buffer[2]; + enum_func_status ret = FAIL; + DBG_ENTER("mysqlnd_conn_data::set_server_option"); + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { - int2store(buffer, (unsigned int) option); - ret = conn->m->simple_command(conn, COM_SET_OPTION, buffer, sizeof(buffer), PROT_EOF_PACKET, FALSE, TRUE TSRMLS_CC); + int2store(buffer, (unsigned int) option); + ret = conn->m->simple_command(conn, COM_SET_OPTION, buffer, sizeof(buffer), PROT_EOF_PACKET, FALSE, TRUE TSRMLS_CC); + + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); + } DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_conn::restart_psession */ +/* {{{ mysqlnd_conn_data::restart_psession */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, restart_psession)(MYSQLND * conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, restart_psession)(MYSQLND_CONN_DATA * conn TSRMLS_DC) { - DBG_ENTER("mysqlnd_conn::restart_psession"); + DBG_ENTER("mysqlnd_conn_data::restart_psession"); MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_CONNECT_REUSED); /* Free here what should not be seen by the next script */ if (conn->last_message) { @@ -416,49 +404,38 @@ MYSQLND_METHOD(mysqlnd_conn, restart_psession)(MYSQLND * conn TSRMLS_DC) /* }}} */ -/* {{{ mysqlnd_conn::end_psession */ +/* {{{ mysqlnd_conn_data::end_psession */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, end_psession)(MYSQLND * conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, end_psession)(MYSQLND_CONN_DATA * conn TSRMLS_DC) { - DBG_ENTER("mysqlnd_conn::end_psession"); + DBG_ENTER("mysqlnd_conn_data::end_psession"); DBG_RETURN(PASS); } /* }}} */ -#define MYSQLND_ASSEBLED_PACKET_MAX_SIZE 3UL*1024UL*1024UL*1024UL -/* {{{ mysqlnd_connect_run_authentication */ +/* {{{ mysqlnd_switch_to_ssl_if_needed */ static enum_func_status -mysqlnd_connect_run_authentication( - MYSQLND * conn, - const char * const user, - const char * const passwd, - const char * const db, - size_t db_len, +mysqlnd_switch_to_ssl_if_needed( + MYSQLND_CONN_DATA * conn, const MYSQLND_PACKET_GREET * const greet_packet, const MYSQLND_OPTIONS * const options, unsigned long mysql_flags - TSRMLS_DC) + TSRMLS_DC + ) { - const MYSQLND_CHARSET * charset = NULL; enum_func_status ret = FAIL; - MYSQLND_PACKET_AUTH * auth_packet = conn->protocol->m.get_auth_packet(conn->protocol, FALSE TSRMLS_CC); - MYSQLND_PACKET_OK * ok_packet = conn->protocol->m.get_ok_packet(conn->protocol, FALSE TSRMLS_CC); - - DBG_ENTER("mysqlnd_connect_run_authentication"); - - if (!auth_packet || !ok_packet) { - SET_OOM_ERROR(conn->error_info); - goto err; - } + const MYSQLND_CHARSET * charset; + MYSQLND_PACKET_AUTH * auth_packet; + DBG_ENTER("mysqlnd_switch_to_ssl_if_needed"); -#ifdef MYSQLND_SSL_SUPPORTED - if ((greet_packet->server_capabilities & CLIENT_SSL) && (mysql_flags & CLIENT_SSL)) { - auth_packet->send_half_packet = TRUE; + auth_packet = conn->protocol->m.get_auth_packet(conn->protocol, FALSE TSRMLS_CC); + if (!auth_packet) { + SET_OOM_ERROR(*conn->error_info); + goto end; } -#endif - auth_packet->user = user; - auth_packet->password = passwd; + auth_packet->client_flags = mysql_flags; + auth_packet->max_packet_size = MYSQLND_ASSEMBLED_PACKET_MAX_SIZE; if (options->charset_name && (charset = mysqlnd_find_charset_name(options->charset_name))) { auth_packet->charset_no = charset->nr; @@ -469,106 +446,201 @@ mysqlnd_connect_run_authentication( auth_packet->charset_no = greet_packet->charset_no; #endif } - auth_packet->db = db; - auth_packet->db_len = db_len; - auth_packet->max_packet_size= MYSQLND_ASSEBLED_PACKET_MAX_SIZE; - auth_packet->client_flags= mysql_flags; - - conn->scramble = auth_packet->server_scramble_buf = mnd_pemalloc(SCRAMBLE_LENGTH, conn->persistent); - if (!conn->scramble) { - SET_OOM_ERROR(conn->error_info); - goto err; - } - memcpy(auth_packet->server_scramble_buf, greet_packet->scramble_buf, SCRAMBLE_LENGTH); - - if (!PACKET_WRITE(auth_packet, conn)) { - CONN_SET_STATE(conn, CONN_QUIT_SENT); - SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone); - goto err; - } #ifdef MYSQLND_SSL_SUPPORTED - if (auth_packet->send_half_packet) { + if ((greet_packet->server_capabilities & CLIENT_SSL) && (mysql_flags & CLIENT_SSL)) { zend_bool verify = mysql_flags & CLIENT_SSL_VERIFY_SERVER_CERT? TRUE:FALSE; DBG_INF("Switching to SSL"); - - conn->net->m.set_client_option(conn->net, MYSQL_OPT_SSL_VERIFY_SERVER_CERT, (const char *) &verify TSRMLS_CC); - - if (FAIL == conn->net->m.enable_ssl(conn->net TSRMLS_CC)) { - goto err; - } - - auth_packet->send_half_packet = FALSE; if (!PACKET_WRITE(auth_packet, conn)) { CONN_SET_STATE(conn, CONN_QUIT_SENT); - SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone); - goto err; + SET_CLIENT_ERROR(*conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone); + goto end; } - } -#endif + conn->net->m.set_client_option(conn->net, MYSQL_OPT_SSL_VERIFY_SERVER_CERT, (const char *) &verify TSRMLS_CC); - if (FAIL == PACKET_READ(ok_packet, conn) || ok_packet->field_count >= 0xFE) { - if (ok_packet->field_count == 0xFE) { - /* old authentication with new server !*/ - DBG_ERR(mysqlnd_old_passwd); - SET_CLIENT_ERROR(conn->error_info, CR_UNKNOWN_ERROR, UNKNOWN_SQLSTATE, mysqlnd_old_passwd); - } else if (ok_packet->field_count == 0xFF) { - if (ok_packet->sqlstate[0]) { - strlcpy(conn->error_info.sqlstate, ok_packet->sqlstate, sizeof(conn->error_info.sqlstate)); - DBG_ERR_FMT("ERROR:%u [SQLSTATE:%s] %s", ok_packet->error_no, ok_packet->sqlstate, ok_packet->error); - } - conn->error_info.error_no = ok_packet->error_no; - strlcpy(conn->error_info.error, ok_packet->error, sizeof(conn->error_info.error)); + if (FAIL == conn->net->m.enable_ssl(conn->net TSRMLS_CC)) { + goto end; } - goto err; } - - SET_NEW_MESSAGE(conn->last_message, conn->last_message_len, - ok_packet->message, ok_packet->message_len, - conn->persistent); - conn->charset = mysqlnd_find_charset_nr(auth_packet->charset_no); +#endif ret = PASS; -err: +end: PACKET_FREE(auth_packet); - PACKET_FREE(ok_packet); DBG_RETURN(ret); } /* }}} */ -#define MYSQLND_CAPABILITIES (CLIENT_LONG_PASSWORD | CLIENT_LONG_FLAG | CLIENT_TRANSACTIONS | \ - CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION | \ - CLIENT_MULTI_RESULTS) +/* {{{ mysqlnd_connect_run_authentication */ +static enum_func_status +mysqlnd_connect_run_authentication( + MYSQLND_CONN_DATA * conn, + const char * const user, + const char * const passwd, + const char * const db, + size_t db_len, + size_t passwd_len, + const MYSQLND_PACKET_GREET * const greet_packet, + const MYSQLND_OPTIONS * const options, + unsigned long mysql_flags + TSRMLS_DC) +{ + enum_func_status ret = FAIL; + DBG_ENTER("mysqlnd_connect_run_authentication"); + ret = mysqlnd_switch_to_ssl_if_needed(conn, greet_packet, options, mysql_flags TSRMLS_CC); + if (PASS == ret) { + zend_bool first_call = TRUE; + char * switch_to_auth_protocol = NULL; + size_t switch_to_auth_protocol_len = 0; + char * requested_protocol = NULL; + zend_uchar * plugin_data; + size_t plugin_data_len; -/* {{{ mysqlnd_conn::connect */ + plugin_data_len = greet_packet->auth_plugin_data_len; + plugin_data = mnd_emalloc(plugin_data_len + 1); + if (!plugin_data) { + ret = FAIL; + goto end; + } + memcpy(plugin_data, greet_packet->auth_plugin_data, plugin_data_len); + plugin_data[plugin_data_len] = '\0'; + + requested_protocol = mnd_pestrdup(greet_packet->auth_protocol? greet_packet->auth_protocol: "mysql_native_password", FALSE); + if (!requested_protocol) { + ret = FAIL; + goto end; + } + + do { + struct st_mysqlnd_authentication_plugin * auth_plugin; + { + char * plugin_name = NULL; + + 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); + + if (!auth_plugin) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "The server requested authentication method unknown to the client [%s]", requested_protocol); + SET_CLIENT_ERROR(*conn->error_info, CR_NOT_IMPLEMENTED, UNKNOWN_SQLSTATE, "The server requested authentication method umknown to the client"); + break; + } + } + DBG_INF("plugin found"); + + { + zend_uchar * switch_to_auth_protocol_data = NULL; + size_t switch_to_auth_protocol_data_len = 0; + zend_uchar * scrambled_data = NULL; + size_t scrambled_data_len = 0; + + switch_to_auth_protocol = NULL; + switch_to_auth_protocol_len = 0; + + if (conn->auth_plugin_data) { + mnd_pefree(conn->auth_plugin_data, conn->persistent); + conn->auth_plugin_data = NULL; + } + conn->auth_plugin_data_len = plugin_data_len; + conn->auth_plugin_data = mnd_pemalloc(conn->auth_plugin_data_len, conn->persistent); + if (!conn->auth_plugin_data) { + SET_OOM_ERROR(*conn->error_info); + goto end; + } + memcpy(conn->auth_plugin_data, plugin_data, plugin_data_len); + + DBG_INF_FMT("salt=[%*s]", plugin_data_len - 1, plugin_data); + /* The data should be allocated with malloc() */ + scrambled_data = + auth_plugin->methods.get_auth_data(NULL, &scrambled_data_len, conn, user, passwd, passwd_len, + plugin_data, plugin_data_len, options, mysql_flags TSRMLS_CC); + + + ret = mysqlnd_auth_handshake(conn, user, passwd, passwd_len, db, db_len, options, mysql_flags, + greet_packet->charset_no, + first_call, + requested_protocol, + scrambled_data, scrambled_data_len, + &switch_to_auth_protocol, &switch_to_auth_protocol_len, + &switch_to_auth_protocol_data, &switch_to_auth_protocol_data_len + TSRMLS_CC); + first_call = FALSE; + free(scrambled_data); + + DBG_INF_FMT("switch_to_auth_protocol=%s", switch_to_auth_protocol? switch_to_auth_protocol:"n/a"); + if (requested_protocol && switch_to_auth_protocol) { + mnd_efree(requested_protocol); + requested_protocol = switch_to_auth_protocol; + } + + if (plugin_data) { + mnd_efree(plugin_data); + } + plugin_data_len = switch_to_auth_protocol_data_len; + plugin_data = switch_to_auth_protocol_data; + } + DBG_INF_FMT("conn->error_info->error_no = %d", conn->error_info->error_no); + } while (ret == FAIL && conn->error_info->error_no == 0 && switch_to_auth_protocol != NULL); + if (plugin_data) { + mnd_efree(plugin_data); + } + + if (ret == PASS) { + DBG_INF_FMT("saving requested_protocol=%s", requested_protocol); + conn->m->set_client_option(conn, MYSQLND_OPT_AUTH_PROTOCOL, requested_protocol TSRMLS_CC); + } + + if (requested_protocol) { + mnd_efree(requested_protocol); + } + } +end: + DBG_RETURN(ret); +} +/* }}} */ + + +/* {{{ mysqlnd_conn_data::connect */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND * conn, +MYSQLND_METHOD(mysqlnd_conn_data, connect)(MYSQLND_CONN_DATA * conn, const char *host, const char *user, const char *passwd, unsigned int passwd_len, const char *db, unsigned int db_len, unsigned int port, - const char * socket_or_pipe, + const char *socket_or_pipe, unsigned int mysql_flags TSRMLS_DC) { - char *errstr = NULL; - int errcode = 0, host_len; + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, connect); + size_t host_len; zend_bool unix_socket = FALSE; + zend_bool named_pipe = FALSE; zend_bool reconnect = FALSE; zend_bool saved_compression = FALSE; + zend_bool local_tx_started = FALSE; MYSQLND_PACKET_GREET * greet_packet = NULL; - DBG_ENTER("mysqlnd_conn::connect"); + DBG_ENTER("mysqlnd_conn_data::connect"); + + if (PASS != conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + goto err; + } + local_tx_started = TRUE; + + SET_EMPTY_ERROR(*conn->error_info); + SET_ERROR_AFF_ROWS(conn); DBG_INF_FMT("host=%s user=%s db=%s port=%u flags=%u persistent=%u state=%u", host?host:"", user?user:"", db?db:"", port, mysql_flags, conn? conn->persistent:0, conn? CONN_GET_STATE(conn):-1); - if (conn && CONN_GET_STATE(conn) > CONN_ALLOCED && CONN_GET_STATE(conn) ) { + if (CONN_GET_STATE(conn) > CONN_ALLOCED && CONN_GET_STATE(conn) ) { DBG_INF("Connecting on a connected handle."); if (CONN_GET_STATE(conn) < CONN_QUIT_SENT) { @@ -592,6 +664,9 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND * conn, saved_compression = TRUE; conn->net->compressed = 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 TSRMLS_CC); } if (!host || !host[0]) { @@ -622,24 +697,31 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND * conn, if (!socket_or_pipe) { socket_or_pipe = "/tmp/mysql.sock"; } - transport_len = spprintf(&transport, 0, "unix://%s", socket_or_pipe); + transport_len = mnd_sprintf(&transport, 0, "unix://%s", socket_or_pipe); unix_socket = TRUE; - } else +#else + if (host_len == sizeof(".") - 1 && host[0] == '.') { + /* named pipe in socket */ + if (!socket_or_pipe) { + socket_or_pipe = "\\\\.\\pipe\\MySQL"; + } + transport_len = mnd_sprintf(&transport, 0, "pipe://%s", socket_or_pipe); + named_pipe = TRUE; #endif - { + } else { if (!port) { port = 3306; } - transport_len = spprintf(&transport, 0, "tcp://%s:%u", host, port); + transport_len = mnd_sprintf(&transport, 0, "tcp://%s:%u", host, port); } if (!transport) { - SET_OOM_ERROR(conn->error_info); + SET_OOM_ERROR(*conn->error_info); goto err; /* OOM */ } DBG_INF_FMT("transport=%s conn->scheme=%s", transport, conn->scheme); conn->scheme = mnd_pestrndup(transport, transport_len, conn->persistent); conn->scheme_len = transport_len; - efree(transport); /* allocated by spprintf */ + mnd_sprintf_free(transport); transport = NULL; if (!conn->scheme) { goto err; /* OOM */ @@ -648,11 +730,13 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND * conn, greet_packet = conn->protocol->m.get_greet_packet(conn->protocol, FALSE TSRMLS_CC); if (!greet_packet) { - SET_OOM_ERROR(conn->error_info); + SET_OOM_ERROR(*conn->error_info); goto err; /* OOM */ } - if (FAIL == conn->net->m.connect(conn->net, conn->scheme, conn->scheme_len, conn->persistent, &errstr, &errcode TSRMLS_CC)) { + if (FAIL == conn->net->m.connect_ex(conn->net, conn->scheme, conn->scheme_len, conn->persistent, + conn->stats, conn->error_info TSRMLS_CC)) + { goto err; } @@ -664,13 +748,13 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND * conn, goto err; } else if (greet_packet->error_no) { DBG_ERR_FMT("errorno=%u error=%s", greet_packet->error_no, greet_packet->error); - SET_CLIENT_ERROR(conn->error_info, greet_packet->error_no, greet_packet->sqlstate, greet_packet->error); + SET_CLIENT_ERROR(*conn->error_info, greet_packet->error_no, greet_packet->sqlstate, greet_packet->error); goto err; } else if (greet_packet->pre41) { DBG_ERR_FMT("Connecting to 3.22, 3.23 & 4.0 is not supported. Server is %-.32s", greet_packet->server_version); php_error_docref(NULL TSRMLS_CC, E_WARNING, "Connecting to 3.22, 3.23 & 4.0 " " is not supported. Server is %-.32s", greet_packet->server_version); - SET_CLIENT_ERROR(conn->error_info, CR_NOT_IMPLEMENTED, UNKNOWN_SQLSTATE, + SET_CLIENT_ERROR(*conn->error_info, CR_NOT_IMPLEMENTED, UNKNOWN_SQLSTATE, "Connecting to 3.22, 3.23 & 4.0 servers is not supported"); goto err; } @@ -681,7 +765,6 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND * conn, conn->greet_charset = mysqlnd_find_charset_nr(greet_packet->charset_no); /* we allow load data local infile by default */ - mysql_flags |= CLIENT_LOCAL_FILES | CLIENT_PS_MULTI_RESULTS; mysql_flags |= MYSQLND_CAPABILITIES; if (db) { @@ -713,7 +796,9 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND * conn, } #endif - if (FAIL == mysqlnd_connect_run_authentication(conn, user, passwd, db, db_len, greet_packet, &conn->options, mysql_flags TSRMLS_CC)) { + if (FAIL == mysqlnd_connect_run_authentication(conn, user, passwd, db, db_len, (size_t) passwd_len, + greet_packet, conn->options, mysql_flags TSRMLS_CC)) + { goto err; } @@ -739,49 +824,66 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND * conn, conn->connect_or_select_db_len = db_len; if (!conn->user || !conn->passwd || !conn->connect_or_select_db) { - SET_OOM_ERROR(conn->error_info); + SET_OOM_ERROR(*conn->error_info); goto err; /* OOM */ } - if (!unix_socket) { + if (!unix_socket && !named_pipe) { conn->host = mnd_pestrdup(host, conn->persistent); if (!conn->host) { - SET_OOM_ERROR(conn->error_info); + SET_OOM_ERROR(*conn->error_info); goto err; /* OOM */ } conn->host_len = strlen(conn->host); { char *p; - spprintf(&p, 0, "%s via TCP/IP", conn->host); + mnd_sprintf(&p, 0, "%s via TCP/IP", conn->host); if (!p) { - SET_OOM_ERROR(conn->error_info); + SET_OOM_ERROR(*conn->error_info); goto err; /* OOM */ } conn->host_info = mnd_pestrdup(p, conn->persistent); - efree(p); /* allocated by spprintf */ + mnd_sprintf_free(p); if (!conn->host_info) { - SET_OOM_ERROR(conn->error_info); + SET_OOM_ERROR(*conn->error_info); goto err; /* OOM */ } } } else { - conn->unix_socket = mnd_pestrdup(socket_or_pipe, conn->persistent); - conn->host_info = mnd_pestrdup("Localhost via UNIX socket", conn->persistent); + conn->unix_socket = mnd_pestrdup(socket_or_pipe, 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); + if (!p) { + SET_OOM_ERROR(*conn->error_info); + goto err; /* OOM */ + } + conn->host_info = mnd_pestrdup(p, conn->persistent); + mnd_sprintf_free(p); + if (!conn->host_info) { + SET_OOM_ERROR(*conn->error_info); + goto err; /* OOM */ + } + } else { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Impossible. Should be either socket or a pipe. Report a bug!"); + } if (!conn->unix_socket || !conn->host_info) { - SET_OOM_ERROR(conn->error_info); + SET_OOM_ERROR(*conn->error_info); goto err; /* OOM */ } conn->unix_socket_len = strlen(conn->unix_socket); } conn->client_flag = mysql_flags; - conn->max_packet_size = MYSQLND_ASSEBLED_PACKET_MAX_SIZE; + conn->max_packet_size = MYSQLND_ASSEMBLED_PACKET_MAX_SIZE; /* todo: check if charset is available */ conn->server_capabilities = greet_packet->server_capabilities; - conn->upsert_status.warning_count = 0; - conn->upsert_status.server_status = greet_packet->server_status; - conn->upsert_status.affected_rows = 0; + conn->upsert_status->warning_count = 0; + conn->upsert_status->server_status = greet_packet->server_status; + conn->upsert_status->affected_rows = 0; - SET_EMPTY_ERROR(conn->error_info); + SET_EMPTY_ERROR(*conn->error_info); mysqlnd_local_infile_default(conn); @@ -792,10 +894,10 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND * conn, DBG_INF("unicode set"); } #endif - if (conn->options.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]; + 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) TSRMLS_CC)) { @@ -825,33 +927,63 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND * conn, PACKET_FREE(greet_packet); + conn->m->local_tx_end(conn, this_func, PASS TSRMLS_CC); DBG_RETURN(PASS); } err: PACKET_FREE(greet_packet); - if (errstr) { - DBG_ERR_FMT("[%u] %.128s (trying to connect via %s)", errcode, errstr, conn->scheme); - SET_CLIENT_ERROR(conn->error_info, errcode? errcode:CR_CONNECTION_ERROR, UNKNOWN_SQLSTATE, errstr); - php_error_docref(NULL TSRMLS_CC, E_WARNING, "[%u] %.128s (trying to connect via %s)", errcode, errstr, conn->scheme); - /* no mnd_ since we don't allocate it */ - efree(errstr); + DBG_ERR_FMT("[%u] %.128s (trying to connect via %s)", conn->error_info->error_no, conn->error_info->error, conn->scheme); + if (!conn->error_info->error_no) { + SET_CLIENT_ERROR(*conn->error_info, CR_CONNECTION_ERROR, UNKNOWN_SQLSTATE, conn->error_info->error? conn->error_info->error:"Unknown error"); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "[%u] %.128s (trying to connect via %s)", + conn->error_info->error_no, conn->error_info->error, conn->scheme); } + conn->m->free_contents(conn TSRMLS_CC); MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_CONNECT_FAILURE); + if (TRUE == local_tx_started) { + conn->m->local_tx_end(conn, this_func, FAIL TSRMLS_CC); + } DBG_RETURN(FAIL); } /* }}} */ +/* {{{ mysqlnd_conn::connect */ +static enum_func_status +MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND * conn_handle, + const char * host, const char * user, + const char * passwd, unsigned int passwd_len, + const char * db, unsigned int db_len, + unsigned int port, + const char * socket_or_pipe, + unsigned int mysql_flags + TSRMLS_DC) +{ + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, connect); + enum_func_status ret = FAIL; + MYSQLND_CONN_DATA * conn = conn_handle->data; + + DBG_ENTER("mysqlnd_conn::connect"); + + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + ret = conn->m->connect(conn, host, user, passwd, passwd_len, db, db_len, port, socket_or_pipe, mysql_flags TSRMLS_CC); + + conn->m->local_tx_end(conn, this_func, FAIL TSRMLS_CC); + } + DBG_RETURN(ret); +} + + /* {{{ mysqlnd_connect */ -PHPAPI MYSQLND * mysqlnd_connect(MYSQLND * conn, - const char *host, const char *user, - const char *passwd, unsigned int passwd_len, - const char *db, unsigned int db_len, +PHPAPI MYSQLND * mysqlnd_connect(MYSQLND * conn_handle, + const char * host, const char * user, + const char * passwd, unsigned int passwd_len, + const char * db, unsigned int db_len, unsigned int port, - const char *socket_or_pipe, + const char * socket_or_pipe, unsigned int mysql_flags TSRMLS_DC) { @@ -861,15 +993,15 @@ PHPAPI MYSQLND * mysqlnd_connect(MYSQLND * conn, DBG_ENTER("mysqlnd_connect"); DBG_INF_FMT("host=%s user=%s db=%s port=%u flags=%u", host?host:"", user?user:"", db?db:"", port, mysql_flags); - if (!conn) { + if (!conn_handle) { self_alloced = TRUE; - if (!(conn = mysqlnd_init(FALSE))) { + if (!(conn_handle = mysqlnd_init(FALSE))) { /* OOM */ DBG_RETURN(NULL); } } - ret = conn->m->connect(conn, host, user, passwd, passwd_len, db, db_len, port, socket_or_pipe, mysql_flags TSRMLS_CC); + ret = conn_handle->m->connect(conn_handle, host, user, passwd, passwd_len, db, db_len, port, socket_or_pipe, mysql_flags TSRMLS_CC); if (ret == FAIL) { if (self_alloced) { @@ -877,215 +1009,88 @@ PHPAPI MYSQLND * mysqlnd_connect(MYSQLND * conn, We have alloced, thus there are no references to this object - we are free to kill it! */ - conn->m->dtor(conn TSRMLS_CC); + conn_handle->m->dtor(conn_handle TSRMLS_CC); } DBG_RETURN(NULL); } - DBG_RETURN(conn); + DBG_RETURN(conn_handle); } /* }}} */ -/* {{{ mysqlnd_conn::change_user */ -static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, change_user)(MYSQLND * const conn, - const char *user, - const char *passwd, - const char *db, - zend_bool silent TSRMLS_DC) -{ - size_t user_len; - enum_func_status ret = FAIL; - MYSQLND_PACKET_CHG_USER_RESPONSE * chg_user_resp; - char buffer[MYSQLND_MAX_ALLOWED_USER_LEN + 1 + 1 + SCRAMBLE_LENGTH + MYSQLND_MAX_ALLOWED_DB_LEN + 1 + 2 /* charset*/ + 2]; - char *p = buffer; - const MYSQLND_CHARSET * old_cs = conn->charset; - - DBG_ENTER("mysqlnd_conn::change_user"); - DBG_INF_FMT("conn=%llu user=%s passwd=%s db=%s silent=%u", - conn->thread_id, user?user:"", passwd?"***":"null", db?db:"", (silent == TRUE)?1:0 ); - - SET_ERROR_AFF_ROWS(conn); - - if (!user) { - user = ""; - } - if (!passwd) { - passwd = ""; - } - if (!db) { - db = ""; - } - - /* 1. user ASCIIZ */ - user_len = MIN(strlen(user), MYSQLND_MAX_ALLOWED_USER_LEN); - memcpy(p, user, user_len); - p += user_len; - *p++ = '\0'; - - /* 2. password SCRAMBLE_LENGTH followed by the scramble or \0 */ - if (passwd[0]) { - *p++ = SCRAMBLE_LENGTH; - php_mysqlnd_scramble((unsigned char *)p, conn->scramble, (unsigned char *)passwd); - p += SCRAMBLE_LENGTH; - } else { - *p++ = '\0'; - } - - /* 3. db ASCIIZ */ - if (db[0]) { - size_t db_len = MIN(strlen(db), MYSQLND_MAX_ALLOWED_DB_LEN); - memcpy(p, db, db_len); - p += db_len; - } - *p++ = '\0'; - - /* - 4. request the current charset, or it will be reset to the system one. - 5.0 doesn't support it. Support added in 5.1.23 by fixing the following bug : - Bug #30472 libmysql doesn't reset charset, insert_id after succ. mysql_change_user() call - */ - if (mysqlnd_get_server_version(conn) >= 50123) { - int2store(p, conn->charset->nr); - p+=2; - } - - if (PASS != conn->m->simple_command(conn, COM_CHANGE_USER, buffer, p - buffer, - PROT_LAST /* we will handle the OK packet*/, - silent, TRUE TSRMLS_CC)) { - DBG_RETURN(FAIL); - } - - chg_user_resp = conn->protocol->m.get_change_user_response_packet(conn->protocol, FALSE TSRMLS_CC); - if (!chg_user_resp) { - SET_OOM_ERROR(conn->error_info); - goto end; - } - ret = PACKET_READ(chg_user_resp, conn); - conn->error_info = chg_user_resp->error_info; - - if (conn->error_info.error_no) { - ret = FAIL; - /* - COM_CHANGE_USER is broken in 5.1. At least in 5.1.15 and 5.1.14, 5.1.11 is immune. - bug#25371 mysql_change_user() triggers "packets out of sync" - When it gets fixed, there should be one more check here - */ - if (mysqlnd_get_server_version(conn) > 50113L && mysqlnd_get_server_version(conn) < 50118L) { - MYSQLND_PACKET_OK * redundant_error_packet = conn->protocol->m.get_ok_packet(conn->protocol, FALSE TSRMLS_CC); - if (redundant_error_packet) { - PACKET_READ(redundant_error_packet, conn); - PACKET_FREE(redundant_error_packet); - DBG_INF_FMT("Server is %u, buggy, sends two ERR messages", mysqlnd_get_server_version(conn)); - } else { - SET_OOM_ERROR(conn->error_info); - } - } - } - if (ret == PASS) { - char * tmp = NULL; - /* if we get conn->user as parameter and then we first free it, then estrndup it, we will crash */ - tmp = mnd_pestrndup(user, user_len, conn->persistent); - if (conn->user) { - mnd_pefree(conn->user, conn->persistent); - } - conn->user = tmp; - - tmp = mnd_pestrdup(passwd, conn->persistent); - if (conn->passwd) { - mnd_pefree(conn->passwd, conn->persistent); - } - conn->passwd = tmp; - - if (conn->last_message) { - mnd_pefree(conn->last_message, conn->persistent); - conn->last_message = NULL; - } - memset(&conn->upsert_status, 0, sizeof(conn->upsert_status)); - /* set charset for old servers */ - if (mysqlnd_get_server_version(conn) < 50123) { - ret = conn->m->set_charset(conn, old_cs->name TSRMLS_CC); - } - } else if (ret == FAIL && chg_user_resp->server_asked_323_auth == TRUE) { - /* old authentication with new server !*/ - DBG_ERR(mysqlnd_old_passwd); - SET_CLIENT_ERROR(conn->error_info, CR_UNKNOWN_ERROR, UNKNOWN_SQLSTATE, mysqlnd_old_passwd); - } -end: - PACKET_FREE(chg_user_resp); - - /* - Here we should close all statements. Unbuffered queries should not be a - problem as we won't allow sending COM_CHANGE_USER. - */ - DBG_INF(ret == PASS? "PASS":"FAIL"); - DBG_RETURN(ret); -} -/* }}} */ - - -/* {{{ mysqlnd_conn::query */ +/* {{{ mysqlnd_conn_data::query */ /* - If conn->error_info.error_no is not zero, then we had an error. + 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, query)(MYSQLND * conn, const char * query, unsigned int query_len TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, query)(MYSQLND_CONN_DATA * conn, const char * query, unsigned int query_len TSRMLS_DC) { + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, query); enum_func_status ret = FAIL; - DBG_ENTER("mysqlnd_conn::query"); + DBG_ENTER("mysqlnd_conn_data::query"); DBG_INF_FMT("conn=%llu query=%s", conn->thread_id, query); - if (PASS == conn->m->send_query(conn, query, query_len TSRMLS_CC) && - PASS == conn->m->reap_query(conn TSRMLS_CC)) - { - ret = PASS; - if (conn->last_query_type == QUERY_UPSERT && conn->upsert_status.affected_rows) { - MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn->stats, STAT_ROWS_AFFECTED_NORMAL, conn->upsert_status.affected_rows); + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + if (PASS == conn->m->send_query(conn, query, query_len TSRMLS_CC) && + PASS == conn->m->reap_query(conn TSRMLS_CC)) + { + ret = PASS; + if (conn->last_query_type == QUERY_UPSERT && conn->upsert_status->affected_rows) { + MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn->stats, STAT_ROWS_AFFECTED_NORMAL, conn->upsert_status->affected_rows); + } } + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); } DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_conn::send_query */ +/* {{{ mysqlnd_conn_data::send_query */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, send_query)(MYSQLND * conn, const char * query, unsigned int query_len TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, send_query)(MYSQLND_CONN_DATA * conn, const char * query, unsigned int query_len TSRMLS_DC) { + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, send_query); enum_func_status ret; - DBG_ENTER("mysqlnd_conn::send_query"); + DBG_ENTER("mysqlnd_conn_data::send_query"); DBG_INF_FMT("conn=%llu query=%s", conn->thread_id, query); - ret = conn->m->simple_command(conn, COM_QUERY, query, query_len, - PROT_LAST /* we will handle the OK packet*/, - FALSE, FALSE TSRMLS_CC); - if (PASS == ret) { - CONN_SET_STATE(conn, CONN_QUERY_SENT); + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + ret = conn->m->simple_command(conn, COM_QUERY, (zend_uchar *) query, query_len, + PROT_LAST /* we will handle the OK packet*/, + FALSE, FALSE TSRMLS_CC); + if (PASS == ret) { + CONN_SET_STATE(conn, CONN_QUERY_SENT); + } + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); } DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_conn::reap_query */ +/* {{{ mysqlnd_conn_data::reap_query */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, reap_query)(MYSQLND * conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, reap_query)(MYSQLND_CONN_DATA * conn TSRMLS_DC) { + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, reap_query); enum_mysqlnd_connection_state state = CONN_GET_STATE(conn); - DBG_ENTER("mysqlnd_conn::reap_query"); + enum_func_status ret = FAIL; + DBG_ENTER("mysqlnd_conn_data::reap_query"); DBG_INF_FMT("conn=%llu", conn->thread_id); - if (state <= CONN_READY || state == CONN_QUIT_SENT) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Connection not opened, clear or has been closed"); - DBG_ERR_FMT("Connection not opened, clear or has been closed. State=%u", state); - DBG_RETURN(FAIL); + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + if (state <= CONN_READY || state == CONN_QUIT_SENT) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Connection not opened, clear or has been closed"); + DBG_ERR_FMT("Connection not opened, clear or has been closed. State=%u", state); + DBG_RETURN(ret); + } + ret = conn->m->query_read_result_set_header(conn, NULL TSRMLS_CC); + + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); } - /* - Here read the result set. We don't do it in simple_command because it need - information from the ok packet. We will fetch it ourselves. - */ - DBG_RETURN(conn->m->query_read_result_set_header(conn, NULL TSRMLS_CC)); + DBG_RETURN(ret); } /* }}} */ @@ -1099,7 +1104,7 @@ MYSQLND ** mysqlnd_stream_array_check_for_readiness(MYSQLND ** conn_array TSRMLS MYSQLND **ret = NULL; while (*p) { - if (CONN_GET_STATE(*p) <= CONN_READY || CONN_GET_STATE(*p) == CONN_QUIT_SENT) { + if (CONN_GET_STATE((*p)->data) <= CONN_READY || CONN_GET_STATE((*p)->data) == CONN_QUIT_SENT) { cnt++; } p++; @@ -1108,7 +1113,7 @@ MYSQLND ** mysqlnd_stream_array_check_for_readiness(MYSQLND ** conn_array TSRMLS MYSQLND **ret_p = ret = ecalloc(cnt + 1, sizeof(MYSQLND *)); p_p = p = conn_array; while (*p) { - if (CONN_GET_STATE(*p) <= CONN_READY || CONN_GET_STATE(*p) == CONN_QUIT_SENT) { + if (CONN_GET_STATE((*p)->data) <= CONN_READY || CONN_GET_STATE((*p)->data) == CONN_QUIT_SENT) { *ret_p = *p; *p = NULL; ret_p++; @@ -1125,7 +1130,7 @@ MYSQLND ** mysqlnd_stream_array_check_for_readiness(MYSQLND ** conn_array TSRMLS /* {{{ stream_select mysqlnd_stream_array_to_fd_set functions */ -static int mysqlnd_stream_array_to_fd_set(MYSQLND **conn_array, fd_set *fds, php_socket_t *max_fd TSRMLS_DC) +static int mysqlnd_stream_array_to_fd_set(MYSQLND ** conn_array, fd_set * fds, php_socket_t * max_fd TSRMLS_DC) { php_socket_t this_fd; int cnt = 0; @@ -1137,7 +1142,7 @@ static int mysqlnd_stream_array_to_fd_set(MYSQLND **conn_array, fd_set *fds, php * when casting. It is only used here so that the buffered data warning * is not displayed. * */ - if (SUCCESS == php_stream_cast((*p)->net->stream, PHP_STREAM_AS_FD_FOR_SELECT | PHP_STREAM_CAST_INTERNAL, + if (SUCCESS == php_stream_cast((*p)->data->net->stream, PHP_STREAM_AS_FD_FOR_SELECT | PHP_STREAM_CAST_INTERNAL, (void*)&this_fd, 1) && this_fd >= 0) { PHP_SAFE_FD_SET(this_fd, fds); @@ -1152,7 +1157,7 @@ static int mysqlnd_stream_array_to_fd_set(MYSQLND **conn_array, fd_set *fds, php return cnt ? 1 : 0; } -static int mysqlnd_stream_array_from_fd_set(MYSQLND **conn_array, fd_set *fds TSRMLS_DC) +static int mysqlnd_stream_array_from_fd_set(MYSQLND ** conn_array, fd_set * fds TSRMLS_DC) { php_socket_t this_fd; int ret = 0; @@ -1162,7 +1167,7 @@ static int mysqlnd_stream_array_from_fd_set(MYSQLND **conn_array, fd_set *fds TS MYSQLND **fwd = conn_array, **bckwd = conn_array; while (*fwd) { - if (SUCCESS == php_stream_cast((*fwd)->net->stream, PHP_STREAM_AS_FD_FOR_SELECT | PHP_STREAM_CAST_INTERNAL, + if (SUCCESS == php_stream_cast((*fwd)->data->net->stream, PHP_STREAM_AS_FD_FOR_SELECT | PHP_STREAM_CAST_INTERNAL, (void*)&this_fd, 1) && this_fd >= 0) { if (PHP_SAFE_FD_ISSET(this_fd, fds)) { if (disproportion) { @@ -1183,25 +1188,26 @@ static int mysqlnd_stream_array_from_fd_set(MYSQLND **conn_array, fd_set *fds TS } /* }}} */ + #ifndef PHP_WIN32 #define php_select(m, r, w, e, t) select(m, r, w, e, t) #else #include "win32/select.h" #endif + /* {{{ _mysqlnd_poll */ PHPAPI enum_func_status _mysqlnd_poll(MYSQLND **r_array, MYSQLND **e_array, MYSQLND ***dont_poll, long sec, long usec, uint * desc_num TSRMLS_DC) { - struct timeval tv; struct timeval *tv_p = NULL; fd_set rfds, wfds, efds; php_socket_t max_fd = 0; int retval, sets = 0; int set_count, max_set_count = 0; - DBG_ENTER("mysqlnd_poll"); + DBG_ENTER("_mysqlnd_poll"); if (sec < 0 || usec < 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Negative values passed for sec and/or usec"); DBG_RETURN(FAIL); @@ -1264,7 +1270,6 @@ _mysqlnd_poll(MYSQLND **r_array, MYSQLND **e_array, MYSQLND ***dont_poll, long s } *desc_num = retval; - DBG_RETURN(PASS); } /* }}} */ @@ -1277,322 +1282,385 @@ _mysqlnd_poll(MYSQLND **r_array, MYSQLND **e_array, MYSQLND ***dont_poll, long s - The EOF packet is consumed by the metadata packet reader. */ -/* {{{ mysqlnd_conn::list_fields */ +/* {{{ mysqlnd_conn_data::list_fields */ MYSQLND_RES * -MYSQLND_METHOD(mysqlnd_conn, list_fields)(MYSQLND * conn, const char *table, const char *achtung_wild TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, list_fields)(MYSQLND_CONN_DATA * conn, const char *table, const char *achtung_wild TSRMLS_DC) { + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, list_fields); /* db + \0 + wild + \0 (for wild) */ - char buff[MYSQLND_MAX_ALLOWED_DB_LEN * 2 + 1 + 1], *p; + zend_uchar buff[MYSQLND_MAX_ALLOWED_DB_LEN * 2 + 1 + 1], *p; size_t table_len, wild_len; - MYSQLND_RES *result = NULL; - DBG_ENTER("mysqlnd_conn::list_fields"); + MYSQLND_RES * result = NULL; + DBG_ENTER("mysqlnd_conn_data::list_fields"); DBG_INF_FMT("conn=%llu table=%s wild=%s", conn->thread_id, table? table:"",achtung_wild? achtung_wild:""); - p = buff; - if (table && (table_len = strlen(table))) { - size_t to_copy = MIN(table_len, MYSQLND_MAX_ALLOWED_DB_LEN); - memcpy(p, table, to_copy); - p += to_copy; - *p++ = '\0'; - } + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + do { + p = buff; + if (table && (table_len = strlen(table))) { + size_t to_copy = MIN(table_len, MYSQLND_MAX_ALLOWED_DB_LEN); + memcpy(p, table, to_copy); + p += to_copy; + *p++ = '\0'; + } - if (achtung_wild && (wild_len = strlen(achtung_wild))) { - size_t to_copy = MIN(wild_len, MYSQLND_MAX_ALLOWED_DB_LEN); - memcpy(p, achtung_wild, to_copy); - p += to_copy; - *p++ = '\0'; - } + if (achtung_wild && (wild_len = strlen(achtung_wild))) { + size_t to_copy = MIN(wild_len, MYSQLND_MAX_ALLOWED_DB_LEN); + memcpy(p, achtung_wild, to_copy); + p += to_copy; + *p++ = '\0'; + } - if (PASS != conn->m->simple_command(conn, COM_FIELD_LIST, buff, p - buff, - PROT_LAST /* we will handle the OK packet*/, - FALSE, TRUE TSRMLS_CC)) { - DBG_RETURN(NULL); - } + if (PASS != conn->m->simple_command(conn, COM_FIELD_LIST, buff, p - buff, + PROT_LAST /* we will handle the OK packet*/, + FALSE, TRUE TSRMLS_CC)) { + conn->m->local_tx_end(conn, 0, FAIL TSRMLS_CC); + break; + } - /* - Prepare for the worst case. - MyISAM goes to 2500 BIT columns, double it for safety. - */ - result = conn->m->result_init(5000, conn->persistent TSRMLS_CC); - if (!result) { - DBG_RETURN(NULL); - } + /* + Prepare for the worst case. + MyISAM goes to 2500 BIT columns, double it for safety. + */ + result = conn->m->result_init(5000, conn->persistent TSRMLS_CC); + if (!result) { + break; + } - if (FAIL == result->m.read_result_metadata(result, conn TSRMLS_CC)) { - DBG_ERR("Error ocurred while reading metadata"); - result->m.free_result(result, TRUE TSRMLS_CC); - DBG_RETURN(NULL); - } + if (FAIL == result->m.read_result_metadata(result, conn TSRMLS_CC)) { + DBG_ERR("Error ocurred while reading metadata"); + result->m.free_result(result, TRUE TSRMLS_CC); + result = NULL; + break; + } - result->type = MYSQLND_RES_NORMAL; - result->m.fetch_row = result->m.fetch_row_normal_unbuffered; - result->unbuf = mnd_ecalloc(1, sizeof(MYSQLND_RES_UNBUFFERED)); - if (!result->unbuf) { - /* OOM */ - SET_OOM_ERROR(conn->error_info); - result->m.free_result(result, TRUE TSRMLS_CC); - DBG_RETURN(NULL); + result->type = MYSQLND_RES_NORMAL; + result->m.fetch_row = result->m.fetch_row_normal_unbuffered; + result->unbuf = mnd_ecalloc(1, sizeof(MYSQLND_RES_UNBUFFERED)); + if (!result->unbuf) { + /* OOM */ + SET_OOM_ERROR(*conn->error_info); + result->m.free_result(result, TRUE TSRMLS_CC); + result = NULL; + break; + } + result->unbuf->eof_reached = TRUE; + } while (0); + conn->m->local_tx_end(conn, this_func, result == NULL? FAIL:PASS TSRMLS_CC); } - result->unbuf->eof_reached = TRUE; DBG_RETURN(result); } /* }}} */ -/* {{{ mysqlnd_conn::list_method */ +/* {{{ mysqlnd_conn_data::list_method */ MYSQLND_RES * -MYSQLND_METHOD(mysqlnd_conn, list_method)(MYSQLND * conn, const char * query, const char *achtung_wild, char *par1 TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, list_method)(MYSQLND_CONN_DATA * conn, const char * query, const char *achtung_wild, char *par1 TSRMLS_DC) { - char *show_query = NULL; + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, list_method); + char * show_query = NULL; size_t show_query_len; - MYSQLND_RES *result = NULL; + MYSQLND_RES * result = NULL; - DBG_ENTER("mysqlnd_conn::list_method"); + DBG_ENTER("mysqlnd_conn_data::list_method"); DBG_INF_FMT("conn=%llu query=%s wild=%u", conn->thread_id, query, achtung_wild); - if (par1) { - if (achtung_wild) { - show_query_len = spprintf(&show_query, 0, query, par1, achtung_wild); - } else { - show_query_len = spprintf(&show_query, 0, query, par1); - } - } else { - if (achtung_wild) { - show_query_len = spprintf(&show_query, 0, query, achtung_wild); + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + 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 { - show_query_len = strlen(show_query = (char *)query); + 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 TSRMLS_CC)) { - result = conn->m->store_result(conn TSRMLS_CC); - } - if (show_query != query) { - efree(show_query); /* allocated by spprintf */ + if (PASS == conn->m->query(conn, show_query, show_query_len TSRMLS_CC)) { + result = conn->m->store_result(conn TSRMLS_CC); + } + if (show_query != query) { + mnd_sprintf_free(show_query); + } + conn->m->local_tx_end(conn, this_func, result == NULL? FAIL:PASS TSRMLS_CC); } DBG_RETURN(result); } /* }}} */ -/* {{{ mysqlnd_conn::errno */ +/* {{{ mysqlnd_conn_data::errno */ static unsigned int -MYSQLND_METHOD(mysqlnd_conn, errno)(const MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, errno)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC) { - return conn->error_info.error_no; + return conn->error_info->error_no; } /* }}} */ -/* {{{ mysqlnd_conn::error */ +/* {{{ mysqlnd_conn_data::error */ static const char * -MYSQLND_METHOD(mysqlnd_conn, error)(const MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, error)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC) { - return conn->error_info.error; + return conn->error_info->error; } /* }}} */ -/* {{{ mysqlnd_conn::sqlstate */ +/* {{{ mysqlnd_conn_data::sqlstate */ static const char * -MYSQLND_METHOD(mysqlnd_conn, sqlstate)(const MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, sqlstate)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC) { - return conn->error_info.sqlstate[0] ? conn->error_info.sqlstate:MYSQLND_SQLSTATE_NULL; + return conn->error_info->sqlstate[0] ? conn->error_info->sqlstate:MYSQLND_SQLSTATE_NULL; } /* }}} */ /* {{{ mysqlnd_old_escape_string */ -PHPAPI ulong mysqlnd_old_escape_string(char *newstr, const char *escapestr, size_t escapestr_len TSRMLS_DC) +PHPAPI ulong +mysqlnd_old_escape_string(char * newstr, const char * escapestr, size_t escapestr_len TSRMLS_DC) { DBG_ENTER("mysqlnd_old_escape_string"); DBG_RETURN(mysqlnd_cset_escape_slashes(mysqlnd_find_charset_name("latin1"), newstr, escapestr, escapestr_len TSRMLS_CC)); } /* }}} */ -/* {{{ mysqlnd_conn::ssl_set */ + +/* {{{ mysqlnd_conn_data::ssl_set */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, ssl_set)(MYSQLND * const conn, const char * key, const char * const cert, const char * const ca, const char * const capath, const char * const cipher TSRMLS_DC) +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 TSRMLS_DC) { - return (PASS == conn->net->m.set_client_option(conn->net, MYSQLND_OPT_SSL_KEY, key TSRMLS_CC) && - PASS == conn->net->m.set_client_option(conn->net, MYSQLND_OPT_SSL_CERT, cert TSRMLS_CC) && - PASS == conn->net->m.set_client_option(conn->net, MYSQLND_OPT_SSL_CA, ca TSRMLS_CC) && - PASS == conn->net->m.set_client_option(conn->net, MYSQLND_OPT_SSL_CAPATH, capath TSRMLS_CC) && - PASS == conn->net->m.set_client_option(conn->net, MYSQLND_OPT_SSL_CIPHER, cipher TSRMLS_CC)) ? PASS : FAIL; + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, ssl_set); + enum_func_status ret = FAIL; + DBG_ENTER("mysqlnd_conn_data::ssl_set"); + + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + ret = (PASS == conn->net->m.set_client_option(conn->net, MYSQLND_OPT_SSL_KEY, key TSRMLS_CC) && + PASS == conn->net->m.set_client_option(conn->net, MYSQLND_OPT_SSL_CERT, cert TSRMLS_CC) && + PASS == conn->net->m.set_client_option(conn->net, MYSQLND_OPT_SSL_CA, ca TSRMLS_CC) && + PASS == conn->net->m.set_client_option(conn->net, MYSQLND_OPT_SSL_CAPATH, capath TSRMLS_CC) && + PASS == conn->net->m.set_client_option(conn->net, MYSQLND_OPT_SSL_CIPHER, cipher TSRMLS_CC)) ? PASS : FAIL; + + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); + } + DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_conn::escape_string */ +/* {{{ mysqlnd_conn_data::escape_string */ static ulong -MYSQLND_METHOD(mysqlnd_conn, escape_string)(MYSQLND * const conn, char *newstr, const char *escapestr, size_t escapestr_len TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, escape_string)(MYSQLND_CONN_DATA * const conn, char * newstr, const char * escapestr, size_t escapestr_len TSRMLS_DC) { - DBG_ENTER("mysqlnd_conn::escape_string"); + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, escape_string); + ulong ret; + DBG_ENTER("mysqlnd_conn_data::escape_string"); DBG_INF_FMT("conn=%llu", conn->thread_id); - if (conn->upsert_status.server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES) { - DBG_RETURN(mysqlnd_cset_escape_quotes(conn->charset, newstr, escapestr, escapestr_len TSRMLS_CC)); + + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + if (conn->upsert_status->server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES) { + ret = mysqlnd_cset_escape_quotes(conn->charset, newstr, escapestr, escapestr_len TSRMLS_CC); + } else { + ret = mysqlnd_cset_escape_slashes(conn->charset, newstr, escapestr, escapestr_len TSRMLS_CC); + } + conn->m->local_tx_end(conn, this_func, PASS TSRMLS_CC); } - DBG_RETURN(mysqlnd_cset_escape_slashes(conn->charset, newstr, escapestr, escapestr_len TSRMLS_CC)); + DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_conn::dump_debug_info */ +/* {{{ mysqlnd_conn_data::dump_debug_info */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, dump_debug_info)(MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, dump_debug_info)(MYSQLND_CONN_DATA * const conn TSRMLS_DC) { - DBG_ENTER("mysqlnd_conn::dump_debug_info"); + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, server_dump_debug_information); + enum_func_status ret = FAIL; + DBG_ENTER("mysqlnd_conn_data::dump_debug_info"); DBG_INF_FMT("conn=%llu", conn->thread_id); - DBG_RETURN(conn->m->simple_command(conn, COM_DEBUG, NULL, 0, PROT_EOF_PACKET, FALSE, TRUE TSRMLS_CC)); + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + ret = conn->m->simple_command(conn, COM_DEBUG, NULL, 0, PROT_EOF_PACKET, FALSE, TRUE TSRMLS_CC); + + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); + } + + DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_conn::select_db */ +/* {{{ mysqlnd_conn_data::select_db */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, select_db)(MYSQLND * const conn, const char * const db, unsigned int db_len TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, select_db)(MYSQLND_CONN_DATA * const conn, const char * const db, unsigned int db_len TSRMLS_DC) { - enum_func_status ret; + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, select_db); + enum_func_status ret = FAIL; - DBG_ENTER("mysqlnd_conn::select_db"); + DBG_ENTER("mysqlnd_conn_data::select_db"); DBG_INF_FMT("conn=%llu db=%s", conn->thread_id, db); - ret = conn->m->simple_command(conn, COM_INIT_DB, db, db_len, PROT_OK_PACKET, FALSE, TRUE TSRMLS_CC); - /* - The server sends 0 but libmysql doesn't read it and has established - a protocol of giving back -1. Thus we have to follow it :( - */ - SET_ERROR_AFF_ROWS(conn); - if (ret == PASS) { - if (conn->connect_or_select_db) { - mnd_pefree(conn->connect_or_select_db, conn->persistent); - } - conn->connect_or_select_db = mnd_pestrndup(db, db_len, conn->persistent); - conn->connect_or_select_db_len = db_len; - if (!conn->connect_or_select_db) { - /* OOM */ - SET_OOM_ERROR(conn->error_info); - ret = FAIL; + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + ret = conn->m->simple_command(conn, COM_INIT_DB, (zend_uchar*) db, db_len, PROT_OK_PACKET, FALSE, TRUE TSRMLS_CC); + /* + The server sends 0 but libmysql doesn't read it and has established + a protocol of giving back -1. Thus we have to follow it :( + */ + SET_ERROR_AFF_ROWS(conn); + if (ret == PASS) { + if (conn->connect_or_select_db) { + mnd_pefree(conn->connect_or_select_db, conn->persistent); + } + conn->connect_or_select_db = mnd_pestrndup(db, db_len, conn->persistent); + conn->connect_or_select_db_len = db_len; + if (!conn->connect_or_select_db) { + /* OOM */ + SET_OOM_ERROR(*conn->error_info); + ret = FAIL; + } } + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); } DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_conn::ping */ +/* {{{ mysqlnd_conn_data::ping */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, ping)(MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, ping)(MYSQLND_CONN_DATA * const conn TSRMLS_DC) { - enum_func_status ret; + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, ping); + enum_func_status ret = FAIL; - DBG_ENTER("mysqlnd_conn::ping"); + DBG_ENTER("mysqlnd_conn_data::ping"); DBG_INF_FMT("conn=%llu", conn->thread_id); - ret = conn->m->simple_command(conn, COM_PING, NULL, 0, PROT_OK_PACKET, TRUE, TRUE TSRMLS_CC); - /* - The server sends 0 but libmysql doesn't read it and has established - a protocol of giving back -1. Thus we have to follow it :( - */ - SET_ERROR_AFF_ROWS(conn); + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + ret = conn->m->simple_command(conn, COM_PING, NULL, 0, PROT_OK_PACKET, TRUE, TRUE TSRMLS_CC); + /* + The server sends 0 but libmysql doesn't read it and has established + a protocol of giving back -1. Thus we have to follow it :( + */ + SET_ERROR_AFF_ROWS(conn); + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); + } DBG_INF_FMT("ret=%u", ret); DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_conn::statistic */ +/* {{{ mysqlnd_conn_data::statistic */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, statistic)(MYSQLND * conn, char **message, unsigned int * message_len TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, statistic)(MYSQLND_CONN_DATA * conn, char **message, unsigned int * message_len TSRMLS_DC) { - enum_func_status ret; + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, get_server_statistics); + enum_func_status ret = FAIL; MYSQLND_PACKET_STATS * stats_header; - DBG_ENTER("mysqlnd_conn::statistic"); + DBG_ENTER("mysqlnd_conn_data::statistic"); DBG_INF_FMT("conn=%llu", conn->thread_id); - ret = conn->m->simple_command(conn, COM_STATISTICS, NULL, 0, PROT_LAST, FALSE, TRUE TSRMLS_CC); - if (FAIL == ret) { - DBG_RETURN(FAIL); - } - stats_header = conn->protocol->m.get_stats_packet(conn->protocol, FALSE TSRMLS_CC); - if (!stats_header) { - SET_OOM_ERROR(conn->error_info); - DBG_RETURN(FAIL); - } + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + do { + ret = conn->m->simple_command(conn, COM_STATISTICS, NULL, 0, PROT_LAST, FALSE, TRUE TSRMLS_CC); + if (FAIL == ret) { + break; + } + stats_header = conn->protocol->m.get_stats_packet(conn->protocol, FALSE TSRMLS_CC); + if (!stats_header) { + SET_OOM_ERROR(*conn->error_info); + break; + } - if (FAIL == (ret = PACKET_READ(stats_header, conn))) { - DBG_RETURN(FAIL); - } - /* will be freed by Zend, thus don't use the mnd_ allocator */ - *message = estrndup(stats_header->message, stats_header->message_len); - *message_len = stats_header->message_len; - PACKET_FREE(stats_header); + if (PASS == (ret = PACKET_READ(stats_header, conn))) { + /* will be freed by Zend, thus don't use the mnd_ allocator */ + *message = estrndup(stats_header->message, stats_header->message_len); + *message_len = stats_header->message_len; + DBG_INF(*message); + } + PACKET_FREE(stats_header); + } while (0); - DBG_INF(*message); - DBG_RETURN(PASS); + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); + } + DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_conn::kill */ +/* {{{ mysqlnd_conn_data::kill */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, kill)(MYSQLND * conn, unsigned int pid TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, kill)(MYSQLND_CONN_DATA * conn, unsigned int pid TSRMLS_DC) { - enum_func_status ret; - char buff[4]; + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, kill_connection); + enum_func_status ret = FAIL; + zend_uchar buff[4]; - DBG_ENTER("mysqlnd_conn::kill"); + DBG_ENTER("mysqlnd_conn_data::kill"); DBG_INF_FMT("conn=%llu pid=%u", conn->thread_id, pid); - int4store(buff, pid); + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + int4store(buff, pid); - /* If we kill ourselves don't expect OK packet, PROT_LAST will skip it */ - if (pid != conn->thread_id) { - ret = conn->m->simple_command(conn, COM_PROCESS_KILL, buff, 4, PROT_OK_PACKET, FALSE, TRUE TSRMLS_CC); - /* - The server sends 0 but libmysql doesn't read it and has established - a protocol of giving back -1. Thus we have to follow it :( - */ - SET_ERROR_AFF_ROWS(conn); - } else if (PASS == (ret = conn->m->simple_command(conn, COM_PROCESS_KILL, buff, 4, PROT_LAST, FALSE, TRUE TSRMLS_CC))) { - CONN_SET_STATE(conn, CONN_QUIT_SENT); + /* If we kill ourselves don't expect OK packet, PROT_LAST will skip it */ + if (pid != conn->thread_id) { + ret = conn->m->simple_command(conn, COM_PROCESS_KILL, buff, 4, PROT_OK_PACKET, FALSE, TRUE TSRMLS_CC); + /* + The server sends 0 but libmysql doesn't read it and has established + a protocol of giving back -1. Thus we have to follow it :( + */ + SET_ERROR_AFF_ROWS(conn); + } else if (PASS == (ret = conn->m->simple_command(conn, COM_PROCESS_KILL, buff, 4, PROT_LAST, FALSE, TRUE TSRMLS_CC))) { + CONN_SET_STATE(conn, CONN_QUIT_SENT); + } + + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); } DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_conn::set_charset */ +/* {{{ mysqlnd_conn_data::set_charset */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, set_charset)(MYSQLND * const conn, const char * const csname TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, set_charset)(MYSQLND_CONN_DATA * const conn, const char * const csname TSRMLS_DC) { - enum_func_status ret = PASS; - char * query; - size_t query_len; + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, set_charset); + enum_func_status ret = FAIL; const MYSQLND_CHARSET * const charset = mysqlnd_find_charset_name(csname); - DBG_ENTER("mysqlnd_conn::set_charset"); + DBG_ENTER("mysqlnd_conn_data::set_charset"); DBG_INF_FMT("conn=%llu cs=%s", conn->thread_id, csname); if (!charset) { - SET_CLIENT_ERROR(conn->error_info, CR_CANT_FIND_CHARSET, UNKNOWN_SQLSTATE, + SET_CLIENT_ERROR(*conn->error_info, CR_CANT_FIND_CHARSET, UNKNOWN_SQLSTATE, "Invalid characterset or character set not supported"); - DBG_RETURN(FAIL); + DBG_RETURN(ret); } - query_len = spprintf(&query, 0, "SET NAMES %s", csname); + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + char * query; + size_t query_len = mnd_sprintf(&query, 0, "SET NAMES %s", csname); - if (FAIL == conn->m->query(conn, query, query_len TSRMLS_CC)) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error executing query"); - } else if (conn->error_info.error_no) { - ret = FAIL; - } else { - conn->charset = charset; + if (FAIL == (ret = conn->m->query(conn, query, query_len TSRMLS_CC))) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error executing query"); + } else if (conn->error_info->error_no) { + ret = FAIL; + } else { + conn->charset = charset; + } + mnd_sprintf_free(query); + + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); } - efree(query); /* allocated by spprintf */ DBG_INF(ret == PASS? "PASS":"FAIL"); DBG_RETURN(ret); @@ -1600,39 +1668,53 @@ MYSQLND_METHOD(mysqlnd_conn, set_charset)(MYSQLND * const conn, const char * con /* }}} */ -/* {{{ mysqlnd_conn::refresh */ +/* {{{ mysqlnd_conn_data::refresh */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, refresh)(MYSQLND * const conn, uint8_t options TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, refresh)(MYSQLND_CONN_DATA * const conn, uint8_t options TSRMLS_DC) { + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, refresh_server); + enum_func_status ret = FAIL; zend_uchar bits[1]; - DBG_ENTER("mysqlnd_conn::refresh"); + DBG_ENTER("mysqlnd_conn_data::refresh"); DBG_INF_FMT("conn=%llu options=%lu", conn->thread_id, options); - int1store(bits, options); + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + int1store(bits, options); + + ret = conn->m->simple_command(conn, COM_REFRESH, bits, 1, PROT_OK_PACKET, FALSE, TRUE TSRMLS_CC); - DBG_RETURN(conn->m->simple_command(conn, COM_REFRESH, (char *)bits, 1, PROT_OK_PACKET, FALSE, TRUE TSRMLS_CC)); + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); + } + DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_conn::shutdown */ +/* {{{ mysqlnd_conn_data::shutdown */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, shutdown)(MYSQLND * const conn, uint8_t level TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, shutdown)(MYSQLND_CONN_DATA * const conn, uint8_t level TSRMLS_DC) { + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, shutdown_server); + enum_func_status ret = FAIL; zend_uchar bits[1]; - DBG_ENTER("mysqlnd_conn::shutdown"); + DBG_ENTER("mysqlnd_conn_data::shutdown"); DBG_INF_FMT("conn=%llu level=%lu", conn->thread_id, level); - int1store(bits, level); + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + int1store(bits, level); - DBG_RETURN(conn->m->simple_command(conn, COM_SHUTDOWN, (char *)bits, 1, PROT_OK_PACKET, FALSE, TRUE TSRMLS_CC)); + ret = conn->m->simple_command(conn, COM_SHUTDOWN, bits, 1, PROT_OK_PACKET, FALSE, TRUE TSRMLS_CC); + + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); + } + DBG_RETURN(ret); } /* }}} */ /* {{{ mysqlnd_send_close */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, send_close)(MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, send_close)(MYSQLND_CONN_DATA * const conn TSRMLS_DC) { enum_func_status ret = PASS; @@ -1640,11 +1722,17 @@ MYSQLND_METHOD(mysqlnd_conn, send_close)(MYSQLND * const conn TSRMLS_DC) DBG_INF_FMT("conn=%llu conn->net->stream->abstract=%p", conn->thread_id, conn->net->stream? conn->net->stream->abstract:NULL); + if (CONN_GET_STATE(conn) >= CONN_READY) { + MYSQLND_DEC_CONN_STATISTIC(conn->stats, STAT_OPENED_CONNECTIONS); + if (conn->persistent) { + MYSQLND_DEC_CONN_STATISTIC(conn->stats, STAT_OPENED_PERSISTENT_CONNECTIONS); + } + } switch (CONN_GET_STATE(conn)) { case CONN_READY: DBG_INF("Connection clean, sending COM_QUIT"); if (conn->net->stream) { - ret = conn->m->simple_command(conn, COM_QUIT, NULL, 0, PROT_LAST, TRUE, TRUE TSRMLS_CC); + ret = conn->m->simple_command(conn, COM_QUIT, NULL, 0, PROT_LAST, TRUE, TRUE TSRMLS_CC); } /* Do nothing */ break; @@ -1684,48 +1772,11 @@ MYSQLND_METHOD(mysqlnd_conn, send_close)(MYSQLND * const conn TSRMLS_DC) /* }}} */ -/* {{{ mysqlnd_conn::close */ -static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, close)(MYSQLND * conn, enum_connection_close_type close_type TSRMLS_DC) +/* {{{ mysqlnd_conn_data::get_reference */ +static MYSQLND_CONN_DATA * +MYSQLND_METHOD_PRIVATE(mysqlnd_conn_data, get_reference)(MYSQLND_CONN_DATA * const conn TSRMLS_DC) { - enum_func_status ret = PASS; - static enum_mysqlnd_collected_stats - close_type_to_stat_map[MYSQLND_CLOSE_LAST] = { - STAT_CLOSE_EXPLICIT, - STAT_CLOSE_IMPLICIT, - STAT_CLOSE_DISCONNECT - }; - enum_mysqlnd_collected_stats statistic = close_type_to_stat_map[close_type]; - - DBG_ENTER("mysqlnd_conn::close"); - DBG_INF_FMT("conn=%llu", conn->thread_id); - - if (conn->state >= CONN_READY) { - MYSQLND_INC_CONN_STATISTIC(conn->stats, statistic); - MYSQLND_DEC_CONN_STATISTIC(conn->stats, STAT_OPENED_CONNECTIONS); - if (conn->persistent) { - MYSQLND_DEC_CONN_STATISTIC(conn->stats, STAT_OPENED_PERSISTENT_CONNECTIONS); - } - } - - /* - Close now, free_reference will try, - if we are last, but that's not a problem. - */ - ret = conn->m->send_close(conn TSRMLS_CC); - - ret = conn->m->free_reference(conn TSRMLS_CC); - - DBG_RETURN(ret); -} -/* }}} */ - - -/* {{{ mysqlnd_conn::get_reference */ -static MYSQLND * -MYSQLND_METHOD_PRIVATE(mysqlnd_conn, get_reference)(MYSQLND * const conn TSRMLS_DC) -{ - DBG_ENTER("mysqlnd_conn::get_reference"); + DBG_ENTER("mysqlnd_conn_data::get_reference"); ++conn->refcount; DBG_INF_FMT("conn=%llu new_refcount=%u", conn->thread_id, conn->refcount); DBG_RETURN(conn); @@ -1733,12 +1784,12 @@ MYSQLND_METHOD_PRIVATE(mysqlnd_conn, get_reference)(MYSQLND * const conn TSRMLS_ /* }}} */ -/* {{{ mysqlnd_conn::free_reference */ +/* {{{ mysqlnd_conn_data::free_reference */ static enum_func_status -MYSQLND_METHOD_PRIVATE(mysqlnd_conn, free_reference)(MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD_PRIVATE(mysqlnd_conn_data, free_reference)(MYSQLND_CONN_DATA * const conn TSRMLS_DC) { enum_func_status ret = PASS; - DBG_ENTER("mysqlnd_conn::free_reference"); + DBG_ENTER("mysqlnd_conn_data::free_reference"); DBG_INF_FMT("conn=%llu old_refcount=%u", conn->thread_id, conn->refcount); if (!(--conn->refcount)) { /* @@ -1754,21 +1805,21 @@ MYSQLND_METHOD_PRIVATE(mysqlnd_conn, free_reference)(MYSQLND * const conn TSRMLS /* }}} */ -/* {{{ mysqlnd_conn::get_state */ +/* {{{ mysqlnd_conn_data::get_state */ static enum mysqlnd_connection_state -MYSQLND_METHOD_PRIVATE(mysqlnd_conn, get_state)(MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD_PRIVATE(mysqlnd_conn_data, get_state)(MYSQLND_CONN_DATA * const conn TSRMLS_DC) { - DBG_ENTER("mysqlnd_conn::get_state"); + DBG_ENTER("mysqlnd_conn_data::get_state"); DBG_RETURN(conn->state); } /* }}} */ -/* {{{ mysqlnd_conn::set_state */ +/* {{{ mysqlnd_conn_data::set_state */ static void -MYSQLND_METHOD_PRIVATE(mysqlnd_conn, set_state)(MYSQLND * const conn, enum mysqlnd_connection_state new_state TSRMLS_DC) +MYSQLND_METHOD_PRIVATE(mysqlnd_conn_data, set_state)(MYSQLND_CONN_DATA * const conn, enum mysqlnd_connection_state new_state TSRMLS_DC) { - DBG_ENTER("mysqlnd_conn::set_state"); + DBG_ENTER("mysqlnd_conn_data::set_state"); DBG_INF_FMT("New state=%u", new_state); conn->state = new_state; DBG_VOID_RETURN; @@ -1776,51 +1827,59 @@ MYSQLND_METHOD_PRIVATE(mysqlnd_conn, set_state)(MYSQLND * const conn, enum mysql /* }}} */ -/* {{{ mysqlnd_conn::field_count */ +/* {{{ mysqlnd_conn_data::field_count */ static unsigned int -MYSQLND_METHOD(mysqlnd_conn, field_count)(const MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, field_count)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC) { return conn->field_count; } /* }}} */ -/* {{{ mysqlnd_conn::insert_id */ +/* {{{ mysqlnd_conn_data::server_status */ +static unsigned int +MYSQLND_METHOD(mysqlnd_conn_data, server_status)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC) +{ + return conn->upsert_status->server_status; +} +/* }}} */ + + +/* {{{ mysqlnd_conn_data::insert_id */ static uint64_t -MYSQLND_METHOD(mysqlnd_conn, insert_id)(const MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, insert_id)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC) { - return conn->upsert_status.last_insert_id; + return conn->upsert_status->last_insert_id; } /* }}} */ -/* {{{ mysqlnd_conn::affected_rows */ +/* {{{ mysqlnd_conn_data::affected_rows */ static uint64_t -MYSQLND_METHOD(mysqlnd_conn, affected_rows)(const MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, affected_rows)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC) { - return conn->upsert_status.affected_rows; + return conn->upsert_status->affected_rows; } /* }}} */ -/* {{{ mysqlnd_conn::warning_count */ +/* {{{ mysqlnd_conn_data::warning_count */ static unsigned int -MYSQLND_METHOD(mysqlnd_conn, warning_count)(const MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, warning_count)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC) { - return conn->upsert_status.warning_count; + return conn->upsert_status->warning_count; } /* }}} */ -/* {{{ mysqlnd_conn::info */ +/* {{{ mysqlnd_conn_data::info */ static const char * -MYSQLND_METHOD(mysqlnd_conn, info)(const MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, info)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC) { return conn->last_message; } /* }}} */ -#if !defined(MYSQLND_USE_OPTIMISATIONS) || MYSQLND_USE_OPTIMISATIONS == 0 /* {{{ mysqlnd_get_client_info */ PHPAPI const char * mysqlnd_get_client_info() { @@ -1835,56 +1894,56 @@ PHPAPI unsigned int mysqlnd_get_client_version() return MYSQLND_VERSION_ID; } /* }}} */ -#endif -/* {{{ mysqlnd_conn::get_server_info */ + +/* {{{ mysqlnd_conn_data::get_server_info */ static const char * -MYSQLND_METHOD(mysqlnd_conn, get_server_info)(const MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, get_server_info)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC) { return conn->server_version; } /* }}} */ -/* {{{ mysqlnd_conn::get_host_info */ +/* {{{ mysqlnd_conn_data::get_host_info */ static const char * -MYSQLND_METHOD(mysqlnd_conn, get_host_info)(const MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, get_host_info)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC) { return conn->host_info; } /* }}} */ -/* {{{ mysqlnd_conn::get_proto_info */ +/* {{{ mysqlnd_conn_data::get_proto_info */ static unsigned int -MYSQLND_METHOD(mysqlnd_conn, get_proto_info)(const MYSQLND *const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, get_proto_info)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC) { return conn->protocol_version; } /* }}} */ -/* {{{ mysqlnd_conn::charset_name */ +/* {{{ mysqlnd_conn_data::charset_name */ static const char * -MYSQLND_METHOD(mysqlnd_conn, charset_name)(const MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, charset_name)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC) { return conn->charset->name; } /* }}} */ -/* {{{ mysqlnd_conn::thread_id */ +/* {{{ mysqlnd_conn_data::thread_id */ static uint64_t -MYSQLND_METHOD(mysqlnd_conn, thread_id)(const MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, thread_id)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC) { return conn->thread_id; } /* }}} */ -/* {{{ mysqlnd_conn::get_server_version */ +/* {{{ mysqlnd_conn_data::get_server_version */ static unsigned long -MYSQLND_METHOD(mysqlnd_conn, get_server_version)(const MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, get_server_version)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC) { long major, minor, patch; char *p; @@ -1904,51 +1963,58 @@ MYSQLND_METHOD(mysqlnd_conn, get_server_version)(const MYSQLND * const conn TSRM /* }}} */ -/* {{{ mysqlnd_conn::more_results */ +/* {{{ mysqlnd_conn_data::more_results */ static zend_bool -MYSQLND_METHOD(mysqlnd_conn, more_results)(const MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, more_results)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC) { - DBG_ENTER("mysqlnd_conn::more_results"); + DBG_ENTER("mysqlnd_conn_data::more_results"); /* (conn->state == CONN_NEXT_RESULT_PENDING) too */ - DBG_RETURN(conn->upsert_status.server_status & SERVER_MORE_RESULTS_EXISTS? TRUE:FALSE); + DBG_RETURN(conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS? TRUE:FALSE); } /* }}} */ -/* {{{ mysqlnd_conn::next_result */ +/* {{{ mysqlnd_conn_data::next_result */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, next_result)(MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, next_result)(MYSQLND_CONN_DATA * const conn TSRMLS_DC) { - enum_func_status ret; + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, next_result); + enum_func_status ret = FAIL; - DBG_ENTER("mysqlnd_conn::next_result"); + DBG_ENTER("mysqlnd_conn_data::next_result"); DBG_INF_FMT("conn=%llu", conn->thread_id); - if (CONN_GET_STATE(conn) != CONN_NEXT_RESULT_PENDING) { - DBG_RETURN(FAIL); - } + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + do { + if (CONN_GET_STATE(conn) != CONN_NEXT_RESULT_PENDING) { + break; + } - SET_EMPTY_ERROR(conn->error_info); - SET_ERROR_AFF_ROWS(conn); - /* - We are sure that there is a result set, since conn->state is set accordingly - in mysqlnd_store_result() or mysqlnd_fetch_row_unbuffered() - */ - if (FAIL == (ret = conn->m->query_read_result_set_header(conn, NULL TSRMLS_CC))) { - /* - There can be an error in the middle of a multi-statement, which will cancel the multi-statement. - So there are no more results and we should just return FALSE, error_no has been set - */ - if (!conn->error_info.error_no) { - DBG_ERR_FMT("Serious error. %s::%u", __FILE__, __LINE__); - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Serious error. PID=%d", getpid()); - CONN_SET_STATE(conn, CONN_QUIT_SENT); - } else { - DBG_INF_FMT("Error from the server : (%u) %s", conn->error_info.error_no, conn->error_info.error); - } - } - if (ret == PASS && conn->last_query_type == QUERY_UPSERT && conn->upsert_status.affected_rows) { - MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn->stats, STAT_ROWS_AFFECTED_NORMAL, conn->upsert_status.affected_rows); + SET_EMPTY_ERROR(*conn->error_info); + SET_ERROR_AFF_ROWS(conn); + /* + We are sure that there is a result set, since conn->state is set accordingly + in mysqlnd_store_result() or mysqlnd_fetch_row_unbuffered() + */ + if (FAIL == (ret = conn->m->query_read_result_set_header(conn, NULL TSRMLS_CC))) { + /* + There can be an error in the middle of a multi-statement, which will cancel the multi-statement. + So there are no more results and we should just return FALSE, error_no has been set + */ + if (!conn->error_info->error_no) { + DBG_ERR_FMT("Serious error. %s::%u", __FILE__, __LINE__); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Serious error. PID=%d", getpid()); + CONN_SET_STATE(conn, CONN_QUIT_SENT); + } else { + DBG_INF_FMT("Error from the server : (%u) %s", conn->error_info->error_no, conn->error_info->error); + } + break; + } + if (conn->last_query_type == QUERY_UPSERT && conn->upsert_status->affected_rows) { + MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn->stats, STAT_ROWS_AFFECTED_NORMAL, conn->upsert_status->affected_rows); + } + } while (0); + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); } DBG_RETURN(ret); @@ -2007,16 +2073,182 @@ PHPAPI const char *mysqlnd_field_type_name(enum mysqlnd_field_types field_type) /* }}} */ -/* {{{ mysqlnd_conn::set_client_option */ +/* {{{ mysqlnd_conn_data::change_user */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, set_client_option)(MYSQLND * const conn, +MYSQLND_METHOD(mysqlnd_conn_data, change_user)(MYSQLND_CONN_DATA * const conn, + const char * user, + const char * passwd, + const char * db, + zend_bool silent, + size_t passwd_len + TSRMLS_DC) +{ + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, change_user); + /* + User could be max 16 * 3 (utf8), pass is 20 usually, db is up to 64*3 + Stack space is not that expensive, so use a bit more to be protected against + buffer overflows. + */ + enum_func_status ret = FAIL; + zend_bool local_tx_started = FALSE; + + DBG_ENTER("mysqlnd_conn_data::change_user"); + DBG_INF_FMT("conn=%llu user=%s passwd=%s db=%s silent=%u", + conn->thread_id, user?user:"", passwd?"***":"null", db?db:"", (silent == TRUE)?1:0 ); + + if (PASS != conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + goto end; + } + local_tx_started = TRUE; + + SET_EMPTY_ERROR(*conn->error_info); + SET_ERROR_AFF_ROWS(conn); + + if (!user) { + user = ""; + } + if (!passwd) { + passwd = ""; + } + if (!db) { + db = ""; + } + + { + zend_bool first_call = TRUE; + char * switch_to_auth_protocol = NULL; + size_t switch_to_auth_protocol_len = 0; + char * requested_protocol = NULL; + zend_uchar * plugin_data; + size_t plugin_data_len; + + plugin_data_len = conn->auth_plugin_data_len; + plugin_data = mnd_emalloc(plugin_data_len); + if (!plugin_data) { + ret = FAIL; + goto end; + } + memcpy(plugin_data, conn->auth_plugin_data, plugin_data_len); + + requested_protocol = mnd_pestrdup(conn->options->auth_protocol? conn->options->auth_protocol:"mysql_native_password", FALSE); + if (!requested_protocol) { + ret = FAIL; + goto end; + } + + do { + struct st_mysqlnd_authentication_plugin * auth_plugin; + { + char * plugin_name = NULL; + + 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); + + if (!auth_plugin) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "The server requested authentication method unknown to the client [%s]", requested_protocol); + SET_CLIENT_ERROR(*conn->error_info, CR_NOT_IMPLEMENTED, UNKNOWN_SQLSTATE, "The server requested authentication method umknown to the client"); + break; + } + } + DBG_INF("plugin found"); + + { + zend_uchar * switch_to_auth_protocol_data = NULL; + size_t switch_to_auth_protocol_data_len = 0; + zend_uchar * scrambled_data = NULL; + size_t scrambled_data_len = 0; + + switch_to_auth_protocol = NULL; + switch_to_auth_protocol_len = 0; + + if (conn->auth_plugin_data) { + mnd_pefree(conn->auth_plugin_data, conn->persistent); + conn->auth_plugin_data = NULL; + } + conn->auth_plugin_data_len = plugin_data_len; + conn->auth_plugin_data = mnd_pemalloc(conn->auth_plugin_data_len, conn->persistent); + if (!conn->auth_plugin_data) { + SET_OOM_ERROR(*conn->error_info); + ret = FAIL; + goto end; + } + memcpy(conn->auth_plugin_data, plugin_data, plugin_data_len); + + DBG_INF_FMT("salt=[%*s]", plugin_data_len - 1, plugin_data); + + /* The data should be allocated with malloc() */ + scrambled_data = + auth_plugin->methods.get_auth_data(NULL, &scrambled_data_len, conn, user, passwd, passwd_len, + plugin_data, plugin_data_len, 0, conn->server_capabilities TSRMLS_CC); + + + ret = mysqlnd_auth_change_user(conn, user, strlen(user), passwd, passwd_len, db, strlen(db), silent, + first_call, + requested_protocol, + scrambled_data, scrambled_data_len, + &switch_to_auth_protocol, &switch_to_auth_protocol_len, + &switch_to_auth_protocol_data, &switch_to_auth_protocol_data_len + TSRMLS_CC); + + first_call = FALSE; + free(scrambled_data); + + DBG_INF_FMT("switch_to_auth_protocol=%s", switch_to_auth_protocol? switch_to_auth_protocol:"n/a"); + if (requested_protocol) { + mnd_efree(requested_protocol); + } + requested_protocol = switch_to_auth_protocol; + + if (plugin_data) { + mnd_efree(plugin_data); + } + plugin_data_len = switch_to_auth_protocol_data_len; + plugin_data = switch_to_auth_protocol_data; + } + DBG_INF_FMT("conn->error_info->error_no = %d", conn->error_info->error_no); + } while (ret == FAIL && conn->error_info->error_no == 0 && switch_to_auth_protocol != NULL); + if (plugin_data) { + mnd_efree(plugin_data); + } + if (ret == PASS) { + conn->m->set_client_option(conn, MYSQLND_OPT_AUTH_PROTOCOL, requested_protocol TSRMLS_CC); + } + if (requested_protocol) { + mnd_efree(requested_protocol); + } + } + /* + Here we should close all statements. Unbuffered queries should not be a + problem as we won't allow sending COM_CHANGE_USER. + */ +end: + if (TRUE == local_tx_started) { + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); + } + DBG_INF(ret == PASS? "PASS":"FAIL"); + DBG_RETURN(ret); +} +/* }}} */ + + +/* {{{ mysqlnd_conn_data::set_client_option */ +static enum_func_status +MYSQLND_METHOD(mysqlnd_conn_data, set_client_option)(MYSQLND_CONN_DATA * const conn, enum mysqlnd_option option, const char * const value TSRMLS_DC) { + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, set_client_option); enum_func_status ret = PASS; - DBG_ENTER("mysqlnd_conn::set_client_option"); + DBG_ENTER("mysqlnd_conn_data::set_client_option"); DBG_INF_FMT("conn=%llu option=%u", conn->thread_id, option); + + if (PASS != conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + goto end; + } switch (option) { case MYSQL_OPT_COMPRESS: #ifdef WHEN_SUPPORTED_BY_MYSQLI @@ -2036,42 +2268,38 @@ MYSQLND_METHOD(mysqlnd_conn, set_client_option)(MYSQLND * const conn, break; #if MYSQLND_UNICODE case MYSQLND_OPT_NUMERIC_AND_DATETIME_AS_UNICODE: - conn->options.numeric_and_datetime_as_unicode = *(unsigned int*) value; + conn->options->numeric_and_datetime_as_unicode = *(unsigned int*) value; break; #endif #ifdef MYSQLND_STRING_TO_INT_CONVERSION case MYSQLND_OPT_INT_AND_FLOAT_NATIVE: - DBG_INF("MYSQLND_OPT_INT_AND_FLOAT_NATIVE"); - conn->options.int_and_float_native = *(unsigned int*) value; + conn->options->int_and_float_native = *(unsigned int*) value; break; #endif case MYSQL_OPT_LOCAL_INFILE: - DBG_INF("MYSQL_OPT_LOCAL_INFILE"); if (!value || (*(unsigned int*) value) ? 1 : 0) { - conn->options.flags |= CLIENT_LOCAL_FILES; + conn->options->flags |= CLIENT_LOCAL_FILES; } else { - conn->options.flags &= ~CLIENT_LOCAL_FILES; + conn->options->flags &= ~CLIENT_LOCAL_FILES; } break; case MYSQL_INIT_COMMAND: { char ** new_init_commands; char * new_command; - DBG_INF("MYSQL_INIT_COMMAND"); - DBG_INF_FMT("command=%s", value); /* when num_commands is 0, then realloc will be effectively a malloc call, internally */ - /* Don't assign to conn->options.init_commands because in case of OOM we will lose the pointer and leak */ - new_init_commands = mnd_perealloc(conn->options.init_commands, sizeof(char *) * (conn->options.num_commands + 1), conn->persistent); + /* Don't assign to conn->options->init_commands because in case of OOM we will lose the pointer and leak */ + new_init_commands = mnd_perealloc(conn->options->init_commands, sizeof(char *) * (conn->options->num_commands + 1), conn->persistent); if (!new_init_commands) { goto oom; } - conn->options.init_commands = new_init_commands; + conn->options->init_commands = new_init_commands; new_command = mnd_pestrdup(value, conn->persistent); if (!new_command) { goto oom; } - conn->options.init_commands[conn->options.num_commands] = new_command; - ++conn->options.num_commands; + conn->options->init_commands[conn->options->num_commands] = new_command; + ++conn->options->num_commands; break; } case MYSQL_READ_DEFAULT_FILE: @@ -2085,23 +2313,22 @@ MYSQLND_METHOD(mysqlnd_conn, set_client_option)(MYSQLND * const conn, case MYSQL_SET_CHARSET_NAME: { char * new_charset_name = mnd_pestrdup(value, conn->persistent); - DBG_INF("MYSQL_SET_CHARSET_NAME"); if (!new_charset_name) { goto oom; } - if (conn->options.charset_name) { - mnd_pefree(conn->options.charset_name, conn->persistent); + if (conn->options->charset_name) { + mnd_pefree(conn->options->charset_name, conn->persistent); } - conn->options.charset_name = new_charset_name; - DBG_INF_FMT("charset=%s", conn->options.charset_name); + conn->options->charset_name = new_charset_name; + DBG_INF_FMT("charset=%s", conn->options->charset_name); break; } case MYSQL_OPT_NAMED_PIPE: - conn->options.protocol = MYSQL_PROTOCOL_PIPE; + conn->options->protocol = MYSQL_PROTOCOL_PIPE; break; case MYSQL_OPT_PROTOCOL: if (*(unsigned int*) value < MYSQL_PROTOCOL_LAST) { - conn->options.protocol = *(unsigned int*) value; + conn->options->protocol = *(unsigned int*) value; } break; #ifdef WHEN_SUPPORTED_BY_MYSQLI @@ -2116,7 +2343,24 @@ MYSQLND_METHOD(mysqlnd_conn, set_client_option)(MYSQLND * const conn, /* todo: throw an error, we don't support embedded */ break; #endif - + case MYSQLND_OPT_MAX_ALLOWED_PACKET: + if (*(unsigned int*) value > (1<<16)) { + conn->options->max_allowed_packet = *(unsigned int*) value; + } + break; + case MYSQLND_OPT_AUTH_PROTOCOL: + { + char * new_auth_protocol = value? mnd_pestrdup(value, conn->persistent) : NULL; + if (value && !new_auth_protocol) { + goto oom; + } + if (conn->options->auth_protocol) { + mnd_pefree(conn->options->auth_protocol, conn->persistent); + } + conn->options->auth_protocol = new_auth_protocol; + DBG_INF_FMT("auth_protocol=%s", conn->options->auth_protocol); + break; + } #ifdef WHEN_SUPPORTED_BY_MYSQLI case MYSQL_SHARED_MEMORY_BASE_NAME: case MYSQL_OPT_USE_RESULT: @@ -2126,315 +2370,364 @@ MYSQLND_METHOD(mysqlnd_conn, set_client_option)(MYSQLND * const conn, default: ret = FAIL; } + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); DBG_RETURN(ret); oom: - SET_OOM_ERROR(conn->error_info); + SET_OOM_ERROR(*conn->error_info); + conn->m->local_tx_end(conn, this_func, FAIL TSRMLS_CC); +end: DBG_RETURN(FAIL); } /* }}} */ -/* {{{ mysqlnd_conn::use_result */ +/* {{{ mysqlnd_conn_data::use_result */ static MYSQLND_RES * -MYSQLND_METHOD(mysqlnd_conn, use_result)(MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, use_result)(MYSQLND_CONN_DATA * const conn TSRMLS_DC) { - MYSQLND_RES * result; + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, use_result); + MYSQLND_RES * result = NULL; - DBG_ENTER("mysqlnd_conn::use_result"); + DBG_ENTER("mysqlnd_conn_data::use_result"); DBG_INF_FMT("conn=%llu", conn->thread_id); - if (!conn->current_result) { - DBG_RETURN(NULL); - } + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + do { + if (!conn->current_result) { + break; + } - /* Nothing to store for UPSERT/LOAD DATA */ - if (conn->last_query_type != QUERY_SELECT || CONN_GET_STATE(conn) != CONN_FETCHING_DATA) { - SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, - mysqlnd_out_of_sync); - DBG_ERR("Command out of sync"); - DBG_RETURN(NULL); - } + /* Nothing to store for UPSERT/LOAD DATA */ + if (conn->last_query_type != QUERY_SELECT || CONN_GET_STATE(conn) != CONN_FETCHING_DATA) { + SET_CLIENT_ERROR(*conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync); + DBG_ERR("Command out of sync"); + break; + } - MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_UNBUFFERED_SETS); + MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_UNBUFFERED_SETS); - conn->current_result->conn = conn->m->get_reference(conn TSRMLS_CC); - result = conn->current_result->m.use_result(conn->current_result, FALSE TSRMLS_CC); + conn->current_result->conn = conn->m->get_reference(conn TSRMLS_CC); + result = conn->current_result->m.use_result(conn->current_result, FALSE TSRMLS_CC); - if (!result) { - conn->current_result->m.free_result(conn->current_result, TRUE TSRMLS_CC); + if (!result) { + conn->current_result->m.free_result(conn->current_result, TRUE TSRMLS_CC); + } + conn->current_result = NULL; + } while (0); + + conn->m->local_tx_end(conn, this_func, result == NULL? FAIL:PASS TSRMLS_CC); } - conn->current_result = NULL; DBG_RETURN(result); } /* }}} */ -/* {{{ mysqlnd_conn::store_result */ +/* {{{ mysqlnd_conn_data::store_result */ static MYSQLND_RES * -MYSQLND_METHOD(mysqlnd_conn, store_result)(MYSQLND * const conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, store_result)(MYSQLND_CONN_DATA * const conn TSRMLS_DC) { - MYSQLND_RES *result; + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, store_result); + MYSQLND_RES * result = NULL; - DBG_ENTER("mysqlnd_conn::store_result"); + DBG_ENTER("mysqlnd_conn_data::store_result"); DBG_INF_FMT("conn=%llu", conn->thread_id); - if (!conn->current_result) { - DBG_RETURN(NULL); - } + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + do { + if (!conn->current_result) { + break; + } - /* Nothing to store for UPSERT/LOAD DATA*/ - if (conn->last_query_type != QUERY_SELECT || CONN_GET_STATE(conn) != CONN_FETCHING_DATA) { - SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, - mysqlnd_out_of_sync); - DBG_ERR("Command out of sync"); - DBG_RETURN(NULL); - } + /* Nothing to store for UPSERT/LOAD DATA*/ + if (conn->last_query_type != QUERY_SELECT || CONN_GET_STATE(conn) != CONN_FETCHING_DATA) { + SET_CLIENT_ERROR(*conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync); + DBG_ERR("Command out of sync"); + break; + } - MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_BUFFERED_SETS); + MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_BUFFERED_SETS); - result = conn->current_result->m.store_result(conn->current_result, conn, FALSE TSRMLS_CC); - if (!result) { - conn->current_result->m.free_result(conn->current_result, TRUE TSRMLS_CC); + result = conn->current_result->m.store_result(conn->current_result, conn, FALSE TSRMLS_CC); + if (!result) { + conn->current_result->m.free_result(conn->current_result, TRUE TSRMLS_CC); + } + conn->current_result = NULL; + } while (0); + + conn->m->local_tx_end(conn, this_func, result == NULL? FAIL:PASS TSRMLS_CC); } - conn->current_result = NULL; DBG_RETURN(result); } /* }}} */ -/* {{{ mysqlnd_conn::get_connection_stats */ +/* {{{ mysqlnd_conn_data::get_connection_stats */ static void -MYSQLND_METHOD(mysqlnd_conn, get_connection_stats)(const MYSQLND * const conn, - zval *return_value - TSRMLS_DC ZEND_FILE_LINE_DC) +MYSQLND_METHOD(mysqlnd_conn_data, get_connection_stats)(const MYSQLND_CONN_DATA * const conn, + zval * return_value TSRMLS_DC ZEND_FILE_LINE_DC) { - DBG_ENTER("mysqlnd_conn::get_connection_stats"); - DBG_INF_FMT("conn=%llu", conn->thread_id); + DBG_ENTER("mysqlnd_conn_data::get_connection_stats"); mysqlnd_fill_stats_hash(conn->stats, mysqlnd_stats_values_names, return_value TSRMLS_CC ZEND_FILE_LINE_CC); DBG_VOID_RETURN; } /* }}} */ -/* {{{ mysqlnd_conn::set_autocommit */ +/* {{{ mysqlnd_conn_data::set_autocommit */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, set_autocommit)(MYSQLND * conn, unsigned int mode TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, set_autocommit)(MYSQLND_CONN_DATA * conn, unsigned int mode TSRMLS_DC) { - enum_func_status ret; - DBG_ENTER("mysqlnd_conn::set_autocommit"); - ret = conn->m->query(conn, (mode) ? "SET AUTOCOMMIT=1":"SET AUTOCOMMIT=0", sizeof("SET AUTOCOMMIT=1") - 1 TSRMLS_CC); + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, set_autocommit); + enum_func_status ret = FAIL; + DBG_ENTER("mysqlnd_conn_data::set_autocommit"); + + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + ret = conn->m->query(conn, (mode) ? "SET AUTOCOMMIT=1":"SET AUTOCOMMIT=0", sizeof("SET AUTOCOMMIT=1") - 1 TSRMLS_CC); + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); + } + DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_conn::tx_commit */ +/* {{{ mysqlnd_conn_data::tx_commit */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, tx_commit)(MYSQLND * conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, tx_commit)(MYSQLND_CONN_DATA * conn TSRMLS_DC) { - enum_func_status ret; - DBG_ENTER("mysqlnd_conn::tx_commit"); - ret = conn->m->query(conn, "COMMIT", sizeof("COMMIT") - 1 TSRMLS_CC); + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, tx_commit); + enum_func_status ret = FAIL; + DBG_ENTER("mysqlnd_conn_data::tx_commit"); + + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + ret = conn->m->query(conn, "COMMIT", sizeof("COMMIT") - 1 TSRMLS_CC); + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); + } + DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_conn::tx_rollback */ +/* {{{ mysqlnd_conn_data::tx_rollback */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, tx_rollback)(MYSQLND * conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, tx_rollback)(MYSQLND_CONN_DATA * conn TSRMLS_DC) { - enum_func_status ret; - DBG_ENTER("mysqlnd_conn::tx_rollback"); - ret = conn->m->query(conn, "ROLLBACK", sizeof("ROLLBACK") - 1 TSRMLS_CC); + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, tx_rollback); + enum_func_status ret = FAIL; + DBG_ENTER("mysqlnd_conn_data::tx_rollback"); + + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + ret = conn->m->query(conn, "ROLLBACK", sizeof("ROLLBACK") - 1 TSRMLS_CC); + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); + } + DBG_RETURN(ret); } /* }}} */ +/* {{{ mysqlnd_conn_data::local_tx_start */ +static enum_func_status +MYSQLND_METHOD(mysqlnd_conn_data, local_tx_start)(MYSQLND_CONN_DATA * conn, size_t this_func TSRMLS_DC) +{ + enum_func_status ret = PASS; + DBG_ENTER("mysqlnd_conn_data::local_tx_start"); + DBG_RETURN(ret); +} +/* }}} */ -MYSQLND_STMT * _mysqlnd_stmt_init(MYSQLND * const conn TSRMLS_DC); -static enum_func_status MYSQLND_METHOD(mysqlnd_conn, init)(MYSQLND * conn TSRMLS_DC); - -static -MYSQLND_CLASS_METHODS_START(mysqlnd_conn) - MYSQLND_METHOD(mysqlnd_conn, init), - MYSQLND_METHOD(mysqlnd_conn, connect), - - MYSQLND_METHOD(mysqlnd_conn, escape_string), - MYSQLND_METHOD(mysqlnd_conn, set_charset), - MYSQLND_METHOD(mysqlnd_conn, query), - MYSQLND_METHOD(mysqlnd_conn, send_query), - MYSQLND_METHOD(mysqlnd_conn, reap_query), - MYSQLND_METHOD(mysqlnd_conn, use_result), - MYSQLND_METHOD(mysqlnd_conn, store_result), - MYSQLND_METHOD(mysqlnd_conn, next_result), - MYSQLND_METHOD(mysqlnd_conn, more_results), - - _mysqlnd_stmt_init, - - MYSQLND_METHOD(mysqlnd_conn, shutdown), - MYSQLND_METHOD(mysqlnd_conn, refresh), - - MYSQLND_METHOD(mysqlnd_conn, ping), - MYSQLND_METHOD(mysqlnd_conn, kill), - MYSQLND_METHOD(mysqlnd_conn, select_db), - MYSQLND_METHOD(mysqlnd_conn, dump_debug_info), - MYSQLND_METHOD(mysqlnd_conn, change_user), - - MYSQLND_METHOD(mysqlnd_conn, errno), - MYSQLND_METHOD(mysqlnd_conn, error), - MYSQLND_METHOD(mysqlnd_conn, sqlstate), - MYSQLND_METHOD(mysqlnd_conn, thread_id), - - MYSQLND_METHOD(mysqlnd_conn, get_connection_stats), - - MYSQLND_METHOD(mysqlnd_conn, get_server_version), - MYSQLND_METHOD(mysqlnd_conn, get_server_info), - MYSQLND_METHOD(mysqlnd_conn, statistic), - MYSQLND_METHOD(mysqlnd_conn, get_host_info), - MYSQLND_METHOD(mysqlnd_conn, get_proto_info), - MYSQLND_METHOD(mysqlnd_conn, info), - MYSQLND_METHOD(mysqlnd_conn, charset_name), - MYSQLND_METHOD(mysqlnd_conn, list_fields), - MYSQLND_METHOD(mysqlnd_conn, list_method), - - MYSQLND_METHOD(mysqlnd_conn, insert_id), - MYSQLND_METHOD(mysqlnd_conn, affected_rows), - MYSQLND_METHOD(mysqlnd_conn, warning_count), - MYSQLND_METHOD(mysqlnd_conn, field_count), - - MYSQLND_METHOD(mysqlnd_conn, set_server_option), - MYSQLND_METHOD(mysqlnd_conn, set_client_option), - MYSQLND_METHOD(mysqlnd_conn, free_contents), - MYSQLND_METHOD(mysqlnd_conn, free_options), - MYSQLND_METHOD(mysqlnd_conn, close), - - MYSQLND_METHOD_PRIVATE(mysqlnd_conn, dtor), - - mysqlnd_query_read_result_set_header, - MYSQLND_METHOD_PRIVATE(mysqlnd_conn, get_reference), - MYSQLND_METHOD_PRIVATE(mysqlnd_conn, free_reference), - MYSQLND_METHOD_PRIVATE(mysqlnd_conn, get_state), - MYSQLND_METHOD_PRIVATE(mysqlnd_conn, set_state), - - MYSQLND_METHOD(mysqlnd_conn, simple_command), - MYSQLND_METHOD(mysqlnd_conn, simple_command_handle_response), - MYSQLND_METHOD(mysqlnd_conn, restart_psession), - MYSQLND_METHOD(mysqlnd_conn, end_psession), - MYSQLND_METHOD(mysqlnd_conn, send_close), - - MYSQLND_METHOD(mysqlnd_conn, ssl_set), - mysqlnd_result_init -#ifdef AUTOCOMMIT_TX_COMMIT_ROLLBACK - ,MYSQLND_METHOD(mysqlnd_conn, set_autocommit), - MYSQLND_METHOD(mysqlnd_conn, tx_commit), - MYSQLND_METHOD(mysqlnd_conn, tx_rollback) -#endif -MYSQLND_CLASS_METHODS_END; +/* {{{ mysqlnd_conn_data::local_tx_end */ +static enum_func_status +MYSQLND_METHOD(mysqlnd_conn_data, local_tx_end)(MYSQLND_CONN_DATA * conn, size_t this_func, enum_func_status status TSRMLS_DC) +{ + DBG_ENTER("mysqlnd_conn_data::local_tx_end"); + DBG_RETURN(status); +} +/* }}} */ -/* {{{ mysqlnd_conn::init */ +/* {{{ mysqlnd_conn_data::init */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, init)(MYSQLND * conn TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn_data, init)(MYSQLND_CONN_DATA * conn TSRMLS_DC) { - DBG_ENTER("mysqlnd_conn::init"); + DBG_ENTER("mysqlnd_conn_data::init"); mysqlnd_stats_init(&conn->stats, STAT_LAST); SET_ERROR_AFF_ROWS(conn); - conn->net = mysqlnd_net_init(conn->persistent TSRMLS_CC); + conn->net = mysqlnd_net_init(conn->persistent, conn->stats, conn->error_info TSRMLS_CC); conn->protocol = mysqlnd_protocol_init(conn->persistent TSRMLS_CC); - DBG_RETURN(conn->net && conn->protocol? PASS:FAIL); + DBG_RETURN(conn->stats && conn->net && conn->protocol? PASS:FAIL); } /* }}} */ -/* {{{ mysqlnd_init */ -PHPAPI MYSQLND * _mysqlnd_init(zend_bool persistent TSRMLS_DC) -{ - size_t alloc_size = sizeof(MYSQLND) + mysqlnd_plugin_count() * sizeof(void *); - MYSQLND *ret; +MYSQLND_STMT * _mysqlnd_stmt_init(MYSQLND_CONN_DATA * const conn TSRMLS_DC); - DBG_ENTER("mysqlnd_init"); - DBG_INF_FMT("persistent=%u", persistent); - ret = mnd_pecalloc(1, alloc_size, persistent); - if (!ret) { - DBG_RETURN(NULL); - } - ret->persistent = persistent; - ret->m = mysqlnd_conn_methods; - CONN_SET_STATE(ret, CONN_ALLOCED); - ret->m->get_reference(ret TSRMLS_CC); +MYSQLND_CLASS_METHODS_START(mysqlnd_conn_data) + MYSQLND_METHOD(mysqlnd_conn_data, init), + MYSQLND_METHOD(mysqlnd_conn_data, connect), - if (PASS != ret->m->init(ret TSRMLS_CC)) { - ret->m->dtor(ret TSRMLS_CC); - ret = NULL; - } + MYSQLND_METHOD(mysqlnd_conn_data, escape_string), + MYSQLND_METHOD(mysqlnd_conn_data, set_charset), + MYSQLND_METHOD(mysqlnd_conn_data, query), + MYSQLND_METHOD(mysqlnd_conn_data, send_query), + MYSQLND_METHOD(mysqlnd_conn_data, reap_query), + MYSQLND_METHOD(mysqlnd_conn_data, use_result), + MYSQLND_METHOD(mysqlnd_conn_data, store_result), + MYSQLND_METHOD(mysqlnd_conn_data, next_result), + MYSQLND_METHOD(mysqlnd_conn_data, more_results), - DBG_RETURN(ret); -} -/* }}} */ + _mysqlnd_stmt_init, + MYSQLND_METHOD(mysqlnd_conn_data, shutdown), + MYSQLND_METHOD(mysqlnd_conn_data, refresh), -/* {{{ mysqlnd_library_init */ -PHPAPI void mysqlnd_library_init(TSRMLS_D) -{ - if (mysqlnd_library_initted == FALSE) { - mysqlnd_library_initted = TRUE; - mysqlnd_conn_methods = &MYSQLND_CLASS_METHOD_TABLE_NAME(mysqlnd_conn); - _mysqlnd_init_ps_subsystem(); - /* Should be calloc, as mnd_calloc will reference LOCK_access*/ - mysqlnd_stats_init(&mysqlnd_global_stats, STAT_LAST); - } -} -/* }}} */ + MYSQLND_METHOD(mysqlnd_conn_data, ping), + MYSQLND_METHOD(mysqlnd_conn_data, kill), + MYSQLND_METHOD(mysqlnd_conn_data, select_db), + MYSQLND_METHOD(mysqlnd_conn_data, dump_debug_info), + MYSQLND_METHOD(mysqlnd_conn_data, change_user), + + MYSQLND_METHOD(mysqlnd_conn_data, errno), + MYSQLND_METHOD(mysqlnd_conn_data, error), + MYSQLND_METHOD(mysqlnd_conn_data, sqlstate), + MYSQLND_METHOD(mysqlnd_conn_data, thread_id), + + MYSQLND_METHOD(mysqlnd_conn_data, get_connection_stats), + + MYSQLND_METHOD(mysqlnd_conn_data, get_server_version), + MYSQLND_METHOD(mysqlnd_conn_data, get_server_info), + MYSQLND_METHOD(mysqlnd_conn_data, statistic), + MYSQLND_METHOD(mysqlnd_conn_data, get_host_info), + MYSQLND_METHOD(mysqlnd_conn_data, get_proto_info), + MYSQLND_METHOD(mysqlnd_conn_data, info), + MYSQLND_METHOD(mysqlnd_conn_data, charset_name), + MYSQLND_METHOD(mysqlnd_conn_data, list_fields), + MYSQLND_METHOD(mysqlnd_conn_data, list_method), + + MYSQLND_METHOD(mysqlnd_conn_data, insert_id), + MYSQLND_METHOD(mysqlnd_conn_data, affected_rows), + MYSQLND_METHOD(mysqlnd_conn_data, warning_count), + MYSQLND_METHOD(mysqlnd_conn_data, field_count), + + MYSQLND_METHOD(mysqlnd_conn_data, server_status), + + MYSQLND_METHOD(mysqlnd_conn_data, set_server_option), + MYSQLND_METHOD(mysqlnd_conn_data, set_client_option), + MYSQLND_METHOD(mysqlnd_conn_data, free_contents), + MYSQLND_METHOD(mysqlnd_conn_data, free_options), + + MYSQLND_METHOD_PRIVATE(mysqlnd_conn_data, dtor), + + mysqlnd_query_read_result_set_header, + + MYSQLND_METHOD_PRIVATE(mysqlnd_conn_data, get_reference), + MYSQLND_METHOD_PRIVATE(mysqlnd_conn_data, free_reference), + MYSQLND_METHOD_PRIVATE(mysqlnd_conn_data, get_state), + MYSQLND_METHOD_PRIVATE(mysqlnd_conn_data, set_state), + + MYSQLND_METHOD(mysqlnd_conn_data, simple_command), + MYSQLND_METHOD(mysqlnd_conn_data, simple_command_handle_response), + MYSQLND_METHOD(mysqlnd_conn_data, restart_psession), + MYSQLND_METHOD(mysqlnd_conn_data, end_psession), + MYSQLND_METHOD(mysqlnd_conn_data, send_close), + + MYSQLND_METHOD(mysqlnd_conn_data, ssl_set), + mysqlnd_result_init, + MYSQLND_METHOD(mysqlnd_conn_data, set_autocommit), + MYSQLND_METHOD(mysqlnd_conn_data, tx_commit), + MYSQLND_METHOD(mysqlnd_conn_data, tx_rollback), + MYSQLND_METHOD(mysqlnd_conn_data, local_tx_start), + MYSQLND_METHOD(mysqlnd_conn_data, local_tx_end) +MYSQLND_CLASS_METHODS_END; -/* {{{ mysqlnd_conn_get_methods */ -PHPAPI struct st_mysqlnd_conn_methods * mysqlnd_conn_get_methods() + +/* {{{ mysqlnd_conn::get_reference */ +static MYSQLND * +MYSQLND_METHOD(mysqlnd_conn, clone_object)(MYSQLND * const conn TSRMLS_DC) { - return mysqlnd_conn_methods; + MYSQLND * ret; + DBG_ENTER("mysqlnd_conn::get_reference"); + ret = MYSQLND_CLASS_METHOD_TABLE_NAME(mysqlnd_object_factory).clone_connection_object(conn TSRMLS_CC); + DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_conn_set_methods */ -PHPAPI void mysqlnd_conn_set_methods(struct st_mysqlnd_conn_methods *methods) + +/* {{{ mysqlnd_conn_data::dtor */ +static void +MYSQLND_METHOD_PRIVATE(mysqlnd_conn, dtor)(MYSQLND * conn TSRMLS_DC) { - mysqlnd_conn_methods = methods; -} -/* }}} */ + DBG_ENTER("mysqlnd_conn::dtor"); + DBG_INF_FMT("conn=%llu", conn->data->thread_id); + conn->data->m->free_reference(conn->data TSRMLS_CC); -static unsigned int mysqlnd_plugins_counter = 0; + mnd_pefree(conn, conn->persistent); -/* {{{ mysqlnd_plugin_register */ -PHPAPI unsigned int mysqlnd_plugin_register() -{ - return mysqlnd_plugins_counter++; + DBG_VOID_RETURN; } /* }}} */ -/* {{{ mysqlnd_plugin_count */ -PHPAPI unsigned int mysqlnd_plugin_count() +/* {{{ mysqlnd_conn_data::close */ +static enum_func_status +MYSQLND_METHOD(mysqlnd_conn, close)(MYSQLND * conn_handle, enum_connection_close_type close_type TSRMLS_DC) { - return mysqlnd_plugins_counter; + size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_methods, close); + MYSQLND_CONN_DATA * conn = conn_handle->data; + enum_func_status ret = FAIL; + + DBG_ENTER("mysqlnd_conn::close"); + DBG_INF_FMT("conn=%llu", conn->thread_id); + + if (PASS == conn->m->local_tx_start(conn, this_func TSRMLS_CC)) { + if (CONN_GET_STATE(conn) >= CONN_READY) { + static enum_mysqlnd_collected_stats close_type_to_stat_map[MYSQLND_CLOSE_LAST] = { + STAT_CLOSE_EXPLICIT, + STAT_CLOSE_IMPLICIT, + STAT_CLOSE_DISCONNECT + }; + MYSQLND_INC_CONN_STATISTIC(conn->stats, close_type_to_stat_map[close_type]); + } + + /* + Close now, free_reference will try, + if we are last, but that's not a problem. + */ + ret = conn->m->send_close(conn TSRMLS_CC); + + /* do it after free_reference/dtor and we might crash */ + conn->m->local_tx_end(conn, this_func, ret TSRMLS_CC); + + conn_handle->m->dtor(conn_handle TSRMLS_CC); + } + DBG_RETURN(ret); } /* }}} */ -/* {{{ _mysqlnd_plugin_get_plugin_connection_data */ -PHPAPI void ** _mysqlnd_plugin_get_plugin_connection_data(const MYSQLND * conn, unsigned int plugin_id TSRMLS_DC) +MYSQLND_CLASS_METHODS_START(mysqlnd_conn) + MYSQLND_METHOD(mysqlnd_conn, connect), + MYSQLND_METHOD(mysqlnd_conn, clone_object), + MYSQLND_METHOD_PRIVATE(mysqlnd_conn, dtor), + MYSQLND_METHOD(mysqlnd_conn, close) +MYSQLND_CLASS_METHODS_END; + + +/* {{{ _mysqlnd_init */ +PHPAPI MYSQLND * +_mysqlnd_init(zend_bool persistent TSRMLS_DC) { - DBG_ENTER("_mysqlnd_plugin_get_plugin_connection_data"); - DBG_INF_FMT("plugin_id=%u", plugin_id); - if (!conn || plugin_id >= mysqlnd_plugin_count()) { - return NULL; - } - DBG_RETURN((void *)((char *)conn + sizeof(MYSQLND) + plugin_id * sizeof(void *))); + MYSQLND * ret; + DBG_ENTER("mysqlnd_init"); + ret = MYSQLND_CLASS_METHOD_TABLE_NAME(mysqlnd_object_factory).get_connection(persistent TSRMLS_CC); + DBG_RETURN(ret); } /* }}} */ |