diff options
Diffstat (limited to 'ext/mysqlnd/mysqlnd.c')
| -rw-r--r-- | ext/mysqlnd/mysqlnd.c | 670 |
1 files changed, 513 insertions, 157 deletions
diff --git a/ext/mysqlnd/mysqlnd.c b/ext/mysqlnd/mysqlnd.c index 78ac992ebb..98b3ab7dc9 100644 --- a/ext/mysqlnd/mysqlnd.c +++ b/ext/mysqlnd/mysqlnd.c @@ -19,7 +19,6 @@ */ /* $Id$ */ - #include "php.h" #include "mysqlnd.h" #include "mysqlnd_wireprotocol.h" @@ -27,13 +26,12 @@ #include "mysqlnd_result.h" #include "mysqlnd_statistics.h" #include "mysqlnd_charset.h" +#include "mysqlnd_debug.h" #include "php_ini.h" #include "ext/standard/basic_functions.h" #include "ext/standard/php_lcg.h" #include "ext/standard/info.h" -#define MYSQLND_SILENT - /* the server doesn't support 4byte utf8, but let's make it forward compatible */ #define MYSQLND_MAX_ALLOWED_USER_LEN 256 /* 64 char * 4byte */ #define MYSQLND_MAX_ALLOWED_DB_LEN 256 /* 64 char * 4byte */ @@ -62,26 +60,27 @@ extern MYSQLND_CHARSET *mysqlnd_charsets; -static const char * mysqlnd_server_gone = "MySQL server has gone away"; +const char * mysqlnd_server_gone = "MySQL server has gone away"; const char * mysqlnd_out_of_sync = "Commands out of sync; you can't run this command now"; MYSQLND_STATS *mysqlnd_global_stats = NULL; static zend_bool mysqlnd_library_initted = FALSE; + +enum_func_status mysqlnd_send_close(MYSQLND * conn TSRMLS_DC); + /* {{{ mysqlnd_library_init */ static -void mysqlnd_library_init(zend_bool collect_statistics) +void mysqlnd_library_init() { if (mysqlnd_library_initted == FALSE) { mysqlnd_library_initted = TRUE; _mysqlnd_init_ps_subsystem(); - if (collect_statistics) { - mysqlnd_global_stats = calloc(1, sizeof(MYSQLND_STATS)); - + /* Should be calloc, as mnd_calloc will reference LOCK_access*/ + mysqlnd_global_stats = calloc(1, sizeof(MYSQLND_STATS)); #ifdef ZTS - mysqlnd_global_stats->LOCK_access = tsrm_mutex_alloc(); + mysqlnd_global_stats->LOCK_access = tsrm_mutex_alloc(); #endif - } } } /* }}} */ @@ -92,13 +91,12 @@ static void mysqlnd_library_end() { if (mysqlnd_library_initted == TRUE) { - if (mysqlnd_global_stats) { #ifdef ZTS - tsrm_mutex_free(mysqlnd_global_stats->LOCK_access); + tsrm_mutex_free(mysqlnd_global_stats->LOCK_access); #endif - free(mysqlnd_global_stats); - mysqlnd_global_stats = NULL; - } + /* mnd_free will reference LOCK_access and crash...*/ + free(mysqlnd_global_stats); + mysqlnd_global_stats = NULL; mysqlnd_library_initted = FALSE; } } @@ -111,106 +109,130 @@ MYSQLND_METHOD(mysqlnd_conn, free_contents)(MYSQLND *conn TSRMLS_DC) { zend_bool pers = conn->persistent; - mysqlnd_local_infile_default(conn, TRUE); + DBG_ENTER("mysqlnd_conn::free_contents"); + + mysqlnd_local_infile_default(conn); if (conn->current_result) { conn->current_result->m.free_result_contents(conn->current_result TSRMLS_CC); - efree(conn->current_result); + mnd_efree(conn->current_result); conn->current_result = NULL; } if (conn->net.stream) { - php_stream_free(conn->net.stream, (pers) ? PHP_STREAM_FREE_RSRC_DTOR : - PHP_STREAM_FREE_CLOSE); + DBG_INF_FMT("Freeing stream. abstract=%p", conn->net.stream->abstract); + if (pers) { + php_stream_free(conn->net.stream, PHP_STREAM_FREE_CLOSE_PERSISTENT | PHP_STREAM_FREE_RSRC_DTOR); + } else { + php_stream_free(conn->net.stream, PHP_STREAM_FREE_CLOSE); + + } conn->net.stream = NULL; } + + DBG_INF("Freeing memory of members"); if (conn->host) { - pefree(conn->host, pers); + DBG_INF("Freeing host"); + mnd_pefree(conn->host, pers); conn->host = NULL; } if (conn->user) { - pefree(conn->user, pers); + DBG_INF("Freeing user"); + mnd_pefree(conn->user, pers); conn->user = NULL; } if (conn->passwd) { - pefree(conn->passwd, pers); + DBG_INF("Freeing passwd"); + mnd_pefree(conn->passwd, pers); conn->passwd = NULL; } if (conn->unix_socket) { - pefree(conn->unix_socket, pers); + DBG_INF("Freeing unix_socket"); + mnd_pefree(conn->unix_socket, pers); conn->unix_socket = NULL; } if (conn->scheme) { - pefree(conn->scheme, pers); + DBG_INF("Freeing scheme"); + mnd_pefree(conn->scheme, pers); conn->scheme = NULL; } if (conn->server_version) { - pefree(conn->server_version, pers); + DBG_INF("Freeing server_version"); + mnd_pefree(conn->server_version, pers); conn->server_version = NULL; } if (conn->host_info) { - pefree(conn->host_info, pers); + DBG_INF("Freeing host_info"); + mnd_pefree(conn->host_info, pers); conn->host_info = NULL; } if (conn->scramble) { - pefree(conn->scramble, pers); + DBG_INF("Freeing scramble"); + mnd_pefree(conn->scramble, pers); conn->scramble = NULL; } if (conn->last_message) { - pefree(conn->last_message, pers); + mnd_pefree(conn->last_message, pers); conn->last_message = NULL; } if (conn->options.charset_name) { - pefree(conn->options.charset_name, pers); + mnd_pefree(conn->options.charset_name, pers); conn->options.charset_name = NULL; } if (conn->options.num_commands) { unsigned int i; for (i=0; i < conn->options.num_commands; i++) { - pefree(conn->options.init_commands[i], pers); + mnd_pefree(conn->options.init_commands[i], pers); } - pefree(conn->options.init_commands, pers); + mnd_pefree(conn->options.init_commands, pers); conn->options.init_commands = NULL; } if (conn->options.cfg_file) { - pefree(conn->options.cfg_file, pers); + mnd_pefree(conn->options.cfg_file, pers); conn->options.cfg_file = NULL; } if (conn->options.cfg_section) { - pefree(conn->options.cfg_section, pers); + mnd_pefree(conn->options.cfg_section, pers); conn->options.cfg_section = NULL; } if (conn->options.ssl_key) { - pefree(conn->options.ssl_key, pers); + mnd_pefree(conn->options.ssl_key, pers); conn->options.ssl_key = NULL; } if (conn->options.ssl_cert) { - pefree(conn->options.ssl_cert, pers); + mnd_pefree(conn->options.ssl_cert, pers); conn->options.ssl_cert = NULL; } if (conn->options.ssl_ca) { - pefree(conn->options.ssl_ca, pers); + mnd_pefree(conn->options.ssl_ca, pers); conn->options.ssl_ca = NULL; } if (conn->options.ssl_capath) { - pefree(conn->options.ssl_capath, pers); + mnd_pefree(conn->options.ssl_capath, pers); conn->options.ssl_capath = NULL; } if (conn->options.ssl_cipher) { - pefree(conn->options.ssl_cipher, pers); + mnd_pefree(conn->options.ssl_cipher, pers); conn->options.ssl_cipher = NULL; } if (conn->zval_cache) { + DBG_INF("Freeing zval cache reference"); mysqlnd_palloc_free_thd_cache_reference(&conn->zval_cache); conn->zval_cache = NULL; } if (conn->qcache) { + DBG_INF("Freeing qcache reference"); mysqlnd_qcache_free_cache_reference(&conn->qcache); conn->qcache = NULL; } if (conn->net.cmd_buffer.buffer) { - pefree(conn->net.cmd_buffer.buffer, pers); + DBG_INF("Freeing cmd buffer"); + mnd_pefree(conn->net.cmd_buffer.buffer, pers); conn->net.cmd_buffer.buffer = NULL; } + conn->charset = NULL; + conn->greet_charset = NULL; + + DBG_VOID_RETURN; } /* }}} */ @@ -219,9 +241,14 @@ MYSQLND_METHOD(mysqlnd_conn, free_contents)(MYSQLND *conn TSRMLS_DC) static void MYSQLND_METHOD_PRIVATE(mysqlnd_conn, dtor)(MYSQLND *conn TSRMLS_DC) { + DBG_ENTER("mysqlnd_conn::dtor"); + DBG_INF_FMT("conn=%llu", conn->thread_id); + conn->m->free_contents(conn TSRMLS_CC); - pefree(conn, conn->persistent); + mnd_pefree(conn, conn->persistent); + + DBG_VOID_RETURN; } /* }}} */ @@ -233,19 +260,22 @@ mysqlnd_simple_command_handle_response(MYSQLND *conn, enum php_mysql_packet_type TSRMLS_DC) { enum_func_status ret; + + DBG_ENTER("mysqlnd_simple_command_handle_response"); + DBG_INF_FMT("silent=%d packet=%d command=%s", silent, ok_packet, mysqlnd_command_to_text[command]); + switch (ok_packet) { case PROT_OK_PACKET:{ php_mysql_packet_ok ok_response; PACKET_INIT_ALLOCA(ok_response, PROT_OK_PACKET); if (FAIL == (ret = PACKET_READ_ALLOCA(ok_response, conn))) { if (!silent) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading %s's OK packet", - mysqlnd_command_to_text[command]); + DBG_ERR_FMT("Error while reading %s's OK packet", mysqlnd_command_to_text[command]); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading %s's OK packet. PID=%d", + mysqlnd_command_to_text[command], getpid()); } } else { -#ifndef MYSQLND_SILENT - php_printf("\tOK from server\n"); -#endif + 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, @@ -283,8 +313,9 @@ mysqlnd_simple_command_handle_response(MYSQLND *conn, enum php_mysql_packet_type SET_CLIENT_ERROR(conn->error_info, CR_MALFORMED_PACKET, UNKNOWN_SQLSTATE, "Malformed packet"); if (!silent) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading %s's EOF packet", - mysqlnd_command_to_text[command]); + DBG_ERR_FMT("Error while reading %s's EOF packet", mysqlnd_command_to_text[command]); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading %s's EOF packet. PID=%d", + mysqlnd_command_to_text[command], getpid()); } } else if (0xFF == ok_response.field_count) { /* The server signalled error. Set the error */ @@ -295,14 +326,13 @@ mysqlnd_simple_command_handle_response(MYSQLND *conn, enum php_mysql_packet_type 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", ok_response.field_count); } } else { -#ifndef MYSQLND_SILENT - php_printf("\tOK from server\n"); -#endif + DBG_INF_FMT("OK from server"); } PACKET_FREE_ALLOCA(ok_response); break; @@ -315,7 +345,8 @@ mysqlnd_simple_command_handle_response(MYSQLND *conn, enum php_mysql_packet_type ok_packet); break; } - return ret; + DBG_INF(ret == PASS ? "PASS":"FAIL"); + DBG_RETURN(ret); } /* }}} */ @@ -329,16 +360,21 @@ mysqlnd_simple_command(MYSQLND *conn, enum php_mysqlnd_server_command command, enum_func_status ret = PASS; php_mysql_packet_command cmd_packet; + DBG_ENTER("mysqlnd_simple_command"); + DBG_INF_FMT("command=%s ok_packet=%d silent=%d", mysqlnd_command_to_text[command], ok_packet, silent); + switch (conn->state) { case CONN_READY: break; case CONN_QUIT_SENT: SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone); - return FAIL; + 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); - return FAIL; + DBG_ERR("Command out of sync"); + DBG_RETURN(FAIL); } /* clean UPSERT info */ @@ -355,9 +391,10 @@ mysqlnd_simple_command(MYSQLND *conn, enum php_mysqlnd_server_command command, if (! PACKET_WRITE_ALLOCA(cmd_packet, conn)) { if (!silent) { - php_error(E_WARNING, "Error while sending %s packet", mysqlnd_command_to_text[command]); + 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()); } - SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone); + DBG_ERR("Server is gone"); ret = FAIL; } else if (ok_packet != PROT_LAST) { ret = mysqlnd_simple_command_handle_response(conn, ok_packet, silent, command TSRMLS_CC); @@ -369,7 +406,8 @@ mysqlnd_simple_command(MYSQLND *conn, enum php_mysqlnd_server_command command, to us. We should not free it. */ - return ret; + DBG_INF(ret == PASS ? "PASS":"FAIL"); + DBG_RETURN(ret); } /* }}} */ @@ -379,23 +417,29 @@ static enum_func_status MYSQLND_METHOD(mysqlnd_conn, set_server_option)(MYSQLND * const conn, enum_mysqlnd_server_option option TSRMLS_DC) { + enum_func_status ret; char buffer[2]; + DBG_ENTER("mysqlnd_conn::set_server_option"); + int2store(buffer, (uint) option); - return mysqlnd_simple_command(conn, COM_SET_OPTION, buffer, sizeof(buffer), - PROT_EOF_PACKET, FALSE TSRMLS_CC); + ret = mysqlnd_simple_command(conn, COM_SET_OPTION, buffer, sizeof(buffer), + PROT_EOF_PACKET, FALSE TSRMLS_CC); + DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_start_psession */ -PHPAPI void mysqlnd_restart_psession(MYSQLND *conn) +/* {{{ _mysqlnd_restart_psession */ +PHPAPI void _mysqlnd_restart_psession(MYSQLND *conn TSRMLS_DC) { + DBG_ENTER("_mysqlnd_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) { - pefree(conn->last_message, conn->persistent); + mnd_pefree(conn->last_message, conn->persistent); conn->last_message = NULL; } + DBG_VOID_RETURN; } /* }}} */ @@ -421,22 +465,40 @@ PHPAPI MYSQLND *mysqlnd_connect(MYSQLND *conn, { char *transport = NULL, *errstr = NULL; char *hashed_details = NULL; - int transport_len, errcode = 0; + int transport_len, hashed_details_len, errcode = 0; unsigned int streams_options = ENFORCE_SAFE_MODE; unsigned int streams_flags = STREAM_XPORT_CLIENT | STREAM_XPORT_CONNECT; zend_bool self_alloced = FALSE; struct timeval tv; zend_bool unix_socket = FALSE; const MYSQLND_CHARSET * charset; + zend_bool reconnect = FALSE; php_mysql_packet_greet greet_packet; php_mysql_packet_auth *auth_packet; php_mysql_packet_ok ok_packet; - if (conn && conn->state != CONN_ALLOCED) { - SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, - mysqlnd_out_of_sync); - return NULL; + DBG_ENTER("mysqlnd_connect"); + DBG_INF_FMT("host=%s user=%s db=%s port=%d flags=%d persistent=%d state=%d", + host?host:"", user?user:"", db?db:"", port, mysql_flags, + conn? conn->persistent:0, conn? conn->state:-1); + + DBG_INF_FMT("state=%d", conn->state); + if (conn && conn->state > CONN_ALLOCED && conn->state ) { + DBG_INF("Connecting on a connected handle."); + + if (conn->state < CONN_QUIT_SENT) { + MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_CLOSE_IMPLICIT); + reconnect = TRUE; + mysqlnd_send_close(conn TSRMLS_CC); + } + + conn->m->free_contents(conn TSRMLS_CC); + MYSQLND_DEC_CONN_STATISTIC(&conn->stats, STAT_OPENED_CONNECTIONS); + if (conn->persistent) { + MYSQLND_DEC_CONN_STATISTIC(&conn->stats, STAT_OPENED_PERSISTENT_CONNECTIONS); + } + /* Now reconnect using the same handle */ } if (!host || !host[0]) { @@ -468,14 +530,16 @@ PHPAPI MYSQLND *mysqlnd_connect(MYSQLND *conn, { transport_len = spprintf(&transport, 0, "tcp://%s:%d", host, port); } + DBG_INF_FMT("transport=%p", transport); if (conn->persistent) { struct timeval tv; gettimeofday(&tv, NULL); /* We should generate something unique */ - spprintf(&hashed_details, 0, "%s@%s@%s@%ld@%ld@%0.8F", - transport, user, db, tv.tv_sec, (long int)tv.tv_usec, - php_combined_lcg(TSRMLS_C) * 10); + hashed_details_len = spprintf(&hashed_details, 0, "%s@%s@%s@%ld@%ld@%0.8F", + transport, user, db, tv.tv_sec, (long int)tv.tv_usec, + php_combined_lcg(TSRMLS_C) * 10); + DBG_INF_FMT("hashed_details=%s", hashed_details); } PACKET_INIT_ALLOCA(greet_packet, PROT_GREET_PACKET); @@ -496,17 +560,43 @@ PHPAPI MYSQLND *mysqlnd_connect(MYSQLND *conn, } if (conn->persistent) { conn->scheme = pestrndup(transport, transport_len, 1); - efree(transport); + mnd_efree(transport); } else { conn->scheme = transport; } + DBG_INF(conn->scheme); conn->net.stream = php_stream_xport_create(conn->scheme, transport_len, streams_options, streams_flags, hashed_details, (conn->options.timeout_connect) ? &tv : NULL, NULL /*ctx*/, &errstr, &errcode); + DBG_INF_FMT("stream=%p", conn->net.stream); + if (hashed_details) { - efree(hashed_details); + /* + If persistent, the streams register it in EG(persistent_list). + This is unwanted. ext/mysql or ext/mysqli are responsible to clean, + whatever they have to. + */ + zend_rsrc_list_entry *le; + + if (zend_hash_find(&EG(persistent_list), hashed_details, hashed_details_len + 1, + (void*) &le) == SUCCESS) { + /* + in_free will let streams code skip destructing - big HACK, + but STREAMS suck big time regarding persistent streams. + Just not compatible for extensions that need persistency. + */ + conn->net.stream->in_free = 1; + zend_hash_del(&EG(persistent_list), hashed_details, hashed_details_len + 1); + conn->net.stream->in_free = 0; + } +#if ZEND_DEBUG + /* Shut-up the streams, they don't know what they are doing */ + conn->net.stream->__exposed = 1; +#endif + mnd_efree(hashed_details); } + if (errstr || !conn->net.stream) { goto err; } @@ -524,15 +614,17 @@ PHPAPI MYSQLND *mysqlnd_connect(MYSQLND *conn, } if (FAIL == PACKET_READ_ALLOCA(greet_packet, conn)) { -#ifndef MYSQLND_SILENT - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading greeting packet"); -#endif + DBG_ERR("Error while reading greeting packet"); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading greeting packet. PID=%d", getpid()); goto err; } else if (greet_packet.error_no) { + DBG_ERR_FMT("errorno=%d 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); 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, @@ -545,6 +637,7 @@ PHPAPI MYSQLND *mysqlnd_connect(MYSQLND *conn, conn->server_version = greet_packet.server_version; greet_packet.server_version = NULL; /* The string will be freed otherwise */ + conn->greet_charset = mysqlnd_find_charset_nr(greet_packet.charset_no); /* we allow load data local infile by default */ mysql_flags |= CLIENT_LOCAL_FILES; @@ -567,23 +660,26 @@ PHPAPI MYSQLND *mysqlnd_connect(MYSQLND *conn, auth_packet->max_packet_size= 3UL*1024UL*1024UL*1024UL; auth_packet->client_flags= mysql_flags; - conn->scramble = auth_packet->server_scramble_buf = pemalloc(SCRAMBLE_LENGTH, conn->persistent); + conn->scramble = auth_packet->server_scramble_buf = mnd_pemalloc(SCRAMBLE_LENGTH, conn->persistent); memcpy(auth_packet->server_scramble_buf, greet_packet.scramble_buf, SCRAMBLE_LENGTH); - PACKET_WRITE(auth_packet, conn); + if (!PACKET_WRITE(auth_packet, conn)) { + conn->state = CONN_QUIT_SENT; + SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone); + goto err; + } if (FAIL == PACKET_READ_ALLOCA(ok_packet, conn) || ok_packet.field_count >= 0xFE) { if (ok_packet.field_count == 0xFE) { /* old authentication with new server !*/ + DBG_ERR("mysqlnd cannot connect to MySQL 4.1+ using old authentication"); php_error_docref(NULL TSRMLS_CC, E_WARNING, "mysqlnd cannot connect to MySQL 4.1+ using old authentication"); } else if (ok_packet.field_count == 0xFF) { if (ok_packet.sqlstate[0]) { if (!self_alloced) { strncpy(conn->error_info.sqlstate, ok_packet.sqlstate, sizeof(conn->error_info.sqlstate)); } -#ifndef MYSQLND_SILENT - php_error_docref(NULL TSRMLS_CC, E_WARNING, "ERROR:%d [SQLSTATE:%s] %s", - ok_packet.error_no, ok_packet.sqlstate, ok_packet.error); -#endif + DBG_ERR_FMT("ERROR:%d [SQLSTATE:%s] %s", + ok_packet.error_no, ok_packet.sqlstate, ok_packet.error); } if (!self_alloced) { conn->error_info.error_no = ok_packet.error_no; @@ -603,7 +699,7 @@ PHPAPI MYSQLND *mysqlnd_connect(MYSQLND *conn, spprintf(&p, 0, "MySQL host info: %s via TCP/IP", conn->host); if (conn->persistent) { conn->host_info = pestrdup(p, 1); - efree(p); + mnd_efree(p); } else { conn->host_info = p; } @@ -631,17 +727,39 @@ PHPAPI MYSQLND *mysqlnd_connect(MYSQLND *conn, conn->zval_cache = mysqlnd_palloc_get_thd_cache_reference(zval_cache); conn->net.cmd_buffer.length = 128L*1024L; - conn->net.cmd_buffer.buffer = pemalloc(conn->net.cmd_buffer.length, conn->persistent); + conn->net.cmd_buffer.buffer = mnd_pemalloc(conn->net.cmd_buffer.length, conn->persistent); + + mysqlnd_local_infile_default(conn); + { + uint buf_size; + buf_size = MYSQLND_G(net_read_buffer_size); /* this is long, cast to uint*/ + conn->m->set_client_option(conn, MYSQLND_OPT_NET_READ_BUFFER_SIZE, + (char *)&buf_size TSRMLS_CC); + + buf_size = MYSQLND_G(net_cmd_buffer_size); /* this is long, cast to uint*/ + conn->m->set_client_option(conn, MYSQLND_OPT_NET_CMD_BUFFER_SIZE, + (char *)&buf_size TSRMLS_CC); + } MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_CONNECT_SUCCESS); + if (reconnect) { + MYSQLND_INC_GLOBAL_STATISTIC(STAT_RECONNECT); + } + MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_OPENED_CONNECTIONS); + if (conn->persistent) { + MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_OPENED_PERSISTENT_CONNECTIONS); + } + DBG_INF_FMT("connection_id=%llu", conn->thread_id); +#if PHP_MAJOR_VERSION >= 6 { uint as_unicode = 1; conn->m->set_client_option(conn, MYSQLND_OPT_NUMERIC_AND_DATETIME_AS_UNICODE, - (char *)&as_unicode); + (char *)&as_unicode TSRMLS_CC); + DBG_INF("unicode set"); } - - return conn; +#endif + DBG_RETURN(conn); } err: PACKET_FREE_ALLOCA(greet_packet); @@ -649,14 +767,15 @@ err: PACKET_FREE_ALLOCA(ok_packet); if (errstr) { + DBG_ERR_FMT("[%d] %.64s (trying to connect via %s)", errcode, errstr, conn->scheme); SET_CLIENT_ERROR(conn->error_info, errcode, UNKNOWN_SQLSTATE, errstr); php_error_docref(NULL TSRMLS_CC, E_WARNING, "[%d] %.64s (trying to connect via %s)", errcode, errstr, conn->scheme); - efree(errstr); + mnd_efree(errstr); } if (conn->scheme) { - pefree(conn->scheme, conn->persistent); + mnd_pefree(conn->scheme, conn->persistent); conn->scheme = NULL; } @@ -673,7 +792,7 @@ err: } else { MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_CONNECT_FAILURE); } - return NULL; + DBG_RETURN(NULL); } /* }}} */ @@ -687,11 +806,13 @@ static enum_func_status MYSQLND_METHOD(mysqlnd_conn, query)(MYSQLND *conn, const char *query, unsigned int query_len TSRMLS_DC) { enum_func_status ret; + DBG_ENTER("mysqlnd_conn::query"); + DBG_INF_FMT("conn=%llu query=%s", conn->thread_id, query); if (PASS != mysqlnd_simple_command(conn, COM_QUERY, query, query_len, PROT_LAST /* we will handle the OK packet*/, FALSE TSRMLS_CC)) { - return FAIL; + DBG_RETURN(FAIL); } /* @@ -699,21 +820,82 @@ MYSQLND_METHOD(mysqlnd_conn, query)(MYSQLND *conn, const char *query, unsigned i information from the ok packet. We will fetch it ourselves. */ ret = mysqlnd_query_read_result_set_header(conn, NULL TSRMLS_CC); - - return ret; + DBG_RETURN(ret); } /* }}} */ +/* + COM_FIELD_LIST is special, different from a SHOW FIELDS FROM : + - There is no result set header - status from the command, which + impacts us to allocate big chunk of memory for reading the metadata. + - The EOF packet is consumed by the metadata packet reader. +*/ + +/* {{{ mysqlnd_conn::list_fields */ +MYSQLND_RES * +MYSQLND_METHOD(mysqlnd_conn, list_fields)(MYSQLND *conn, const char *table, const char *achtung_wild TSRMLS_DC) +{ + /* db + \0 + wild + \0 (for wild) */ + char buff[MYSQLND_MAX_ALLOWED_DB_LEN * 4 * 2 + 1 + 1], *p; + size_t table_len, wild_len; + MYSQLND_RES *result = NULL; + DBG_ENTER("mysqlnd_conn::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))) { + memcpy(p, table, MIN(table_len, MYSQLND_MAX_ALLOWED_DB_LEN * 4)); + p += table_len; + *p++ = '\0'; + } + + if (achtung_wild && (wild_len = strlen(achtung_wild))) { + memcpy(p, achtung_wild, MIN(wild_len, MYSQLND_MAX_ALLOWED_DB_LEN * 4)); + p += wild_len; + *p++ = '\0'; + } + + if (PASS != mysqlnd_simple_command(conn, COM_FIELD_LIST, buff, p - buff, + PROT_LAST /* we will handle the OK packet*/, + FALSE TSRMLS_CC)) { + DBG_RETURN(NULL); + } + /* + Prepare for the worst case. + MyISAM goes to 2500 BIT columns, double it for safety. + */ + result = mysqlnd_result_init(5000, mysqlnd_palloc_get_thd_cache_reference(conn->zval_cache) TSRMLS_CC); + + + 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); + } + + result->type = MYSQLND_RES_NORMAL; + result->m.fetch_row = result->m.fetch_row_normal_unbuffered; + result->unbuf = mnd_ecalloc(1, sizeof(MYSQLND_RES_UNBUFFERED)); + result->unbuf->eof_reached = TRUE; + + DBG_RETURN(result); +} +/* }}} */ + /* {{{ mysqlnd_conn::list_method */ MYSQLND_RES * -MYSQLND_METHOD(mysqlnd_conn, list_method)(MYSQLND *conn, const char *query, char *achtung_wild, char *par1 TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn, list_method)(MYSQLND *conn, const char *query, + const char *achtung_wild, char *par1 TSRMLS_DC) { char *show_query = NULL; size_t show_query_len; MYSQLND_RES *result = NULL; + DBG_ENTER("mysqlnd_conn::list_method"); + DBG_INF_FMT("conn=%llu query=%s wild=%d", conn->thread_id, query, achtung_wild); + if (par1) { if (achtung_wild) { show_query_len = spprintf(&show_query, 0, query, par1, achtung_wild); @@ -732,12 +914,13 @@ MYSQLND_METHOD(mysqlnd_conn, list_method)(MYSQLND *conn, const char *query, char result = conn->m->store_result(conn TSRMLS_CC); } if (show_query != query) { - efree(show_query); + mnd_efree(show_query); } - return result; + DBG_RETURN(result); } /* }}} */ + /* {{{ mysqlnd_conn::errno */ static unsigned int MYSQLND_METHOD(mysqlnd_conn, errno)(const MYSQLND * const conn) @@ -766,22 +949,26 @@ MYSQLND_METHOD(mysqlnd_conn, sqlstate)(const MYSQLND * const conn) /* {{{ mysqlnd_old_escape_string */ -PHPAPI ulong mysqlnd_old_escape_string(char *newstr, const char *escapestr, int escapestr_len) +PHPAPI ulong mysqlnd_old_escape_string(char *newstr, const char *escapestr, int escapestr_len TSRMLS_DC) { - return mysqlnd_cset_escape_slashes(mysqlnd_find_charset_name("latin1"), - newstr, escapestr, escapestr_len); + 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::escape_string */ static ulong -MYSQLND_METHOD(mysqlnd_conn, escape_string)(const MYSQLND * const conn, char *newstr, const char *escapestr, int escapestr_len) +MYSQLND_METHOD(mysqlnd_conn, escape_string)(const MYSQLND * const conn, char *newstr, + const char *escapestr, int escapestr_len TSRMLS_DC) { + DBG_ENTER("mysqlnd_conn::escape_string"); + DBG_INF_FMT("conn=%llu", conn->thread_id); if (conn->upsert_status.server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES) { - return mysqlnd_cset_escape_quotes(conn->charset, newstr, escapestr, escapestr_len); + DBG_RETURN(mysqlnd_cset_escape_quotes(conn->charset, newstr, escapestr, escapestr_len TSRMLS_CC)); } - return mysqlnd_cset_escape_slashes(conn->charset, newstr, escapestr, escapestr_len); + DBG_RETURN(mysqlnd_cset_escape_slashes(conn->charset, newstr, escapestr, escapestr_len TSRMLS_CC)); } /* }}} */ @@ -790,7 +977,9 @@ MYSQLND_METHOD(mysqlnd_conn, escape_string)(const MYSQLND * const conn, char *ne static enum_func_status MYSQLND_METHOD(mysqlnd_conn, dump_debug_info)(MYSQLND * const conn TSRMLS_DC) { - return mysqlnd_simple_command(conn, COM_DEBUG, NULL, 0, PROT_EOF_PACKET, FALSE TSRMLS_CC); + DBG_ENTER("mysqlnd_conn::dump_debug_info"); + DBG_INF_FMT("conn=%llu", conn->thread_id); + DBG_RETURN(mysqlnd_simple_command(conn, COM_DEBUG, NULL, 0, PROT_EOF_PACKET, FALSE TSRMLS_CC)); } /* }}} */ @@ -802,6 +991,10 @@ MYSQLND_METHOD(mysqlnd_conn, select_db)(MYSQLND * const conn, unsigned int db_len TSRMLS_DC) { enum_func_status ret; + + DBG_ENTER("mysqlnd_conn::select_db"); + DBG_INF_FMT("conn=%llu db=%s", conn->thread_id, db); + ret = mysqlnd_simple_command(conn, COM_INIT_DB, db, db_len, PROT_OK_PACKET, FALSE TSRMLS_CC); /* The server sends 0 but libmysql doesn't read it and has established @@ -809,7 +1002,7 @@ MYSQLND_METHOD(mysqlnd_conn, select_db)(MYSQLND * const conn, */ SET_ERROR_AFF_ROWS(conn); - return ret; + DBG_RETURN(ret); } /* }}} */ @@ -819,14 +1012,19 @@ static enum_func_status MYSQLND_METHOD(mysqlnd_conn, ping)(MYSQLND * const conn TSRMLS_DC) { enum_func_status ret; - ret = mysqlnd_simple_command(conn, COM_PING, NULL, 0, PROT_OK_PACKET, FALSE TSRMLS_CC); + + DBG_ENTER("mysqlnd_conn::ping"); + DBG_INF_FMT("conn=%llu", conn->thread_id); + + ret = mysqlnd_simple_command(conn, COM_PING, NULL, 0, PROT_OK_PACKET, 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); - return ret; + DBG_INF_FMT("ret=%d", ret); + DBG_RETURN(ret); } /* }}} */ @@ -838,13 +1036,16 @@ MYSQLND_METHOD(mysqlnd_conn, stat)(MYSQLND *conn, char **message, unsigned int * enum_func_status ret; php_mysql_packet_stats stats_header; + DBG_ENTER("mysqlnd_conn::stat"); + DBG_INF_FMT("conn=%llu", conn->thread_id); + ret = mysqlnd_simple_command(conn, COM_STATISTICS, NULL, 0, PROT_LAST, FALSE TSRMLS_CC); if (FAIL == ret) { - return FAIL; + DBG_RETURN(FAIL); } PACKET_INIT_ALLOCA(stats_header, PROT_STATS_PACKET); if (FAIL == (ret = PACKET_READ_ALLOCA(stats_header, conn))) { - return FAIL; + DBG_RETURN(FAIL); } *message = stats_header.message; *message_len = stats_header.message_len; @@ -852,18 +1053,22 @@ MYSQLND_METHOD(mysqlnd_conn, stat)(MYSQLND *conn, char **message, unsigned int * stats_header.message = NULL; PACKET_FREE_ALLOCA(stats_header); - return PASS; + DBG_INF(*message); + DBG_RETURN(PASS); } /* }}} */ /* {{{ mysqlnd_conn::kill */ static enum_func_status -MYSQLND_METHOD(mysqlnd_conn, kill)(MYSQLND *conn, unsigned long pid TSRMLS_DC) +MYSQLND_METHOD(mysqlnd_conn, kill)(MYSQLND *conn, unsigned int pid TSRMLS_DC) { enum_func_status ret; char buff[4]; + DBG_ENTER("mysqlnd_conn::kill"); + DBG_INF_FMT("conn=%llu pid=%lu", conn->thread_id, pid); + int4store(buff, pid); /* If we kill ourselves don't expect OK packet, PROT_LAST will skip it */ @@ -878,7 +1083,7 @@ MYSQLND_METHOD(mysqlnd_conn, kill)(MYSQLND *conn, unsigned long pid TSRMLS_DC) 4, PROT_LAST, FALSE TSRMLS_CC))) { conn->state = CONN_QUIT_SENT; } - return ret; + DBG_RETURN(ret); } /* }}} */ @@ -892,10 +1097,13 @@ MYSQLND_METHOD(mysqlnd_conn, set_charset)(MYSQLND * const conn, const char * con size_t query_len; const MYSQLND_CHARSET * const charset = mysqlnd_find_charset_name(csname); + DBG_ENTER("mysqlnd_conn::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, "Invalid characterset or character set not supported"); - return FAIL; + DBG_RETURN(FAIL); } query_len = spprintf(&query, 0, "SET NAMES %s", csname); @@ -907,8 +1115,10 @@ MYSQLND_METHOD(mysqlnd_conn, set_charset)(MYSQLND * const conn, const char * con } else { conn->charset = charset; } - efree(query); - return ret; + mnd_efree(query); + + DBG_INF(ret == PASS? "PASS":"FAIL"); + DBG_RETURN(ret); } /* }}} */ @@ -918,9 +1128,12 @@ static enum_func_status MYSQLND_METHOD(mysqlnd_conn, refresh)(MYSQLND * const conn, unsigned long options TSRMLS_DC) { zend_uchar bits[1]; + DBG_ENTER("mysqlnd_conn::refresh"); + DBG_INF_FMT("conn=%llu options=%lu", conn->thread_id, options); + int1store(bits, options); - return mysqlnd_simple_command(conn, COM_REFRESH, (char *)bits, 1, PROT_OK_PACKET, FALSE TSRMLS_CC); + DBG_RETURN(mysqlnd_simple_command(conn, COM_REFRESH, (char *)bits, 1, PROT_OK_PACKET, FALSE TSRMLS_CC)); } /* }}} */ @@ -930,22 +1143,31 @@ static enum_func_status MYSQLND_METHOD(mysqlnd_conn, shutdown)(MYSQLND * const conn, unsigned long level TSRMLS_DC) { zend_uchar bits[1]; + DBG_ENTER("mysqlnd_conn::shutdown"); + DBG_INF_FMT("conn=%llu level=%lu", conn->thread_id, level); + int1store(bits, level); - return mysqlnd_simple_command(conn, COM_SHUTDOWN, (char *)bits, 1, PROT_OK_PACKET, FALSE TSRMLS_CC); + DBG_RETURN(mysqlnd_simple_command(conn, COM_SHUTDOWN, (char *)bits, 1, PROT_OK_PACKET, FALSE TSRMLS_CC)); } /* }}} */ /* {{{ mysqlnd_send_close */ -static enum_func_status +enum_func_status mysqlnd_send_close(MYSQLND * conn TSRMLS_DC) { enum_func_status ret = PASS; + + DBG_ENTER("mysqlnd_send_close"); + DBG_INF_FMT("conn=%llu conn->net.stream->abstract=%p", + conn->thread_id, conn->net.stream? conn->net.stream->abstract:NULL); + switch (conn->state) { case CONN_READY: + DBG_INF("Connection clean, sending COM_QUIT"); ret = mysqlnd_simple_command(conn, COM_QUIT, NULL, 0, PROT_LAST, - conn->tmp_int? TRUE : FALSE TSRMLS_CC); + TRUE TSRMLS_CC); /* Do nothing */ break; case CONN_SENDING_LOAD_DATA: @@ -956,10 +1178,8 @@ mysqlnd_send_close(MYSQLND * conn TSRMLS_DC) case CONN_NEXT_RESULT_PENDING: case CONN_QUERY_SENT: case CONN_FETCHING_DATA: - MYSQLND_INC_CONN_STATISTIC(NULL, STAT_CLOSE_IN_MIDDLE); -#ifndef MYSQLND_SILENT - php_printf("Brutally closing connection [%p][%s]\n", conn, conn->scheme); -#endif + MYSQLND_INC_GLOBAL_STATISTIC(STAT_CLOSE_IN_MIDDLE); + DBG_ERR_FMT("Brutally closing connection [%p][%s]", conn, conn->scheme); /* Do nothing, the connection will be brutally closed and the server will catch it and free close from its side. @@ -981,7 +1201,7 @@ mysqlnd_send_close(MYSQLND * conn TSRMLS_DC) */ conn->state = CONN_QUIT_SENT; - return ret; + DBG_RETURN(ret); } /* }}} */ @@ -999,13 +1219,25 @@ MYSQLND_METHOD(mysqlnd_conn, close)(MYSQLND * conn, enum_connection_close_type c }; enum_mysqlnd_collected_stats stat = close_type_to_stat_map[close_type]; - MYSQLND_INC_CONN_STATISTIC(NULL, stat); + DBG_ENTER("mysqlnd_conn::close"); + DBG_INF_FMT("conn=%llu", conn->thread_id); - mysqlnd_send_close(conn TSRMLS_CC); + MYSQLND_INC_CONN_STATISTIC(&conn->stats, stat); + MYSQLND_DEC_CONN_STATISTIC(&conn->stats, STAT_OPENED_CONNECTIONS); + if (conn->persistent) { + MYSQLND_DEC_CONN_STATISTIC(&conn->stats, STAT_OPENED_PERSISTENT_CONNECTIONS); + } - conn->m->free_reference(conn TSRMLS_CC); + /* + Close now, free_reference will try, + if we are last, but that's not a problem. + */ + ret = mysqlnd_send_close(conn TSRMLS_CC); + + ret = conn->m->free_reference(conn TSRMLS_CC); - return ret; + + DBG_RETURN(ret); } /* }}} */ @@ -1021,18 +1253,22 @@ MYSQLND_METHOD_PRIVATE(mysqlnd_conn, get_reference)(MYSQLND * const conn) /* {{{ mysqlnd_conn::free_reference */ -static void +static enum_func_status MYSQLND_METHOD_PRIVATE(mysqlnd_conn, free_reference)(MYSQLND * const conn TSRMLS_DC) { + enum_func_status ret = PASS; + DBG_ENTER("mysqlnd_conn::free_reference"); + DBG_INF_FMT("conn=%llu conn->refcount=%u", conn->thread_id, conn->refcount); if (!(--conn->refcount)) { /* No multithreading issues as we don't share the connection :) This will free the object too, of course because references has reached zero. */ - mysqlnd_send_close(conn TSRMLS_CC); + ret = mysqlnd_send_close(conn TSRMLS_CC); conn->m->dtor(conn TSRMLS_CC); } + DBG_RETURN(ret); } /* }}} */ @@ -1181,8 +1417,11 @@ MYSQLND_METHOD(mysqlnd_conn, next_result)(MYSQLND * const conn TSRMLS_DC) { enum_func_status ret; + DBG_ENTER("mysqlnd_conn::next_result"); + DBG_INF_FMT("conn=%llu", conn->thread_id); + if (conn->state != CONN_NEXT_RESULT_PENDING) { - return FAIL; + DBG_RETURN(FAIL); } SET_EMPTY_ERROR(conn->error_info); @@ -1192,13 +1431,12 @@ MYSQLND_METHOD(mysqlnd_conn, next_result)(MYSQLND * const conn TSRMLS_DC) in mysqlnd_store_result() or mysqlnd_fetch_row_unbuffered() */ if (FAIL == (ret = mysqlnd_query_read_result_set_header(conn, NULL TSRMLS_CC))) { -#ifndef MYSQLND_SILENT - php_error_docref(NULL TSRMLS_CC, E_WARNING, "Serious error"); -#endif + DBG_ERR_FMT("Serious error. %s::%d", __FILE__, __LINE__); + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Serious error. PID=%d", getpid()); conn->state = CONN_QUIT_SENT; } - return ret; + DBG_RETURN(ret); } /* }}} */ @@ -1272,6 +1510,10 @@ MYSQLND_METHOD(mysqlnd_conn, change_user)(MYSQLND * const conn, char buffer[MYSQLND_MAX_ALLOWED_USER_LEN + 1 + SCRAMBLE_LENGTH + MYSQLND_MAX_ALLOWED_DB_LEN + 1]; char *p = buffer; + DBG_ENTER("mysqlnd_conn::change_user"); + DBG_INF_FMT("conn=%llu user=%s passwd=%s db=%s", + conn->thread_id, user?user:"", passwd?"***":"null", db?db:""); + if (!user) { user = ""; } @@ -1283,8 +1525,8 @@ MYSQLND_METHOD(mysqlnd_conn, change_user)(MYSQLND * const conn, } /* 1. user ASCIIZ */ - user_len = strlen(user); - memcpy(p, user, MIN(user_len, MYSQLND_MAX_ALLOWED_DB_LEN)); + user_len = MIN(strlen(user), MYSQLND_MAX_ALLOWED_DB_LEN); + memcpy(p, user, user_len); p += user_len; *p++ = '\0'; @@ -1308,7 +1550,7 @@ MYSQLND_METHOD(mysqlnd_conn, change_user)(MYSQLND * const conn, if (PASS != mysqlnd_simple_command(conn, COM_CHANGE_USER, buffer, p - buffer, PROT_LAST /* we will handle the OK packet*/, FALSE TSRMLS_CC)) { - return FAIL; + DBG_RETURN(FAIL); } PACKET_INIT_ALLOCA(chg_user_resp, PROT_CHG_USER_PACKET); @@ -1330,15 +1572,30 @@ MYSQLND_METHOD(mysqlnd_conn, change_user)(MYSQLND * const conn, PACKET_INIT_ALLOCA(redundant_error_packet, PROT_OK_PACKET); PACKET_READ_ALLOCA(redundant_error_packet, conn); PACKET_FREE_ALLOCA(redundant_error_packet); + DBG_INF_FMT("Server is %d, buggy, sends two ERR messages", mysqlnd_get_server_version(conn)); } } + if (ret == PASS) { + mnd_pefree(conn->user, conn->persistent); + conn->user = pestrndup(user, user_len, conn->persistent); + mnd_pefree(conn->passwd, conn->persistent); + conn->passwd = pestrdup(passwd, conn->persistent); + if (conn->last_message) { + mnd_pefree(conn->last_message, conn->persistent); + conn->last_message = NULL; + } + conn->charset = conn->greet_charset; + memset(&conn->upsert_status, 0, sizeof(conn->upsert_status)); + } + + SET_ERROR_AFF_ROWS(conn); /* Here we should close all statements. Unbuffered queries should not be a problem as we won't allow sending COM_CHANGE_USER. */ - - return ret; + DBG_INF(ret == PASS? "PASS":"FAIL"); + DBG_RETURN(ret); } /* }}} */ @@ -1347,12 +1604,30 @@ MYSQLND_METHOD(mysqlnd_conn, change_user)(MYSQLND * const conn, static enum_func_status MYSQLND_METHOD(mysqlnd_conn, set_client_option)(MYSQLND * const conn, enum mysqlnd_option option, - const char * const value) + const char * const value + TSRMLS_DC) { + DBG_ENTER("mysqlnd_conn::set_client_option"); + DBG_INF_FMT("conn=%llu option=%d", conn->thread_id, option); switch (option) { +#if PHP_MAJOR_VERSION >= 6 case MYSQLND_OPT_NUMERIC_AND_DATETIME_AS_UNICODE: conn->options.numeric_and_datetime_as_unicode = *(uint*) value; break; +#endif + case MYSQLND_OPT_NET_CMD_BUFFER_SIZE: + conn->net.cmd_buffer.length = *(uint*) value; + if (!conn->net.cmd_buffer.buffer) { + conn->net.cmd_buffer.buffer = mnd_pemalloc(conn->net.cmd_buffer.length, conn->persistent); + } else { + conn->net.cmd_buffer.buffer = mnd_perealloc(conn->net.cmd_buffer.buffer, + conn->net.cmd_buffer.length, + conn->persistent); + } + break; + case MYSQLND_OPT_NET_READ_BUFFER_SIZE: + conn->options.net_read_buffer_size = *(uint*) value; + break; #ifdef MYSQLND_STRING_TO_INT_CONVERSION case MYSQLND_OPT_INT_AND_YEAR_AS_INT: conn->options.int_and_year_as_int = *(uint*) value; @@ -1414,9 +1689,9 @@ MYSQLND_METHOD(mysqlnd_conn, set_client_option)(MYSQLND * const conn, /* not sure, todo ? */ #endif default: - return FAIL; + DBG_RETURN(FAIL); } - return PASS; + DBG_RETURN(PASS); } /* }}} */ @@ -1427,15 +1702,19 @@ MYSQLND_METHOD(mysqlnd_conn, use_result)(MYSQLND * const conn TSRMLS_DC) { MYSQLND_RES *result; + DBG_ENTER("mysqlnd_conn::use_result"); + DBG_INF_FMT("conn=%llu", conn->thread_id); + if (!conn->current_result) { - return NULL; + DBG_RETURN(NULL); } /* Nothing to store for UPSERT/LOAD DATA */ if (conn->last_query_type != QUERY_SELECT || conn->state != CONN_FETCHING_DATA) { SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, - mysqlnd_out_of_sync); - return NULL; + mysqlnd_out_of_sync); + DBG_ERR("Command out of sync"); + DBG_RETURN(NULL); } MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_UNBUFFERED_SETS); @@ -1444,7 +1723,8 @@ MYSQLND_METHOD(mysqlnd_conn, use_result)(MYSQLND * const conn TSRMLS_DC) conn->current_result = NULL; result->conn = conn->m->get_reference(conn); - return result->m.use_result(result, FALSE TSRMLS_CC); + result = result->m.use_result(result, FALSE TSRMLS_CC); + DBG_RETURN(result); } /* }}} */ @@ -1455,15 +1735,19 @@ MYSQLND_METHOD(mysqlnd_conn, store_result)(MYSQLND * const conn TSRMLS_DC) { MYSQLND_RES *result; + DBG_ENTER("mysqlnd_conn::store_result"); + DBG_INF_FMT("conn=%llu", conn->thread_id); + if (!conn->current_result) { - return NULL; + DBG_RETURN(NULL); } /* Nothing to store for UPSERT/LOAD DATA*/ if (conn->last_query_type != QUERY_SELECT || conn->state != CONN_FETCHING_DATA) { SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync); - return NULL; + DBG_ERR("Command out of sync"); + DBG_RETURN(NULL); } MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_BUFFERED_SETS); @@ -1471,7 +1755,8 @@ MYSQLND_METHOD(mysqlnd_conn, store_result)(MYSQLND * const conn TSRMLS_DC) result = conn->current_result; conn->current_result = NULL; - return result->m.store_result(result, conn, FALSE TSRMLS_CC); + result = result->m.store_result(result, conn, FALSE TSRMLS_CC); + DBG_RETURN(result); } /* }}} */ @@ -1482,12 +1767,15 @@ MYSQLND_METHOD(mysqlnd_conn, get_connection_stats)(const MYSQLND * 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); mysqlnd_fill_stats_hash(&(conn->stats), return_value TSRMLS_CC ZEND_FILE_LINE_CC); + DBG_VOID_RETURN; } /* }}} */ -MYSQLND_STMT * _mysqlnd_stmt_init(MYSQLND * const conn); +MYSQLND_STMT * _mysqlnd_stmt_init(MYSQLND * const conn TSRMLS_DC); MYSQLND_CLASS_METHODS_START(mysqlnd_conn) @@ -1524,6 +1812,7 @@ MYSQLND_CLASS_METHODS_START(mysqlnd_conn) 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), @@ -1544,16 +1833,20 @@ MYSQLND_CLASS_METHODS_END; /* {{{ mysqlnd_init */ -PHPAPI MYSQLND *mysqlnd_init(zend_bool persistent) +PHPAPI MYSQLND *_mysqlnd_init(zend_bool persistent TSRMLS_DC) { - MYSQLND *ret = pecalloc(1, sizeof(MYSQLND), persistent); + MYSQLND *ret = mnd_pecalloc(1, sizeof(MYSQLND), persistent); + + DBG_ENTER("mysqlnd_init"); + DBG_INF_FMT("persistent=%d", persistent); + SET_ERROR_AFF_ROWS(ret); ret->persistent = persistent; ret->m = & mysqlnd_mysqlnd_conn_methods; ret->m->get_reference(ret); - return ret; + DBG_RETURN(ret); } /* }}} */ @@ -1562,7 +1855,7 @@ PHPAPI MYSQLND *mysqlnd_init(zend_bool persistent) * * Every user visible function must have an entry in mysqlnd_functions[]. */ -static const zend_function_entry mysqlnd_functions[] = { +static zend_function_entry mysqlnd_functions[] = { {NULL, NULL, NULL} /* Must be the last line in mysqlnd_functions[] */ }; /* }}} */ @@ -1595,7 +1888,7 @@ PHPAPI void mysqlnd_minfo_print_hash(zval *values) php_info_print_table_row(2, s, Z_STRVAL_PP(values_entry)); } if (s) { - efree(s); + mnd_efree(s); } } else { php_info_print_table_row(2, string_key.s, Z_STRVAL_PP(values_entry)); @@ -1632,6 +1925,7 @@ void mysqlnd_minfo_print_hash(zval *values) */ PHP_MINFO_FUNCTION(mysqlnd) { + char buf[32]; zval values; php_info_print_table_start(); @@ -1642,19 +1936,33 @@ PHP_MINFO_FUNCTION(mysqlnd) php_info_print_table_header(2, "Client statistics", ""); mysqlnd_get_client_stats(&values); mysqlnd_minfo_print_hash(&values); + php_info_print_table_row(2, "Collecting statistics", MYSQLND_G(collect_statistics)? "Yes":"No"); + php_info_print_table_row(2, "Collecting memory statistics", MYSQLND_G(collect_memory_statistics)? "Yes":"No"); + + snprintf(buf, sizeof(buf), "%ld", MYSQLND_G(net_cmd_buffer_size)); + php_info_print_table_row(2, "Command buffer size", buf); + snprintf(buf, sizeof(buf), "%ld", MYSQLND_G(net_read_buffer_size)); + php_info_print_table_row(2, "Read buffer size", buf); + zval_dtor(&values); php_info_print_table_end(); } /* }}} */ -ZEND_DECLARE_MODULE_GLOBALS(mysqlnd) +ZEND_DECLARE_MODULE_GLOBALS(mysqlnd); + /* {{{ PHP_GINIT_FUNCTION */ static PHP_GINIT_FUNCTION(mysqlnd) { - mysqlnd_globals->collect_statistics = FALSE; + mysqlnd_globals->collect_statistics = TRUE; + mysqlnd_globals->collect_memory_statistics = FALSE; + mysqlnd_globals->debug = NULL; /* The actual string */ + mysqlnd_globals->dbg = NULL; /* The DBG object*/ + mysqlnd_globals->net_cmd_buffer_size = 2048; + mysqlnd_globals->net_read_buffer_size = 32768; } /* }}} */ @@ -1662,7 +1970,11 @@ static PHP_GINIT_FUNCTION(mysqlnd) /* {{{ PHP_INI_BEGIN */ PHP_INI_BEGIN() - STD_PHP_INI_BOOLEAN("mysqlnd.collect_statistics", "1", PHP_INI_SYSTEM, OnUpdateBool, collect_statistics, zend_mysqlnd_globals, mysqlnd_globals) + STD_PHP_INI_BOOLEAN("mysqlnd.collect_statistics", "1", PHP_INI_ALL, OnUpdateBool, collect_statistics, zend_mysqlnd_globals, mysqlnd_globals) + STD_PHP_INI_BOOLEAN("mysqlnd.collect_memory_statistics", "0", PHP_INI_SYSTEM, OnUpdateBool, collect_memory_statistics, zend_mysqlnd_globals, mysqlnd_globals) + STD_PHP_INI_ENTRY("mysqlnd.debug", NULL, PHP_INI_SYSTEM, OnUpdateString, debug, zend_mysqlnd_globals, mysqlnd_globals) + STD_PHP_INI_ENTRY("mysqlnd.net_cmd_buffer_size", "2048", PHP_INI_ALL, OnUpdateLong, net_cmd_buffer_size, zend_mysqlnd_globals, mysqlnd_globals) + STD_PHP_INI_ENTRY("mysqlnd.net_read_buffer_size", "32768",PHP_INI_ALL, OnUpdateLong, net_read_buffer_size, zend_mysqlnd_globals, mysqlnd_globals) PHP_INI_END() /* }}} */ @@ -1673,7 +1985,7 @@ static PHP_MINIT_FUNCTION(mysqlnd) { REGISTER_INI_ENTRIES(); - mysqlnd_library_init(MYSQLND_G(collect_statistics)); + mysqlnd_library_init(); return SUCCESS; } /* }}} */ @@ -1691,6 +2003,45 @@ static PHP_MSHUTDOWN_FUNCTION(mysqlnd) /* }}} */ +#if PHP_DEBUG +/* {{{ PHP_RINIT_FUNCTION + */ +static PHP_RINIT_FUNCTION(mysqlnd) +{ +#ifdef PHP_DEBUG + if (MYSQLND_G(debug)) { + MYSQLND_DEBUG *dbg = mysqlnd_debug_init(TSRMLS_C); + if (!dbg) { + return FAILURE; + } + dbg->m->set_mode(dbg, MYSQLND_G(debug)); + MYSQLND_G(dbg) = dbg; + } +#endif + return SUCCESS; +} +/* }}} */ + + +/* {{{ PHP_RSHUTDOWN_FUNCTION + */ +static PHP_RSHUTDOWN_FUNCTION(mysqlnd) +{ +#ifdef PHP_DEBUG + MYSQLND_DEBUG *dbg = MYSQLND_G(dbg); + DBG_ENTER("RSHUTDOWN"); + if (dbg) { + dbg->m->close(dbg); + dbg->m->free(dbg); + MYSQLND_G(dbg) = NULL; + } +#endif + return SUCCESS; +} +/* }}} */ +#endif + + /* {{{ mysqlnd_module_entry */ zend_module_entry mysqlnd_module_entry = { @@ -1699,8 +2050,13 @@ zend_module_entry mysqlnd_module_entry = { mysqlnd_functions, PHP_MINIT(mysqlnd), PHP_MSHUTDOWN(mysqlnd), +#if PHP_DEBUG + PHP_RINIT(mysqlnd), + PHP_RSHUTDOWN(mysqlnd), +#else NULL, NULL, +#endif PHP_MINFO(mysqlnd), MYSQLND_VERSION, PHP_MODULE_GLOBALS(mysqlnd), |