archive/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2025-08-16 14:08:47 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

- revert revision 297277, break the builds (declaration must go 1st, size of void * and other known situations). Also Johannes, can you check that commit pls? Thought we were in bugs fixing only for 5.3

Browse source
This commit is contained in:
Pierre Joye 2010-04-01 20:21:50 +00:00
parent a3857fd963
commit 96e2651fa2
9 changed files with 150 additions and 188 deletions
Download patch file Download diff file Expand all files Collapse all files

35
ext/mysqlnd/mysqlnd.c
View file

@ -529,7 +529,6 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND *conn,
db = ""; db = "";
db_len = 0; db_len = 0;
} }
host_len = strlen(host); host_len = strlen(host);
{ {
char * transport = NULL; char * transport = NULL;
@ -554,7 +553,7 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND *conn,
DBG_INF_FMT("transport=%s", transport); DBG_INF_FMT("transport=%s", transport);
conn->scheme = mnd_pestrndup(transport, transport_len, conn->persistent); conn->scheme = mnd_pestrndup(transport, transport_len, conn->persistent);
conn->scheme_len = transport_len; conn->scheme_len = transport_len;
efree(transport); /* allocated by spprintf */ efree(transport);
transport = NULL; transport = NULL;
} }
@ -644,7 +643,6 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND *conn,
} }
} else { } else {
CONN_SET_STATE(conn, CONN_READY); CONN_SET_STATE(conn, CONN_READY);
if (!self_alloced && saved_compression) { if (!self_alloced && saved_compression) {
conn->net->compressed = TRUE; conn->net->compressed = TRUE;
} }
@ -664,14 +662,16 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND *conn,
conn->connect_or_select_db_len = db_len; conn->connect_or_select_db_len = db_len;
if (!unix_socket) { if (!unix_socket) {
char *p;
conn->host = mnd_pestrdup(host, conn->persistent); conn->host = mnd_pestrdup(host, conn->persistent);
conn->host_len = strlen(conn->host); conn->host_len = strlen(conn->host);
{ spprintf(&p, 0, "%s via TCP/IP", conn->host);
char *p; if (conn->persistent) {
spprintf(&p, 0, "%s via TCP/IP", conn->host); conn->host_info = mnd_pestrdup(p, 1);
conn->host_info = mnd_pestrdup(p, conn->persistent); mnd_efree(p);
efree(p); /* allocated by spprintf */ } else {
conn->host_info = p;
} }
} else { } else {
conn->unix_socket = mnd_pestrdup(socket, conn->persistent); conn->unix_socket = mnd_pestrdup(socket, conn->persistent);
@ -693,6 +693,10 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND *conn,
SET_EMPTY_ERROR(conn->error_info); SET_EMPTY_ERROR(conn->error_info);
mysqlnd_local_infile_default(conn); mysqlnd_local_infile_default(conn);
{
unsigned int buf_size = MYSQLND_G(net_cmd_buffer_size); /* this is long, cast to unsigned int*/
conn->m->set_client_option(conn, MYSQLND_OPT_NET_CMD_BUFFER_SIZE, (char *)&buf_size TSRMLS_CC);
}
MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn->stats, STAT_CONNECT_SUCCESS, 1, STAT_OPENED_CONNECTIONS, 1); MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn->stats, STAT_CONNECT_SUCCESS, 1, STAT_OPENED_CONNECTIONS, 1);
if (reconnect) { if (reconnect) {
@ -703,7 +707,6 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND *conn,
} }
DBG_INF_FMT("connection_id=%llu", conn->thread_id); DBG_INF_FMT("connection_id=%llu", conn->thread_id);
#if PHP_MAJOR_VERSION >= 6 #if PHP_MAJOR_VERSION >= 6
{ {
unsigned int as_unicode = 1; unsigned int as_unicode = 1;
@ -712,6 +715,7 @@ MYSQLND_METHOD(mysqlnd_conn, connect)(MYSQLND *conn,
DBG_INF("unicode set"); DBG_INF("unicode set");
} }
#endif #endif
if (conn->options.init_commands) { if (conn->options.init_commands) {
int current_command = 0; int current_command = 0;
for (; current_command < conn->options.num_commands; ++current_command) { for (; current_command < conn->options.num_commands; ++current_command) {
@ -769,7 +773,7 @@ PHPAPI MYSQLND * mysqlnd_connect(MYSQLND * conn,
unsigned int mysql_flags unsigned int mysql_flags
TSRMLS_DC) TSRMLS_DC)
{ {
enum_func_status ret = FAIL; enum_func_status ret;
zend_bool self_alloced = FALSE; zend_bool self_alloced = FALSE;
DBG_ENTER("mysqlnd_connect"); DBG_ENTER("mysqlnd_connect");
@ -1135,7 +1139,7 @@ MYSQLND_METHOD(mysqlnd_conn, list_method)(MYSQLND *conn, const char *query, cons
result = conn->m->store_result(conn TSRMLS_CC); result = conn->m->store_result(conn TSRMLS_CC);
} }
if (show_query != query) { if (show_query != query) {
efree(show_query); /* allocated by spprintf */ mnd_efree(show_query);
} }
DBG_RETURN(result); DBG_RETURN(result);
} }
@ -1221,7 +1225,7 @@ MYSQLND_METHOD(mysqlnd_conn, select_db)(MYSQLND * const conn, const char * const
SET_ERROR_AFF_ROWS(conn); SET_ERROR_AFF_ROWS(conn);
if (ret == PASS) { if (ret == PASS) {
if (conn->connect_or_select_db) { if (conn->connect_or_select_db) {
mnd_pefree(conn->connect_or_select_db, conn->persistent); 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 = mnd_pestrndup(db, db_len, conn->persistent);
conn->connect_or_select_db_len = db_len; conn->connect_or_select_db_len = db_len;
@ -1271,9 +1275,10 @@ MYSQLND_METHOD(mysqlnd_conn, stat)(MYSQLND *conn, char **message, unsigned int *
if (FAIL == (ret = PACKET_READ(stats_header, conn))) { if (FAIL == (ret = PACKET_READ(stats_header, conn))) {
DBG_RETURN(FAIL); DBG_RETURN(FAIL);
} }
/* will be freed by Zend, thus don't use the mnd_ allocator */ *message = stats_header->message;
*message = estrndup(stats_header->message, stats_header->message_len);
*message_len = stats_header->message_len; *message_len = stats_header->message_len;
/* Ownership transfer */
stats_header->message = NULL;
PACKET_FREE(stats_header); PACKET_FREE(stats_header);
DBG_INF(*message); DBG_INF(*message);
@ -1338,7 +1343,7 @@ MYSQLND_METHOD(mysqlnd_conn, set_charset)(MYSQLND * const conn, const char * con
} else { } else {
conn->charset = charset; conn->charset = charset;
} }
efree(query); /* allocated by spprintf */ mnd_efree(query);
DBG_INF(ret == PASS? "PASS":"FAIL"); DBG_INF(ret == PASS? "PASS":"FAIL");
DBG_RETURN(ret); DBG_RETURN(ret);

235
ext/mysqlnd/mysqlnd_debug.c
View file

@ -656,30 +656,24 @@ PHPAPI void _mysqlnd_debug(const char * mode TSRMLS_DC)
#define __zend_filename "/unknown/unknown" #define __zend_filename "/unknown/unknown"
#define __zend_lineno 0 #define __zend_lineno 0
#endif #endif
#define REAL_SIZE(s) (collect_memory_statistics? (s) + sizeof(size_t) : (s))
#define REAL_PTR(p) (collect_memory_statistics && (p)? ((p) - sizeof(size_t)) : (p))
#define FAKE_PTR(p) (collect_memory_statistics && (p)? ((p) + sizeof(size_t)) : (p))
/* {{{ _mysqlnd_emalloc */ /* {{{ _mysqlnd_emalloc */
void * _mysqlnd_emalloc(size_t size MYSQLND_MEM_D) void * _mysqlnd_emalloc(size_t size MYSQLND_MEM_D)
{ {
void *ret; void *ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
DBG_ENTER(mysqlnd_emalloc_name); DBG_ENTER(mysqlnd_emalloc_name);
DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno);
DBG_INF_FMT("before: %lu", zend_memory_usage(FALSE TSRMLS_CC));
ret = emalloc(size);
DBG_INF_FMT("after : %lu", zend_memory_usage(FALSE TSRMLS_CC));
DBG_INF_FMT("size=%lu ptr=%p", size, ret);
ret = emalloc(REAL_SIZE(size)); if (MYSQLND_G(collect_memory_statistics)) {
MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_EMALLOC_COUNT, 1, STAT_MEM_EMALLOC_AMMOUNT, size);
DBG_INF_FMT("size=%lu ptr=%p", size, ret);
if (collect_memory_statistics) {
*(size_t *) ret = size;
MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_EMALLOC_COUNT, 1, STAT_MEM_EMALLOC_AMOUNT, size);
} }
DBG_RETURN(FAKE_PTR(ret)); DBG_RETURN(ret);
} }
/* }}} */ /* }}} */
@ -688,21 +682,29 @@ void * _mysqlnd_emalloc(size_t size MYSQLND_MEM_D)
void * _mysqlnd_pemalloc(size_t size, zend_bool persistent MYSQLND_MEM_D) void * _mysqlnd_pemalloc(size_t size, zend_bool persistent MYSQLND_MEM_D)
{ {
void *ret; void *ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
DBG_ENTER(mysqlnd_pemalloc_name); DBG_ENTER(mysqlnd_pemalloc_name);
DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno);
if (persistent == FALSE) {
DBG_INF_FMT("before: %lu", zend_memory_usage(persistent TSRMLS_CC));
}
ret = pemalloc(REAL_SIZE(size), persistent); ret = pemalloc(size, persistent);
DBG_INF_FMT("size=%lu ptr=%p persistent=%d", size, ret, persistent); DBG_INF_FMT("size=%lu ptr=%p persistent=%d", size, ret, persistent);
if (collect_memory_statistics) { if (persistent == FALSE) {
*(size_t *) ret = size; DBG_INF_FMT("after : %lu", zend_memory_usage(persistent TSRMLS_CC));
}
if (MYSQLND_G(collect_memory_statistics)) {
enum mysqlnd_collected_stats s1 = persistent? STAT_MEM_MALLOC_COUNT:STAT_MEM_EMALLOC_COUNT; enum mysqlnd_collected_stats s1 = persistent? STAT_MEM_MALLOC_COUNT:STAT_MEM_EMALLOC_COUNT;
enum mysqlnd_collected_stats s2 = persistent? STAT_MEM_MALLOC_AMOUNT:STAT_MEM_EMALLOC_AMOUNT; enum mysqlnd_collected_stats s2 = persistent? STAT_MEM_MALLOC_AMMOUNT:STAT_MEM_EMALLOC_AMMOUNT;
*(size_t *) ret = size;
MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(s1, 1, s2, size); MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(s1, 1, s2, size);
} }
DBG_RETURN(FAKE_PTR(ret)); DBG_RETURN(ret);
} }
/* }}} */ /* }}} */
@ -711,20 +713,18 @@ void * _mysqlnd_pemalloc(size_t size, zend_bool persistent MYSQLND_MEM_D)
void * _mysqlnd_ecalloc(unsigned int nmemb, size_t size MYSQLND_MEM_D) void * _mysqlnd_ecalloc(unsigned int nmemb, size_t size MYSQLND_MEM_D)
{ {
void *ret; void *ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
DBG_ENTER(mysqlnd_ecalloc_name); DBG_ENTER(mysqlnd_ecalloc_name);
DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno);
DBG_INF_FMT("before: %lu", zend_memory_usage(FALSE TSRMLS_CC)); DBG_INF_FMT("before: %lu", zend_memory_usage(FALSE TSRMLS_CC));
ret = ecalloc(nmemb, REAL_SIZE(size)); ret = ecalloc(nmemb, size);
DBG_INF_FMT("after : %lu", zend_memory_usage(FALSE TSRMLS_CC)); DBG_INF_FMT("after : %lu", zend_memory_usage(FALSE TSRMLS_CC));
DBG_INF_FMT("size=%lu ptr=%p", size, ret); DBG_INF_FMT("size=%lu ptr=%p", size, ret);
if (collect_memory_statistics) { if (MYSQLND_G(collect_memory_statistics)) {
*(size_t *) ret = size; MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_ECALLOC_COUNT, 1, STAT_MEM_ECALLOC_AMMOUNT, size);
MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_ECALLOC_COUNT, 1, STAT_MEM_ECALLOC_AMOUNT, size);
} }
DBG_RETURN(FAKE_PTR(ret)); DBG_RETURN(ret);
} }
/* }}} */ /* }}} */
@ -733,21 +733,26 @@ void * _mysqlnd_ecalloc(unsigned int nmemb, size_t size MYSQLND_MEM_D)
void * _mysqlnd_pecalloc(unsigned int nmemb, size_t size, zend_bool persistent MYSQLND_MEM_D) void * _mysqlnd_pecalloc(unsigned int nmemb, size_t size, zend_bool persistent MYSQLND_MEM_D)
{ {
void *ret; void *ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
DBG_ENTER(mysqlnd_pecalloc_name); DBG_ENTER(mysqlnd_pecalloc_name);
DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno);
if (persistent == FALSE) {
DBG_INF_FMT("before: %lu", zend_memory_usage(persistent TSRMLS_CC));
}
ret = pecalloc(nmemb, REAL_SIZE(size), persistent); ret = pecalloc(nmemb, size, persistent);
DBG_INF_FMT("size=%lu ptr=%p", size, ret); DBG_INF_FMT("size=%lu ptr=%p", size, ret);
if (collect_memory_statistics) { if (persistent == FALSE) {
*(size_t *) ret = size; DBG_INF_FMT("after : %lu", zend_memory_usage(persistent TSRMLS_CC));
}
if (MYSQLND_G(collect_memory_statistics)) {
enum mysqlnd_collected_stats s1 = persistent? STAT_MEM_CALLOC_COUNT:STAT_MEM_ECALLOC_COUNT; enum mysqlnd_collected_stats s1 = persistent? STAT_MEM_CALLOC_COUNT:STAT_MEM_ECALLOC_COUNT;
enum mysqlnd_collected_stats s2 = persistent? STAT_MEM_CALLOC_AMOUNT:STAT_MEM_ECALLOC_AMOUNT; enum mysqlnd_collected_stats s2 = persistent? STAT_MEM_CALLOC_AMMOUNT:STAT_MEM_ECALLOC_AMMOUNT;
MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(s1, 1, s2, size); MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(s1, 1, s2, size);
} }
DBG_RETURN(FAKE_PTR(ret)); DBG_RETURN(ret);
} }
/* }}} */ /* }}} */
@ -756,20 +761,19 @@ void * _mysqlnd_pecalloc(unsigned int nmemb, size_t size, zend_bool persistent M
void * _mysqlnd_erealloc(void *ptr, size_t new_size MYSQLND_MEM_D) void * _mysqlnd_erealloc(void *ptr, size_t new_size MYSQLND_MEM_D)
{ {
void *ret; void *ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
size_t old_size = collect_memory_statistics && ptr? *(size_t *) (ptr - sizeof(size_t)) : 0;
DBG_ENTER(mysqlnd_erealloc_name); DBG_ENTER(mysqlnd_erealloc_name);
DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno);
DBG_INF_FMT("ptr=%p old_size=%lu, new_size=%lu", ptr, old_size, new_size); DBG_INF_FMT("ptr=%p new_size=%lu", ptr, new_size);
DBG_INF_FMT("before: %lu", zend_memory_usage(FALSE TSRMLS_CC));
ret = erealloc(REAL_PTR(ptr), REAL_SIZE(new_size)); ret = erealloc(ptr, new_size);
DBG_INF_FMT("after : %lu", zend_memory_usage(FALSE TSRMLS_CC));
DBG_INF_FMT("new_ptr=%p", ret); DBG_INF_FMT("new_ptr=%p", ret);
if (collect_memory_statistics) { if (MYSQLND_G(collect_memory_statistics)) {
*(size_t *) ret = new_size; MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_EREALLOC_COUNT, 1, STAT_MEM_EREALLOC_AMMOUNT, new_size);
MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_EREALLOC_COUNT, 1, STAT_MEM_EREALLOC_AMOUNT, new_size);
} }
DBG_RETURN(FAKE_PTR(ret)); DBG_RETURN(ret);
} }
/* }}} */ /* }}} */
@ -778,23 +782,27 @@ void * _mysqlnd_erealloc(void *ptr, size_t new_size MYSQLND_MEM_D)
void * _mysqlnd_perealloc(void *ptr, size_t new_size, zend_bool persistent MYSQLND_MEM_D) void * _mysqlnd_perealloc(void *ptr, size_t new_size, zend_bool persistent MYSQLND_MEM_D)
{ {
void *ret; void *ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
size_t old_size = collect_memory_statistics && ptr? *(size_t *) (ptr - sizeof(size_t)) : 0;
DBG_ENTER(mysqlnd_perealloc_name); DBG_ENTER(mysqlnd_perealloc_name);
DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno);
DBG_INF_FMT("ptr=%p old_size=%lu new_size=%lu persist=%d", ptr, old_size, new_size, persistent); DBG_INF_FMT("ptr=%p new_size=%lu persist=%d", ptr, new_size, persistent);
if (persistent == FALSE) {
DBG_INF_FMT("before: %lu", zend_memory_usage(persistent TSRMLS_CC));
}
ret = perealloc(REAL_PTR(ptr), REAL_SIZE(new_size), persistent); ret = perealloc(ptr, new_size, persistent);
DBG_INF_FMT("new_ptr=%p", ret); DBG_INF_FMT("new_ptr=%p", ret);
if (collect_memory_statistics) { if (persistent == FALSE) {
*(size_t *) ret = new_size; DBG_INF_FMT("after : %lu", zend_memory_usage(persistent TSRMLS_CC));
}
MYSQLND_INC_GLOBAL_STATISTIC(persistent? STAT_MEM_REALLOC_COUNT:STAT_MEM_EREALLOC_COUNT);
if (MYSQLND_G(collect_memory_statistics)) {
enum mysqlnd_collected_stats s1 = persistent? STAT_MEM_REALLOC_COUNT:STAT_MEM_EREALLOC_COUNT; enum mysqlnd_collected_stats s1 = persistent? STAT_MEM_REALLOC_COUNT:STAT_MEM_EREALLOC_COUNT;
enum mysqlnd_collected_stats s2 = persistent? STAT_MEM_REALLOC_AMOUNT:STAT_MEM_EREALLOC_AMOUNT; enum mysqlnd_collected_stats s2 = persistent? STAT_MEM_REALLOC_AMMOUNT:STAT_MEM_EREALLOC_AMMOUNT;
MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(s1, 1, s2, new_size); MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(s1, 1, s2, new_size);
} }
DBG_RETURN(FAKE_PTR(ret)); DBG_RETURN(ret);
} }
/* }}} */ /* }}} */
@ -802,23 +810,15 @@ void * _mysqlnd_perealloc(void *ptr, size_t new_size, zend_bool persistent MYSQL
/* {{{ _mysqlnd_efree */ /* {{{ _mysqlnd_efree */
void _mysqlnd_efree(void *ptr MYSQLND_MEM_D) void _mysqlnd_efree(void *ptr MYSQLND_MEM_D)
{ {
size_t free_amount = 0;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
DBG_ENTER(mysqlnd_efree_name); DBG_ENTER(mysqlnd_efree_name);
DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno);
DBG_INF_FMT("ptr=%p", ptr); DBG_INF_FMT("ptr=%p", ptr);
DBG_INF_FMT("before: %lu", zend_memory_usage(FALSE TSRMLS_CC));
MYSQLND_INC_GLOBAL_STATISTIC(STAT_MEM_EFREE_COUNT);
if (ptr) { efree(ptr);
if (collect_memory_statistics) {
free_amount = *(size_t *)(ptr - sizeof(size_t));
DBG_INF_FMT("ptr=%p size=%u", ptr - sizeof(size_t), (unsigned int) free_amount);
}
efree(REAL_PTR(ptr));
}
if (collect_memory_statistics) { DBG_INF_FMT("after : %lu", zend_memory_usage(FALSE TSRMLS_CC));
MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_EFREE_COUNT, 1, STAT_MEM_EFREE_AMOUNT, free_amount);
}
DBG_VOID_RETURN; DBG_VOID_RETURN;
} }
/* }}} */ /* }}} */
@ -827,23 +827,22 @@ void _mysqlnd_efree(void *ptr MYSQLND_MEM_D)
/* {{{ _mysqlnd_pefree */ /* {{{ _mysqlnd_pefree */
void _mysqlnd_pefree(void *ptr, zend_bool persistent MYSQLND_MEM_D) void _mysqlnd_pefree(void *ptr, zend_bool persistent MYSQLND_MEM_D)
{ {
size_t free_amount = 0;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
DBG_ENTER(mysqlnd_pefree_name); DBG_ENTER(mysqlnd_pefree_name);
DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno);
DBG_INF_FMT("ptr=%p persistent=%d", ptr, persistent); DBG_INF_FMT("ptr=%p persistent=%d", ptr, persistent);
if (persistent == FALSE) {
if (ptr) { DBG_INF_FMT("before: %lu", zend_memory_usage(persistent TSRMLS_CC));
if (collect_memory_statistics) {
free_amount = *(size_t *)(ptr - sizeof(size_t));
DBG_INF_FMT("ptr=%p size=%u", ptr - sizeof(size_t), (unsigned int) free_amount);
}
pefree(REAL_PTR(ptr), persistent);
} }
if (collect_memory_statistics) { if (ptr) {
MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(persistent? STAT_MEM_FREE_COUNT:STAT_MEM_EFREE_COUNT, 1, pefree(ptr, persistent);
persistent? STAT_MEM_FREE_AMOUNT:STAT_MEM_EFREE_AMOUNT, free_amount); }
if (persistent == FALSE) {
DBG_INF_FMT("after : %lu", zend_memory_usage(persistent TSRMLS_CC));
}
if (MYSQLND_G(collect_memory_statistics)) {
MYSQLND_INC_GLOBAL_STATISTIC(persistent? STAT_MEM_FREE_COUNT:STAT_MEM_EFREE_COUNT);
} }
DBG_VOID_RETURN; DBG_VOID_RETURN;
} }
@ -853,18 +852,16 @@ void _mysqlnd_pefree(void *ptr, zend_bool persistent MYSQLND_MEM_D)
void * _mysqlnd_malloc(size_t size MYSQLND_MEM_D) void * _mysqlnd_malloc(size_t size MYSQLND_MEM_D)
{ {
void *ret; void *ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
DBG_ENTER(mysqlnd_malloc_name); DBG_ENTER(mysqlnd_malloc_name);
DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno);
ret = malloc(REAL_SIZE(size)); ret = malloc(size);
DBG_INF_FMT("size=%lu ptr=%p", size, ret); DBG_INF_FMT("size=%lu ptr=%p", size, ret);
if (collect_memory_statistics) { if (MYSQLND_G(collect_memory_statistics)) {
*(size_t *) ret = size; MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_MALLOC_COUNT, 1, STAT_MEM_MALLOC_AMMOUNT, size);
MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_MALLOC_COUNT, 1, STAT_MEM_MALLOC_AMOUNT, size);
} }
DBG_RETURN(FAKE_PTR(ret)); DBG_RETURN(ret);
} }
/* }}} */ /* }}} */
@ -873,18 +870,16 @@ void * _mysqlnd_malloc(size_t size MYSQLND_MEM_D)
void * _mysqlnd_calloc(unsigned int nmemb, size_t size MYSQLND_MEM_D) void * _mysqlnd_calloc(unsigned int nmemb, size_t size MYSQLND_MEM_D)
{ {
void *ret; void *ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
DBG_ENTER(mysqlnd_calloc_name); DBG_ENTER(mysqlnd_calloc_name);
DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno);
ret = calloc(nmemb, REAL_SIZE(size)); ret = calloc(nmemb, size);
DBG_INF_FMT("size=%lu ptr=%p", size, ret); DBG_INF_FMT("size=%lu ptr=%p", size, ret);
if (collect_memory_statistics) { if (MYSQLND_G(collect_memory_statistics)) {
*(size_t *) ret = size; MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_CALLOC_COUNT, 1, STAT_MEM_CALLOC_AMMOUNT, size);
MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_CALLOC_COUNT, 1, STAT_MEM_CALLOC_AMOUNT, size);
} }
DBG_RETURN(FAKE_PTR(ret)); DBG_RETURN(ret);
} }
/* }}} */ /* }}} */
@ -893,21 +888,19 @@ void * _mysqlnd_calloc(unsigned int nmemb, size_t size MYSQLND_MEM_D)
void * _mysqlnd_realloc(void *ptr, size_t new_size MYSQLND_MEM_D) void * _mysqlnd_realloc(void *ptr, size_t new_size MYSQLND_MEM_D)
{ {
void *ret; void *ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
DBG_ENTER(mysqlnd_realloc_name); DBG_ENTER(mysqlnd_realloc_name);
DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno);
DBG_INF_FMT("ptr=%p new_size=%lu ", new_size, ptr); DBG_INF_FMT("ptr=%p new_size=%lu ", new_size, ptr);
DBG_INF_FMT("before: %lu", zend_memory_usage(TRUE TSRMLS_CC)); DBG_INF_FMT("before: %lu", zend_memory_usage(TRUE TSRMLS_CC));
ret = realloc(REAL_PTR(ptr), REAL_SIZE(new_size)); ret = realloc(ptr, new_size);
DBG_INF_FMT("new_ptr=%p", ret); DBG_INF_FMT("new_ptr=%p", ret);
if (collect_memory_statistics) { if (MYSQLND_G(collect_memory_statistics)) {
*(size_t *) ret = new_size; MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_REALLOC_COUNT, 1, STAT_MEM_REALLOC_AMMOUNT, new_size);
MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_REALLOC_COUNT, 1, STAT_MEM_REALLOC_AMOUNT, new_size);
} }
DBG_RETURN(FAKE_PTR(ret)); DBG_RETURN(ret);
} }
/* }}} */ /* }}} */
@ -915,58 +908,35 @@ void * _mysqlnd_realloc(void *ptr, size_t new_size MYSQLND_MEM_D)
/* {{{ _mysqlnd_free */ /* {{{ _mysqlnd_free */
void _mysqlnd_free(void *ptr MYSQLND_MEM_D) void _mysqlnd_free(void *ptr MYSQLND_MEM_D)
{ {
size_t free_amount = 0;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
DBG_ENTER(mysqlnd_free_name); DBG_ENTER(mysqlnd_free_name);
DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno);
DBG_INF_FMT("ptr=%p", ptr); DBG_INF_FMT("ptr=%p", ptr);
if (ptr) { free(ptr);
if (collect_memory_statistics) {
free_amount = *(size_t *)(ptr - sizeof(size_t));
DBG_INF_FMT("ptr=%p size=%u", ptr - sizeof(size_t), (unsigned int) free_amount);
}
free(REAL_PTR(ptr));
}
if (collect_memory_statistics) { if (MYSQLND_G(collect_memory_statistics)) {
MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(STAT_MEM_FREE_COUNT, 1, STAT_MEM_FREE_AMOUNT, free_amount); MYSQLND_INC_GLOBAL_STATISTIC(STAT_MEM_FREE_COUNT);
} }
DBG_VOID_RETURN; DBG_VOID_RETURN;
} }
/* }}} */ /* }}} */
#define SMART_STR_START_SIZE 2048
#define SMART_STR_PREALLOC 512
#include "ext/standard/php_smart_str.h"
/* {{{ _mysqlnd_pestrndup */ /* {{{ _mysqlnd_pestrndup */
char * _mysqlnd_pestrndup(const char * const ptr, size_t length, zend_bool persistent MYSQLND_MEM_D) char * _mysqlnd_pestrndup(const char * const ptr, size_t length, zend_bool persistent MYSQLND_MEM_D)
{ {
char * ret; char * ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
DBG_ENTER(mysqlnd_pestrndup_name); DBG_ENTER(mysqlnd_pestrndup_name);
DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno);
DBG_INF_FMT("ptr=%p", ptr); DBG_INF_FMT("ptr=%p", ptr);
ret = pemalloc(REAL_SIZE(length) + 1, persistent); ret = pestrndup(ptr, length, persistent);
{
size_t l = length;
char * p = (char *) ptr;
char * dest = (char *) FAKE_PTR(ret);
while (*p && l--) {
*dest++ = *p++;
}
*dest = '\0';
}
if (collect_memory_statistics) { if (MYSQLND_G(collect_memory_statistics)) {
*(size_t *) ret = length;
MYSQLND_INC_GLOBAL_STATISTIC(persistent? STAT_MEM_STRNDUP_COUNT : STAT_MEM_ESTRNDUP_COUNT); MYSQLND_INC_GLOBAL_STATISTIC(persistent? STAT_MEM_STRNDUP_COUNT : STAT_MEM_ESTRNDUP_COUNT);
} }
DBG_RETURN(FAKE_PTR(ret)); DBG_RETURN(ret);
} }
/* }}} */ /* }}} */
@ -975,26 +945,17 @@ char * _mysqlnd_pestrndup(const char * const ptr, size_t length, zend_bool persi
char * _mysqlnd_pestrdup(const char * const ptr, zend_bool persistent MYSQLND_MEM_D) char * _mysqlnd_pestrdup(const char * const ptr, zend_bool persistent MYSQLND_MEM_D)
{ {
char * ret; char * ret;
smart_str tmp_str = {0, 0, 0};
char * p = ptr;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
DBG_ENTER(mysqlnd_pestrdup_name); DBG_ENTER(mysqlnd_pestrdup_name);
DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno); DBG_INF_FMT("file=%-15s line=%4d", strrchr(__zend_filename, PHP_DIR_SEPARATOR) + 1, __zend_lineno);
DBG_INF_FMT("ptr=%p", ptr); DBG_INF_FMT("ptr=%p", ptr);
do {
smart_str_appendc(&tmp_str, *p);
} while (*p++);
ret = pemalloc(tmp_str.len + sizeof(size_t), persistent); ret = pestrdup(ptr, persistent);
memcpy(FAKE_PTR(ret), tmp_str.c, tmp_str.len);
if (collect_memory_statistics) { if (MYSQLND_G(collect_memory_statistics)) {
*(size_t *) ret = tmp_str.len;
MYSQLND_INC_GLOBAL_STATISTIC(persistent? STAT_MEM_STRDUP_COUNT : STAT_MEM_ESTRDUP_COUNT); MYSQLND_INC_GLOBAL_STATISTIC(persistent? STAT_MEM_STRDUP_COUNT : STAT_MEM_ESTRDUP_COUNT);
} }
smart_str_free(&tmp_str);
DBG_RETURN(FAKE_PTR(ret)); DBG_RETURN(ret);
} }
/* }}} */ /* }}} */
@ -1047,11 +1008,11 @@ char * _mysqlnd_pestrdup(const char * const ptr, zend_bool persistent MYSQLND_ME
zval copy; \ zval copy; \
int use_copy; \ int use_copy; \
zend_make_printable_zval(*tmp, &copy, &use_copy); \ zend_make_printable_zval(*tmp, &copy, &use_copy); \
TRACE_APPEND_STRL(Z_STRVAL(copy), Z_STRLEN(copy)); \ TRACE_APPEND_STRL(Z_STRVAL(copy), Z_STRLEN(copy)); \
zval_dtor(&copy); \ zval_dtor(&copy); \
} else { \ } else { \
TRACE_APPEND_STRL(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp)); \ TRACE_APPEND_STRL(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp)); \
} \ } \
} }
/* }}} */ /* }}} */

14
ext/mysqlnd/mysqlnd_enum_n_def.h
View file

@ -388,21 +388,19 @@ typedef enum mysqlnd_collected_stats
STAT_STMT_CLOSE_EXPLICIT, STAT_STMT_CLOSE_EXPLICIT,
STAT_STMT_CLOSE_IMPLICIT, STAT_STMT_CLOSE_IMPLICIT,
STAT_MEM_EMALLOC_COUNT, STAT_MEM_EMALLOC_COUNT,
STAT_MEM_EMALLOC_AMOUNT, STAT_MEM_EMALLOC_AMMOUNT,
STAT_MEM_ECALLOC_COUNT, STAT_MEM_ECALLOC_COUNT,
STAT_MEM_ECALLOC_AMOUNT, STAT_MEM_ECALLOC_AMMOUNT,
STAT_MEM_EREALLOC_COUNT, STAT_MEM_EREALLOC_COUNT,
STAT_MEM_EREALLOC_AMOUNT, STAT_MEM_EREALLOC_AMMOUNT,
STAT_MEM_EFREE_COUNT, STAT_MEM_EFREE_COUNT,
STAT_MEM_EFREE_AMOUNT,
STAT_MEM_MALLOC_COUNT, STAT_MEM_MALLOC_COUNT,
STAT_MEM_MALLOC_AMOUNT, STAT_MEM_MALLOC_AMMOUNT,
STAT_MEM_CALLOC_COUNT, STAT_MEM_CALLOC_COUNT,
STAT_MEM_CALLOC_AMOUNT, STAT_MEM_CALLOC_AMMOUNT,
STAT_MEM_REALLOC_COUNT, STAT_MEM_REALLOC_COUNT,
STAT_MEM_REALLOC_AMOUNT, STAT_MEM_REALLOC_AMMOUNT,
STAT_MEM_FREE_COUNT, STAT_MEM_FREE_COUNT,
STAT_MEM_FREE_AMOUNT,
STAT_MEM_ESTRNDUP_COUNT, STAT_MEM_ESTRNDUP_COUNT,
STAT_MEM_STRNDUP_COUNT, STAT_MEM_STRNDUP_COUNT,
STAT_MEM_ESTRDUP_COUNT, STAT_MEM_ESTRDUP_COUNT,

20
ext/mysqlnd/mysqlnd_net.c
View file

@ -121,14 +121,14 @@ MYSQLND_METHOD(mysqlnd_net, connect)(MYSQLND_NET * net, const char * const schem
tv.tv_usec = 0; tv.tv_usec = 0;
} }
DBG_INF_FMT("calling php_stream_xport_create");
net->stream = php_stream_xport_create(scheme, scheme_len, streams_options, streams_flags, net->stream = php_stream_xport_create(scheme, scheme_len, streams_options, streams_flags,
hashed_details, (net->options.timeout_connect) ? &tv : NULL, hashed_details, (net->options.timeout_connect) ? &tv : NULL,
NULL /*ctx*/, errstr, errcode); NULL /*ctx*/, errstr, errcode);
if (*errstr || !net->stream) { if (*errstr || !net->stream) {
if (hashed_details) { if (hashed_details) {
efree(hashed_details); /* allocated by spprintf */ efree(hashed_details);
} }
*errcode = CR_CONNECTION_ERROR; *errcode = CR_CONNECTION_ERROR;
DBG_RETURN(FAIL); DBG_RETURN(FAIL);
@ -231,7 +231,7 @@ MYSQLND_METHOD(mysqlnd_net, send)(MYSQLND * const conn, char * const buf, size_t
if (net->compressed == TRUE) { if (net->compressed == TRUE) {
size_t comp_buf_size = MYSQLND_HEADER_SIZE + COMPRESSED_HEADER_SIZE + MYSQLND_HEADER_SIZE + MIN(left, MYSQLND_MAX_PACKET_SIZE); size_t comp_buf_size = MYSQLND_HEADER_SIZE + COMPRESSED_HEADER_SIZE + MYSQLND_HEADER_SIZE + MIN(left, MYSQLND_MAX_PACKET_SIZE);
DBG_INF_FMT("compress_buf_size=%d", comp_buf_size); DBG_INF_FMT("compress_buf_size=%d", comp_buf_size);
compress_buf = mnd_emalloc(comp_buf_size); compress_buf = emalloc(comp_buf_size);
} }
do { do {
@ -264,7 +264,7 @@ MYSQLND_METHOD(mysqlnd_net, send)(MYSQLND * const conn, char * const buf, size_t
#if WHEN_WE_NEED_TO_CHECK_WHETHER_COMPRESSION_WORKS_CORRECTLY #if WHEN_WE_NEED_TO_CHECK_WHETHER_COMPRESSION_WORKS_CORRECTLY
if (res == Z_OK) { if (res == Z_OK) {
size_t decompressed_size = left + MYSQLND_HEADER_SIZE; size_t decompressed_size = left + MYSQLND_HEADER_SIZE;
zend_uchar * decompressed_data = mnd_malloc(decompressed_size); zend_uchar * decompressed_data = malloc(decompressed_size);
int error = net->m.decode(decompressed_data, decompressed_size, compress_buf + MYSQLND_HEADER_SIZE + COMPRESSED_HEADER_SIZE, payload_size); int error = net->m.decode(decompressed_data, decompressed_size, compress_buf + MYSQLND_HEADER_SIZE + COMPRESSED_HEADER_SIZE, payload_size);
if (error == Z_OK) { if (error == Z_OK) {
int i; int i;
@ -279,7 +279,7 @@ MYSQLND_METHOD(mysqlnd_net, send)(MYSQLND * const conn, char * const buf, size_t
} else { } else {
DBG_INF("error decompressing"); DBG_INF("error decompressing");
} }
mnd_free(decompressed_data); free(decompressed_data);
} }
#endif /* WHEN_WE_NEED_TO_CHECK_WHETHER_COMPRESSION_WORKS_CORRECTLY */ #endif /* WHEN_WE_NEED_TO_CHECK_WHETHER_COMPRESSION_WORKS_CORRECTLY */
} else } else
@ -322,7 +322,7 @@ MYSQLND_METHOD(mysqlnd_net, send)(MYSQLND * const conn, char * const buf, size_t
net->stream->chunk_size = old_chunk_size; net->stream->chunk_size = old_chunk_size;
if (compress_buf) { if (compress_buf) {
mnd_efree(compress_buf); efree(compress_buf);
} }
DBG_RETURN(ret); DBG_RETURN(ret);
} }
@ -415,7 +415,7 @@ mysqlnd_read_compressed_packet_from_stream_and_fill_read_buffer(MYSQLND * conn,
/* we need to decompress the data */ /* we need to decompress the data */
if (decompressed_size) { if (decompressed_size) {
compressed_data = mnd_emalloc(net_payload_size); compressed_data = emalloc(net_payload_size);
if (FAIL == conn->net->m.network_read(conn, compressed_data, net_payload_size TSRMLS_CC)) { if (FAIL == conn->net->m.network_read(conn, compressed_data, net_payload_size TSRMLS_CC)) {
ret = FAIL; ret = FAIL;
goto end; goto end;
@ -435,7 +435,7 @@ mysqlnd_read_compressed_packet_from_stream_and_fill_read_buffer(MYSQLND * conn,
} }
end: end:
if (compressed_data) { if (compressed_data) {
mnd_efree(compressed_data); efree(compressed_data);
} }
DBG_RETURN(ret); DBG_RETURN(ret);
} }
@ -688,7 +688,7 @@ mysqlnd_net_init(zend_bool persistent TSRMLS_DC)
net->m.free_contents = MYSQLND_METHOD(mysqlnd_net, free_contents); net->m.free_contents = MYSQLND_METHOD(mysqlnd_net, free_contents);
{ {
unsigned int buf_size = MYSQLND_G(net_cmd_buffer_size); /* this is long, cast to unsigned int*/ unsigned int buf_size = MYSQLND_G(net_read_buffer_size); /* this is long, cast to unsigned int*/
net->m.set_client_option(net, MYSQLND_OPT_NET_CMD_BUFFER_SIZE, (char *) &buf_size TSRMLS_CC); net->m.set_client_option(net, MYSQLND_OPT_NET_CMD_BUFFER_SIZE, (char *) &buf_size TSRMLS_CC);
} }
DBG_RETURN(net); DBG_RETURN(net);
@ -716,7 +716,7 @@ mysqlnd_net_free(MYSQLND_NET * const net TSRMLS_DC)
if (pers) { if (pers) {
php_stream_free(net->stream, PHP_STREAM_FREE_CLOSE_PERSISTENT | PHP_STREAM_FREE_RSRC_DTOR); php_stream_free(net->stream, PHP_STREAM_FREE_CLOSE_PERSISTENT | PHP_STREAM_FREE_RSRC_DTOR);
} else { } else {
php_stream_free(net->stream, PHP_STREAM_FREE_CLOSE); php_stream_free(net->stream, PHP_STREAM_FREE_CLOSE);
} }
net->stream = NULL; net->stream = NULL;
} }

6
ext/mysqlnd/mysqlnd_priv.h
View file

@ -93,10 +93,10 @@
#define SET_NEW_MESSAGE(buf, buf_len, message, len, persistent) \ #define SET_NEW_MESSAGE(buf, buf_len, message, len, persistent) \
{\ {\
if ((buf)) { \ if ((buf)) { \
mnd_pefree((buf), (persistent)); \ pefree((buf), (persistent)); \
} \ } \
if ((message)) { \ if ((message)) { \
(buf) = mnd_pestrndup((message), (len), (persistent)); \ (buf) = pestrndup((message), (len), (persistent)); \
} else { \ } else { \
buf = NULL; \ buf = NULL; \
} \ } \
@ -106,7 +106,7 @@
#define SET_EMPTY_MESSAGE(buf, buf_len, persistent) \ #define SET_EMPTY_MESSAGE(buf, buf_len, persistent) \
{\ {\
if ((buf)) { \ if ((buf)) { \
mnd_pefree((buf), (persistent)); \ pefree((buf), (persistent)); \
(buf) = NULL; \ (buf) = NULL; \
} \ } \
(buf_len) = 0; \ (buf_len) = 0; \

6
ext/mysqlnd/mysqlnd_ps.c
View file

@ -599,7 +599,7 @@ MYSQLND_METHOD(mysqlnd_stmt, execute)(MYSQLND_STMT * const s TSRMLS_DC)
not_bound, not_bound>1 ?"s":""); not_bound, not_bound>1 ?"s":"");
SET_STMT_ERROR(stmt, CR_PARAMS_NOT_BOUND, UNKNOWN_SQLSTATE, msg); SET_STMT_ERROR(stmt, CR_PARAMS_NOT_BOUND, UNKNOWN_SQLSTATE, msg);
if (msg) { if (msg) {
efree(msg); /* allocated by spprintf */ efree(msg);
} }
DBG_INF("FAIL"); DBG_INF("FAIL");
DBG_RETURN(FAIL); DBG_RETURN(FAIL);
@ -2055,7 +2055,7 @@ MYSQLND_METHOD(mysqlnd_stmt, alloc_param_bind)(MYSQLND_STMT * const s TSRMLS_DC)
{ {
MYSQLND_STMT_DATA * stmt = s->data; MYSQLND_STMT_DATA * stmt = s->data;
DBG_ENTER("mysqlnd_stmt::alloc_param_bind"); DBG_ENTER("mysqlnd_stmt::alloc_param_bind");
DBG_RETURN(mnd_pecalloc(stmt->param_count, sizeof(MYSQLND_PARAM_BIND), stmt->persistent)); DBG_RETURN(pecalloc(stmt->param_count, sizeof(MYSQLND_PARAM_BIND), stmt->persistent));
} }
/* }}} */ /* }}} */
@ -2066,7 +2066,7 @@ MYSQLND_METHOD(mysqlnd_stmt, alloc_result_bind)(MYSQLND_STMT * const s TSRMLS_DC
{ {
MYSQLND_STMT_DATA * stmt = s->data; MYSQLND_STMT_DATA * stmt = s->data;
DBG_ENTER("mysqlnd_stmt::alloc_result_bind"); DBG_ENTER("mysqlnd_stmt::alloc_result_bind");
DBG_RETURN(mnd_pecalloc(stmt->field_count, sizeof(MYSQLND_RESULT_BIND), stmt->persistent)); DBG_RETURN(pecalloc(stmt->field_count, sizeof(MYSQLND_RESULT_BIND), stmt->persistent));
} }
/* }}} */ /* }}} */

6
ext/mysqlnd/mysqlnd_ps_codec.c
View file

@ -270,7 +270,7 @@ void ps_fetch_time(zval *zv, const MYSQLND_FIELD * const field,
if (!as_unicode) { if (!as_unicode) {
#endif #endif
ZVAL_STRINGL(zv, to, length, 1); ZVAL_STRINGL(zv, to, length, 1);
efree(to); /* allocated by spprintf */ mnd_efree(to);
#if PHP_MAJOR_VERSION >= 6 #if PHP_MAJOR_VERSION >= 6
} else { } else {
ZVAL_UTF8_STRINGL(zv, to, length, ZSTR_AUTOFREE); ZVAL_UTF8_STRINGL(zv, to, length, ZSTR_AUTOFREE);
@ -321,7 +321,7 @@ void ps_fetch_date(zval *zv, const MYSQLND_FIELD * const field,
if (!as_unicode) { if (!as_unicode) {
#endif #endif
ZVAL_STRINGL(zv, to, length, 1); ZVAL_STRINGL(zv, to, length, 1);
efree(to); /* allocated by spprintf */ mnd_efree(to);
#if PHP_MAJOR_VERSION >= 6 #if PHP_MAJOR_VERSION >= 6
} else { } else {
ZVAL_UTF8_STRINGL(zv, to, length, ZSTR_AUTOFREE); ZVAL_UTF8_STRINGL(zv, to, length, ZSTR_AUTOFREE);
@ -380,7 +380,7 @@ void ps_fetch_datetime(zval *zv, const MYSQLND_FIELD * const field,
if (!as_unicode) { if (!as_unicode) {
#endif #endif
ZVAL_STRINGL(zv, to, length, 1); ZVAL_STRINGL(zv, to, length, 1);
efree(to); /* allocated by spprintf */ mnd_efree(to);
#if PHP_MAJOR_VERSION >= 6 #if PHP_MAJOR_VERSION >= 6
} else { } else {
ZVAL_UTF8_STRINGL(zv, to, length, ZSTR_AUTOFREE); ZVAL_UTF8_STRINGL(zv, to, length, ZSTR_AUTOFREE);

14
ext/mysqlnd/mysqlnd_statistics.c
View file

@ -99,21 +99,19 @@ const MYSQLND_STRING mysqlnd_stats_values_names[STAT_LAST] =
{ STR_W_LEN("explicit_stmt_close") }, { STR_W_LEN("explicit_stmt_close") },
{ STR_W_LEN("implicit_stmt_close") }, { STR_W_LEN("implicit_stmt_close") },
{ STR_W_LEN("mem_emalloc_count") }, { STR_W_LEN("mem_emalloc_count") },
{ STR_W_LEN("mem_emalloc_amount") }, { STR_W_LEN("mem_emalloc_ammount") },
{ STR_W_LEN("mem_ecalloc_count") }, { STR_W_LEN("mem_ecalloc_count") },
{ STR_W_LEN("mem_ecalloc_amount") }, { STR_W_LEN("mem_ecalloc_ammount") },
{ STR_W_LEN("mem_erealloc_count") }, { STR_W_LEN("mem_erealloc_count") },
{ STR_W_LEN("mem_erealloc_amount") }, { STR_W_LEN("mem_erealloc_ammount") },
{ STR_W_LEN("mem_efree_count") }, { STR_W_LEN("mem_efree_count") },
{ STR_W_LEN("mem_efree_amount") },
{ STR_W_LEN("mem_malloc_count") }, { STR_W_LEN("mem_malloc_count") },
{ STR_W_LEN("mem_malloc_amount") }, { STR_W_LEN("mem_malloc_ammount") },
{ STR_W_LEN("mem_calloc_count") }, { STR_W_LEN("mem_calloc_count") },
{ STR_W_LEN("mem_calloc_amount") }, { STR_W_LEN("mem_calloc_ammount") },
{ STR_W_LEN("mem_realloc_count") }, { STR_W_LEN("mem_realloc_count") },
{ STR_W_LEN("mem_realloc_amount") }, { STR_W_LEN("mem_realloc_ammount") },
{ STR_W_LEN("mem_free_count") }, { STR_W_LEN("mem_free_count") },
{ STR_W_LEN("mem_free_amount") },
{ STR_W_LEN("mem_estrndup_count") }, { STR_W_LEN("mem_estrndup_count") },
{ STR_W_LEN("mem_strndup_count") }, { STR_W_LEN("mem_strndup_count") },
{ STR_W_LEN("mem_estndup_count") }, { STR_W_LEN("mem_estndup_count") },

2
ext/mysqlnd/mysqlnd_wireprotocol.c
View file

@ -542,7 +542,7 @@ php_mysqlnd_ok_read(void *_packet, MYSQLND *conn TSRMLS_DC)
/* There is a message */ /* There is a message */
if (packet->header.size > p - buf && (i = php_mysqlnd_net_field_length(&p))) { if (packet->header.size > p - buf && (i = php_mysqlnd_net_field_length(&p))) {
packet->message = mnd_pestrndup((char *)p, MIN(i, buf_len - (p - begin)), FALSE); packet->message = estrndup((char *)p, MIN(i, buf_len - (p - begin)));
packet->message_len = i; packet->message_len = i;
} else { } else {
packet->message = NULL; packet->message = NULL;