diff options
Diffstat (limited to 'ext/mysqlnd')
25 files changed, 1310 insertions, 1918 deletions
diff --git a/ext/mysqlnd/mysqlnd.h b/ext/mysqlnd/mysqlnd.h index 38fea24f28..401a40ebd5 100644 --- a/ext/mysqlnd/mysqlnd.h +++ b/ext/mysqlnd/mysqlnd.h @@ -162,7 +162,7 @@ PHPAPI enum_func_status mysqlnd_poll(MYSQLND **r_array, MYSQLND **e_array, MYSQL /* mysqlnd metadata */ PHPAPI const char * mysqlnd_get_client_info(); -PHPAPI unsigned int mysqlnd_get_client_version(); +PHPAPI unsigned long mysqlnd_get_client_version(); #define mysqlnd_ssl_set(conn, key, cert, ca, capath, cipher) ((conn)->data)->m->ssl_set((conn)->data, (key), (cert), (ca), (capath), (cipher)) diff --git a/ext/mysqlnd/mysqlnd_auth.c b/ext/mysqlnd/mysqlnd_auth.c index 3ba447cfdf..c5d610c1eb 100644 --- a/ext/mysqlnd/mysqlnd_auth.c +++ b/ext/mysqlnd/mysqlnd_auth.c @@ -193,11 +193,7 @@ mysqlnd_switch_to_ssl_if_needed(MYSQLND_CONN_DATA * conn, { size_t client_capabilities = mysql_flags; - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_ENABLE_SSL, conn, client_capabilities, server_capabilities, charset_no); - if (command) { - ret = command->run(command); - command->free_command(command); - } + ret = conn->run_command(COM_ENABLE_SSL, conn, client_capabilities, server_capabilities, charset_no); } DBG_RETURN(ret); } @@ -258,100 +254,97 @@ mysqlnd_auth_handshake(MYSQLND_CONN_DATA * conn, { enum_func_status ret = FAIL; const MYSQLND_CHARSET * charset = NULL; - MYSQLND_PACKET_CHANGE_AUTH_RESPONSE * change_auth_resp_packet = NULL; - MYSQLND_PACKET_AUTH_RESPONSE * auth_resp_packet = NULL; - MYSQLND_PACKET_AUTH * auth_packet = NULL; + MYSQLND_PACKET_AUTH_RESPONSE auth_resp_packet; DBG_ENTER("mysqlnd_auth_handshake"); - auth_resp_packet = conn->payload_decoder_factory->m.get_auth_response_packet(conn->payload_decoder_factory, FALSE); - - if (!auth_resp_packet) { - SET_OOM_ERROR(conn->error_info); - goto end; - } + conn->payload_decoder_factory->m.init_auth_response_packet(&auth_resp_packet); if (use_full_blown_auth_packet != TRUE) { - change_auth_resp_packet = conn->payload_decoder_factory->m.get_change_auth_response_packet(conn->payload_decoder_factory, FALSE); - if (!change_auth_resp_packet) { - SET_OOM_ERROR(conn->error_info); - goto end; - } + MYSQLND_PACKET_CHANGE_AUTH_RESPONSE change_auth_resp_packet; - change_auth_resp_packet->auth_data = auth_plugin_data; - change_auth_resp_packet->auth_data_len = auth_plugin_data_len; + conn->payload_decoder_factory->m.init_change_auth_response_packet(&change_auth_resp_packet); - if (!PACKET_WRITE(change_auth_resp_packet)) { + change_auth_resp_packet.auth_data = auth_plugin_data; + change_auth_resp_packet.auth_data_len = auth_plugin_data_len; + + if (!PACKET_WRITE(conn, &change_auth_resp_packet)) { SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT); SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone); + PACKET_FREE(&change_auth_resp_packet); goto end; } + PACKET_FREE(&change_auth_resp_packet); } else { - auth_packet = conn->payload_decoder_factory->m.get_auth_packet(conn->payload_decoder_factory, FALSE); + MYSQLND_PACKET_AUTH auth_packet; + + conn->payload_decoder_factory->m.init_auth_packet(&auth_packet); - auth_packet->client_flags = mysql_flags; - auth_packet->max_packet_size = session_options->max_allowed_packet; + auth_packet.client_flags = mysql_flags; + auth_packet.max_packet_size = session_options->max_allowed_packet; if (session_options->charset_name && (charset = mysqlnd_find_charset_name(session_options->charset_name))) { - auth_packet->charset_no = charset->nr; + auth_packet.charset_no = charset->nr; } else { - auth_packet->charset_no = server_charset_no; + auth_packet.charset_no = server_charset_no; } - auth_packet->send_auth_data = TRUE; - auth_packet->user = user; - auth_packet->db = db; - auth_packet->db_len = db_len; + auth_packet.send_auth_data = TRUE; + auth_packet.user = user; + auth_packet.db = db; + auth_packet.db_len = db_len; - auth_packet->auth_data = auth_plugin_data; - auth_packet->auth_data_len = auth_plugin_data_len; - auth_packet->auth_plugin_name = auth_protocol; + auth_packet.auth_data = auth_plugin_data; + auth_packet.auth_data_len = auth_plugin_data_len; + auth_packet.auth_plugin_name = auth_protocol; if (conn->server_capabilities & CLIENT_CONNECT_ATTRS) { - auth_packet->connect_attr = conn->options->connect_attr; + auth_packet.connect_attr = conn->options->connect_attr; } - if (!PACKET_WRITE(auth_packet)) { + if (!PACKET_WRITE(conn, &auth_packet)) { + PACKET_FREE(&auth_packet); goto end; } - } - if (use_full_blown_auth_packet == TRUE) { - conn->charset = mysqlnd_find_charset_nr(auth_packet->charset_no); + + if (use_full_blown_auth_packet == TRUE) { + conn->charset = mysqlnd_find_charset_nr(auth_packet.charset_no); + } + + PACKET_FREE(&auth_packet); } - if (FAIL == PACKET_READ(auth_resp_packet) || auth_resp_packet->response_code >= 0xFE) { - if (auth_resp_packet->response_code == 0xFE) { + if (FAIL == PACKET_READ(conn, &auth_resp_packet) || auth_resp_packet.response_code >= 0xFE) { + if (auth_resp_packet.response_code == 0xFE) { /* old authentication with new server !*/ - if (!auth_resp_packet->new_auth_protocol) { + if (!auth_resp_packet.new_auth_protocol) { DBG_ERR(mysqlnd_old_passwd); SET_CLIENT_ERROR(conn->error_info, CR_UNKNOWN_ERROR, UNKNOWN_SQLSTATE, mysqlnd_old_passwd); } else { - *switch_to_auth_protocol = mnd_pestrndup(auth_resp_packet->new_auth_protocol, auth_resp_packet->new_auth_protocol_len, FALSE); - *switch_to_auth_protocol_len = auth_resp_packet->new_auth_protocol_len; - if (auth_resp_packet->new_auth_protocol_data) { - *switch_to_auth_protocol_data_len = auth_resp_packet->new_auth_protocol_data_len; + *switch_to_auth_protocol = mnd_pestrndup(auth_resp_packet.new_auth_protocol, auth_resp_packet.new_auth_protocol_len, FALSE); + *switch_to_auth_protocol_len = auth_resp_packet.new_auth_protocol_len; + if (auth_resp_packet.new_auth_protocol_data) { + *switch_to_auth_protocol_data_len = auth_resp_packet.new_auth_protocol_data_len; *switch_to_auth_protocol_data = mnd_emalloc(*switch_to_auth_protocol_data_len); - memcpy(*switch_to_auth_protocol_data, auth_resp_packet->new_auth_protocol_data, *switch_to_auth_protocol_data_len); + memcpy(*switch_to_auth_protocol_data, auth_resp_packet.new_auth_protocol_data, *switch_to_auth_protocol_data_len); } else { *switch_to_auth_protocol_data = NULL; *switch_to_auth_protocol_data_len = 0; } } - } else if (auth_resp_packet->response_code == 0xFF) { - if (auth_resp_packet->sqlstate[0]) { - strlcpy(conn->error_info->sqlstate, auth_resp_packet->sqlstate, sizeof(conn->error_info->sqlstate)); - DBG_ERR_FMT("ERROR:%u [SQLSTATE:%s] %s", auth_resp_packet->error_no, auth_resp_packet->sqlstate, auth_resp_packet->error); + } else if (auth_resp_packet.response_code == 0xFF) { + if (auth_resp_packet.sqlstate[0]) { + strlcpy(conn->error_info->sqlstate, auth_resp_packet.sqlstate, sizeof(conn->error_info->sqlstate)); + DBG_ERR_FMT("ERROR:%u [SQLSTATE:%s] %s", auth_resp_packet.error_no, auth_resp_packet.sqlstate, auth_resp_packet.error); } - SET_CLIENT_ERROR(conn->error_info, auth_resp_packet->error_no, UNKNOWN_SQLSTATE, auth_resp_packet->error); + SET_CLIENT_ERROR(conn->error_info, auth_resp_packet.error_no, UNKNOWN_SQLSTATE, auth_resp_packet.error); } goto end; } - SET_NEW_MESSAGE(conn->last_message.s, conn->last_message.l, auth_resp_packet->message, auth_resp_packet->message_len, conn->persistent); + SET_NEW_MESSAGE(conn->last_message.s, conn->last_message.l, auth_resp_packet.message, auth_resp_packet.message_len); ret = PASS; end: - PACKET_FREE(change_auth_resp_packet); - PACKET_FREE(auth_packet); - PACKET_FREE(auth_resp_packet); + PACKET_FREE(&auth_resp_packet); DBG_RETURN(ret); } /* }}} */ @@ -379,79 +372,73 @@ mysqlnd_auth_change_user(MYSQLND_CONN_DATA * const conn, { enum_func_status ret = FAIL; const MYSQLND_CHARSET * old_cs = conn->charset; - MYSQLND_PACKET_CHANGE_AUTH_RESPONSE * change_auth_resp_packet = NULL; - MYSQLND_PACKET_CHG_USER_RESPONSE * chg_user_resp = NULL; - MYSQLND_PACKET_AUTH * auth_packet = NULL; + MYSQLND_PACKET_CHG_USER_RESPONSE chg_user_resp; DBG_ENTER("mysqlnd_auth_change_user"); - chg_user_resp = conn->payload_decoder_factory->m.get_change_user_response_packet(conn->payload_decoder_factory, FALSE); - - if (!chg_user_resp) { - SET_OOM_ERROR(conn->error_info); - goto end; - } + conn->payload_decoder_factory->m.init_change_user_response_packet(&chg_user_resp); if (use_full_blown_auth_packet != TRUE) { - change_auth_resp_packet = conn->payload_decoder_factory->m.get_change_auth_response_packet(conn->payload_decoder_factory, FALSE); - if (!change_auth_resp_packet) { - SET_OOM_ERROR(conn->error_info); - goto end; - } + MYSQLND_PACKET_CHANGE_AUTH_RESPONSE change_auth_resp_packet; + + conn->payload_decoder_factory->m.init_change_auth_response_packet(&change_auth_resp_packet); - change_auth_resp_packet->auth_data = auth_plugin_data; - change_auth_resp_packet->auth_data_len = auth_plugin_data_len; + change_auth_resp_packet.auth_data = auth_plugin_data; + change_auth_resp_packet.auth_data_len = auth_plugin_data_len; - if (!PACKET_WRITE(change_auth_resp_packet)) { + if (!PACKET_WRITE(conn, &change_auth_resp_packet)) { SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT); SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone); + PACKET_FREE(&change_auth_resp_packet); goto end; } + + PACKET_FREE(&change_auth_resp_packet); } else { - auth_packet = conn->payload_decoder_factory->m.get_auth_packet(conn->payload_decoder_factory, FALSE); + MYSQLND_PACKET_AUTH auth_packet; - if (!auth_packet) { - SET_OOM_ERROR(conn->error_info); - goto end; - } + conn->payload_decoder_factory->m.init_auth_packet(&auth_packet); - auth_packet->is_change_user_packet = TRUE; - auth_packet->user = user; - auth_packet->db = db; - auth_packet->db_len = db_len; - auth_packet->silent = silent; + auth_packet.is_change_user_packet = TRUE; + auth_packet.user = user; + auth_packet.db = db; + auth_packet.db_len = db_len; + auth_packet.silent = silent; - auth_packet->auth_data = auth_plugin_data; - auth_packet->auth_data_len = auth_plugin_data_len; - auth_packet->auth_plugin_name = auth_protocol; + auth_packet.auth_data = auth_plugin_data; + auth_packet.auth_data_len = auth_plugin_data_len; + auth_packet.auth_plugin_name = auth_protocol; if (conn->m->get_server_version(conn) >= 50123) { - auth_packet->charset_no = conn->charset->nr; + auth_packet.charset_no = conn->charset->nr; } - if (!PACKET_WRITE(auth_packet)) { + if (!PACKET_WRITE(conn, &auth_packet)) { SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT); SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone); + PACKET_FREE(&auth_packet); goto end; } + + PACKET_FREE(&auth_packet); } - ret = PACKET_READ(chg_user_resp); - COPY_CLIENT_ERROR(conn->error_info, chg_user_resp->error_info); + ret = PACKET_READ(conn, &chg_user_resp); + COPY_CLIENT_ERROR(conn->error_info, chg_user_resp.error_info); - if (0xFE == chg_user_resp->response_code) { + if (0xFE == chg_user_resp.response_code) { ret = FAIL; - if (!chg_user_resp->new_auth_protocol) { + if (!chg_user_resp.new_auth_protocol) { DBG_ERR(mysqlnd_old_passwd); SET_CLIENT_ERROR(conn->error_info, CR_UNKNOWN_ERROR, UNKNOWN_SQLSTATE, mysqlnd_old_passwd); } else { - *switch_to_auth_protocol = mnd_pestrndup(chg_user_resp->new_auth_protocol, chg_user_resp->new_auth_protocol_len, FALSE); - *switch_to_auth_protocol_len = chg_user_resp->new_auth_protocol_len; - if (chg_user_resp->new_auth_protocol_data) { - *switch_to_auth_protocol_data_len = chg_user_resp->new_auth_protocol_data_len; + *switch_to_auth_protocol = mnd_pestrndup(chg_user_resp.new_auth_protocol, chg_user_resp.new_auth_protocol_len, FALSE); + *switch_to_auth_protocol_len = chg_user_resp.new_auth_protocol_len; + if (chg_user_resp.new_auth_protocol_data) { + *switch_to_auth_protocol_data_len = chg_user_resp.new_auth_protocol_data_len; *switch_to_auth_protocol_data = mnd_emalloc(*switch_to_auth_protocol_data_len); - memcpy(*switch_to_auth_protocol_data, chg_user_resp->new_auth_protocol_data, *switch_to_auth_protocol_data_len); + memcpy(*switch_to_auth_protocol_data, chg_user_resp.new_auth_protocol_data, *switch_to_auth_protocol_data_len); } else { *switch_to_auth_protocol_data = NULL; *switch_to_auth_protocol_data_len = 0; @@ -467,14 +454,12 @@ mysqlnd_auth_change_user(MYSQLND_CONN_DATA * const conn, When it gets fixed, there should be one more check here */ if (conn->m->get_server_version(conn) > 50113L &&conn->m->get_server_version(conn) < 50118L) { - MYSQLND_PACKET_OK * redundant_error_packet = conn->payload_decoder_factory->m.get_ok_packet(conn->payload_decoder_factory, FALSE); - if (redundant_error_packet) { - PACKET_READ(redundant_error_packet); - PACKET_FREE(redundant_error_packet); - DBG_INF_FMT("Server is %u, buggy, sends two ERR messages", conn->m->get_server_version(conn)); - } else { - SET_OOM_ERROR(conn->error_info); - } + MYSQLND_PACKET_OK redundant_error_packet; + + conn->payload_decoder_factory->m.init_ok_packet(&redundant_error_packet); + PACKET_READ(conn, &redundant_error_packet); + PACKET_FREE(&redundant_error_packet); + DBG_INF_FMT("Server is %u, buggy, sends two ERR messages", conn->m->get_server_version(conn)); } } if (ret == PASS) { @@ -501,15 +486,13 @@ mysqlnd_auth_change_user(MYSQLND_CONN_DATA * const conn, if (conn->m->get_server_version(conn) < 50123) { ret = conn->m->set_charset(conn, old_cs->name); } - } else if (ret == FAIL && chg_user_resp->server_asked_323_auth == TRUE) { + } 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(change_auth_resp_packet); - PACKET_FREE(auth_packet); - PACKET_FREE(chg_user_resp); + PACKET_FREE(&chg_user_resp); DBG_RETURN(ret); } /* }}} */ @@ -701,45 +684,36 @@ mysqlnd_sha256_get_rsa_key(MYSQLND_CONN_DATA * conn, pfc_data->sha256_server_public_key? pfc_data->sha256_server_public_key:"n/a", MYSQLND_G(sha256_server_public_key)? MYSQLND_G(sha256_server_public_key):"n/a"); if (!fname || fname[0] == '\0') { - MYSQLND_PACKET_SHA256_PK_REQUEST * pk_req_packet = NULL; - MYSQLND_PACKET_SHA256_PK_REQUEST_RESPONSE * pk_resp_packet = NULL; + MYSQLND_PACKET_SHA256_PK_REQUEST pk_req_packet; + MYSQLND_PACKET_SHA256_PK_REQUEST_RESPONSE pk_resp_packet; do { DBG_INF("requesting the public key from the server"); - pk_req_packet = conn->payload_decoder_factory->m.get_sha256_pk_request_packet(conn->payload_decoder_factory, FALSE); - if (!pk_req_packet) { - SET_OOM_ERROR(conn->error_info); - break; - } - pk_resp_packet = conn->payload_decoder_factory->m.get_sha256_pk_request_response_packet(conn->payload_decoder_factory, FALSE); - if (!pk_resp_packet) { - SET_OOM_ERROR(conn->error_info); - PACKET_FREE(pk_req_packet); - break; - } + conn->payload_decoder_factory->m.init_sha256_pk_request_packet(&pk_req_packet); + conn->payload_decoder_factory->m.init_sha256_pk_request_response_packet(&pk_resp_packet); - if (! PACKET_WRITE(pk_req_packet)) { + if (! PACKET_WRITE(conn, &pk_req_packet)) { DBG_ERR_FMT("Error while sending public key request packet"); php_error(E_WARNING, "Error while sending public key request packet. PID=%d", getpid()); SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT); break; } - if (FAIL == PACKET_READ(pk_resp_packet) || NULL == pk_resp_packet->public_key) { + if (FAIL == PACKET_READ(conn, &pk_resp_packet) || NULL == pk_resp_packet.public_key) { DBG_ERR_FMT("Error while receiving public key"); php_error(E_WARNING, "Error while receiving public key. PID=%d", getpid()); SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT); break; } - DBG_INF_FMT("Public key(%d):\n%s", pk_resp_packet->public_key_len, pk_resp_packet->public_key); + DBG_INF_FMT("Public key(%d):\n%s", pk_resp_packet.public_key_len, pk_resp_packet.public_key); /* now extract the public key */ { - BIO * bio = BIO_new_mem_buf(pk_resp_packet->public_key, pk_resp_packet->public_key_len); + BIO * bio = BIO_new_mem_buf(pk_resp_packet.public_key, pk_resp_packet.public_key_len); ret = PEM_read_bio_RSA_PUBKEY(bio, NULL, NULL, NULL); BIO_free(bio); } } while (0); - PACKET_FREE(pk_req_packet); - PACKET_FREE(pk_resp_packet); + PACKET_FREE(&pk_req_packet); + PACKET_FREE(&pk_resp_packet); DBG_INF_FMT("ret=%p", ret); DBG_RETURN(ret); diff --git a/ext/mysqlnd/mysqlnd_block_alloc.c b/ext/mysqlnd/mysqlnd_block_alloc.c index 87afd8e0a8..227b9540e2 100644 --- a/ext/mysqlnd/mysqlnd_block_alloc.c +++ b/ext/mysqlnd/mysqlnd_block_alloc.c @@ -14,6 +14,7 @@ +----------------------------------------------------------------------+ | Authors: Andrey Hristov <andrey@php.net> | | Ulf Wendel <uw@php.net> | + | Dmitry Stogov <dmitry@zend.com> | +----------------------------------------------------------------------+ */ @@ -24,114 +25,130 @@ #include "mysqlnd_priv.h" +/* {{{ mysqlnd_arena_create */ +static zend_always_inline zend_arena* mysqlnd_arena_create(size_t size) +{ + zend_arena *arena = (zend_arena*)mnd_emalloc(size); + + arena->ptr = (char*) arena + ZEND_MM_ALIGNED_SIZE(sizeof(zend_arena)); + arena->end = (char*) arena + size; + arena->prev = NULL; + return arena; +} +/* }}} */ + +/* {{{ mysqlnd_arena_destroy */ +static zend_always_inline void mysqlnd_arena_destroy(zend_arena *arena) +{ + do { + zend_arena *prev = arena->prev; + mnd_efree(arena); + arena = prev; + } while (arena); +} +/* }}} */ + +/* {{{ mysqlnd_arena_alloc */ +static zend_always_inline void* mysqlnd_arena_alloc(zend_arena **arena_ptr, size_t size) +{ + zend_arena *arena = *arena_ptr; + char *ptr = arena->ptr; + + size = ZEND_MM_ALIGNED_SIZE(size); + + if (EXPECTED(size <= (size_t)(arena->end - ptr))) { + arena->ptr = ptr + size; + } else { + size_t arena_size = + UNEXPECTED((size + ZEND_MM_ALIGNED_SIZE(sizeof(zend_arena))) > (size_t)(arena->end - (char*) arena)) ? + (size + ZEND_MM_ALIGNED_SIZE(sizeof(zend_arena))) : + (size_t)(arena->end - (char*) arena); + zend_arena *new_arena = (zend_arena*)mnd_emalloc(arena_size); + + ptr = (char*) new_arena + ZEND_MM_ALIGNED_SIZE(sizeof(zend_arena)); + new_arena->ptr = (char*) new_arena + ZEND_MM_ALIGNED_SIZE(sizeof(zend_arena)) + size; + new_arena->end = (char*) new_arena + arena_size; + new_arena->prev = arena; + *arena_ptr = new_arena; + } + + return (void*) ptr; +} +/* }}} */ + +static zend_always_inline void* mysqlnd_arena_checkpoint(zend_arena *arena) +{ + return arena->ptr; +} + +static zend_always_inline void mysqlnd_arena_release(zend_arena **arena_ptr, void *checkpoint) +{ + zend_arena *arena = *arena_ptr; + + while (UNEXPECTED((char*)checkpoint > arena->end) || + UNEXPECTED((char*)checkpoint <= (char*)arena)) { + zend_arena *prev = arena->prev; + mnd_efree(arena); + *arena_ptr = arena = prev; + } + ZEND_ASSERT((char*)checkpoint > (char*)arena && (char*)checkpoint <= arena->end); + arena->ptr = (char*)checkpoint; +} + /* {{{ mysqlnd_mempool_free_chunk */ static void -mysqlnd_mempool_free_chunk(MYSQLND_MEMORY_POOL * pool, MYSQLND_MEMORY_POOL_CHUNK * chunk) +mysqlnd_mempool_free_chunk(MYSQLND_MEMORY_POOL * pool, void * ptr) { DBG_ENTER("mysqlnd_mempool_free_chunk"); - if (chunk->from_pool) { - /* Try to back-off and guess if this is the last block allocated */ - if (chunk->ptr == (pool->arena + (pool->arena_size - pool->free_size - chunk->size))) { - /* - This was the last allocation. Lucky us, we can free - a bit of memory from the pool. Next time we will return from the same ptr. - */ - pool->free_size += chunk->size; - } - } else { - mnd_efree(chunk->ptr); + /* Try to back-off and guess if this is the last block allocated */ + if (ptr == pool->last) { + /* + This was the last allocation. Lucky us, we can free + a bit of memory from the pool. Next time we will return from the same ptr. + */ + pool->arena->ptr = (char*)ptr; + pool->last = NULL; } - mnd_efree(chunk); DBG_VOID_RETURN; } /* }}} */ /* {{{ mysqlnd_mempool_resize_chunk */ -static enum_func_status -mysqlnd_mempool_resize_chunk(MYSQLND_MEMORY_POOL * pool, MYSQLND_MEMORY_POOL_CHUNK * chunk, unsigned int size) +static void * +mysqlnd_mempool_resize_chunk(MYSQLND_MEMORY_POOL * pool, void * ptr, size_t old_size, size_t size) { DBG_ENTER("mysqlnd_mempool_resize_chunk"); - if (chunk->from_pool) { - /* Try to back-off and guess if this is the last block allocated */ - if (chunk->ptr == (pool->arena + (pool->arena_size - pool->free_size - chunk->size))) { - /* - This was the last allocation. Lucky us, we can free - a bit of memory from the pool. Next time we will return from the same ptr. - */ - if ((chunk->size + pool->free_size) < size) { - zend_uchar *new_ptr; - new_ptr = mnd_emalloc(size); - if (!new_ptr) { - DBG_RETURN(FAIL); - } - memcpy(new_ptr, chunk->ptr, chunk->size); - chunk->ptr = new_ptr; - pool->free_size += chunk->size; - chunk->size = size; - chunk->from_pool = FALSE; /* now we have no pool memory */ - } else { - /* If the chunk is > than asked size then free_memory increases, otherwise decreases*/ - pool->free_size += (chunk->size - size); - } - } else { - /* Not last chunk, if the user asks for less, give it to him */ - if (chunk->size >= size) { - ; /* nop */ - } else { - zend_uchar *new_ptr; - new_ptr = mnd_emalloc(size); - if (!new_ptr) { - DBG_RETURN(FAIL); - } - memcpy(new_ptr, chunk->ptr, chunk->size); - chunk->ptr = new_ptr; - chunk->size = size; - chunk->from_pool = FALSE; /* now we have non-pool memory */ - } - } + + /* Try to back-off and guess if this is the last block allocated */ + if (ptr == pool->last + && (ZEND_MM_ALIGNED_SIZE(size) <= ((char*)pool->arena->end - (char*)ptr))) { + /* + This was the last allocation. Lucky us, we can free + a bit of memory from the pool. Next time we will return from the same ptr. + */ + pool->arena->ptr = (char*)ptr + ZEND_MM_ALIGNED_SIZE(size); } else { - zend_uchar *new_ptr = mnd_erealloc(chunk->ptr, size); - if (!new_ptr) { - DBG_RETURN(FAIL); - } - chunk->ptr = new_ptr; + void *new_ptr = mysqlnd_arena_alloc(&pool->arena, size); + memcpy(new_ptr, ptr, MIN(old_size, size)); + pool->last = ptr = new_ptr; } - DBG_RETURN(PASS); + DBG_RETURN(ptr); } /* }}} */ /* {{{ mysqlnd_mempool_get_chunk */ -static -MYSQLND_MEMORY_POOL_CHUNK * mysqlnd_mempool_get_chunk(MYSQLND_MEMORY_POOL * pool, unsigned int size) +static void * +mysqlnd_mempool_get_chunk(MYSQLND_MEMORY_POOL * pool, size_t size) { - MYSQLND_MEMORY_POOL_CHUNK *chunk = NULL; + void *ptr = NULL; DBG_ENTER("mysqlnd_mempool_get_chunk"); - chunk = mnd_emalloc(sizeof(MYSQLND_MEMORY_POOL_CHUNK)); - if (chunk) { - chunk->size = size; - /* - Should not go over MYSQLND_MAX_PACKET_SIZE, since we - expect non-arena memory in mysqlnd_wireprotocol.c . We - realloc the non-arena memory. - */ - if (size > pool->free_size) { - chunk->from_pool = FALSE; - chunk->ptr = mnd_emalloc(size); - if (!chunk->ptr) { - pool->free_chunk(pool, chunk); - chunk = NULL; - } - } else { - chunk->from_pool = TRUE; - chunk->ptr = pool->arena + (pool->arena_size - pool->free_size); - /* Last step, update free_size */ - pool->free_size -= size; - } - } - DBG_RETURN(chunk); + ptr = mysqlnd_arena_alloc(&pool->arena, size); + pool->last = ptr; + + DBG_RETURN(ptr); } /* }}} */ @@ -140,21 +157,18 @@ MYSQLND_MEMORY_POOL_CHUNK * mysqlnd_mempool_get_chunk(MYSQLND_MEMORY_POOL * pool PHPAPI MYSQLND_MEMORY_POOL * mysqlnd_mempool_create(size_t arena_size) { - /* We calloc, because we free(). We don't mnd_calloc() for a reason. */ - MYSQLND_MEMORY_POOL * ret = mnd_ecalloc(1, sizeof(MYSQLND_MEMORY_POOL)); + zend_arena * arena; + MYSQLND_MEMORY_POOL * ret; + DBG_ENTER("mysqlnd_mempool_create"); - if (ret) { - ret->get_chunk = mysqlnd_mempool_get_chunk; - ret->free_chunk = mysqlnd_mempool_free_chunk; - ret->resize_chunk = mysqlnd_mempool_resize_chunk; - ret->free_size = ret->arena_size = arena_size ? arena_size : 0; - /* OOM ? */ - ret->arena = mnd_emalloc(ret->arena_size); - if (!ret->arena) { - mysqlnd_mempool_destroy(ret); - ret = NULL; - } - } + arena = mysqlnd_arena_create(MAX(arena_size, sizeof(zend_arena))); + ret = mysqlnd_arena_alloc(&arena, sizeof(MYSQLND_MEMORY_POOL)); + ret->arena = arena; + ret->last = NULL; + ret->checkpoint = NULL; + ret->get_chunk = mysqlnd_mempool_get_chunk; + ret->free_chunk = mysqlnd_mempool_free_chunk; + ret->resize_chunk = mysqlnd_mempool_resize_chunk; DBG_RETURN(ret); } /* }}} */ @@ -166,12 +180,34 @@ mysqlnd_mempool_destroy(MYSQLND_MEMORY_POOL * pool) { DBG_ENTER("mysqlnd_mempool_destroy"); /* mnd_free will reference LOCK_access and might crash, depending on the caller...*/ - mnd_efree(pool->arena); - mnd_efree(pool); + mysqlnd_arena_destroy(pool->arena); DBG_VOID_RETURN; } /* }}} */ +/* {{{ mysqlnd_mempool_save_state */ +PHPAPI void +mysqlnd_mempool_save_state(MYSQLND_MEMORY_POOL * pool) +{ + DBG_ENTER("mysqlnd_mempool_save_state"); + pool->checkpoint = mysqlnd_arena_checkpoint(pool->arena); + DBG_VOID_RETURN; +} +/* }}} */ + +/* {{{ mysqlnd_mempool_restore_state */ +PHPAPI void +mysqlnd_mempool_restore_state(MYSQLND_MEMORY_POOL * pool) +{ + DBG_ENTER("mysqlnd_mempool_restore_state"); + if (pool->checkpoint) { + mysqlnd_arena_release(&pool->arena, pool->checkpoint); + pool->last = NULL; + pool->checkpoint = NULL; + } + DBG_VOID_RETURN; +} +/* }}} */ /* * Local variables: diff --git a/ext/mysqlnd/mysqlnd_block_alloc.h b/ext/mysqlnd/mysqlnd_block_alloc.h index 074cd55e16..f3adde5af0 100644 --- a/ext/mysqlnd/mysqlnd_block_alloc.h +++ b/ext/mysqlnd/mysqlnd_block_alloc.h @@ -22,6 +22,8 @@ PHPAPI MYSQLND_MEMORY_POOL * mysqlnd_mempool_create(size_t arena_size); PHPAPI void mysqlnd_mempool_destroy(MYSQLND_MEMORY_POOL * pool); +PHPAPI void mysqlnd_mempool_save_state(MYSQLND_MEMORY_POOL * pool); +PHPAPI void mysqlnd_mempool_restore_state(MYSQLND_MEMORY_POOL * pool); #endif /* MYSQLND_BLOCK_ALLOC_H */ diff --git a/ext/mysqlnd/mysqlnd_commands.c b/ext/mysqlnd/mysqlnd_commands.c index 4a43888c82..21b95a8f57 100644 --- a/ext/mysqlnd/mysqlnd_commands.c +++ b/ext/mysqlnd/mysqlnd_commands.c @@ -29,28 +29,16 @@ struct st_mysqlnd_protocol_no_params_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_protocol_no_params_command_context { MYSQLND_CONN_DATA * conn; } context; }; -/* {{{ mysqlnd_com_no_params_free_command */ -static void -mysqlnd_com_no_params_free_command(void * command) -{ - DBG_ENTER("mysqlnd_com_no_params_free_command"); - mnd_efree(command); - DBG_VOID_RETURN; -} -/* }}} */ - /************************** COM_SET_OPTION ******************************************/ struct st_mysqlnd_protocol_com_set_option_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_set_option_context { MYSQLND_CONN_DATA * conn; @@ -60,7 +48,7 @@ struct st_mysqlnd_protocol_com_set_option_command /* {{{ mysqlnd_com_set_option_run */ -enum_func_status +static enum_func_status mysqlnd_com_set_option_run(void *cmd) { struct st_mysqlnd_protocol_com_set_option_command * command = (struct st_mysqlnd_protocol_com_set_option_command *) cmd; @@ -83,29 +71,27 @@ mysqlnd_com_set_option_run(void *cmd) conn); if (PASS == ret) { ret = send_command_handle_response(conn->payload_decoder_factory, PROT_EOF_PACKET, FALSE, COM_SET_OPTION, TRUE, - conn->error_info, conn->upsert_status, &conn->last_message, conn->persistent); + conn->error_info, conn->upsert_status, &conn->last_message); } DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_com_set_option_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_set_option_create_command(va_list args) +/* {{{ mysqlnd_com_set_option_run_command */ +static enum_func_status +mysqlnd_com_set_option_run_command(va_list args) { - struct st_mysqlnd_protocol_com_set_option_command * command; - DBG_ENTER("mysqlnd_com_set_option_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_set_option_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->context.option = va_arg(args, enum_mysqlnd_server_option); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_set_option_run; - } + struct st_mysqlnd_protocol_com_set_option_command command; + enum_func_status ret; - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + DBG_ENTER("mysqlnd_com_set_option_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + command.context.option = va_arg(args, enum_mysqlnd_server_option); + + ret = mysqlnd_com_set_option_run(&command); + + DBG_RETURN(ret); } /* }}} */ @@ -132,7 +118,7 @@ mysqlnd_com_debug_run(void *cmd) conn); if (PASS == ret) { ret = send_command_handle_response(conn->payload_decoder_factory, PROT_EOF_PACKET, FALSE, COM_DEBUG, TRUE, - conn->error_info, conn->upsert_status, &conn->last_message, conn->persistent); + conn->error_info, conn->upsert_status, &conn->last_message); } DBG_RETURN(ret); @@ -140,21 +126,19 @@ mysqlnd_com_debug_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_debug_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_debug_create_command(va_list args) +/* {{{ mysqlnd_com_debug_run_command */ +static enum_func_status +mysqlnd_com_debug_run_command(va_list args) { - struct st_mysqlnd_protocol_no_params_command * command; - DBG_ENTER("mysqlnd_com_debug_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_no_params_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->parent.free_command = mysqlnd_com_no_params_free_command; - - command->parent.run = mysqlnd_com_debug_run; - } + struct st_mysqlnd_protocol_no_params_command command; + enum_func_status ret; + + DBG_ENTER("mysqlnd_com_debug_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + + ret = mysqlnd_com_debug_run(&command); - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + DBG_RETURN(ret); } /* }}} */ @@ -162,7 +146,6 @@ mysqlnd_com_debug_create_command(va_list args) /************************** COM_INIT_DB ******************************************/ struct st_mysqlnd_protocol_com_init_db_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_init_db_context { MYSQLND_CONN_DATA * conn; @@ -193,7 +176,7 @@ mysqlnd_com_init_db_run(void *cmd) conn); if (PASS == ret) { ret = send_command_handle_response(conn->payload_decoder_factory, PROT_OK_PACKET, FALSE, COM_INIT_DB, TRUE, - conn->error_info, conn->upsert_status, &conn->last_message, conn->persistent); + conn->error_info, conn->upsert_status, &conn->last_message); } /* @@ -219,22 +202,20 @@ mysqlnd_com_init_db_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_init_db_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_init_db_create_command(va_list args) +/* {{{ mysqlnd_com_init_db_run_command */ +static enum_func_status +mysqlnd_com_init_db_run_command(va_list args) { - struct st_mysqlnd_protocol_com_init_db_command * command; - DBG_ENTER("mysqlnd_com_init_db_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_init_db_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->context.db = va_arg(args, MYSQLND_CSTRING); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_init_db_run; - } + struct st_mysqlnd_protocol_com_init_db_command command; + enum_func_status ret; + + DBG_ENTER("mysqlnd_com_init_db_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + command.context.db = va_arg(args, MYSQLND_CSTRING); - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + ret = mysqlnd_com_init_db_run(&command); + + DBG_RETURN(ret); } /* }}} */ @@ -261,7 +242,7 @@ mysqlnd_com_ping_run(void *cmd) conn); if (PASS == ret) { ret = send_command_handle_response(conn->payload_decoder_factory, PROT_OK_PACKET, TRUE, COM_PING, TRUE, - conn->error_info, conn->upsert_status, &conn->last_message, conn->persistent); + conn->error_info, conn->upsert_status, &conn->last_message); } /* The server sends 0 but libmysql doesn't read it and has established @@ -274,21 +255,19 @@ mysqlnd_com_ping_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_ping_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_ping_create_command(va_list args) +/* {{{ mysqlnd_com_ping_run_command */ +static enum_func_status +mysqlnd_com_ping_run_command(va_list args) { - struct st_mysqlnd_protocol_no_params_command * command; - DBG_ENTER("mysqlnd_com_ping_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_no_params_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->parent.free_command = mysqlnd_com_no_params_free_command; - - command->parent.run = mysqlnd_com_ping_run; - } + struct st_mysqlnd_protocol_no_params_command command; + enum_func_status ret; + + DBG_ENTER("mysqlnd_com_ping_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + ret = mysqlnd_com_ping_run(&command); + + DBG_RETURN(ret); } /* }}} */ @@ -296,7 +275,6 @@ mysqlnd_com_ping_create_command(va_list args) /************************** COM_STATISTICS ******************************************/ struct st_mysqlnd_protocol_com_statistics_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_statistics_context { MYSQLND_CONN_DATA * conn; @@ -326,17 +304,15 @@ mysqlnd_com_statistics_run(void *cmd) conn); if (PASS == ret) { - MYSQLND_PACKET_STATS * stats_header = conn->payload_decoder_factory->m.get_stats_packet(conn->payload_decoder_factory, FALSE); - if (!stats_header) { - SET_OOM_ERROR(conn->error_info); - } else { - if (PASS == (ret = PACKET_READ(stats_header))) { - /* will be freed by Zend, thus don't use the mnd_ allocator */ - *message = zend_string_init(stats_header->message.s, stats_header->message.l, 0); - DBG_INF(ZSTR_VAL(*message)); - } - PACKET_FREE(stats_header); + MYSQLND_PACKET_STATS stats_header; + + conn->payload_decoder_factory->m.init_stats_packet(&stats_header); + if (PASS == (ret = PACKET_READ(conn, &stats_header))) { + /* will be freed by Zend, thus don't use the mnd_ allocator */ + *message = zend_string_init(stats_header.message.s, stats_header.message.l, 0); + DBG_INF(ZSTR_VAL(*message)); } + PACKET_FREE(&stats_header); } DBG_RETURN(ret); @@ -344,29 +320,26 @@ mysqlnd_com_statistics_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_statistics_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_statistics_create_command(va_list args) +/* {{{ mysqlnd_com_statistics_run_command */ +static enum_func_status +mysqlnd_com_statistics_run_command(va_list args) { - struct st_mysqlnd_protocol_com_statistics_command * command; - DBG_ENTER("mysqlnd_com_statistics_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_statistics_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->context.message = va_arg(args, zend_string **); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_statistics_run; - } + struct st_mysqlnd_protocol_com_statistics_command command; + enum_func_status ret; + + DBG_ENTER("mysqlnd_com_statistics_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + command.context.message = va_arg(args, zend_string **); - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + ret = mysqlnd_com_statistics_run(&command); + + DBG_RETURN(ret); } /* }}} */ /************************** COM_PROCESS_KILL ******************************************/ struct st_mysqlnd_protocol_com_process_kill_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_process_kill_context { MYSQLND_CONN_DATA * conn; @@ -400,7 +373,7 @@ mysqlnd_com_process_kill_run(void *cmd) conn); if (PASS == ret && read_response) { ret = send_command_handle_response(conn->payload_decoder_factory, PROT_OK_PACKET, FALSE, COM_PROCESS_KILL, TRUE, - conn->error_info, conn->upsert_status, &conn->last_message, conn->persistent); + conn->error_info, conn->upsert_status, &conn->last_message); } if (read_response) { @@ -419,30 +392,27 @@ mysqlnd_com_process_kill_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_process_kill_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_process_kill_create_command(va_list args) +/* {{{ mysqlnd_com_process_kill_run_command */ +static enum_func_status +mysqlnd_com_process_kill_run_command(va_list args) { - struct st_mysqlnd_protocol_com_process_kill_command * command; - DBG_ENTER("mysqlnd_com_process_kill_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_process_kill_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->context.process_id = va_arg(args, unsigned int); - command->context.read_response = va_arg(args, unsigned int)? TRUE:FALSE; - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_process_kill_run; - } + struct st_mysqlnd_protocol_com_process_kill_command command; + enum_func_status ret; + + DBG_ENTER("mysqlnd_com_process_kill_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + command.context.process_id = va_arg(args, unsigned int); + command.context.read_response = va_arg(args, unsigned int)? TRUE:FALSE; - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + ret = mysqlnd_com_process_kill_run(&command); + + DBG_RETURN(ret); } /* }}} */ /************************** COM_REFRESH ******************************************/ struct st_mysqlnd_protocol_com_refresh_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_refresh_context { MYSQLND_CONN_DATA * conn; @@ -474,7 +444,7 @@ mysqlnd_com_refresh_run(void *cmd) conn); if (PASS == ret) { ret = send_command_handle_response(conn->payload_decoder_factory, PROT_OK_PACKET, FALSE, COM_REFRESH, TRUE, - conn->error_info, conn->upsert_status, &conn->last_message, conn->persistent); + conn->error_info, conn->upsert_status, &conn->last_message); } DBG_RETURN(ret); @@ -482,22 +452,20 @@ mysqlnd_com_refresh_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_refresh_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_refresh_create_command(va_list args) +/* {{{ mysqlnd_com_refresh_run_command */ +static enum_func_status +mysqlnd_com_refresh_run_command(va_list args) { - struct st_mysqlnd_protocol_com_refresh_command * command; - DBG_ENTER("mysqlnd_com_refresh_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_refresh_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->context.options = va_arg(args, unsigned int); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_refresh_run; - } + struct st_mysqlnd_protocol_com_refresh_command command; + enum_func_status ret; + + DBG_ENTER("mysqlnd_com_refresh_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + command.context.options = va_arg(args, unsigned int); - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + ret = mysqlnd_com_refresh_run(&command); + + DBG_RETURN(ret); } /* }}} */ @@ -505,7 +473,6 @@ mysqlnd_com_refresh_create_command(va_list args) /************************** COM_SHUTDOWN ******************************************/ struct st_mysqlnd_protocol_com_shutdown_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_shutdown_context { MYSQLND_CONN_DATA * conn; @@ -537,7 +504,7 @@ mysqlnd_com_shutdown_run(void *cmd) conn); if (PASS == ret) { ret = send_command_handle_response(conn->payload_decoder_factory, PROT_OK_PACKET, FALSE, COM_SHUTDOWN, TRUE, - conn->error_info, conn->upsert_status, &conn->last_message, conn->persistent); + conn->error_info, conn->upsert_status, &conn->last_message); } DBG_RETURN(ret); @@ -545,22 +512,20 @@ mysqlnd_com_shutdown_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_shutdown_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_shutdown_create_command(va_list args) +/* {{{ mysqlnd_com_shutdown_run_command */ +static enum_func_status +mysqlnd_com_shutdown_run_command(va_list args) { - struct st_mysqlnd_protocol_com_shutdown_command * command; - DBG_ENTER("mysqlnd_com_shutdown_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_shutdown_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->context.level = va_arg(args, unsigned int); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_shutdown_run; - } + struct st_mysqlnd_protocol_com_shutdown_command command; + enum_func_status ret; - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + DBG_ENTER("mysqlnd_com_shutdown_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + command.context.level = va_arg(args, unsigned int); + + ret = mysqlnd_com_shutdown_run(&command); + + DBG_RETURN(ret); } /* }}} */ @@ -568,7 +533,6 @@ mysqlnd_com_shutdown_create_command(va_list args) /************************** COM_QUIT ******************************************/ struct st_mysqlnd_protocol_com_quit_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_quit_context { MYSQLND_CONN_DATA * conn; @@ -600,28 +564,25 @@ mysqlnd_com_quit_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_quit_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_quit_create_command(va_list args) +/* {{{ mysqlnd_com_quit_run_command */ +static enum_func_status +mysqlnd_com_quit_run_command(va_list args) { - struct st_mysqlnd_protocol_com_quit_command * command; - DBG_ENTER("mysqlnd_com_quit_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_quit_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_quit_run; - } + struct st_mysqlnd_protocol_com_quit_command command; + enum_func_status ret; + + DBG_ENTER("mysqlnd_com_quit_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + + ret = mysqlnd_com_quit_run(&command); - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + DBG_RETURN(ret); } /* }}} */ /************************** COM_QUERY ******************************************/ struct st_mysqlnd_protocol_com_query_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_query_context { MYSQLND_CONN_DATA * conn; @@ -658,29 +619,26 @@ mysqlnd_com_query_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_query_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_query_create_command(va_list args) +/* {{{ mysqlnd_com_query_run_command */ +static enum_func_status +mysqlnd_com_query_run_command(va_list args) { - struct st_mysqlnd_protocol_com_query_command * command; - DBG_ENTER("mysqlnd_com_query_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_query_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->context.query = va_arg(args, MYSQLND_CSTRING); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_query_run; - } + struct st_mysqlnd_protocol_com_query_command command; + enum_func_status ret; - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + DBG_ENTER("mysqlnd_com_query_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + command.context.query = va_arg(args, MYSQLND_CSTRING); + + ret = mysqlnd_com_query_run(&command); + + DBG_RETURN(ret); } /* }}} */ /************************** COM_CHANGE_USER ******************************************/ struct st_mysqlnd_protocol_com_change_user_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_change_user_context { MYSQLND_CONN_DATA * conn; @@ -714,23 +672,21 @@ mysqlnd_com_change_user_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_change_user_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_change_user_create_command(va_list args) +/* {{{ mysqlnd_com_change_user_run_command */ +static enum_func_status +mysqlnd_com_change_user_run_command(va_list args) { - struct st_mysqlnd_protocol_com_change_user_command * command; - DBG_ENTER("mysqlnd_com_change_user_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_change_user_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->context.payload = va_arg(args, MYSQLND_CSTRING); - command->context.silent = va_arg(args, unsigned int); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_change_user_run; - } + struct st_mysqlnd_protocol_com_change_user_command command; + enum_func_status ret; + + DBG_ENTER("mysqlnd_com_change_user_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + command.context.payload = va_arg(args, MYSQLND_CSTRING); + command.context.silent = va_arg(args, unsigned int); - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + ret = mysqlnd_com_change_user_run(&command); + + DBG_RETURN(ret); } /* }}} */ @@ -738,7 +694,6 @@ mysqlnd_com_change_user_create_command(va_list args) /************************** COM_REAP_RESULT ******************************************/ struct st_mysqlnd_protocol_com_reap_result_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_reap_result_context { MYSQLND_CONN_DATA * conn; @@ -768,21 +723,19 @@ mysqlnd_com_reap_result_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_reap_result_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_reap_result_create_command(va_list args) +/* {{{ mysqlnd_com_reap_result_run_command */ +static enum_func_status +mysqlnd_com_reap_result_run_command(va_list args) { - struct st_mysqlnd_protocol_com_reap_result_command * command; - DBG_ENTER("mysqlnd_com_reap_result_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_reap_result_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_reap_result_run; - } + struct st_mysqlnd_protocol_com_reap_result_command command; + enum_func_status ret; + + DBG_ENTER("mysqlnd_com_reap_result_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + + ret = mysqlnd_com_reap_result_run(&command); - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + DBG_RETURN(ret); } /* }}} */ @@ -790,7 +743,6 @@ mysqlnd_com_reap_result_create_command(va_list args) /************************** COM_STMT_PREPARE ******************************************/ struct st_mysqlnd_protocol_com_stmt_prepare_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_stmt_prepare_context { MYSQLND_CONN_DATA * conn; @@ -823,22 +775,20 @@ mysqlnd_com_stmt_prepare_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_stmt_prepare_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_stmt_prepare_create_command(va_list args) +/* {{{ mysqlnd_com_stmt_prepare_run_command */ +static enum_func_status +mysqlnd_com_stmt_prepare_run_command(va_list args) { - struct st_mysqlnd_protocol_com_stmt_prepare_command * command; - DBG_ENTER("mysqlnd_com_stmt_prepare_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_stmt_prepare_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->context.query = va_arg(args, MYSQLND_CSTRING); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_stmt_prepare_run; - } + struct st_mysqlnd_protocol_com_stmt_prepare_command command; + enum_func_status ret; - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + DBG_ENTER("mysqlnd_com_stmt_prepare_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + command.context.query = va_arg(args, MYSQLND_CSTRING); + + ret = mysqlnd_com_stmt_prepare_run(&command); + + DBG_RETURN(ret); } /* }}} */ @@ -846,7 +796,6 @@ mysqlnd_com_stmt_prepare_create_command(va_list args) /************************** COM_STMT_EXECUTE ******************************************/ struct st_mysqlnd_protocol_com_stmt_execute_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_stmt_execute_context { MYSQLND_CONN_DATA * conn; @@ -879,22 +828,20 @@ mysqlnd_com_stmt_execute_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_stmt_execute_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_stmt_execute_create_command(va_list args) +/* {{{ mysqlnd_com_stmt_execute_run_command */ +static enum_func_status +mysqlnd_com_stmt_execute_run_command(va_list args) { - struct st_mysqlnd_protocol_com_stmt_execute_command * command; - DBG_ENTER("mysqlnd_com_stmt_execute_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_stmt_execute_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->context.payload = va_arg(args, MYSQLND_CSTRING); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_stmt_execute_run; - } + struct st_mysqlnd_protocol_com_stmt_execute_command command; + enum_func_status ret; + + DBG_ENTER("mysqlnd_com_stmt_execute_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + command.context.payload = va_arg(args, MYSQLND_CSTRING); + + ret = mysqlnd_com_stmt_execute_run(&command); - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + DBG_RETURN(ret); } /* }}} */ @@ -902,7 +849,6 @@ mysqlnd_com_stmt_execute_create_command(va_list args) /************************** COM_STMT_FETCH ******************************************/ struct st_mysqlnd_protocol_com_stmt_fetch_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_stmt_fetch_context { MYSQLND_CONN_DATA * conn; @@ -935,22 +881,20 @@ mysqlnd_com_stmt_fetch_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_stmt_fetch_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_stmt_fetch_create_command(va_list args) +/* {{{ mysqlnd_com_stmt_fetch_run_command */ +static enum_func_status +mysqlnd_com_stmt_fetch_run_command(va_list args) { - struct st_mysqlnd_protocol_com_stmt_fetch_command * command; - DBG_ENTER("mysqlnd_com_stmt_fetch_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_stmt_fetch_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->context.payload = va_arg(args, MYSQLND_CSTRING); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_stmt_fetch_run; - } + struct st_mysqlnd_protocol_com_stmt_fetch_command command; + enum_func_status ret; + + DBG_ENTER("mysqlnd_com_stmt_fetch_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + command.context.payload = va_arg(args, MYSQLND_CSTRING); - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + ret = mysqlnd_com_stmt_fetch_run(&command); + + DBG_RETURN(ret); } /* }}} */ @@ -958,7 +902,6 @@ mysqlnd_com_stmt_fetch_create_command(va_list args) /************************** COM_STMT_RESET ******************************************/ struct st_mysqlnd_protocol_com_stmt_reset_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_stmt_reset_context { MYSQLND_CONN_DATA * conn; @@ -990,7 +933,7 @@ mysqlnd_com_stmt_reset_run(void *cmd) conn); if (PASS == ret) { ret = send_command_handle_response(conn->payload_decoder_factory, PROT_OK_PACKET, FALSE, COM_STMT_RESET, TRUE, - conn->error_info, conn->upsert_status, &conn->last_message, conn->persistent); + conn->error_info, conn->upsert_status, &conn->last_message); } DBG_RETURN(ret); @@ -998,22 +941,20 @@ mysqlnd_com_stmt_reset_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_stmt_reset_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_stmt_reset_create_command(va_list args) +/* {{{ mysqlnd_com_stmt_reset_run_command */ +static enum_func_status +mysqlnd_com_stmt_reset_run_command(va_list args) { - struct st_mysqlnd_protocol_com_stmt_reset_command * command; - DBG_ENTER("mysqlnd_com_stmt_reset_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_stmt_reset_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->context.stmt_id = va_arg(args, size_t); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_stmt_reset_run; - } + struct st_mysqlnd_protocol_com_stmt_reset_command command; + enum_func_status ret; + + DBG_ENTER("mysqlnd_com_stmt_reset_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + command.context.stmt_id = va_arg(args, size_t); - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + ret = mysqlnd_com_stmt_reset_run(&command); + + DBG_RETURN(ret); } /* }}} */ @@ -1021,7 +962,6 @@ mysqlnd_com_stmt_reset_create_command(va_list args) /************************** COM_STMT_SEND_LONG_DATA ******************************************/ struct st_mysqlnd_protocol_com_stmt_send_long_data_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_stmt_send_long_data_context { MYSQLND_CONN_DATA * conn; @@ -1054,22 +994,20 @@ mysqlnd_com_stmt_send_long_data_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_stmt_send_long_data_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_stmt_send_long_data_create_command(va_list args) +/* {{{ mysqlnd_com_stmt_send_long_data_run_command */ +static enum_func_status +mysqlnd_com_stmt_send_long_data_run_command(va_list args) { - struct st_mysqlnd_protocol_com_stmt_send_long_data_command * command; - DBG_ENTER("mysqlnd_com_stmt_send_long_data_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_stmt_send_long_data_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->context.payload = va_arg(args, MYSQLND_CSTRING); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_stmt_send_long_data_run; - } + struct st_mysqlnd_protocol_com_stmt_send_long_data_command command; + enum_func_status ret; + + DBG_ENTER("mysqlnd_com_stmt_send_long_data_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + command.context.payload = va_arg(args, MYSQLND_CSTRING); - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + ret = mysqlnd_com_stmt_send_long_data_run(&command); + + DBG_RETURN(ret); } /* }}} */ @@ -1077,7 +1015,6 @@ mysqlnd_com_stmt_send_long_data_create_command(va_list args) /************************** COM_STMT_CLOSE ******************************************/ struct st_mysqlnd_protocol_com_stmt_close_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_stmt_close_context { MYSQLND_CONN_DATA * conn; @@ -1112,22 +1049,20 @@ mysqlnd_com_stmt_close_run(void *cmd) /* }}} */ -/* {{{ mysqlnd_com_stmt_close_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_stmt_close_create_command(va_list args) +/* {{{ mysqlnd_com_stmt_close_run_command */ +static enum_func_status +mysqlnd_com_stmt_close_run_command(va_list args) { - struct st_mysqlnd_protocol_com_stmt_close_command * command; - DBG_ENTER("mysqlnd_com_stmt_close_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_stmt_close_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->context.stmt_id = va_arg(args, size_t); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_stmt_close_run; - } + struct st_mysqlnd_protocol_com_stmt_close_command command; + enum_func_status ret; - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + DBG_ENTER("mysqlnd_com_stmt_close_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + command.context.stmt_id = va_arg(args, size_t); + + ret = mysqlnd_com_stmt_close_run(&command); + + DBG_RETURN(ret); } /* }}} */ @@ -1136,7 +1071,6 @@ mysqlnd_com_stmt_close_create_command(va_list args) /************************** COM_ENABLE_SSL ******************************************/ struct st_mysqlnd_protocol_com_enable_ssl_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_enable_ssl_context { MYSQLND_CONN_DATA * conn; @@ -1154,7 +1088,7 @@ mysqlnd_com_enable_ssl_run(void *cmd) struct st_mysqlnd_protocol_com_enable_ssl_command * command = (struct st_mysqlnd_protocol_com_enable_ssl_command *) cmd; enum_func_status ret = FAIL; MYSQLND_CONN_DATA * conn = command->context.conn; - MYSQLND_PACKET_AUTH * auth_packet; + MYSQLND_PACKET_AUTH auth_packet; size_t client_capabilities = command->context.client_capabilities; size_t server_capabilities = command->context.server_capabilities; @@ -1185,15 +1119,11 @@ mysqlnd_com_enable_ssl_run(void *cmd) DBG_INF_FMT("CLIENT_SSL_VERIFY_SERVER_CERT= %d", client_capabilities & CLIENT_SSL_VERIFY_SERVER_CERT? 1:0); DBG_INF_FMT("CLIENT_REMEMBER_OPTIONS= %d", client_capabilities & CLIENT_REMEMBER_OPTIONS? 1:0); - auth_packet = conn->payload_decoder_factory->m.get_auth_packet(conn->payload_decoder_factory, FALSE); - if (!auth_packet) { - SET_OOM_ERROR(conn->error_info); - goto end; - } - auth_packet->client_flags = client_capabilities; - auth_packet->max_packet_size = MYSQLND_ASSEMBLED_PACKET_MAX_SIZE; + conn->payload_decoder_factory->m.init_auth_packet(&auth_packet); + auth_packet.client_flags = client_capabilities; + auth_packet.max_packet_size = MYSQLND_ASSEMBLED_PACKET_MAX_SIZE; - auth_packet->charset_no = command->context.charset_no; + auth_packet.charset_no = command->context.charset_no; #ifdef MYSQLND_SSL_SUPPORTED if (client_capabilities & CLIENT_SSL) { @@ -1207,7 +1137,7 @@ mysqlnd_com_enable_ssl_run(void *cmd) MYSQLND_SSL_PEER_DONT_VERIFY: MYSQLND_SSL_PEER_DEFAULT); DBG_INF("Switching to SSL"); - if (!PACKET_WRITE(auth_packet)) { + if (!PACKET_WRITE(conn, &auth_packet)) { goto close_conn; } @@ -1219,51 +1149,48 @@ mysqlnd_com_enable_ssl_run(void *cmd) } } #else - auth_packet->client_flags &= ~CLIENT_SSL; - if (!PACKET_WRITE(auth_packet)) { + auth_packet.client_flags &= ~CLIENT_SSL; + if (!PACKET_WRITE(conn, &auth_packet)) { goto close_conn; } #endif ret = PASS; end: - PACKET_FREE(auth_packet); + PACKET_FREE(&auth_packet); DBG_RETURN(ret); close_conn: SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT); conn->m->send_close(conn); SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone); - PACKET_FREE(auth_packet); + PACKET_FREE(&auth_packet); DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_com_enable_ssl_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_enable_ssl_create_command(va_list args) +/* {{{ mysqlnd_com_enable_ssl_run_command */ +static enum_func_status +mysqlnd_com_enable_ssl_run_command(va_list args) { - struct st_mysqlnd_protocol_com_enable_ssl_command * command; - DBG_ENTER("mysqlnd_com_enable_ssl_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_enable_ssl_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->context.client_capabilities = va_arg(args, size_t); - command->context.server_capabilities = va_arg(args, size_t); - command->context.charset_no = va_arg(args, unsigned int); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_enable_ssl_run; - } + struct st_mysqlnd_protocol_com_enable_ssl_command command; + enum_func_status ret; + + DBG_ENTER("mysqlnd_com_enable_ssl_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + command.context.client_capabilities = va_arg(args, size_t); + command.context.server_capabilities = va_arg(args, size_t); + command.context.charset_no = va_arg(args, unsigned int); - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + ret = mysqlnd_com_enable_ssl_run(&command); + + DBG_RETURN(ret); } /* }}} */ /************************** COM_READ_HANDSHAKE ******************************************/ struct st_mysqlnd_protocol_com_handshake_command { - struct st_mysqlnd_protocol_command parent; struct st_mysqlnd_com_handshake_context { MYSQLND_CONN_DATA * conn; @@ -1291,164 +1218,158 @@ mysqlnd_com_handshake_run(void *cmd) size_t mysql_flags = command->context.client_flags; MYSQLND_CONN_DATA * conn = command->context.conn; - MYSQLND_PACKET_GREET * greet_packet; + MYSQLND_PACKET_GREET greet_packet; DBG_ENTER("mysqlnd_conn_data::connect_handshake"); DBG_INF_FMT("stream=%p", conn->vio->data->m.get_stream(conn->vio)); DBG_INF_FMT("[user=%s] [db=%s:%d] [flags=%llu]", user, db, db_len, mysql_flags); - greet_packet = conn->payload_decoder_factory->m.get_greet_packet(conn->payload_decoder_factory, FALSE); - if (!greet_packet) { - SET_OOM_ERROR(conn->error_info); - DBG_RETURN(FAIL); /* OOM */ - } + conn->payload_decoder_factory->m.init_greet_packet(&greet_packet); - if (FAIL == PACKET_READ(greet_packet)) { + if (FAIL == PACKET_READ(conn, &greet_packet)) { DBG_ERR("Error while reading greeting packet"); php_error_docref(NULL, E_WARNING, "Error while reading greeting packet. PID=%d", getpid()); 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); + } 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); 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); + } 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, E_WARNING, "Connecting to 3.22, 3.23 & 4.0 " - " is not supported. Server is %-.32s", greet_packet->server_version); + " is not supported. Server is %-.32s", greet_packet.server_version); 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; } - conn->thread_id = greet_packet->thread_id; - conn->protocol_version = greet_packet->protocol_version; - conn->server_version = mnd_pestrdup(greet_packet->server_version, conn->persistent); + conn->thread_id = greet_packet.thread_id; + conn->protocol_version = greet_packet.protocol_version; + conn->server_version = mnd_pestrdup(greet_packet.server_version, conn->persistent); - conn->greet_charset = mysqlnd_find_charset_nr(greet_packet->charset_no); + conn->greet_charset = mysqlnd_find_charset_nr(greet_packet.charset_no); if (!conn->greet_charset) { php_error_docref(NULL, E_WARNING, - "Server sent charset (%d) unknown to the client. Please, report to the developers", greet_packet->charset_no); + "Server sent charset (%d) unknown to the client. Please, report to the developers", greet_packet.charset_no); SET_CLIENT_ERROR(conn->error_info, CR_NOT_IMPLEMENTED, UNKNOWN_SQLSTATE, "Server sent charset unknown to the client. Please, report to the developers"); goto err; } - conn->server_capabilities = greet_packet->server_capabilities; + conn->server_capabilities = greet_packet.server_capabilities; if (FAIL == mysqlnd_connect_run_authentication(conn, user, passwd, db, db_len, (size_t) passwd_len, - greet_packet->authentication_plugin_data, greet_packet->auth_protocol, - greet_packet->charset_no, greet_packet->server_capabilities, + greet_packet.authentication_plugin_data, greet_packet.auth_protocol, + greet_packet.charset_no, greet_packet.server_capabilities, conn->options, mysql_flags)) { goto err; } UPSERT_STATUS_RESET(conn->upsert_status); - UPSERT_STATUS_SET_SERVER_STATUS(conn->upsert_status, greet_packet->server_status); + UPSERT_STATUS_SET_SERVER_STATUS(conn->upsert_status, greet_packet.server_status); - PACKET_FREE(greet_packet); + PACKET_FREE(&greet_packet); DBG_RETURN(PASS); err: conn->server_capabilities = 0; - PACKET_FREE(greet_packet); + PACKET_FREE(&greet_packet); DBG_RETURN(FAIL); } /* }}} */ -/* {{{ mysqlnd_com_handshake_create_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_com_handshake_create_command(va_list args) +/* {{{ mysqlnd_com_handshake_run_command */ +static enum_func_status +mysqlnd_com_handshake_run_command(va_list args) { - struct st_mysqlnd_protocol_com_handshake_command * command; - DBG_ENTER("mysqlnd_com_handshake_create_command"); - command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_handshake_command)); - if (command) { - command->context.conn = va_arg(args, MYSQLND_CONN_DATA *); - command->context.user = *va_arg(args, const MYSQLND_CSTRING *); - command->context.passwd = *va_arg(args, const MYSQLND_CSTRING *); - command->context.database = *va_arg(args, const MYSQLND_CSTRING *); - command->context.client_flags = va_arg(args, size_t); - - command->parent.free_command = mysqlnd_com_no_params_free_command; - command->parent.run = mysqlnd_com_handshake_run; - } + struct st_mysqlnd_protocol_com_handshake_command command; + enum_func_status ret; + + DBG_ENTER("mysqlnd_com_handshake_run_command"); + command.context.conn = va_arg(args, MYSQLND_CONN_DATA *); + command.context.user = *va_arg(args, const MYSQLND_CSTRING *); + command.context.passwd = *va_arg(args, const MYSQLND_CSTRING *); + command.context.database = *va_arg(args, const MYSQLND_CSTRING *); + command.context.client_flags = va_arg(args, size_t); + + ret = mysqlnd_com_handshake_run(&command); - DBG_RETURN((struct st_mysqlnd_protocol_command *) command); + DBG_RETURN(ret); } /* }}} */ -/* {{{ mysqlnd_get_command */ -static struct st_mysqlnd_protocol_command * -mysqlnd_get_command(enum php_mysqlnd_server_command command, ...) +/* {{{ _mysqlnd_run_command */ +static enum_func_status +_mysqlnd_run_command(enum php_mysqlnd_server_command command, ...) { - struct st_mysqlnd_protocol_command * ret; + enum_func_status ret = FAIL; va_list args; - DBG_ENTER("mysqlnd_get_command"); + DBG_ENTER("_mysqlnd_run_command"); va_start(args, command); switch (command) { case COM_SET_OPTION: - ret = mysqlnd_com_set_option_create_command(args); + ret = mysqlnd_com_set_option_run_command(args); break; case COM_DEBUG: - ret = mysqlnd_com_debug_create_command(args); + ret = mysqlnd_com_debug_run_command(args); break; case COM_INIT_DB: - ret = mysqlnd_com_init_db_create_command(args); + ret = mysqlnd_com_init_db_run_command(args); break; case COM_PING: - ret = mysqlnd_com_ping_create_command(args); + ret = mysqlnd_com_ping_run_command(args); break; case COM_STATISTICS: - ret = mysqlnd_com_statistics_create_command(args); + ret = mysqlnd_com_statistics_run_command(args); break; case COM_PROCESS_KILL: - ret = mysqlnd_com_process_kill_create_command(args); + ret = mysqlnd_com_process_kill_run_command(args); break; case COM_REFRESH: - ret = mysqlnd_com_refresh_create_command(args); + ret = mysqlnd_com_refresh_run_command(args); break; case COM_SHUTDOWN: - ret = mysqlnd_com_shutdown_create_command(args); + ret = mysqlnd_com_shutdown_run_command(args); break; case COM_QUIT: - ret = mysqlnd_com_quit_create_command(args); + ret = mysqlnd_com_quit_run_command(args); break; case COM_QUERY: - ret = mysqlnd_com_query_create_command(args); + ret = mysqlnd_com_query_run_command(args); break; case COM_REAP_RESULT: - ret = mysqlnd_com_reap_result_create_command(args); + ret = mysqlnd_com_reap_result_run_command(args); break; case COM_CHANGE_USER: - ret = mysqlnd_com_change_user_create_command(args); + ret = mysqlnd_com_change_user_run_command(args); break; case COM_STMT_PREPARE: - ret = mysqlnd_com_stmt_prepare_create_command(args); + ret = mysqlnd_com_stmt_prepare_run_command(args); break; case COM_STMT_EXECUTE: - ret = mysqlnd_com_stmt_execute_create_command(args); + ret = mysqlnd_com_stmt_execute_run_command(args); break; case COM_STMT_FETCH: - ret = mysqlnd_com_stmt_fetch_create_command(args); + ret = mysqlnd_com_stmt_fetch_run_command(args); break; case COM_STMT_RESET: - ret = mysqlnd_com_stmt_reset_create_command(args); + ret = mysqlnd_com_stmt_reset_run_command(args); break; case COM_STMT_SEND_LONG_DATA: - ret = mysqlnd_com_stmt_send_long_data_create_command(args); + ret = mysqlnd_com_stmt_send_long_data_run_command(args); break; case COM_STMT_CLOSE: - ret = mysqlnd_com_stmt_close_create_command(args); + ret = mysqlnd_com_stmt_close_run_command(args); break; case COM_ENABLE_SSL: - ret = mysqlnd_com_enable_ssl_create_command(args); + ret = mysqlnd_com_enable_ssl_run_command(args); break; case COM_HANDSHAKE: - ret = mysqlnd_com_handshake_create_command(args); + ret = mysqlnd_com_handshake_run_command(args); break; default: break; @@ -1458,7 +1379,7 @@ mysqlnd_get_command(enum php_mysqlnd_server_command command, ...) } /* }}} */ -func_mysqlnd__command_factory mysqlnd_command_factory = mysqlnd_get_command; +func_mysqlnd__run_command mysqlnd_run_command = _mysqlnd_run_command; /* * Local variables: diff --git a/ext/mysqlnd/mysqlnd_commands.h b/ext/mysqlnd/mysqlnd_commands.h index bd335a3aab..86b4ccebb4 100644 --- a/ext/mysqlnd/mysqlnd_commands.h +++ b/ext/mysqlnd/mysqlnd_commands.h @@ -20,7 +20,7 @@ #ifndef MYSQLND_COMMANDS_H #define MYSQLND_COMMANDS_H -extern func_mysqlnd__command_factory mysqlnd_command_factory; +extern func_mysqlnd__run_command mysqlnd_run_command; #endif /* MYSQLND_COMMANDS_H */ diff --git a/ext/mysqlnd/mysqlnd_connection.c b/ext/mysqlnd/mysqlnd_connection.c index ea3d1cb0b7..1e21e46ed0 100644 --- a/ext/mysqlnd/mysqlnd_connection.c +++ b/ext/mysqlnd/mysqlnd_connection.c @@ -102,10 +102,8 @@ MYSQLND_METHOD(mysqlnd_error_info, reset)(MYSQLND_ERROR_INFO * const info) info->error_no = 0; info->error[0] = '\0'; - memset(info->sqlstate, 0, sizeof(info->sqlstate)); - if (info->error_list) { - zend_llist_clean(info->error_list); - } + memset(&info->sqlstate, 0, sizeof(info->sqlstate)); + zend_llist_clean(&info->error_list); DBG_VOID_RETURN; } @@ -121,19 +119,18 @@ MYSQLND_METHOD(mysqlnd_error_info, set_client_error)(MYSQLND_ERROR_INFO * const { DBG_ENTER("mysqlnd_error_info::set_client_error"); if (err_no) { + MYSQLND_ERROR_LIST_ELEMENT error_for_the_list = {0}; + info->error_no = err_no; strlcpy(info->sqlstate, sqlstate, sizeof(info->sqlstate)); strlcpy(info->error, error, sizeof(info->error)); - if (info->error_list) { - MYSQLND_ERROR_LIST_ELEMENT error_for_the_list = {0}; - - error_for_the_list.error_no = err_no; - strlcpy(error_for_the_list.sqlstate, sqlstate, sizeof(error_for_the_list.sqlstate)); - error_for_the_list.error = mnd_pestrdup(error, TRUE); - if (error_for_the_list.error) { - DBG_INF_FMT("adding error [%s] to the list", error_for_the_list.error); - zend_llist_add_element(info->error_list, &error_for_the_list); - } + + error_for_the_list.error_no = err_no; + strlcpy(error_for_the_list.sqlstate, sqlstate, sizeof(error_for_the_list.sqlstate)); + error_for_the_list.error = mnd_pestrdup(error, TRUE); + if (error_for_the_list.error) { + DBG_INF_FMT("adding error [%s] to the list", error_for_the_list.error); + zend_llist_add_element(&info->error_list, &error_for_the_list); } } else { info->m->reset(info); @@ -158,12 +155,9 @@ mysqlnd_error_info_init(MYSQLND_ERROR_INFO * const info, const zend_bool persist info->m = mysqlnd_error_info_get_methods(); info->m->reset(info); - info->error_list = mnd_pecalloc(1, sizeof(zend_llist), persistent); - if (info->error_list) { - zend_llist_init(info->error_list, sizeof(MYSQLND_ERROR_LIST_ELEMENT), (llist_dtor_func_t) mysqlnd_error_list_pdtor, persistent); - } + zend_llist_init(&info->error_list, sizeof(MYSQLND_ERROR_LIST_ELEMENT), (llist_dtor_func_t) mysqlnd_error_list_pdtor, persistent); info->persistent = persistent; - DBG_RETURN(info->error_list? PASS:FAIL); + DBG_RETURN(PASS); } /* }}} */ @@ -174,11 +168,6 @@ mysqlnd_error_info_free_contents(MYSQLND_ERROR_INFO * const info) { DBG_ENTER("mysqlnd_error_info_free_contents"); info->m->reset(info); - if (info->error_list) { - mnd_pefree(info->error_list, info->persistent); - info->error_list = NULL; - } - DBG_VOID_RETURN; } /* }}} */ @@ -329,7 +318,7 @@ MYSQLND_METHOD(mysqlnd_conn_data, free_contents)(MYSQLND_CONN_DATA * conn) conn->authentication_plugin_data.s = NULL; } if (conn->last_message.s) { - mnd_pefree(conn->last_message.s, pers); + mnd_efree(conn->last_message.s); conn->last_message.s = NULL; } @@ -390,12 +379,7 @@ MYSQLND_METHOD(mysqlnd_conn_data, set_server_option)(MYSQLND_CONN_DATA * const c enum_func_status ret = FAIL; DBG_ENTER("mysqlnd_conn_data::set_server_option"); if (PASS == conn->m->local_tx_start(conn, this_func)) { - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_SET_OPTION, conn, option); - if (command) { - ret = command->run(command); - command->free_command(command); - } - + ret = conn->run_command(COM_SET_OPTION, conn, option); conn->m->local_tx_end(conn, this_func, ret); } DBG_RETURN(ret); @@ -409,11 +393,8 @@ MYSQLND_METHOD(mysqlnd_conn_data, restart_psession)(MYSQLND_CONN_DATA * conn) { DBG_ENTER("mysqlnd_conn_data::restart_psession"); MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_CONNECT_REUSED); - /* Free here what should not be seen by the next script */ - if (conn->last_message.s) { - mnd_pefree(conn->last_message.s, conn->persistent); - conn->last_message.s = NULL; - } + conn->current_result = NULL; + conn->last_message.s = NULL; DBG_RETURN(PASS); } /* }}} */ @@ -424,6 +405,16 @@ static enum_func_status MYSQLND_METHOD(mysqlnd_conn_data, end_psession)(MYSQLND_CONN_DATA * conn) { DBG_ENTER("mysqlnd_conn_data::end_psession"); + /* Free here what should not be seen by the next script */ + if (conn->current_result) { + conn->current_result->m.free_result(conn->current_result, TRUE); + conn->current_result = NULL; + } + if (conn->last_message.s) { + mnd_efree(conn->last_message.s); + conn->last_message.s = NULL; + } + conn->error_info = &conn->error_info_impl; DBG_RETURN(PASS); } /* }}} */ @@ -539,11 +530,8 @@ MYSQLND_METHOD(mysqlnd_conn_data, connect_handshake)(MYSQLND_CONN_DATA * conn, PASS == conn->protocol_frame_codec->data->m.reset(conn->protocol_frame_codec, conn->stats, conn->error_info)) { size_t client_flags = mysql_flags; - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_HANDSHAKE, conn, username, password, database, client_flags); - if (command) { - ret = command->run(command); - command->free_command(command); - } + + ret = conn->run_command(COM_HANDSHAKE, conn, username, password, database, client_flags); } DBG_RETURN(ret); } @@ -884,11 +872,8 @@ MYSQLND_METHOD(mysqlnd_conn_data, send_query)(MYSQLND_CONN_DATA * conn, const ch if (type == MYSQLND_SEND_QUERY_IMPLICIT || PASS == conn->m->local_tx_start(conn, this_func)) { const MYSQLND_CSTRING query_string = {query, query_len}; - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_QUERY, conn, query_string); - if (command) { - ret = command->run(command); - command->free_command(command); - } + + ret = conn->run_command(COM_QUERY, conn, query_string); if (type == MYSQLND_SEND_QUERY_EXPLICIT) { conn->m->local_tx_end(conn, this_func, ret); @@ -912,11 +897,7 @@ MYSQLND_METHOD(mysqlnd_conn_data, reap_query)(MYSQLND_CONN_DATA * conn, enum_mys DBG_INF_FMT("conn->server_status=%u", UPSERT_STATUS_GET_SERVER_STATUS(conn->upsert_status)); if (type == MYSQLND_REAP_RESULT_IMPLICIT || PASS == conn->m->local_tx_start(conn, this_func)) { - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_REAP_RESULT, conn); - if (command) { - ret = command->run(command); - command->free_command(command); - } + ret = conn->run_command(COM_REAP_RESULT, conn); if (type == MYSQLND_REAP_RESULT_EXPLICIT) { conn->m->local_tx_end(conn, this_func, ret); @@ -1061,12 +1042,7 @@ MYSQLND_METHOD(mysqlnd_conn_data, dump_debug_info)(MYSQLND_CONN_DATA * const con DBG_ENTER("mysqlnd_conn_data::dump_debug_info"); DBG_INF_FMT("conn=%llu", conn->thread_id); if (PASS == conn->m->local_tx_start(conn, this_func)) { - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_DEBUG, conn); - if (command) { - ret = command->run(command); - command->free_command(command); - } - + ret = conn->run_command(COM_DEBUG, conn); conn->m->local_tx_end(conn, this_func, ret); } @@ -1087,12 +1063,8 @@ MYSQLND_METHOD(mysqlnd_conn_data, select_db)(MYSQLND_CONN_DATA * const conn, con if (PASS == conn->m->local_tx_start(conn, this_func)) { const MYSQLND_CSTRING database = {db, db_len}; - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_INIT_DB, conn, database); - if (command) { - ret = command->run(command); - command->free_command(command); - } + ret = conn->run_command(COM_INIT_DB, conn, database); conn->m->local_tx_end(conn, this_func, ret); } DBG_RETURN(ret); @@ -1111,11 +1083,7 @@ MYSQLND_METHOD(mysqlnd_conn_data, ping)(MYSQLND_CONN_DATA * const conn) DBG_INF_FMT("conn=%llu", conn->thread_id); if (PASS == conn->m->local_tx_start(conn, this_func)) { - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_PING, conn); - if (command) { - ret = command->run(command); - command->free_command(command); - } + ret = conn->run_command(COM_PING, conn); conn->m->local_tx_end(conn, this_func, ret); } DBG_INF_FMT("ret=%u", ret); @@ -1135,11 +1103,7 @@ MYSQLND_METHOD(mysqlnd_conn_data, statistic)(MYSQLND_CONN_DATA * conn, zend_stri DBG_INF_FMT("conn=%llu", conn->thread_id); if (PASS == conn->m->local_tx_start(conn, this_func)) { - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_STATISTICS, conn, message); - if (command) { - ret = command->run(command); - command->free_command(command); - } + ret = conn->run_command(COM_STATISTICS, conn, message); conn->m->local_tx_end(conn, this_func, ret); } DBG_RETURN(ret); @@ -1161,11 +1125,8 @@ MYSQLND_METHOD(mysqlnd_conn_data, kill)(MYSQLND_CONN_DATA * conn, unsigned int p unsigned int process_id = pid; /* 'unsigned char' is promoted to 'int' when passed through '...' */ unsigned int read_response = (pid != conn->thread_id); - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_PROCESS_KILL, conn, process_id, read_response); - if (command) { - ret = command->run(command); - command->free_command(command); - } + + ret = conn->run_command(COM_PROCESS_KILL, conn, process_id, read_response); conn->m->local_tx_end(conn, this_func, ret); } DBG_RETURN(ret); @@ -1223,11 +1184,8 @@ MYSQLND_METHOD(mysqlnd_conn_data, refresh)(MYSQLND_CONN_DATA * const conn, uint8 if (PASS == conn->m->local_tx_start(conn, this_func)) { unsigned int options_param = (unsigned int) options; - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_REFRESH, conn, options_param); - if (command) { - ret = command->run(command); - command->free_command(command); - } + + ret = conn->run_command(COM_REFRESH, conn, options_param); conn->m->local_tx_end(conn, this_func, ret); } DBG_RETURN(ret); @@ -1246,11 +1204,8 @@ MYSQLND_METHOD(mysqlnd_conn_data, shutdown)(MYSQLND_CONN_DATA * const conn, uint if (PASS == conn->m->local_tx_start(conn, this_func)) { unsigned int level_param = (unsigned int) level; - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_SHUTDOWN, conn, level_param); - if (command) { - ret = command->run(command); - command->free_command(command); - } + + ret = conn->run_command(COM_SHUTDOWN, conn, level_param); conn->m->local_tx_end(conn, this_func, ret); } DBG_RETURN(ret); @@ -1281,11 +1236,7 @@ MYSQLND_METHOD(mysqlnd_conn_data, send_close)(MYSQLND_CONN_DATA * const conn) case CONN_READY: DBG_INF("Connection clean, sending COM_QUIT"); if (net_stream) { - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_QUIT, conn); - if (command) { - ret = command->run(command); - command->free_command(command); - } + ret = conn->run_command(COM_QUIT, conn); vio->data->m.close_stream(vio, conn->stats, conn->error_info); } SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT); @@ -1421,7 +1372,7 @@ PHPAPI const char * mysqlnd_get_client_info() /* {{{ mysqlnd_get_client_version */ -PHPAPI unsigned int mysqlnd_get_client_version() +PHPAPI unsigned long mysqlnd_get_client_version() { return MYSQLND_VERSION_ID; } @@ -1859,8 +1810,12 @@ MYSQLND_METHOD(mysqlnd_conn_data, set_client_option_2d)(MYSQLND_CONN_DATA * cons DBG_INF_FMT("Adding [%s][%s]", key, value); { zval attrz; + zend_string *str = zend_string_init(key, strlen(key), 1); + GC_MAKE_PERSISTENT_LOCAL(str); ZVAL_NEW_STR(&attrz, zend_string_init(value, strlen(value), conn->persistent)); - zend_hash_str_update(conn->options->connect_attr, key, strlen(key), &attrz); + GC_MAKE_PERSISTENT_LOCAL(Z_COUNTED(attrz)); + zend_hash_update(conn->options->connect_attr, str, &attrz); + zend_string_release(str); } break; default: @@ -2321,7 +2276,7 @@ MYSQLND_METHOD(mysqlnd_conn_data, stmt_init)(MYSQLND_CONN_DATA * const conn) { MYSQLND_STMT * ret; DBG_ENTER("mysqlnd_conn_data::stmt_init"); - ret = conn->object_factory.get_prepared_statement(conn, conn->persistent); + ret = conn->object_factory.get_prepared_statement(conn); DBG_RETURN(ret); } /* }}} */ diff --git a/ext/mysqlnd/mysqlnd_connection.h b/ext/mysqlnd/mysqlnd_connection.h index 85ae933e43..a5c07c3af6 100644 --- a/ext/mysqlnd/mysqlnd_connection.h +++ b/ext/mysqlnd/mysqlnd_connection.h @@ -44,23 +44,23 @@ void mysqlnd_upsert_status_init(MYSQLND_UPSERT_STATUS * const upsert_status); /* Error handling */ -#define SET_NEW_MESSAGE(buf, buf_len, message, len, persistent) \ +#define SET_NEW_MESSAGE(buf, buf_len, message, len) \ {\ if ((buf)) { \ - mnd_pefree((buf), (persistent)); \ + mnd_efree((buf)); \ } \ if ((message)) { \ - (buf) = mnd_pestrndup((message), (len), (persistent)); \ + (buf) = mnd_pestrndup((message), (len), 0); \ } else { \ (buf) = NULL; \ } \ (buf_len) = (len); \ } -#define SET_EMPTY_MESSAGE(buf, buf_len, persistent) \ +#define SET_EMPTY_MESSAGE(buf, buf_len) \ {\ if ((buf)) { \ - mnd_pefree((buf), (persistent)); \ + mnd_efree((buf)); \ (buf) = NULL; \ } \ (buf_len) = 0; \ diff --git a/ext/mysqlnd/mysqlnd_driver.c b/ext/mysqlnd/mysqlnd_driver.c index 59b1349d63..b61720fe7c 100644 --- a/ext/mysqlnd/mysqlnd_driver.c +++ b/ext/mysqlnd/mysqlnd_driver.c @@ -143,9 +143,9 @@ MYSQLND_METHOD(mysqlnd_object_factory, get_connection)(MYSQLND_CLASS_METHODS_TYP data->protocol_frame_codec = mysqlnd_pfc_init(persistent, factory, data->stats, data->error_info); data->vio = mysqlnd_vio_init(persistent, factory, data->stats, data->error_info); data->payload_decoder_factory = mysqlnd_protocol_payload_decoder_factory_init(data, persistent); - data->command_factory = mysqlnd_command_factory_get(); + data->run_command = mysqlnd_command_factory_get(); - if (!data->protocol_frame_codec || !data->vio || !data->payload_decoder_factory || !data->command_factory) { + if (!data->protocol_frame_codec || !data->vio || !data->payload_decoder_factory || !data->run_command) { new_object->m->dtor(new_object); DBG_RETURN(NULL); } @@ -186,10 +186,10 @@ MYSQLND_METHOD(mysqlnd_object_factory, clone_connection_object)(MYSQLND * to_be_ /* {{{ mysqlnd_object_factory::get_prepared_statement */ static MYSQLND_STMT * -MYSQLND_METHOD(mysqlnd_object_factory, get_prepared_statement)(MYSQLND_CONN_DATA * const conn, const zend_bool persistent) +MYSQLND_METHOD(mysqlnd_object_factory, get_prepared_statement)(MYSQLND_CONN_DATA * const conn) { size_t alloc_size = sizeof(MYSQLND_STMT) + mysqlnd_plugin_count() * sizeof(void *); - MYSQLND_STMT * ret = mnd_pecalloc(1, alloc_size, conn->persistent); + MYSQLND_STMT * ret = mnd_ecalloc(1, alloc_size); MYSQLND_STMT_DATA * stmt = NULL; DBG_ENTER("mysqlnd_object_factory::get_prepared_statement"); @@ -198,17 +198,15 @@ MYSQLND_METHOD(mysqlnd_object_factory, get_prepared_statement)(MYSQLND_CONN_DATA break; } ret->m = mysqlnd_stmt_get_methods(); - ret->persistent = conn->persistent; - stmt = ret->data = mnd_pecalloc(1, sizeof(MYSQLND_STMT_DATA), persistent); + stmt = ret->data = mnd_ecalloc(1, sizeof(MYSQLND_STMT_DATA)); DBG_INF_FMT("stmt=%p", stmt); if (!stmt) { break; } - stmt->persistent = persistent; - if (FAIL == mysqlnd_error_info_init(&stmt->error_info_impl, persistent)) { - break; + if (FAIL == mysqlnd_error_info_init(&stmt->error_info_impl, 0)) { + break; } stmt->error_info = &stmt->error_info_impl; @@ -216,7 +214,7 @@ MYSQLND_METHOD(mysqlnd_object_factory, get_prepared_statement)(MYSQLND_CONN_DATA stmt->upsert_status = &(stmt->upsert_status_impl); stmt->state = MYSQLND_STMT_INITTED; stmt->execute_cmd_buffer.length = 4096; - stmt->execute_cmd_buffer.buffer = mnd_pemalloc(stmt->execute_cmd_buffer.length, stmt->persistent); + stmt->execute_cmd_buffer.buffer = mnd_emalloc(stmt->execute_cmd_buffer.length); if (!stmt->execute_cmd_buffer.buffer) { break; } @@ -247,15 +245,14 @@ MYSQLND_METHOD(mysqlnd_object_factory, get_prepared_statement)(MYSQLND_CONN_DATA static MYSQLND_PFC * MYSQLND_METHOD(mysqlnd_object_factory, get_pfc)(const zend_bool persistent, MYSQLND_STATS * stats, MYSQLND_ERROR_INFO * error_info) { - size_t pfc_alloc_size = sizeof(MYSQLND_PFC) + mysqlnd_plugin_count() * sizeof(void *); + size_t pfc_alloc_size = ZEND_MM_ALIGNED_SIZE(sizeof(MYSQLND_PFC) + mysqlnd_plugin_count() * sizeof(void *)); size_t pfc_data_alloc_size = sizeof(MYSQLND_PFC_DATA) + mysqlnd_plugin_count() * sizeof(void *); - MYSQLND_PFC * pfc = mnd_pecalloc(1, pfc_alloc_size, persistent); - MYSQLND_PFC_DATA * pfc_data = mnd_pecalloc(1, pfc_data_alloc_size, persistent); + MYSQLND_PFC * pfc = mnd_pecalloc(1, pfc_alloc_size + pfc_data_alloc_size, persistent); DBG_ENTER("mysqlnd_object_factory::get_pfc"); DBG_INF_FMT("persistent=%u", persistent); - if (pfc && pfc_data) { - pfc->data = pfc_data; + if (pfc) { + pfc->data = (MYSQLND_PFC_DATA*)((char*)pfc + pfc_alloc_size); pfc->persistent = pfc->data->persistent = persistent; pfc->data->m = *mysqlnd_pfc_get_methods(); @@ -263,15 +260,6 @@ MYSQLND_METHOD(mysqlnd_object_factory, get_pfc)(const zend_bool persistent, MYSQ pfc->data->m.dtor(pfc, stats, error_info); pfc = NULL; } - } else { - if (pfc_data) { - mnd_pefree(pfc_data, persistent); - pfc_data = NULL; - } - if (pfc) { - mnd_pefree(pfc, persistent); - pfc = NULL; - } } DBG_RETURN(pfc); } @@ -282,15 +270,14 @@ MYSQLND_METHOD(mysqlnd_object_factory, get_pfc)(const zend_bool persistent, MYSQ static MYSQLND_VIO * MYSQLND_METHOD(mysqlnd_object_factory, get_vio)(const zend_bool persistent, MYSQLND_STATS * stats, MYSQLND_ERROR_INFO * error_info) { - size_t vio_alloc_size = sizeof(MYSQLND_VIO) + mysqlnd_plugin_count() * sizeof(void *); + size_t vio_alloc_size = ZEND_MM_ALIGNED_SIZE(sizeof(MYSQLND_VIO) + mysqlnd_plugin_count() * sizeof(void *)); size_t vio_data_alloc_size = sizeof(MYSQLND_VIO_DATA) + mysqlnd_plugin_count() * sizeof(void *); - MYSQLND_VIO * vio = mnd_pecalloc(1, vio_alloc_size, persistent); - MYSQLND_VIO_DATA * vio_data = mnd_pecalloc(1, vio_data_alloc_size, persistent); + MYSQLND_VIO * vio = mnd_pecalloc(1, vio_alloc_size + vio_data_alloc_size, persistent); DBG_ENTER("mysqlnd_object_factory::get_vio"); DBG_INF_FMT("persistent=%u", persistent); - if (vio && vio_data) { - vio->data = vio_data; + if (vio) { + vio->data = (MYSQLND_VIO_DATA*)((char*)vio + vio_alloc_size); vio->persistent = vio->data->persistent = persistent; vio->data->m = *mysqlnd_vio_get_methods(); @@ -298,15 +285,6 @@ MYSQLND_METHOD(mysqlnd_object_factory, get_vio)(const zend_bool persistent, MYSQ vio->data->m.dtor(vio, stats, error_info); vio = NULL; } - } else { - if (vio_data) { - mnd_pefree(vio_data, persistent); - vio_data = NULL; - } - if (vio) { - mnd_pefree(vio, persistent); - vio = NULL; - } } DBG_RETURN(vio); } diff --git a/ext/mysqlnd/mysqlnd_ext_plugin.c b/ext/mysqlnd/mysqlnd_ext_plugin.c index 5f5bfbb11b..b17c80f190 100644 --- a/ext/mysqlnd/mysqlnd_ext_plugin.c +++ b/ext/mysqlnd/mysqlnd_ext_plugin.c @@ -13,7 +13,7 @@ | license@php.net so we can mail you a copy immediately. | +----------------------------------------------------------------------+ | Authors: Andrey Hristov <andrey@php.net> | - | Johannes Schlüter <johannes@php.net> | + | Johannes Schlüter <johannes@php.net> | | Ulf Wendel <uw@php.net> | +----------------------------------------------------------------------+ */ @@ -362,19 +362,19 @@ _mysqlnd_vio_set_methods(MYSQLND_CLASS_METHODS_TYPE(mysqlnd_vio) * methods) /* {{{ mysqlnd_command_factory_get */ -static func_mysqlnd__command_factory +static func_mysqlnd__run_command _mysqlnd_command_factory_get() { - return mysqlnd_command_factory; + return mysqlnd_run_command; } /* }}} */ /* {{{ mysqlnd_command_factory_set */ static void -_mysqlnd_command_factory_set(func_mysqlnd__command_factory factory) +_mysqlnd_command_factory_set(func_mysqlnd__run_command run_command) { - mysqlnd_command_factory = factory; + mysqlnd_run_command = run_command; } /* }}} */ diff --git a/ext/mysqlnd/mysqlnd_ext_plugin.h b/ext/mysqlnd/mysqlnd_ext_plugin.h index 7346f67209..a821a5a702 100644 --- a/ext/mysqlnd/mysqlnd_ext_plugin.h +++ b/ext/mysqlnd/mysqlnd_ext_plugin.h @@ -13,7 +13,7 @@ | license@php.net so we can mail you a copy immediately. | +----------------------------------------------------------------------+ | Authors: Andrey Hristov <andrey@php.net> | - | Johannes Schlüter <johannes@php.net> | + | Johannes Schlüter <johannes@php.net> | | Ulf Wendel <uw@php.net> | +----------------------------------------------------------------------+ */ @@ -119,8 +119,8 @@ struct st_mysqlnd_plugin_methods_xetters struct st_mnd_command_factory_xetters { - func_mysqlnd__command_factory (*get)(); - void (*set)(func_mysqlnd__command_factory factory); + func_mysqlnd__run_command (*get)(); + void (*set)(func_mysqlnd__run_command factory); } command_factory; }; diff --git a/ext/mysqlnd/mysqlnd_loaddata.c b/ext/mysqlnd/mysqlnd_loaddata.c index 049ccc0b0f..8e2bb9ed2d 100644 --- a/ext/mysqlnd/mysqlnd_loaddata.c +++ b/ext/mysqlnd/mysqlnd_loaddata.c @@ -216,8 +216,7 @@ infile_error: PROT_OK_PACKET, FALSE, COM_QUERY, FALSE, conn->error_info, conn->upsert_status, - &conn->last_message, - conn->persistent)) { + &conn->last_message)) { result = FAIL; } diff --git a/ext/mysqlnd/mysqlnd_protocol_frame_codec.c b/ext/mysqlnd/mysqlnd_protocol_frame_codec.c index 9e39501501..4f84c02c5d 100644 --- a/ext/mysqlnd/mysqlnd_protocol_frame_codec.c +++ b/ext/mysqlnd/mysqlnd_protocol_frame_codec.c @@ -441,7 +441,6 @@ MYSQLND_METHOD(mysqlnd_pfc, dtor)(MYSQLND_PFC * const pfc, MYSQLND_STATS * const pfc->cmd_buffer.buffer = NULL; } - mnd_pefree(pfc->data, pfc->data->persistent); mnd_pefree(pfc, pfc->persistent); } DBG_VOID_RETURN; diff --git a/ext/mysqlnd/mysqlnd_ps.c b/ext/mysqlnd/mysqlnd_ps.c index a9a603c6a9..56d66f0f85 100644 --- a/ext/mysqlnd/mysqlnd_ps.c +++ b/ext/mysqlnd/mysqlnd_ps.c @@ -82,7 +82,7 @@ MYSQLND_METHOD(mysqlnd_stmt, store_result)(MYSQLND_STMT * const s) result->type = MYSQLND_RES_PS_BUF; /* result->m.row_decoder = php_mysqlnd_rowp_read_binary_protocol; */ - result->stored_data = (MYSQLND_RES_BUFFERED *) mysqlnd_result_buffered_zval_init(result->field_count, TRUE, result->persistent); + result->stored_data = (MYSQLND_RES_BUFFERED *) mysqlnd_result_buffered_zval_init(result, result->field_count, TRUE); if (!result->stored_data) { SET_OOM_ERROR(conn->error_info); DBG_RETURN(NULL); @@ -122,7 +122,7 @@ MYSQLND_METHOD(mysqlnd_stmt, store_result)(MYSQLND_STMT * const s) } else { COPY_CLIENT_ERROR(conn->error_info, result->stored_data->error_info); stmt->result->m.free_result_contents(stmt->result); - mnd_pefree(stmt->result, stmt->result->persistent); + mysqlnd_mempool_destroy(stmt->result->memory_pool); stmt->result = NULL; stmt->state = MYSQLND_STMT_PREPARED; } @@ -167,13 +167,13 @@ MYSQLND_METHOD(mysqlnd_stmt, get_result)(MYSQLND_STMT * const s) MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_BUFFERED_SETS); do { - result = conn->m->result_init(stmt->result->field_count, stmt->persistent); + result = conn->m->result_init(stmt->result->field_count); if (!result) { SET_OOM_ERROR(conn->error_info); break; } - result->meta = stmt->result->meta->m->clone_metadata(stmt->result->meta, FALSE); + result->meta = stmt->result->meta->m->clone_metadata(result, stmt->result->meta); if (!result->meta) { SET_OOM_ERROR(conn->error_info); break; @@ -250,29 +250,32 @@ mysqlnd_stmt_skip_metadata(MYSQLND_STMT * s) /* Follows parameter metadata, we have just to skip it, as libmysql does */ unsigned int i = 0; enum_func_status ret = FAIL; - MYSQLND_PACKET_RES_FIELD * field_packet; + MYSQLND_PACKET_RES_FIELD field_packet; + MYSQLND_MEMORY_POOL * pool; DBG_ENTER("mysqlnd_stmt_skip_metadata"); if (!stmt || !conn) { DBG_RETURN(FAIL); } + pool = mysqlnd_mempool_create(MYSQLND_G(mempool_default_size)); + if (!pool) { + DBG_RETURN(FAIL); + } DBG_INF_FMT("stmt=%lu", stmt->stmt_id); - field_packet = conn->payload_decoder_factory->m.get_result_field_packet(conn->payload_decoder_factory, FALSE); - if (!field_packet) { - SET_OOM_ERROR(stmt->error_info); - SET_OOM_ERROR(conn->error_info); - } else { - ret = PASS; - field_packet->skip_parsing = TRUE; - for (;i < stmt->param_count; i++) { - if (FAIL == PACKET_READ(field_packet)) { - ret = FAIL; - break; - } + conn->payload_decoder_factory->m.init_result_field_packet(&field_packet); + field_packet.memory_pool = pool; + + ret = PASS; + field_packet.skip_parsing = TRUE; + for (;i < stmt->param_count; i++) { + if (FAIL == PACKET_READ(conn, &field_packet)) { + ret = FAIL; + break; } - PACKET_FREE(field_packet); } + PACKET_FREE(&field_packet); + mysqlnd_mempool_destroy(pool); DBG_RETURN(ret); } @@ -285,7 +288,7 @@ mysqlnd_stmt_read_prepare_response(MYSQLND_STMT * s) { MYSQLND_STMT_DATA * stmt = s? s->data : NULL; MYSQLND_CONN_DATA * conn = stmt? stmt->conn : NULL; - MYSQLND_PACKET_PREPARE_RESPONSE * prepare_resp; + MYSQLND_PACKET_PREPARE_RESPONSE prepare_resp; enum_func_status ret = FAIL; DBG_ENTER("mysqlnd_stmt_read_prepare_response"); @@ -294,30 +297,25 @@ mysqlnd_stmt_read_prepare_response(MYSQLND_STMT * s) } DBG_INF_FMT("stmt=%lu", stmt->stmt_id); - prepare_resp = conn->payload_decoder_factory->m.get_prepare_response_packet(conn->payload_decoder_factory, FALSE); - if (!prepare_resp) { - SET_OOM_ERROR(stmt->error_info); - SET_OOM_ERROR(conn->error_info); - goto done; - } + conn->payload_decoder_factory->m.init_prepare_response_packet(&prepare_resp); - if (FAIL == PACKET_READ(prepare_resp)) { + if (FAIL == PACKET_READ(conn, &prepare_resp)) { goto done; } - if (0xFF == prepare_resp->error_code) { - COPY_CLIENT_ERROR(stmt->error_info, prepare_resp->error_info); - COPY_CLIENT_ERROR(conn->error_info, prepare_resp->error_info); + if (0xFF == prepare_resp.error_code) { + COPY_CLIENT_ERROR(stmt->error_info, prepare_resp.error_info); + COPY_CLIENT_ERROR(conn->error_info, prepare_resp.error_info); goto done; } ret = PASS; - stmt->stmt_id = prepare_resp->stmt_id; - UPSERT_STATUS_SET_WARNINGS(conn->upsert_status, prepare_resp->warning_count); + stmt->stmt_id = prepare_resp.stmt_id; + UPSERT_STATUS_SET_WARNINGS(conn->upsert_status, prepare_resp.warning_count); UPSERT_STATUS_SET_AFFECTED_ROWS(stmt->upsert_status, 0); /* be like libmysql */ - stmt->field_count = conn->field_count = prepare_resp->field_count; - stmt->param_count = prepare_resp->param_count; + stmt->field_count = conn->field_count = prepare_resp.field_count; + stmt->param_count = prepare_resp.param_count; done: - PACKET_FREE(prepare_resp); + PACKET_FREE(&prepare_resp); DBG_RETURN(ret); } @@ -330,7 +328,7 @@ mysqlnd_stmt_prepare_read_eof(MYSQLND_STMT * s) { MYSQLND_STMT_DATA * stmt = s? s->data : NULL; MYSQLND_CONN_DATA * conn = stmt? stmt->conn : NULL; - MYSQLND_PACKET_EOF * fields_eof; + MYSQLND_PACKET_EOF fields_eof; enum_func_status ret = FAIL; DBG_ENTER("mysqlnd_stmt_prepare_read_eof"); @@ -339,29 +337,23 @@ mysqlnd_stmt_prepare_read_eof(MYSQLND_STMT * s) } DBG_INF_FMT("stmt=%lu", stmt->stmt_id); - fields_eof = conn->payload_decoder_factory->m.get_eof_packet(conn->payload_decoder_factory, FALSE); - if (!fields_eof) { - SET_OOM_ERROR(stmt->error_info); - SET_OOM_ERROR(conn->error_info); - } else { - if (FAIL == (ret = PACKET_READ(fields_eof))) { - if (stmt->result) { - stmt->result->m.free_result_contents(stmt->result); - mnd_pefree(stmt->result, stmt->result->persistent); - /* XXX: This will crash, because we will null also the methods. - But seems it happens in extreme cases or doesn't. Should be fixed by exporting a function - (from mysqlnd_driver.c?) to do the reset. - This bad handling is also in mysqlnd_result.c - */ - memset(stmt, 0, sizeof(MYSQLND_STMT_DATA)); - stmt->state = MYSQLND_STMT_INITTED; - } - } else { - UPSERT_STATUS_SET_SERVER_STATUS(stmt->upsert_status, fields_eof->server_status); - UPSERT_STATUS_SET_WARNINGS(stmt->upsert_status, fields_eof->warning_count); - stmt->state = MYSQLND_STMT_PREPARED; + conn->payload_decoder_factory->m.init_eof_packet(&fields_eof); + if (FAIL == (ret = PACKET_READ(conn, &fields_eof))) { + if (stmt->result) { + stmt->result->m.free_result_contents(stmt->result); + mnd_efree(stmt->result); + /* XXX: This will crash, because we will null also the methods. + But seems it happens in extreme cases or doesn't. Should be fixed by exporting a function + (from mysqlnd_driver.c?) to do the reset. + This bad handling is also in mysqlnd_result.c + */ + memset(stmt, 0, sizeof(MYSQLND_STMT_DATA)); + stmt->state = MYSQLND_STMT_INITTED; } - PACKET_FREE(fields_eof); + } else { + UPSERT_STATUS_SET_SERVER_STATUS(stmt->upsert_status, fields_eof.server_status); + UPSERT_STATUS_SET_WARNINGS(stmt->upsert_status, fields_eof.warning_count); + stmt->state = MYSQLND_STMT_PREPARED; } DBG_RETURN(ret); @@ -416,11 +408,8 @@ MYSQLND_METHOD(mysqlnd_stmt, prepare)(MYSQLND_STMT * const s, const char * const { enum_func_status ret = FAIL; const MYSQLND_CSTRING query_string = {query, query_len}; - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_STMT_PREPARE, conn, query_string); - if (command) { - ret = command->run(command); - command->free_command(command); - } + + ret = conn->run_command(COM_STMT_PREPARE, conn, query_string); if (FAIL == ret) { goto fail; } @@ -444,7 +433,7 @@ MYSQLND_METHOD(mysqlnd_stmt, prepare)(MYSQLND_STMT * const s, const char * const no metadata at prepare. */ if (stmt_to_prepare->field_count) { - MYSQLND_RES * result = conn->m->result_init(stmt_to_prepare->field_count, stmt_to_prepare->persistent); + MYSQLND_RES * result = conn->m->result_init(stmt_to_prepare->field_count); if (!result) { SET_OOM_ERROR(conn->error_info); goto fail; @@ -729,12 +718,8 @@ MYSQLND_METHOD(mysqlnd_stmt, send_execute)(MYSQLND_STMT * const s, const enum_my ret = s->m->generate_execute_request(s, &request, &request_len, &free_request); if (ret == PASS) { const MYSQLND_CSTRING payload = {(const char*) request, request_len}; - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_STMT_EXECUTE, conn, payload); - ret = FAIL; - if (command) { - ret = command->run(command); - command->free_command(command); - } + + ret = conn->run_command(COM_STMT_EXECUTE, conn, payload); } else { SET_CLIENT_ERROR(stmt->error_info, CR_UNKNOWN_ERROR, UNKNOWN_SQLSTATE, "Couldn't generate the request. Possibly OOM."); } @@ -781,7 +766,7 @@ mysqlnd_stmt_fetch_row_buffered(MYSQLND_RES * result, void * param, const unsign if (Z_ISUNDEF(current_row[0])) { uint64_t row_num = (set->data_cursor - set->data) / field_count; - enum_func_status rc = result->stored_data->m.row_decoder(result->stored_data->row_buffers[row_num], + enum_func_status rc = result->stored_data->m.row_decoder(&result->stored_data->row_buffers[row_num], current_row, meta->field_count, meta->fields, @@ -892,7 +877,7 @@ mysqlnd_stmt_fetch_row_unbuffered(MYSQLND_RES * result, void * param, const unsi If we skip rows (stmt == NULL || stmt->result_bind == NULL) we have to result->unbuf->m.free_last_data() before it. The function returns always true. */ - if (PASS == (ret = PACKET_READ(row_packet)) && !row_packet->eof) { + if (PASS == (ret = PACKET_READ(conn, row_packet)) && !row_packet->eof) { unsigned int i, field_count = result->field_count; if (!row_packet->skip_extraction) { @@ -901,9 +886,9 @@ mysqlnd_stmt_fetch_row_unbuffered(MYSQLND_RES * result, void * param, const unsi result->unbuf->last_row_data = row_packet->fields; result->unbuf->last_row_buffer = row_packet->row_buffer; row_packet->fields = NULL; - row_packet->row_buffer = NULL; + row_packet->row_buffer.ptr = NULL; - if (PASS != result->unbuf->m.row_decoder(result->unbuf->last_row_buffer, + if (PASS != result->unbuf->m.row_decoder(&result->unbuf->last_row_buffer, result->unbuf->last_row_data, row_packet->field_count, row_packet->fields_metadata, @@ -948,8 +933,8 @@ mysqlnd_stmt_fetch_row_unbuffered(MYSQLND_RES * result, void * param, const unsi report leaks. */ row_packet->result_set_memory_pool->free_chunk( - row_packet->result_set_memory_pool, row_packet->row_buffer); - row_packet->row_buffer = NULL; + row_packet->result_set_memory_pool, row_packet->row_buffer.ptr); + row_packet->row_buffer.ptr = NULL; } result->unbuf->row_count++; @@ -1063,16 +1048,10 @@ mysqlnd_fetch_stmt_row_cursor(MYSQLND_RES * result, void * param, const unsigned { const MYSQLND_CSTRING payload = {(const char*) buf, sizeof(buf)}; - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_STMT_FETCH, conn, payload); - ret = FAIL; - if (command) { - ret = command->run(command); - command->free_command(command); - if (ret == FAIL) { - COPY_CLIENT_ERROR(stmt->error_info, *conn->error_info); - } - } - if (FAIL == ret) { + + ret = conn->run_command(COM_STMT_FETCH, conn, payload); + if (ret == FAIL) { + COPY_CLIENT_ERROR(stmt->error_info, *conn->error_info); DBG_RETURN(FAIL); } @@ -1081,7 +1060,7 @@ mysqlnd_fetch_stmt_row_cursor(MYSQLND_RES * result, void * param, const unsigned row_packet->skip_extraction = stmt->result_bind? FALSE:TRUE; UPSERT_STATUS_RESET(stmt->upsert_status); - if (PASS == (ret = PACKET_READ(row_packet)) && !row_packet->eof) { + if (PASS == (ret = PACKET_READ(conn, row_packet)) && !row_packet->eof) { const MYSQLND_RES_METADATA * const meta = result->meta; unsigned int i, field_count = result->field_count; @@ -1091,9 +1070,9 @@ mysqlnd_fetch_stmt_row_cursor(MYSQLND_RES * result, void * param, const unsigned result->unbuf->last_row_data = row_packet->fields; result->unbuf->last_row_buffer = row_packet->row_buffer; row_packet->fields = NULL; - row_packet->row_buffer = NULL; + row_packet->row_buffer.ptr = NULL; - if (PASS != result->unbuf->m.row_decoder(result->unbuf->last_row_buffer, + if (PASS != result->unbuf->m.row_decoder(&result->unbuf->last_row_buffer, result->unbuf->last_row_data, row_packet->field_count, row_packet->fields_metadata, @@ -1143,15 +1122,15 @@ mysqlnd_fetch_stmt_row_cursor(MYSQLND_RES * result, void * param, const unsigned report leaks. */ row_packet->result_set_memory_pool->free_chunk( - row_packet->result_set_memory_pool, row_packet->row_buffer); - row_packet->row_buffer = NULL; + row_packet->result_set_memory_pool, row_packet->row_buffer.ptr); + row_packet->row_buffer.ptr = NULL; } /* We asked for one row, the next one should be EOF, eat it */ - ret = PACKET_READ(row_packet); - if (row_packet->row_buffer) { + ret = PACKET_READ(conn, row_packet); + if (row_packet->row_buffer.ptr) { row_packet->result_set_memory_pool->free_chunk( - row_packet->result_set_memory_pool, row_packet->row_buffer); - row_packet->row_buffer = NULL; + row_packet->result_set_memory_pool, row_packet->row_buffer.ptr); + row_packet->row_buffer.ptr = NULL; } MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_PS_CURSOR); @@ -1277,15 +1256,10 @@ MYSQLND_METHOD(mysqlnd_stmt, reset)(MYSQLND_STMT * const s) if (GET_CONNECTION_STATE(&conn->state) == CONN_READY) { size_t stmt_id = stmt->stmt_id; - struct st_mysqlnd_protocol_command * command = stmt->conn->command_factory(COM_STMT_RESET, stmt->conn, stmt_id); - ret = FAIL; - if (command) { - ret = command->run(command); - command->free_command(command); - if (ret == FAIL) { - COPY_CLIENT_ERROR(stmt->error_info, *conn->error_info); - } + ret = stmt->conn->run_command(COM_STMT_RESET, stmt->conn, stmt_id); + if (ret == FAIL) { + COPY_CLIENT_ERROR(stmt->error_info, *conn->error_info); } } *stmt->upsert_status = *conn->upsert_status; @@ -1388,14 +1362,10 @@ MYSQLND_METHOD(mysqlnd_stmt, send_long_data)(MYSQLND_STMT * const s, unsigned in /* COM_STMT_SEND_LONG_DATA doesn't acknowledge with an OK packet */ { const MYSQLND_CSTRING payload = {(const char *) cmd_buf, packet_len}; - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_STMT_SEND_LONG_DATA, conn, payload); - ret = FAIL; - if (command) { - ret = command->run(command); - command->free_command(command); - if (ret == FAIL) { - COPY_CLIENT_ERROR(stmt->error_info, *conn->error_info); - } + + ret = conn->run_command(COM_STMT_SEND_LONG_DATA, conn, payload); + if (ret == FAIL) { + COPY_CLIENT_ERROR(stmt->error_info, *conn->error_info); } } @@ -1543,7 +1513,7 @@ MYSQLND_METHOD(mysqlnd_stmt, bind_one_parameter)(MYSQLND_STMT * const s, unsigne if (stmt->param_count) { if (!stmt->param_bind) { - stmt->param_bind = mnd_pecalloc(stmt->param_count, sizeof(MYSQLND_PARAM_BIND), stmt->persistent); + stmt->param_bind = mnd_ecalloc(stmt->param_count, sizeof(MYSQLND_PARAM_BIND)); if (!stmt->param_bind) { DBG_RETURN(FAIL); } @@ -1691,9 +1661,9 @@ MYSQLND_METHOD(mysqlnd_stmt, bind_one_result)(MYSQLND_STMT * const s, unsigned i mysqlnd_stmt_separate_one_result_bind(s, param_no); /* Guaranteed is that stmt->result_bind is NULL */ if (!stmt->result_bind) { - stmt->result_bind = mnd_pecalloc(stmt->field_count, sizeof(MYSQLND_RESULT_BIND), stmt->persistent); + stmt->result_bind = mnd_ecalloc(stmt->field_count, sizeof(MYSQLND_RESULT_BIND)); } else { - stmt->result_bind = mnd_perealloc(stmt->result_bind, stmt->field_count * sizeof(MYSQLND_RESULT_BIND), stmt->persistent); + stmt->result_bind = mnd_erealloc(stmt->result_bind, stmt->field_count * sizeof(MYSQLND_RESULT_BIND)); } if (!stmt->result_bind) { DBG_RETURN(FAIL); @@ -1868,17 +1838,17 @@ MYSQLND_METHOD(mysqlnd_stmt, result_metadata)(MYSQLND_STMT * const s) be handled in a better way. */ do { - result_meta = conn->m->result_init(stmt->field_count, stmt->persistent); + result_meta = conn->m->result_init(stmt->field_count); if (!result_meta) { break; } result_meta->type = MYSQLND_RES_NORMAL; - result_meta->unbuf = mysqlnd_result_unbuffered_init(stmt->field_count, TRUE, result_meta->persistent); + result_meta->unbuf = mysqlnd_result_unbuffered_init(result_meta, stmt->field_count, TRUE); if (!result_meta->unbuf) { break; } result_meta->unbuf->eof_reached = TRUE; - result_meta->meta = stmt->result->meta->m->clone_metadata(stmt->result->meta, FALSE); + result_meta->meta = stmt->result->meta->m->clone_metadata(result_meta, stmt->result->meta); if (!result_meta->meta) { break; } @@ -2130,11 +2100,7 @@ MYSQLND_METHOD(mysqlnd_stmt, free_stmt_result)(MYSQLND_STMT * const s) stmt->result->m.free_result_internal(stmt->result); stmt->result = NULL; } - if (stmt->error_info->error_list) { - zend_llist_clean(stmt->error_info->error_list); - mnd_pefree(stmt->error_info->error_list, s->persistent); - stmt->error_info->error_list = NULL; - } + zend_llist_clean(&stmt->error_info->error_list); DBG_VOID_RETURN; } @@ -2223,16 +2189,10 @@ MYSQLND_METHOD_PRIVATE(mysqlnd_stmt, close_on_server)(MYSQLND_STMT * const s, ze if (GET_CONNECTION_STATE(&conn->state) == CONN_READY) { enum_func_status ret = FAIL; size_t stmt_id = stmt->stmt_id; - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_STMT_CLOSE, conn, stmt_id); - if (command) { - ret = command->run(command); - command->free_command(command); - if (ret == FAIL) { - COPY_CLIENT_ERROR(stmt->error_info, *conn->error_info); - } - } + ret = conn->run_command(COM_STMT_CLOSE, conn, stmt_id); if (ret == FAIL) { + COPY_CLIENT_ERROR(stmt->error_info, *conn->error_info); DBG_RETURN(FAIL); } } @@ -2252,7 +2212,7 @@ MYSQLND_METHOD_PRIVATE(mysqlnd_stmt, close_on_server)(MYSQLND_STMT * const s, ze } if (stmt->execute_cmd_buffer.buffer) { - mnd_pefree(stmt->execute_cmd_buffer.buffer, stmt->persistent); + mnd_efree(stmt->execute_cmd_buffer.buffer); stmt->execute_cmd_buffer.buffer = NULL; } @@ -2273,7 +2233,6 @@ MYSQLND_METHOD(mysqlnd_stmt, dtor)(MYSQLND_STMT * const s, zend_bool implicit) { MYSQLND_STMT_DATA * stmt = (s != NULL) ? s->data:NULL; enum_func_status ret = FAIL; - zend_bool persistent = (s != NULL) ? s->persistent : 0; DBG_ENTER("mysqlnd_stmt::dtor"); if (stmt) { @@ -2283,9 +2242,9 @@ MYSQLND_METHOD(mysqlnd_stmt, dtor)(MYSQLND_STMT * const s, zend_bool implicit) STAT_STMT_CLOSE_EXPLICIT); ret = s->m->close_on_server(s, implicit); - mnd_pefree(stmt, persistent); + mnd_efree(stmt); } - mnd_pefree(s, persistent); + mnd_efree(s); DBG_INF(ret == PASS? "PASS":"FAIL"); DBG_RETURN(ret); @@ -2302,7 +2261,7 @@ MYSQLND_METHOD(mysqlnd_stmt, alloc_param_bind)(MYSQLND_STMT * const s) if (!stmt) { DBG_RETURN(NULL); } - DBG_RETURN(mnd_pecalloc(stmt->param_count, sizeof(MYSQLND_PARAM_BIND), stmt->persistent)); + DBG_RETURN(mnd_ecalloc(stmt->param_count, sizeof(MYSQLND_PARAM_BIND))); } /* }}} */ @@ -2316,7 +2275,7 @@ MYSQLND_METHOD(mysqlnd_stmt, alloc_result_bind)(MYSQLND_STMT * const s) if (!stmt) { DBG_RETURN(NULL); } - DBG_RETURN(mnd_pecalloc(stmt->field_count, sizeof(MYSQLND_RESULT_BIND), stmt->persistent)); + DBG_RETURN(mnd_ecalloc(stmt->field_count, sizeof(MYSQLND_RESULT_BIND))); } /* }}} */ @@ -2327,7 +2286,7 @@ MYSQLND_METHOD(mysqlnd_stmt, free_parameter_bind)(MYSQLND_STMT * const s, MYSQLN { MYSQLND_STMT_DATA * stmt = s? s->data : NULL; if (stmt) { - mnd_pefree(param_bind, stmt->persistent); + mnd_efree(param_bind); } } /* }}} */ @@ -2339,7 +2298,7 @@ MYSQLND_METHOD(mysqlnd_stmt, free_result_bind)(MYSQLND_STMT * const s, MYSQLND_R { MYSQLND_STMT_DATA * stmt = s? s->data : NULL; if (stmt) { - mnd_pefree(result_bind, stmt->persistent); + mnd_efree(result_bind); } } /* }}} */ diff --git a/ext/mysqlnd/mysqlnd_ps_codec.c b/ext/mysqlnd/mysqlnd_ps_codec.c index 24f6886723..0d64708851 100644 --- a/ext/mysqlnd/mysqlnd_ps_codec.c +++ b/ext/mysqlnd/mysqlnd_ps_codec.c @@ -600,23 +600,19 @@ mysqlnd_stmt_execute_prepare_param_types(MYSQLND_STMT_DATA * stmt, zval ** copie to losing precision we need second variable. Conversion to double is to see if value is too big for a long. As said, precision could be lost. */ - zval tmp_data_copy; - ZVAL_COPY(&tmp_data_copy, tmp_data); - convert_to_double_ex(&tmp_data_copy); + double d = zval_get_double(tmp_data); /* if it doesn't fit in a long send it as a string. Check bug #52891 : Wrong data inserted with mysqli/mysqlnd when using bind_param, value > LONG_MAX We do transformation here, which will be used later when sending types. The code later relies on this. */ - if (Z_DVAL(tmp_data_copy) > ZEND_LONG_MAX || Z_DVAL(tmp_data_copy) < ZEND_LONG_MIN) { + if (d > ZEND_LONG_MAX || d < ZEND_LONG_MIN) { stmt->send_types_to_server = *resend_types_next_time = 1; convert_to_string_ex(tmp_data); } else { - convert_to_long_ex(tmp_data); + convert_to_long(tmp_data); } - - zval_ptr_dtor(&tmp_data_copy); } } } diff --git a/ext/mysqlnd/mysqlnd_result.c b/ext/mysqlnd/mysqlnd_result.c index 030ee1e020..b436f23ac0 100644 --- a/ext/mysqlnd/mysqlnd_result.c +++ b/ext/mysqlnd/mysqlnd_result.c @@ -52,7 +52,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered_zval, initialize_result_set_rest)(MYSQLND if (Z_ISUNDEF(data_cursor[0])) { unsigned int i; const size_t current_row_num = (data_cursor - data_begin) / field_count; - enum_func_status rc = result->m.row_decoder(result->row_buffers[current_row_num], + enum_func_status rc = result->m.row_decoder(&result->row_buffers[current_row_num], data_cursor, field_count, meta->fields, @@ -108,11 +108,11 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, initialize_result_set_rest)(MYSQLND_RE for (i = 0; i < result->row_count; i++) { /* (i / 8) & the_bit_for_i*/ - if (initialized[i >> 3] & (1 << (i & 7))) { + if (ZEND_BIT_TEST(initialized, i)) { continue; } - rc = result->m.row_decoder(result->row_buffers[i], current_row, field_count, meta->fields, int_and_float_native, stats); + rc = result->m.row_decoder(&result->row_buffers[i], current_row, field_count, meta->fields, int_and_float_native, stats); if (rc != PASS) { ret = FAIL; @@ -163,12 +163,12 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, free_last_data)(MYSQLND_RES_UNBUFFERED mnd_efree(unbuf->last_row_data); unbuf->last_row_data = NULL; } - if (unbuf->last_row_buffer) { + if (unbuf->last_row_buffer.ptr) { DBG_INF("Freeing last row buffer"); /* Nothing points to this buffer now, free it */ unbuf->result_set_memory_pool->free_chunk( - unbuf->result_set_memory_pool, unbuf->last_row_buffer); - unbuf->last_row_buffer = NULL; + unbuf->result_set_memory_pool, unbuf->last_row_buffer.ptr); + unbuf->last_row_buffer.ptr = NULL; } DBG_VOID_RETURN; @@ -183,24 +183,15 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, free_result)(MYSQLND_RES_UNBUFFERED * DBG_ENTER("mysqlnd_result_unbuffered, free_result"); result->m.free_last_data(result, global_stats); - if (result->lengths) { - mnd_pefree(result->lengths, result->persistent); - result->lengths = NULL; - } - /* must be free before because references the memory pool */ if (result->row_packet) { PACKET_FREE(result->row_packet); + mnd_efree(result->row_packet); result->row_packet = NULL; } - if (result->result_set_memory_pool) { - mysqlnd_mempool_destroy(result->result_set_memory_pool); - result->result_set_memory_pool = NULL; - } + mysqlnd_mempool_restore_state(result->result_set_memory_pool); - - mnd_pefree(result, result->persistent); DBG_VOID_RETURN; } /* }}} */ @@ -242,7 +233,7 @@ static void MYSQLND_METHOD(mysqlnd_result_buffered_c, free_result)(MYSQLND_RES_BUFFERED_C * const set) { DBG_ENTER("mysqlnd_result_buffered_c::free_result"); - mnd_pefree(set->initialized, set->persistent); + mnd_efree(set->initialized); set->initialized = NULL; DBG_VOID_RETURN; } @@ -253,8 +244,6 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, free_result)(MYSQLND_RES_BUFFERED_C * static void MYSQLND_METHOD(mysqlnd_result_buffered, free_result)(MYSQLND_RES_BUFFERED * const set) { - int64_t row; - MYSQLND_MEMORY_POOL * pool; DBG_ENTER("mysqlnd_result_buffered::free_result"); DBG_INF_FMT("Freeing "MYSQLND_LLU_SPEC" row(s)", set->row_count); @@ -267,30 +256,12 @@ MYSQLND_METHOD(mysqlnd_result_buffered, free_result)(MYSQLND_RES_BUFFERED * cons MYSQLND_METHOD(mysqlnd_result_buffered_c, free_result)((MYSQLND_RES_BUFFERED_C *) set); } - pool = set->result_set_memory_pool; - for (row = set->row_count - 1; row >= 0; row--) { - MYSQLND_MEMORY_POOL_CHUNK *current_buffer = set->row_buffers[row]; - pool->free_chunk(pool, current_buffer); - } - - if (set->lengths) { - mnd_pefree(set->lengths, set->persistent); - set->lengths = NULL; - } - if (set->row_buffers) { - mnd_pefree(set->row_buffers, 0); + mnd_efree(set->row_buffers); set->row_buffers = NULL; } - if (set->result_set_memory_pool) { - mysqlnd_mempool_destroy(set->result_set_memory_pool); - set->result_set_memory_pool = NULL; - } - - set->row_count = 0; - - mnd_pefree(set, set->persistent); + mysqlnd_mempool_restore_state(set->result_set_memory_pool); DBG_VOID_RETURN; } @@ -349,7 +320,7 @@ void MYSQLND_METHOD(mysqlnd_res, free_result_internal)(MYSQLND_RES * result) result->conn = NULL; } - mnd_pefree(result, result->persistent); + mysqlnd_mempool_destroy(result->memory_pool); DBG_VOID_RETURN; } @@ -373,7 +344,7 @@ MYSQLND_METHOD(mysqlnd_res, read_result_metadata)(MYSQLND_RES * result, MYSQLND_ result->meta = NULL; } - result->meta = result->m.result_meta_init(result->field_count, result->persistent); + result->meta = result->m.result_meta_init(result, result->field_count); if (!result->meta) { SET_OOM_ERROR(conn->error_info); DBG_RETURN(FAIL); @@ -382,7 +353,7 @@ MYSQLND_METHOD(mysqlnd_res, read_result_metadata)(MYSQLND_RES * result, MYSQLND_ /* 1. Read all fields metadata */ /* It's safe to reread without freeing */ - if (FAIL == result->meta->m->read_metadata(result->meta, conn)) { + if (FAIL == result->meta->m->read_metadata(result->meta, conn, result)) { result->m.free_result_contents(result); DBG_RETURN(FAIL); } @@ -407,30 +378,23 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s) { enum_func_status ret; MYSQLND_STMT_DATA * stmt = s ? s->data : NULL; - MYSQLND_PACKET_RSET_HEADER * rset_header = NULL; - MYSQLND_PACKET_EOF * fields_eof = NULL; - const zend_bool persistent = conn->persistent; + MYSQLND_PACKET_RSET_HEADER rset_header; + MYSQLND_PACKET_EOF fields_eof; DBG_ENTER("mysqlnd_query_read_result_set_header"); DBG_INF_FMT("stmt=%lu", stmt? stmt->stmt_id:0); ret = FAIL; do { - rset_header = conn->payload_decoder_factory->m.get_rset_header_packet(conn->payload_decoder_factory, FALSE); - if (!rset_header) { - SET_OOM_ERROR(conn->error_info); - ret = FAIL; - break; - } - + conn->payload_decoder_factory->m.init_rset_header_packet(&rset_header); UPSERT_STATUS_SET_AFFECTED_ROWS_TO_ERROR(conn->upsert_status); - if (FAIL == (ret = PACKET_READ(rset_header))) { + if (FAIL == (ret = PACKET_READ(conn, &rset_header))) { php_error_docref(NULL, E_WARNING, "Error reading result set's header"); break; } - if (rset_header->error_info.error_no) { + if (rset_header.error_info.error_no) { /* Cover a protocol design error: error packet does not contain the server status. Therefore, the client has no way @@ -445,23 +409,23 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s) This will copy the error code and the messages, as they are buffers in the struct */ - COPY_CLIENT_ERROR(conn->error_info, rset_header->error_info); + COPY_CLIENT_ERROR(conn->error_info, rset_header.error_info); ret = FAIL; - DBG_ERR_FMT("error=%s", rset_header->error_info.error); + DBG_ERR_FMT("error=%s", rset_header.error_info.error); /* Return back from CONN_QUERY_SENT */ SET_CONNECTION_STATE(&conn->state, CONN_READY); break; } conn->error_info->error_no = 0; - switch (rset_header->field_count) { + switch (rset_header.field_count) { case MYSQLND_NULL_LENGTH: { /* LOAD DATA LOCAL INFILE */ zend_bool is_warning; DBG_INF("LOAD DATA"); conn->last_query_type = QUERY_LOAD_LOCAL; conn->field_count = 0; /* overwrite previous value, or the last value could be used and lead to bug#53503 */ SET_CONNECTION_STATE(&conn->state, CONN_SENDING_LOAD_DATA); - ret = mysqlnd_handle_local_infile(conn, rset_header->info_or_local_file.s, &is_warning); + ret = mysqlnd_handle_local_infile(conn, rset_header.info_or_local_file.s, &is_warning); SET_CONNECTION_STATE(&conn->state, (ret == PASS || is_warning == TRUE)? CONN_READY:CONN_QUIT_SENT); MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_NON_RSET_QUERY); break; @@ -469,15 +433,14 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s) case 0: /* UPSERT */ DBG_INF("UPSERT"); conn->last_query_type = QUERY_UPSERT; - conn->field_count = rset_header->field_count; + conn->field_count = rset_header.field_count; UPSERT_STATUS_RESET(conn->upsert_status); - UPSERT_STATUS_SET_WARNINGS(conn->upsert_status, rset_header->warning_count); - UPSERT_STATUS_SET_SERVER_STATUS(conn->upsert_status, rset_header->server_status); - UPSERT_STATUS_SET_AFFECTED_ROWS(conn->upsert_status, rset_header->affected_rows); - UPSERT_STATUS_SET_LAST_INSERT_ID(conn->upsert_status, rset_header->last_insert_id); + UPSERT_STATUS_SET_WARNINGS(conn->upsert_status, rset_header.warning_count); + UPSERT_STATUS_SET_SERVER_STATUS(conn->upsert_status, rset_header.server_status); + UPSERT_STATUS_SET_AFFECTED_ROWS(conn->upsert_status, rset_header.affected_rows); + UPSERT_STATUS_SET_LAST_INSERT_ID(conn->upsert_status, rset_header.last_insert_id); SET_NEW_MESSAGE(conn->last_message.s, conn->last_message.l, - rset_header->info_or_local_file.s, rset_header->info_or_local_file.l, - persistent); + rset_header.info_or_local_file.s, rset_header.info_or_local_file.l); /* Result set can follow UPSERT statement, check server_status */ if (UPSERT_STATUS_GET_SERVER_STATUS(conn->upsert_status) & SERVER_MORE_RESULTS_EXISTS) { SET_CONNECTION_STATE(&conn->state, CONN_NEXT_RESULT_PENDING); @@ -492,7 +455,7 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s) enum_mysqlnd_collected_stats statistic = STAT_LAST; DBG_INF("Result set pending"); - SET_EMPTY_MESSAGE(conn->last_message.s, conn->last_message.l, persistent); + SET_EMPTY_MESSAGE(conn->last_message.s, conn->last_message.l); MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_RSET_QUERY); UPSERT_STATUS_RESET(conn->upsert_status); @@ -502,9 +465,9 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s) conn->last_query_type = QUERY_SELECT; SET_CONNECTION_STATE(&conn->state, CONN_FETCHING_DATA); /* PS has already allocated it */ - conn->field_count = rset_header->field_count; + conn->field_count = rset_header.field_count; if (!stmt) { - result = conn->current_result = conn->m->result_init(rset_header->field_count, persistent); + result = conn->current_result = conn->m->result_init(rset_header.field_count); } else { if (!stmt->result) { DBG_INF("This is 'SHOW'/'EXPLAIN'-like query."); @@ -513,7 +476,7 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s) prepared statements can't send result set metadata for these queries on prepare stage. Read it now. */ - result = stmt->result = conn->m->result_init(rset_header->field_count, stmt->persistent); + result = stmt->result = conn->m->result_init(rset_header.field_count); } else { /* Update result set metadata if it for some reason changed between @@ -547,16 +510,11 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s) } /* Check for SERVER_STATUS_MORE_RESULTS if needed */ - fields_eof = conn->payload_decoder_factory->m.get_eof_packet(conn->payload_decoder_factory, FALSE); - if (!fields_eof) { - SET_OOM_ERROR(conn->error_info); - ret = FAIL; - break; - } - if (FAIL == (ret = PACKET_READ(fields_eof))) { + conn->payload_decoder_factory->m.init_eof_packet(&fields_eof); + if (FAIL == (ret = PACKET_READ(conn, &fields_eof))) { DBG_ERR("Error occurred while reading the EOF packet"); result->m.free_result_contents(result); - mnd_efree(result); + mysqlnd_mempool_destroy(result->memory_pool); if (!stmt) { conn->current_result = NULL; } else { @@ -570,8 +528,8 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s) stmt->state = MYSQLND_STMT_INITTED; } } else { - DBG_INF_FMT("warnings=%u server_status=%u", fields_eof->warning_count, fields_eof->server_status); - UPSERT_STATUS_SET_WARNINGS(conn->upsert_status, fields_eof->warning_count); + DBG_INF_FMT("warnings=%u server_status=%u", fields_eof.warning_count, fields_eof.server_status); + UPSERT_STATUS_SET_WARNINGS(conn->upsert_status, fields_eof.warning_count); /* If SERVER_MORE_RESULTS_EXISTS is set then this is either MULTI_QUERY or a CALL() The first packet after sending the query/com_execute has the bit set only @@ -579,22 +537,22 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s) will include many result sets. What actually matters are the bits set at the end of every result set (the EOF packet). */ - UPSERT_STATUS_SET_SERVER_STATUS(conn->upsert_status, fields_eof->server_status); - if (fields_eof->server_status & SERVER_QUERY_NO_GOOD_INDEX_USED) { + UPSERT_STATUS_SET_SERVER_STATUS(conn->upsert_status, fields_eof.server_status); + if (fields_eof.server_status & SERVER_QUERY_NO_GOOD_INDEX_USED) { statistic = STAT_BAD_INDEX_USED; - } else if (fields_eof->server_status & SERVER_QUERY_NO_INDEX_USED) { + } else if (fields_eof.server_status & SERVER_QUERY_NO_INDEX_USED) { statistic = STAT_NO_INDEX_USED; - } else if (fields_eof->server_status & SERVER_QUERY_WAS_SLOW) { + } else if (fields_eof.server_status & SERVER_QUERY_WAS_SLOW) { statistic = STAT_QUERY_WAS_SLOW; } MYSQLND_INC_CONN_STATISTIC(conn->stats, statistic); } } while (0); - PACKET_FREE(fields_eof); + PACKET_FREE(&fields_eof); break; /* switch break */ } } while (0); - PACKET_FREE(rset_header); + PACKET_FREE(&rset_header); DBG_INF(ret == PASS? "PASS":"FAIL"); DBG_RETURN(ret); @@ -716,20 +674,20 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row_c)(MYSQLND_RES * result, voi If we skip rows (row == NULL) we have to result->m.unbuffered_free_last_data() before it. The function returns always true. */ - if (PASS == (ret = PACKET_READ(row_packet)) && !row_packet->eof) { + if (PASS == (ret = PACKET_READ(conn, row_packet)) && !row_packet->eof) { result->unbuf->m.free_last_data(result->unbuf, conn->stats); result->unbuf->last_row_data = row_packet->fields; result->unbuf->last_row_buffer = row_packet->row_buffer; row_packet->fields = NULL; - row_packet->row_buffer = NULL; + row_packet->row_buffer.ptr = NULL; MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_NORMAL_UNBUF); if (!row_packet->skip_extraction) { unsigned int i, field_count = meta->field_count; - enum_func_status rc = result->unbuf->m.row_decoder(result->unbuf->last_row_buffer, + enum_func_status rc = result->unbuf->m.row_decoder(&result->unbuf->last_row_buffer, result->unbuf->last_row_data, field_count, row_packet->fields_metadata, @@ -837,20 +795,20 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row)(MYSQLND_RES * result, void If we skip rows (row == NULL) we have to result->m.unbuffered_free_last_data() before it. The function returns always true. */ - if (PASS == (ret = PACKET_READ(row_packet)) && !row_packet->eof) { + if (PASS == (ret = PACKET_READ(conn, row_packet)) && !row_packet->eof) { result->unbuf->m.free_last_data(result->unbuf, conn->stats); result->unbuf->last_row_data = row_packet->fields; result->unbuf->last_row_buffer = row_packet->row_buffer; row_packet->fields = NULL; - row_packet->row_buffer = NULL; + row_packet->row_buffer.ptr = NULL; MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_NORMAL_UNBUF); if (!row_packet->skip_extraction) { unsigned int i, field_count = meta->field_count; - enum_func_status rc = result->unbuf->m.row_decoder(result->unbuf->last_row_buffer, + enum_func_status rc = result->unbuf->m.row_decoder(&result->unbuf->last_row_buffer, result->unbuf->last_row_data, field_count, row_packet->fields_metadata, @@ -881,10 +839,10 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row)(MYSQLND_RES * result, void hashing of the column name, which is not needed as it can be precomputed. */ Z_TRY_ADDREF_P(data); - if (meta->zend_hash_keys[i].is_numeric == FALSE) { + if (meta->fields[i].is_numeric == FALSE) { zend_hash_update(row_ht, meta->fields[i].sname, data); } else { - zend_hash_index_update(row_ht, meta->zend_hash_keys[i].key, data); + zend_hash_index_update(row_ht, meta->fields[i].num_key, data); } } @@ -948,7 +906,7 @@ MYSQLND_METHOD(mysqlnd_res, use_result)(MYSQLND_RES * const result, const zend_b result->type = MYSQLND_RES_PS_UNBUF; } - result->unbuf = mysqlnd_result_unbuffered_init(result->field_count, ps, result->persistent); + result->unbuf = mysqlnd_result_unbuffered_init(result, result->field_count, ps); if (!result->unbuf) { goto oom; } @@ -960,10 +918,9 @@ MYSQLND_METHOD(mysqlnd_res, use_result)(MYSQLND_RES * const result, const zend_b */ /* FALSE = non-persistent */ { - struct st_mysqlnd_packet_row * row_packet = conn->payload_decoder_factory->m.get_row_packet(conn->payload_decoder_factory, FALSE); - if (!row_packet) { - goto oom; - } + struct st_mysqlnd_packet_row *row_packet = mnd_emalloc(sizeof(struct st_mysqlnd_packet_row)); + + conn->payload_decoder_factory->m.init_row_packet(row_packet); row_packet->result_set_memory_pool = result->unbuf->result_set_memory_pool; row_packet->field_count = result->field_count; row_packet->binary_protocol = ps; @@ -1003,7 +960,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered, fetch_row_c)(MYSQLND_RES * result, void if (Z_ISUNDEF(current_row[0])) { uint64_t row_num = (set->data_cursor - set->data) / field_count; - enum_func_status rc = set->m.row_decoder(set->row_buffers[row_num], + enum_func_status rc = set->m.row_decoder(&set->row_buffers[row_num], current_row, field_count, meta->fields, @@ -1093,7 +1050,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered_zval, fetch_row)(MYSQLND_RES * result, vo if (Z_ISUNDEF(current_row[0])) { const size_t row_num = (set->data_cursor - set->data) / field_count; - enum_func_status rc = set->m.row_decoder(set->row_buffers[row_num], + enum_func_status rc = set->m.row_decoder(&set->row_buffers[row_num], current_row, field_count, meta->fields, @@ -1136,10 +1093,10 @@ MYSQLND_METHOD(mysqlnd_result_buffered_zval, fetch_row)(MYSQLND_RES * result, vo hashing of the column name, which is not needed as it can be precomputed. */ Z_TRY_ADDREF_P(data); - if (meta->zend_hash_keys[i].is_numeric == FALSE) { + if (meta->fields[i].is_numeric == FALSE) { zend_hash_update(Z_ARRVAL_P(row), meta->fields[i].sname, data); } else { - zend_hash_index_update(Z_ARRVAL_P(row), meta->zend_hash_keys[i].key, data); + zend_hash_index_update(Z_ARRVAL_P(row), meta->fields[i].num_key, data); } } } @@ -1185,7 +1142,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_row)(MYSQLND_RES * result, void DBG_RETURN(FAIL); } - rc = result->stored_data->m.row_decoder(result->stored_data->row_buffers[set->current_row], + rc = result->stored_data->m.row_decoder(&result->stored_data->row_buffers[set->current_row], current_row, field_count, meta->fields, @@ -1194,7 +1151,7 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_row)(MYSQLND_RES * result, void if (rc != PASS) { DBG_RETURN(FAIL); } - if (!(set->initialized[set->current_row >> 3] & (1 << (set->current_row & 7)))) { + if (!ZEND_BIT_TEST(set->initialized, set->current_row)) { set->initialized[set->current_row >> 3] |= (1 << (set->current_row & 7)); /* mark initialized */ ++set->initialized_rows; @@ -1232,10 +1189,10 @@ MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_row)(MYSQLND_RES * result, void hashing of the column name, which is not needed as it can be precomputed. */ Z_TRY_ADDREF_P(data); - if (meta->zend_hash_keys[i].is_numeric == FALSE) { + if (meta->fields[i].is_numeric == FALSE) { zend_hash_update(Z_ARRVAL_P(row), meta->fields[i].sname, data); } else { - zend_hash_index_update(Z_ARRVAL_P(row), meta->zend_hash_keys[i].key, data); + zend_hash_index_update(Z_ARRVAL_P(row), meta->fields[i].num_key, data); } } /* @@ -1280,77 +1237,80 @@ MYSQLND_METHOD(mysqlnd_res, fetch_row)(MYSQLND_RES * result, void * param, const /* }}} */ -#define STORE_RESULT_PREALLOCATED_SET_IF_NOT_EMPTY 2 - /* {{{ mysqlnd_res::store_result_fetch_data */ enum_func_status MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(MYSQLND_CONN_DATA * const conn, MYSQLND_RES * result, MYSQLND_RES_METADATA * meta, - MYSQLND_MEMORY_POOL_CHUNK ***row_buffers, + MYSQLND_ROW_BUFFER **row_buffers, zend_bool binary_protocol) { enum_func_status ret; - unsigned int next_extend = STORE_RESULT_PREALLOCATED_SET_IF_NOT_EMPTY, free_rows = 1; + uint64_t total_allocated_rows = 0; + unsigned int free_rows = 0; MYSQLND_RES_BUFFERED * set = result->stored_data; - MYSQLND_PACKET_ROW * row_packet = NULL; + MYSQLND_PACKET_ROW row_packet; DBG_ENTER("mysqlnd_res::store_result_fetch_data"); if (!set || !row_buffers) { ret = FAIL; goto end; } - if (free_rows) { - *row_buffers = mnd_pemalloc((size_t)(free_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *)), 0); - if (!*row_buffers) { - SET_OOM_ERROR(conn->error_info); - ret = FAIL; - goto end; - } - } - /* non-persistent */ - row_packet = conn->payload_decoder_factory->m.get_row_packet(conn->payload_decoder_factory, FALSE); - if (!row_packet) { - SET_OOM_ERROR(conn->error_info); - ret = FAIL; - goto end; - } + + *row_buffers = NULL; + + conn->payload_decoder_factory->m.init_row_packet(&row_packet); set->references = 1; - row_packet->result_set_memory_pool = result->stored_data->result_set_memory_pool; - row_packet->field_count = meta->field_count; - row_packet->binary_protocol = binary_protocol; - row_packet->fields_metadata = meta->fields; + row_packet.result_set_memory_pool = result->stored_data->result_set_memory_pool; + row_packet.field_count = meta->field_count; + row_packet.binary_protocol = binary_protocol; + row_packet.fields_metadata = meta->fields; - row_packet->skip_extraction = TRUE; /* let php_mysqlnd_rowp_read() not allocate row_packet->fields, we will do it */ + row_packet.skip_extraction = TRUE; /* let php_mysqlnd_rowp_read() not allocate row_packet.fields, we will do it */ - while (FAIL != (ret = PACKET_READ(row_packet)) && !row_packet->eof) { + while (FAIL != (ret = PACKET_READ(conn, &row_packet)) && !row_packet.eof) { if (!free_rows) { - uint64_t total_allocated_rows = free_rows = next_extend = next_extend * 11 / 10; /* extend with 10% */ - MYSQLND_MEMORY_POOL_CHUNK ** new_row_buffers; - total_allocated_rows += set->row_count; + MYSQLND_ROW_BUFFER * new_row_buffers; + + if (total_allocated_rows < 1024) { + if (total_allocated_rows == 0) { + free_rows = 1; + total_allocated_rows = 1; + } else { + free_rows = total_allocated_rows; + total_allocated_rows *= 2; + } + } else { + free_rows = 1024; + total_allocated_rows += 1024; + } /* don't try to allocate more than possible - mnd_XXalloc expects size_t, and it can have narrower range than uint64_t */ - if (total_allocated_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *) > SIZE_MAX) { + if (total_allocated_rows * sizeof(MYSQLND_ROW_BUFFER) > SIZE_MAX) { SET_OOM_ERROR(conn->error_info); ret = FAIL; - goto end; + goto free_end; + } + if (*row_buffers) { + new_row_buffers = mnd_erealloc(*row_buffers, (size_t)(total_allocated_rows * sizeof(MYSQLND_ROW_BUFFER))); + } else { + new_row_buffers = mnd_emalloc((size_t)(total_allocated_rows * sizeof(MYSQLND_ROW_BUFFER))); } - new_row_buffers = mnd_perealloc(*row_buffers, (size_t)(total_allocated_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *)), 0); if (!new_row_buffers) { SET_OOM_ERROR(conn->error_info); ret = FAIL; - goto end; + goto free_end; } *row_buffers = new_row_buffers; } free_rows--; - (*row_buffers)[set->row_count] = row_packet->row_buffer; + (*row_buffers)[set->row_count] = row_packet.row_buffer; set->row_count++; /* So row_packet's destructor function won't efree() it */ - row_packet->fields = NULL; - row_packet->row_buffer = NULL; + row_packet.fields = NULL; + row_packet.row_buffer.ptr = NULL; /* No need to FREE_ALLOCA as we can reuse the @@ -1366,20 +1326,21 @@ MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(MYSQLND_CONN_DATA * const c set->row_count); /* Finally clean */ - if (row_packet->eof) { + if (row_packet.eof) { UPSERT_STATUS_RESET(conn->upsert_status); - UPSERT_STATUS_SET_WARNINGS(conn->upsert_status, row_packet->warning_count); - UPSERT_STATUS_SET_SERVER_STATUS(conn->upsert_status, row_packet->server_status); + UPSERT_STATUS_SET_WARNINGS(conn->upsert_status, row_packet.warning_count); + UPSERT_STATUS_SET_SERVER_STATUS(conn->upsert_status, row_packet.server_status); } + /* save some memory */ if (free_rows) { /* don't try to allocate more than possible - mnd_XXalloc expects size_t, and it can have narrower range than uint64_t */ - if (set->row_count * sizeof(MYSQLND_MEMORY_POOL_CHUNK *) > SIZE_MAX) { + if (set->row_count * sizeof(MYSQLND_ROW_BUFFER) > SIZE_MAX) { SET_OOM_ERROR(conn->error_info); ret = FAIL; - goto end; + goto free_end; } - *row_buffers = mnd_perealloc(*row_buffers, (size_t) (set->row_count * sizeof(MYSQLND_MEMORY_POOL_CHUNK *)), 0); + *row_buffers = mnd_erealloc(*row_buffers, (size_t) (set->row_count * sizeof(MYSQLND_ROW_BUFFER))); } if (UPSERT_STATUS_GET_SERVER_STATUS(conn->upsert_status) & SERVER_MORE_RESULTS_EXISTS) { @@ -1389,7 +1350,7 @@ MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(MYSQLND_CONN_DATA * const c } if (ret == FAIL) { - COPY_CLIENT_ERROR(&set->error_info, row_packet->error_info); + COPY_CLIENT_ERROR(&set->error_info, row_packet.error_info); } else { /* libmysql's documentation says it should be so for SELECT statements */ UPSERT_STATUS_SET_AFFECTED_ROWS(conn->upsert_status, set->row_count); @@ -1399,8 +1360,9 @@ MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(MYSQLND_CONN_DATA * const c (uint32_t) set->row_count, UPSERT_STATUS_GET_WARNINGS(conn->upsert_status), UPSERT_STATUS_GET_SERVER_STATUS(conn->upsert_status)); +free_end: + PACKET_FREE(&row_packet); end: - PACKET_FREE(row_packet); DBG_INF_FMT("rows=%llu", (unsigned long long)result->stored_data->row_count); DBG_RETURN(ret); } @@ -1414,7 +1376,7 @@ MYSQLND_METHOD(mysqlnd_res, store_result)(MYSQLND_RES * result, const unsigned int flags) { enum_func_status ret; - MYSQLND_MEMORY_POOL_CHUNK ***row_buffers = NULL; + MYSQLND_ROW_BUFFER **row_buffers = NULL; DBG_ENTER("mysqlnd_res::store_result"); @@ -1426,14 +1388,14 @@ MYSQLND_METHOD(mysqlnd_res, store_result)(MYSQLND_RES * result, SET_CONNECTION_STATE(&conn->state, CONN_FETCHING_DATA); if (flags & MYSQLND_STORE_NO_COPY) { - result->stored_data = (MYSQLND_RES_BUFFERED *) mysqlnd_result_buffered_zval_init(result->field_count, flags & MYSQLND_STORE_PS, result->persistent); + result->stored_data = (MYSQLND_RES_BUFFERED *) mysqlnd_result_buffered_zval_init(result, result->field_count, flags & MYSQLND_STORE_PS); if (!result->stored_data) { SET_OOM_ERROR(conn->error_info); DBG_RETURN(NULL); } row_buffers = &result->stored_data->row_buffers; } else if (flags & MYSQLND_STORE_COPY) { - result->stored_data = (MYSQLND_RES_BUFFERED *) mysqlnd_result_buffered_c_init(result->field_count, flags & MYSQLND_STORE_PS, result->persistent); + result->stored_data = (MYSQLND_RES_BUFFERED *) mysqlnd_result_buffered_c_init(result, result->field_count, flags & MYSQLND_STORE_PS); if (!result->stored_data) { SET_OOM_ERROR(conn->error_info); DBG_RETURN(NULL); @@ -1473,7 +1435,7 @@ MYSQLND_METHOD(mysqlnd_res, store_result)(MYSQLND_RES * result, } else if (flags & MYSQLND_STORE_COPY) { MYSQLND_RES_BUFFERED_C * set = (MYSQLND_RES_BUFFERED_C *) result->stored_data; set->current_row = 0; - set->initialized = mnd_pecalloc((unsigned int) ((set->row_count / 8) + 1), sizeof(zend_uchar), set->persistent); /* +1 for safety */ + set->initialized = mnd_ecalloc((unsigned int) ((set->row_count / 8) + 1), sizeof(zend_uchar)); /* +1 for safety */ } } @@ -1920,18 +1882,23 @@ MYSQLND_CLASS_METHODS_END; /* {{{ mysqlnd_result_init */ PHPAPI MYSQLND_RES * -mysqlnd_result_init(const unsigned int field_count, const zend_bool persistent) +mysqlnd_result_init(const unsigned int field_count) { const size_t alloc_size = sizeof(MYSQLND_RES) + mysqlnd_plugin_count() * sizeof(void *); - MYSQLND_RES * ret = mnd_pecalloc(1, alloc_size, persistent); + MYSQLND_MEMORY_POOL * pool; + MYSQLND_RES * ret; DBG_ENTER("mysqlnd_result_init"); - if (!ret) { + pool = mysqlnd_mempool_create(MYSQLND_G(mempool_default_size)); + if (!pool) { DBG_RETURN(NULL); } - ret->persistent = persistent; + ret = pool->get_chunk(pool, alloc_size); + memset(ret, 0, alloc_size); + + ret->memory_pool = pool; ret->field_count = field_count; ret->m = *mysqlnd_result_get_methods(); @@ -1942,27 +1909,22 @@ mysqlnd_result_init(const unsigned int field_count, const zend_bool persistent) /* {{{ mysqlnd_result_unbuffered_init */ PHPAPI MYSQLND_RES_UNBUFFERED * -mysqlnd_result_unbuffered_init(const unsigned int field_count, const zend_bool ps, const zend_bool persistent) +mysqlnd_result_unbuffered_init(MYSQLND_RES *result, const unsigned int field_count, const zend_bool ps) { const size_t alloc_size = sizeof(MYSQLND_RES_UNBUFFERED) + mysqlnd_plugin_count() * sizeof(void *); - MYSQLND_RES_UNBUFFERED * ret = mnd_pecalloc(1, alloc_size, persistent); + MYSQLND_MEMORY_POOL * pool = result->memory_pool; + MYSQLND_RES_UNBUFFERED * ret; DBG_ENTER("mysqlnd_result_unbuffered_init"); - if (!ret) { - DBG_RETURN(NULL); - } - if (!(ret->lengths = mnd_pecalloc(field_count, sizeof(size_t), persistent))) { - mnd_pefree(ret, persistent); - DBG_RETURN(NULL); - } - if (!(ret->result_set_memory_pool = mysqlnd_mempool_create(MYSQLND_G(mempool_default_size)))) { - mnd_efree(ret->lengths); - mnd_pefree(ret, persistent); - DBG_RETURN(NULL); - } + mysqlnd_mempool_save_state(pool); + ret = pool->get_chunk(pool, alloc_size); + memset(ret, 0, alloc_size); + + ret->lengths = pool->get_chunk(pool, field_count * sizeof(size_t)); + memset(ret->lengths, 0, field_count * sizeof(size_t)); - ret->persistent = persistent; + ret->result_set_memory_pool = pool; ret->field_count= field_count; ret->ps = ps; @@ -1982,31 +1944,27 @@ mysqlnd_result_unbuffered_init(const unsigned int field_count, const zend_bool p /* {{{ mysqlnd_result_buffered_zval_init */ PHPAPI MYSQLND_RES_BUFFERED_ZVAL * -mysqlnd_result_buffered_zval_init(const unsigned int field_count, const zend_bool ps, const zend_bool persistent) +mysqlnd_result_buffered_zval_init(MYSQLND_RES * result, const unsigned int field_count, const zend_bool ps) { const size_t alloc_size = sizeof(MYSQLND_RES_BUFFERED_ZVAL) + mysqlnd_plugin_count() * sizeof(void *); - MYSQLND_RES_BUFFERED_ZVAL * ret = mnd_pecalloc(1, alloc_size, persistent); + MYSQLND_MEMORY_POOL * pool = result->memory_pool; + MYSQLND_RES_BUFFERED_ZVAL * ret; DBG_ENTER("mysqlnd_result_buffered_zval_init"); - if (!ret) { - DBG_RETURN(NULL); - } - if (FAIL == mysqlnd_error_info_init(&ret->error_info, persistent)) { - mnd_pefree(ret, persistent); - DBG_RETURN(NULL); - } - if (!(ret->lengths = mnd_pecalloc(field_count, sizeof(size_t), persistent))) { - mnd_pefree(ret, persistent); - DBG_RETURN(NULL); - } - if (!(ret->result_set_memory_pool = mysqlnd_mempool_create(MYSQLND_G(mempool_default_size)))) { - mnd_efree(ret->lengths); - mnd_pefree(ret, persistent); + mysqlnd_mempool_save_state(pool); + ret = pool->get_chunk(pool, alloc_size); + memset(ret, 0, alloc_size); + + if (FAIL == mysqlnd_error_info_init(&ret->error_info, 0)) { + mysqlnd_mempool_restore_state(pool); DBG_RETURN(NULL); } - ret->persistent = persistent; + ret->lengths = pool->get_chunk(pool, field_count * sizeof(size_t)); + memset(ret->lengths, 0, field_count * sizeof(size_t)); + + ret->result_set_memory_pool = pool; ret->field_count= field_count; ret->ps = ps; ret->m = *mysqlnd_result_buffered_get_methods(); @@ -2029,31 +1987,27 @@ mysqlnd_result_buffered_zval_init(const unsigned int field_count, const zend_boo /* {{{ mysqlnd_result_buffered_c_init */ PHPAPI MYSQLND_RES_BUFFERED_C * -mysqlnd_result_buffered_c_init(const unsigned int field_count, const zend_bool ps, const zend_bool persistent) +mysqlnd_result_buffered_c_init(MYSQLND_RES * result, const unsigned int field_count, const zend_bool ps) { const size_t alloc_size = sizeof(MYSQLND_RES_BUFFERED_C) + mysqlnd_plugin_count() * sizeof(void *); - MYSQLND_RES_BUFFERED_C * ret = mnd_pecalloc(1, alloc_size, persistent); + MYSQLND_MEMORY_POOL * pool = result->memory_pool; + MYSQLND_RES_BUFFERED_C * ret; DBG_ENTER("mysqlnd_result_buffered_c_init"); - if (!ret) { - DBG_RETURN(NULL); - } - if (FAIL == mysqlnd_error_info_init(&ret->error_info, persistent)) { - mnd_pefree(ret, persistent); - DBG_RETURN(NULL); - } - if (!(ret->lengths = mnd_pecalloc(field_count, sizeof(size_t), persistent))) { - mnd_pefree(ret, persistent); - DBG_RETURN(NULL); - } - if (!(ret->result_set_memory_pool = mysqlnd_mempool_create(MYSQLND_G(mempool_default_size)))) { - mnd_efree(ret->lengths); - mnd_pefree(ret, persistent); + mysqlnd_mempool_save_state(pool); + ret = pool->get_chunk(pool, alloc_size); + memset(ret, 0, alloc_size); + + if (FAIL == mysqlnd_error_info_init(&ret->error_info, 0)) { + mysqlnd_mempool_restore_state(pool); DBG_RETURN(NULL); } - ret->persistent = persistent; + ret->lengths = pool->get_chunk(pool, field_count * sizeof(size_t)); + memset(ret->lengths, 0, field_count * sizeof(size_t)); + + ret->result_set_memory_pool = pool; ret->field_count= field_count; ret->ps = ps; ret->m = *mysqlnd_result_buffered_get_methods(); diff --git a/ext/mysqlnd/mysqlnd_result.h b/ext/mysqlnd/mysqlnd_result.h index ec2bb9db2d..b8b919d942 100644 --- a/ext/mysqlnd/mysqlnd_result.h +++ b/ext/mysqlnd/mysqlnd_result.h @@ -20,10 +20,10 @@ #ifndef MYSQLND_RESULT_H #define MYSQLND_RESULT_H -PHPAPI MYSQLND_RES * mysqlnd_result_init(const unsigned int field_count, const zend_bool persistent); -PHPAPI MYSQLND_RES_UNBUFFERED * mysqlnd_result_unbuffered_init(const unsigned int field_count, const zend_bool ps, const zend_bool persistent); -PHPAPI MYSQLND_RES_BUFFERED_ZVAL * mysqlnd_result_buffered_zval_init(const unsigned int field_count, const zend_bool ps, const zend_bool persistent); -PHPAPI MYSQLND_RES_BUFFERED_C * mysqlnd_result_buffered_c_init(const unsigned int field_count, const zend_bool ps, const zend_bool persistent); +PHPAPI MYSQLND_RES * mysqlnd_result_init(const unsigned int field_count); +PHPAPI MYSQLND_RES_UNBUFFERED * mysqlnd_result_unbuffered_init(MYSQLND_RES * result, const unsigned int field_count, const zend_bool ps); +PHPAPI MYSQLND_RES_BUFFERED_ZVAL * mysqlnd_result_buffered_zval_init(MYSQLND_RES * result, const unsigned int field_count, const zend_bool ps); +PHPAPI MYSQLND_RES_BUFFERED_C * mysqlnd_result_buffered_c_init(MYSQLND_RES * result, const unsigned int field_count, const zend_bool ps); enum_func_status mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * stmt); diff --git a/ext/mysqlnd/mysqlnd_result_meta.c b/ext/mysqlnd/mysqlnd_result_meta.c index 6fc6c75cac..5aa8b0d23d 100644 --- a/ext/mysqlnd/mysqlnd_result_meta.c +++ b/ext/mysqlnd/mysqlnd_result_meta.c @@ -30,17 +30,11 @@ /* {{{ php_mysqlnd_free_field_metadata */ static void -php_mysqlnd_free_field_metadata(MYSQLND_FIELD *meta, zend_bool persistent) +php_mysqlnd_free_field_metadata(MYSQLND_FIELD *meta) { if (meta) { - if (meta->root) { - mnd_pefree(meta->root, persistent); - meta->root = NULL; - } - if (meta->def) { - mnd_pefree(meta->def, persistent); - meta->def = NULL; - } + meta->root = NULL; + meta->def = NULL; if (meta->sname) { zend_string_release(meta->sname); } @@ -50,53 +44,47 @@ php_mysqlnd_free_field_metadata(MYSQLND_FIELD *meta, zend_bool persistent) /* {{{ mysqlnd_res_meta::read_metadata */ static enum_func_status -MYSQLND_METHOD(mysqlnd_res_meta, read_metadata)(MYSQLND_RES_METADATA * const meta, MYSQLND_CONN_DATA * conn) +MYSQLND_METHOD(mysqlnd_res_meta, read_metadata)(MYSQLND_RES_METADATA * const meta, MYSQLND_CONN_DATA * conn, MYSQLND_RES * result) { unsigned int i = 0; - MYSQLND_PACKET_RES_FIELD * field_packet; + MYSQLND_PACKET_RES_FIELD field_packet; DBG_ENTER("mysqlnd_res_meta::read_metadata"); - field_packet = conn->payload_decoder_factory->m.get_result_field_packet(conn->payload_decoder_factory, FALSE); - if (!field_packet) { - SET_OOM_ERROR(conn->error_info); - DBG_RETURN(FAIL); - } - field_packet->persistent_alloc = meta->persistent; + conn->payload_decoder_factory->m.init_result_field_packet(&field_packet); + field_packet.memory_pool = result->memory_pool; for (;i < meta->field_count; i++) { zend_ulong idx; - if (meta->fields[i].root) { - /* We re-read metadata for PS */ - mnd_pefree(meta->fields[i].root, meta->persistent); - meta->fields[i].root = NULL; - } + /* We re-read metadata for PS */ + ZEND_ASSERT(meta->fields[i].root == NULL); + meta->fields[i].root = NULL; - field_packet->metadata = &(meta->fields[i]); - if (FAIL == PACKET_READ(field_packet)) { - PACKET_FREE(field_packet); + field_packet.metadata = &(meta->fields[i]); + if (FAIL == PACKET_READ(conn, &field_packet)) { + PACKET_FREE(&field_packet); DBG_RETURN(FAIL); } - if (field_packet->error_info.error_no) { - COPY_CLIENT_ERROR(conn->error_info, field_packet->error_info); + if (field_packet.error_info.error_no) { + COPY_CLIENT_ERROR(conn->error_info, field_packet.error_info); /* Return back from CONN_QUERY_SENT */ - PACKET_FREE(field_packet); + PACKET_FREE(&field_packet); DBG_RETURN(FAIL); } if (mysqlnd_ps_fetch_functions[meta->fields[i].type].func == NULL) { DBG_ERR_FMT("Unknown type %u sent by the server. Please send a report to the developers", meta->fields[i].type); php_error_docref(NULL, E_WARNING, "Unknown type %u sent by the server. Please send a report to the developers", meta->fields[i].type); - PACKET_FREE(field_packet); + PACKET_FREE(&field_packet); DBG_RETURN(FAIL); } /* For BC we have to check whether the key is numeric and use it like this */ - if ((meta->zend_hash_keys[i].is_numeric = ZEND_HANDLE_NUMERIC(field_packet->metadata->sname, idx))) { - meta->zend_hash_keys[i].key = idx; + if ((meta->fields[i].is_numeric = ZEND_HANDLE_NUMERIC(field_packet.metadata->sname, idx))) { + meta->fields[i].num_key = idx; } } - PACKET_FREE(field_packet); + PACKET_FREE(&field_packet); DBG_RETURN(PASS); } @@ -110,25 +98,17 @@ MYSQLND_METHOD(mysqlnd_res_meta, free)(MYSQLND_RES_METADATA * meta) int i; MYSQLND_FIELD *fields; DBG_ENTER("mysqlnd_res_meta::free"); - DBG_INF_FMT("persistent=%u", meta->persistent); if ((fields = meta->fields)) { DBG_INF("Freeing fields metadata"); i = meta->field_count; while (i--) { - php_mysqlnd_free_field_metadata(fields++, meta->persistent); + php_mysqlnd_free_field_metadata(fields++); } - mnd_pefree(meta->fields, meta->persistent); meta->fields = NULL; } - if (meta->zend_hash_keys) { - DBG_INF("Freeing zend_hash_keys"); - mnd_pefree(meta->zend_hash_keys, meta->persistent); - meta->zend_hash_keys = NULL; - } DBG_INF("Freeing metadata structure"); - mnd_pefree(meta, meta->persistent); DBG_VOID_RETURN; } @@ -137,35 +117,28 @@ MYSQLND_METHOD(mysqlnd_res_meta, free)(MYSQLND_RES_METADATA * meta) /* {{{ mysqlnd_res::clone_metadata */ static MYSQLND_RES_METADATA * -MYSQLND_METHOD(mysqlnd_res_meta, clone_metadata)(const MYSQLND_RES_METADATA * const meta, const zend_bool persistent) +MYSQLND_METHOD(mysqlnd_res_meta, clone_metadata)(MYSQLND_RES * result, const MYSQLND_RES_METADATA * const meta) { unsigned int i; /* +1 is to have empty marker at the end */ MYSQLND_RES_METADATA * new_meta = NULL; MYSQLND_FIELD * new_fields; MYSQLND_FIELD * orig_fields = meta->fields; - size_t len = meta->field_count * sizeof(struct mysqlnd_field_hash_key); DBG_ENTER("mysqlnd_res_meta::clone_metadata"); - DBG_INF_FMT("persistent=%u", persistent); - new_meta = mnd_pecalloc(1, sizeof(MYSQLND_RES_METADATA), persistent); + new_meta = result->memory_pool->get_chunk(result->memory_pool, sizeof(MYSQLND_RES_METADATA)); if (!new_meta) { goto oom; } - new_meta->persistent = persistent; + memset(new_meta, 0, sizeof(MYSQLND_RES_METADATA)); new_meta->m = meta->m; - new_fields = mnd_pecalloc(meta->field_count + 1, sizeof(MYSQLND_FIELD), persistent); + new_fields = result->memory_pool->get_chunk(result->memory_pool, (meta->field_count + 1) * sizeof(MYSQLND_FIELD)); if (!new_fields) { goto oom; } - - new_meta->zend_hash_keys = mnd_pemalloc(len, persistent); - if (!new_meta->zend_hash_keys) { - goto oom; - } - memcpy(new_meta->zend_hash_keys, meta->zend_hash_keys, len); + memset(new_fields, 0, (meta->field_count + 1) * sizeof(MYSQLND_FIELD)); /* This will copy also the strings and the root, which we will have @@ -174,7 +147,7 @@ MYSQLND_METHOD(mysqlnd_res_meta, clone_metadata)(const MYSQLND_RES_METADATA * co memcpy(new_fields, orig_fields, (meta->field_count) * sizeof(MYSQLND_FIELD)); for (i = 0; i < meta->field_count; i++) { /* First copy the root, then field by field adjust the pointers */ - new_fields[i].root = mnd_pemalloc(orig_fields[i].root_len, persistent); + new_fields[i].root = result->memory_pool->get_chunk(result->memory_pool, orig_fields[i].root_len); if (!new_fields[i].root) { goto oom; @@ -188,6 +161,9 @@ MYSQLND_METHOD(mysqlnd_res_meta, clone_metadata)(const MYSQLND_RES_METADATA * co new_fields[i].name_length = ZSTR_LEN(new_fields[i].sname); } + new_fields[i].is_numeric = orig_fields[i].is_numeric; + new_fields[i].num_key = orig_fields[i].num_key; + if (orig_fields[i].org_name && orig_fields[i].org_name != mysqlnd_empty_string) { new_fields[i].org_name = new_fields[i].root + (orig_fields[i].org_name - orig_fields[i].root); @@ -208,7 +184,7 @@ MYSQLND_METHOD(mysqlnd_res_meta, clone_metadata)(const MYSQLND_RES_METADATA * co } /* def is not on the root, if allocated at all */ if (orig_fields[i].def) { - new_fields[i].def = mnd_pemalloc(orig_fields[i].def_length + 1, persistent); + new_fields[i].def = result->memory_pool->get_chunk(result->memory_pool, orig_fields[i].def_length + 1); if (!new_fields[i].def) { goto oom; } @@ -309,33 +285,25 @@ MYSQLND_CLASS_METHODS_END; /* {{{ mysqlnd_result_meta_init */ PHPAPI MYSQLND_RES_METADATA * -mysqlnd_result_meta_init(unsigned int field_count, zend_bool persistent) +mysqlnd_result_meta_init(MYSQLND_RES *result, unsigned int field_count) { size_t alloc_size = sizeof(MYSQLND_RES_METADATA) + mysqlnd_plugin_count() * sizeof(void *); - MYSQLND_RES_METADATA *ret = mnd_pecalloc(1, alloc_size, persistent); + MYSQLND_RES_METADATA *ret; DBG_ENTER("mysqlnd_result_meta_init"); - DBG_INF_FMT("persistent=%u", persistent); do { - if (!ret) { - break; - } + ret = result->memory_pool->get_chunk(result->memory_pool, alloc_size); + memset(ret, 0, alloc_size); ret->m = & mysqlnd_mysqlnd_res_meta_methods; - ret->persistent = persistent; ret->field_count = field_count; /* +1 is to have empty marker at the end */ - ret->fields = mnd_pecalloc(field_count + 1, sizeof(MYSQLND_FIELD), ret->persistent); - ret->zend_hash_keys = mnd_pecalloc(field_count, sizeof(struct mysqlnd_field_hash_key), ret->persistent); - if (!ret->fields || !ret->zend_hash_keys) { - break; - } + alloc_size = (field_count + 1) * sizeof(MYSQLND_FIELD); + ret->fields = result->memory_pool->get_chunk(result->memory_pool, alloc_size); + memset(ret->fields, 0, alloc_size); DBG_INF_FMT("meta=%p", ret); DBG_RETURN(ret); } while (0); - if (ret) { - ret->m->free_metadata(ret); - } DBG_RETURN(NULL); } /* }}} */ diff --git a/ext/mysqlnd/mysqlnd_result_meta.h b/ext/mysqlnd/mysqlnd_result_meta.h index 35b9ffcb21..09af69837e 100644 --- a/ext/mysqlnd/mysqlnd_result_meta.h +++ b/ext/mysqlnd/mysqlnd_result_meta.h @@ -13,7 +13,7 @@ | license@php.net so we can mail you a copy immediately. | +----------------------------------------------------------------------+ | Authors: Andrey Hristov <andrey@php.net> | - | Johannes Schlüter <johannes@php.net> | + | Johannes Schlüter <johannes@php.net> | | Ulf Wendel <uw@php.net> | +----------------------------------------------------------------------+ */ @@ -21,7 +21,7 @@ #ifndef MYSQLND_RESULT_META_H #define MYSQLND_RESULT_META_H -PHPAPI MYSQLND_RES_METADATA * mysqlnd_result_meta_init(unsigned int field_count, zend_bool persistent); +PHPAPI MYSQLND_RES_METADATA * mysqlnd_result_meta_init(MYSQLND_RES * result, unsigned int field_count); PHPAPI struct st_mysqlnd_res_meta_methods * mysqlnd_result_metadata_get_methods(); PHPAPI void ** _mysqlnd_plugin_get_plugin_result_metadata_data(const MYSQLND_RES_METADATA * meta, unsigned int plugin_id); diff --git a/ext/mysqlnd/mysqlnd_reverse_api.c b/ext/mysqlnd/mysqlnd_reverse_api.c index d1a1c952b5..931c3b26e2 100644 --- a/ext/mysqlnd/mysqlnd_reverse_api.c +++ b/ext/mysqlnd/mysqlnd_reverse_api.c @@ -13,7 +13,7 @@ | license@php.net so we can mail you a copy immediately. | +----------------------------------------------------------------------+ | Authors: Andrey Hristov <andrey@php.net> | - | Johannes Schlüter <johannes@php.net> | + | Johannes Schlüter <johannes@php.net> | | Ulf Wendel <uw@php.net> | +----------------------------------------------------------------------+ */ @@ -57,9 +57,9 @@ mysqlnd_reverse_api_get_api_list(void) /* {{{ mysqlnd_reverse_api_register_api */ PHPAPI void -mysqlnd_reverse_api_register_api(MYSQLND_REVERSE_API * apiext) +mysqlnd_reverse_api_register_api(const MYSQLND_REVERSE_API * apiext) { - zend_hash_str_add_ptr(&mysqlnd_api_ext_ht, apiext->module->name, strlen(apiext->module->name), apiext); + zend_hash_str_add_ptr(&mysqlnd_api_ext_ht, apiext->module->name, strlen(apiext->module->name), (void*)apiext); } /* }}} */ diff --git a/ext/mysqlnd/mysqlnd_reverse_api.h b/ext/mysqlnd/mysqlnd_reverse_api.h index 9df91a938b..448f33bfea 100644 --- a/ext/mysqlnd/mysqlnd_reverse_api.h +++ b/ext/mysqlnd/mysqlnd_reverse_api.h @@ -32,7 +32,7 @@ PHPAPI void mysqlnd_reverse_api_end(void); PHPAPI HashTable * mysqlnd_reverse_api_get_api_list(void); -PHPAPI void mysqlnd_reverse_api_register_api(MYSQLND_REVERSE_API * apiext); +PHPAPI void mysqlnd_reverse_api_register_api(const MYSQLND_REVERSE_API * apiext); PHPAPI MYSQLND * zval_to_mysqlnd(zval * zv, const unsigned int client_api_capabilities, unsigned int * save_client_api_capabilities); #endif /* MYSQLND_REVERSE_API_H */ diff --git a/ext/mysqlnd/mysqlnd_structs.h b/ext/mysqlnd/mysqlnd_structs.h index 81b2406646..a7c892b48d 100644 --- a/ext/mysqlnd/mysqlnd_structs.h +++ b/ext/mysqlnd/mysqlnd_structs.h @@ -49,29 +49,25 @@ typedef struct st_mysqlnd_const_string typedef struct st_mysqlnd_memory_pool MYSQLND_MEMORY_POOL; -typedef struct st_mysqlnd_memory_pool_chunk MYSQLND_MEMORY_POOL_CHUNK; -typedef struct st_mysqlnd_memory_pool_chunk_llist MYSQLND_MEMORY_POOL_CHUNK_LLIST; - - -#define MYSQLND_MEMORY_POOL_CHUNK_LIST_SIZE 100 struct st_mysqlnd_memory_pool { - zend_uchar *arena; - unsigned int arena_size; - unsigned int free_size; + zend_arena *arena; + void *last; + void *checkpoint; - MYSQLND_MEMORY_POOL_CHUNK* (*get_chunk)(MYSQLND_MEMORY_POOL * pool, unsigned int size); - enum_func_status (*resize_chunk)(MYSQLND_MEMORY_POOL * pool, MYSQLND_MEMORY_POOL_CHUNK * chunk, unsigned int size); - void (*free_chunk)(MYSQLND_MEMORY_POOL * pool, MYSQLND_MEMORY_POOL_CHUNK * chunk); + void* (*get_chunk)(MYSQLND_MEMORY_POOL * pool, size_t size); + void* (*resize_chunk)(MYSQLND_MEMORY_POOL * pool, void * ptr, size_t old_size, size_t size); + void (*free_chunk)(MYSQLND_MEMORY_POOL * pool, void * ptr); }; -struct st_mysqlnd_memory_pool_chunk + +typedef struct st_mysqlnd_row_buffer MYSQLND_ROW_BUFFER; + +struct st_mysqlnd_row_buffer { - size_t app; - zend_uchar *ptr; - unsigned int size; - zend_bool from_pool; + void *ptr; + size_t size; }; @@ -85,6 +81,8 @@ typedef struct st_mysqlnd_cmd_buffer typedef struct st_mysqlnd_field { zend_string *sname; /* Name of column */ + zend_bool is_numeric; + zend_ulong num_key; const char *name; /* Name of column in C string */ const char *org_name; /* Original column name, if an alias */ const char *table; /* Table of column if column was a field */ @@ -152,7 +150,7 @@ struct st_mysqlnd_error_info char error[MYSQLND_ERRMSG_SIZE+1]; char sqlstate[MYSQLND_SQLSTATE_LENGTH + 1]; unsigned int error_no; - zend_llist * error_list; + zend_llist error_list; zend_bool persistent; MYSQLND_CLASS_METHODS_TYPE(mysqlnd_error_info) *m; @@ -370,7 +368,7 @@ MYSQLND_CLASS_METHODS_TYPE(mysqlnd_object_factory); typedef MYSQLND * (*func_mysqlnd_object_factory__get_connection)(MYSQLND_CLASS_METHODS_TYPE(mysqlnd_object_factory) * factory, const zend_bool persistent); typedef MYSQLND * (*func_mysqlnd_object_factory__clone_connection_object)(MYSQLND * conn); -typedef MYSQLND_STMT * (*func_mysqlnd_object_factory__get_prepared_statement)(MYSQLND_CONN_DATA * conn, const zend_bool persistent); +typedef MYSQLND_STMT * (*func_mysqlnd_object_factory__get_prepared_statement)(MYSQLND_CONN_DATA * conn); typedef MYSQLND_PFC * (*func_mysqlnd_object_factory__get_pfc)(const zend_bool persistent, MYSQLND_STATS * stats, MYSQLND_ERROR_INFO * error_info); typedef MYSQLND_VIO * (*func_mysqlnd_object_factory__get_vio)(const zend_bool persistent, MYSQLND_STATS * stats, MYSQLND_ERROR_INFO * error_info); typedef MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * (*func_mysqlnd_object_factory__get_protocol_payload_decoder_factory)(MYSQLND_CONN_DATA * conn, const zend_bool persistent); @@ -451,7 +449,7 @@ typedef enum_func_status (*func_mysqlnd_conn_data__send_close)(MYSQLND_CONN_DATA typedef enum_func_status (*func_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); -typedef MYSQLND_RES * (*func_mysqlnd_conn_data__result_init)(unsigned int field_count, zend_bool persistent); +typedef MYSQLND_RES * (*func_mysqlnd_conn_data__result_init)(unsigned int field_count); typedef enum_func_status (*func_mysqlnd_conn_data__set_autocommit)(MYSQLND_CONN_DATA * conn, unsigned int mode); typedef enum_func_status (*func_mysqlnd_conn_data__tx_commit)(MYSQLND_CONN_DATA * conn); @@ -585,7 +583,7 @@ MYSQLND_CLASS_METHODS_TYPE(mysqlnd_conn) /* for decoding - binary or text protocol */ -typedef enum_func_status (*func_mysqlnd_res__row_decoder)(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval * fields, +typedef enum_func_status (*func_mysqlnd_res__row_decoder)(MYSQLND_ROW_BUFFER * row_buffer, zval * fields, unsigned int field_count, const MYSQLND_FIELD * fields_metadata, zend_bool as_int_or_float, MYSQLND_STATS * stats); @@ -608,7 +606,7 @@ typedef const MYSQLND_FIELD *(*func_mysqlnd_res__fetch_fields)(MYSQLND_RES * con typedef enum_func_status (*func_mysqlnd_res__read_result_metadata)(MYSQLND_RES * result, MYSQLND_CONN_DATA * conn); typedef const size_t * (*func_mysqlnd_res__fetch_lengths)(MYSQLND_RES * const result); -typedef enum_func_status (*func_mysqlnd_res__store_result_fetch_data)(MYSQLND_CONN_DATA * const conn, MYSQLND_RES * result, MYSQLND_RES_METADATA * meta, MYSQLND_MEMORY_POOL_CHUNK *** row_buffers, zend_bool binary_protocol); +typedef enum_func_status (*func_mysqlnd_res__store_result_fetch_data)(MYSQLND_CONN_DATA * const conn, MYSQLND_RES * result, MYSQLND_RES_METADATA * meta, MYSQLND_ROW_BUFFER ** row_buffers, zend_bool binary_protocol); typedef void (*func_mysqlnd_res__free_result_buffers)(MYSQLND_RES * result); /* private */ typedef enum_func_status (*func_mysqlnd_res__free_result)(MYSQLND_RES * result, const zend_bool implicit); @@ -618,7 +616,7 @@ typedef void (*func_mysqlnd_res__free_buffered_data)(MYSQLND_RES *result); typedef void (*func_mysqlnd_res__unbuffered_free_last_data)(MYSQLND_RES *result); -typedef MYSQLND_RES_METADATA * (*func_mysqlnd_res__result_meta_init)(unsigned int field_count, zend_bool persistent); +typedef MYSQLND_RES_METADATA * (*func_mysqlnd_res__result_meta_init)(MYSQLND_RES *result, unsigned int field_count); MYSQLND_CLASS_METHODS_TYPE(mysqlnd_res) { @@ -696,8 +694,8 @@ typedef const MYSQLND_FIELD * (*func_mysqlnd_res_meta__fetch_field_direct)(const typedef const MYSQLND_FIELD * (*func_mysqlnd_res_meta__fetch_fields)(MYSQLND_RES_METADATA * const meta); typedef MYSQLND_FIELD_OFFSET (*func_mysqlnd_res_meta__field_tell)(const MYSQLND_RES_METADATA * const meta); typedef MYSQLND_FIELD_OFFSET (*func_mysqlnd_res_meta__field_seek)(MYSQLND_RES_METADATA * const meta, const MYSQLND_FIELD_OFFSET field_offset); -typedef enum_func_status (*func_mysqlnd_res_meta__read_metadata)(MYSQLND_RES_METADATA * const meta, MYSQLND_CONN_DATA * conn); -typedef MYSQLND_RES_METADATA * (*func_mysqlnd_res_meta__clone_metadata)(const MYSQLND_RES_METADATA * const meta, const zend_bool persistent); +typedef enum_func_status (*func_mysqlnd_res_meta__read_metadata)(MYSQLND_RES_METADATA * const meta, MYSQLND_CONN_DATA * conn, MYSQLND_RES * result); +typedef MYSQLND_RES_METADATA * (*func_mysqlnd_res_meta__clone_metadata)(MYSQLND_RES *result, const MYSQLND_RES_METADATA * const meta); typedef void (*func_mysqlnd_res_meta__free_metadata)(MYSQLND_RES_METADATA * meta); MYSQLND_CLASS_METHODS_TYPE(mysqlnd_res_meta) @@ -843,13 +841,7 @@ struct st_mysqlnd_vio -struct st_mysqlnd_protocol_command -{ - enum_func_status (*run)(void *cmd); - void (*free_command)(void * cmd); -}; - -typedef struct st_mysqlnd_protocol_command * (*func_mysqlnd__command_factory)(enum php_mysqlnd_server_command command, ...); +typedef enum_func_status (*func_mysqlnd__run_command)(enum php_mysqlnd_server_command command, ...); @@ -937,7 +929,7 @@ struct st_mysqlnd_connection_data zend_bool in_async_err_cb; MYSQLND_CLASS_METHODS_TYPE(mysqlnd_object_factory) object_factory; - func_mysqlnd__command_factory command_factory; + func_mysqlnd__run_command run_command; MYSQLND_CLASS_METHODS_TYPE(mysqlnd_conn_data) * m; @@ -956,8 +948,9 @@ struct st_mysqlnd_connection struct st_mysqlnd_packet_greet; -struct st_mysqlnd_packet_greet; struct st_mysqlnd_packet_auth; +struct st_mysqlnd_packet_auth_response; +struct st_mysqlnd_packet_change_auth_response; struct st_mysqlnd_packet_ok; struct st_mysqlnd_packet_command; struct st_mysqlnd_packet_eof; @@ -971,21 +964,21 @@ struct st_mysqlnd_packet_auth_pam; struct st_mysqlnd_packet_sha256_pk_request; struct st_mysqlnd_packet_sha256_pk_request_response; -typedef struct st_mysqlnd_packet_greet * (*func_mysqlnd_protocol_payload_decoder_factory__get_greet_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent); -typedef struct st_mysqlnd_packet_auth * (*func_mysqlnd_protocol_payload_decoder_factory__get_auth_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent); -typedef struct st_mysqlnd_packet_auth_response *(*func_mysqlnd_protocol_payload_decoder_factory__get_auth_response_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent); -typedef struct st_mysqlnd_packet_change_auth_response * (*func_mysqlnd_protocol_payload_decoder_factory__get_change_auth_response_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent); -typedef struct st_mysqlnd_packet_ok * (*func_mysqlnd_protocol_payload_decoder_factory__get_ok_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent); -typedef struct st_mysqlnd_packet_command * (*func_mysqlnd_protocol_payload_decoder_factory__get_command_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent); -typedef struct st_mysqlnd_packet_eof * (*func_mysqlnd_protocol_payload_decoder_factory__get_eof_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent); -typedef struct st_mysqlnd_packet_rset_header * (*func_mysqlnd_protocol_payload_decoder_factory__get_rset_header_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent); -typedef struct st_mysqlnd_packet_res_field * (*func_mysqlnd_protocol_payload_decoder_factory__get_result_field_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent); -typedef struct st_mysqlnd_packet_row * (*func_mysqlnd_protocol_payload_decoder_factory__get_row_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent); -typedef struct st_mysqlnd_packet_stats * (*func_mysqlnd_protocol_payload_decoder_factory__get_stats_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent); -typedef struct st_mysqlnd_packet_prepare_response *(*func_mysqlnd_protocol_payload_decoder_factory__get_prepare_response_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent); -typedef struct st_mysqlnd_packet_chg_user_resp*(*func_mysqlnd_protocol_payload_decoder_factory__get_change_user_response_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent); -typedef struct st_mysqlnd_packet_sha256_pk_request *(*func_mysqlnd_protocol_payload_decoder_factory__get_sha256_pk_request_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent); -typedef struct st_mysqlnd_packet_sha256_pk_request_response *(*func_mysqlnd_protocol_payload_decoder_factory__get_sha256_pk_request_response_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent); +typedef void (*func_mysqlnd_protocol_payload_decoder_factory__init_greet_packet)(struct st_mysqlnd_packet_greet *packet); +typedef void (*func_mysqlnd_protocol_payload_decoder_factory__init_auth_packet)(struct st_mysqlnd_packet_auth *packet); +typedef void (*func_mysqlnd_protocol_payload_decoder_factory__init_auth_response_packet)(struct st_mysqlnd_packet_auth_response *packet); +typedef void (*func_mysqlnd_protocol_payload_decoder_factory__init_change_auth_response_packet)(struct st_mysqlnd_packet_change_auth_response *packet); +typedef void (*func_mysqlnd_protocol_payload_decoder_factory__init_ok_packet)(struct st_mysqlnd_packet_ok *packet); +typedef void (*func_mysqlnd_protocol_payload_decoder_factory__init_command_packet)(struct st_mysqlnd_packet_command *packet); +typedef void (*func_mysqlnd_protocol_payload_decoder_factory__init_eof_packet)(struct st_mysqlnd_packet_eof *packet); +typedef void (*func_mysqlnd_protocol_payload_decoder_factory__init_rset_header_packet)(struct st_mysqlnd_packet_rset_header *packet); +typedef void (*func_mysqlnd_protocol_payload_decoder_factory__init_result_field_packet)(struct st_mysqlnd_packet_res_field *packet); +typedef void (*func_mysqlnd_protocol_payload_decoder_factory__init_row_packet)(struct st_mysqlnd_packet_row *packet); +typedef void (*func_mysqlnd_protocol_payload_decoder_factory__init_stats_packet)(struct st_mysqlnd_packet_stats *packet); +typedef void (*func_mysqlnd_protocol_payload_decoder_factory__init_prepare_response_packet)(struct st_mysqlnd_packet_prepare_response *packet); +typedef void (*func_mysqlnd_protocol_payload_decoder_factory__init_change_user_response_packet)(struct st_mysqlnd_packet_chg_user_resp *packet); +typedef void (*func_mysqlnd_protocol_payload_decoder_factory__init_sha256_pk_request_packet)(struct st_mysqlnd_packet_sha256_pk_request *packet); +typedef void (*func_mysqlnd_protocol_payload_decoder_factory__init_sha256_pk_request_response_packet)(struct st_mysqlnd_packet_sha256_pk_request_response *packet); typedef enum_func_status (*func_mysqlnd_protocol_payload_decoder_factory__send_command)( MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * payload_decoder_factory, @@ -1005,8 +998,7 @@ typedef enum_func_status (*func_mysqlnd_protocol_payload_decoder_factory__send_c MYSQLND_ERROR_INFO * const error_info, MYSQLND_UPSERT_STATUS * const upsert_status, const zend_bool ignore_upsert_status, /* actually used only by LOAD DATA. COM_QUERY and COM_EXECUTE handle the responses themselves */ - MYSQLND_STRING * const last_message, - const zend_bool last_message_persistent); + MYSQLND_STRING * const last_message); typedef enum_func_status (*func_mysqlnd_protocol_payload_decoder_factory__send_command_handle_EOF)( MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const payload_decoder_factory, @@ -1022,27 +1014,26 @@ typedef enum_func_status (*func_mysqlnd_protocol_payload_decoder_factory__send_c MYSQLND_ERROR_INFO * error_info, MYSQLND_UPSERT_STATUS * upsert_status, - MYSQLND_STRING * last_message, - zend_bool last_message_persistent); + MYSQLND_STRING * last_message); MYSQLND_CLASS_METHODS_TYPE(mysqlnd_protocol_payload_decoder_factory) { - func_mysqlnd_protocol_payload_decoder_factory__get_greet_packet get_greet_packet; - func_mysqlnd_protocol_payload_decoder_factory__get_auth_packet get_auth_packet; - func_mysqlnd_protocol_payload_decoder_factory__get_auth_response_packet get_auth_response_packet; - func_mysqlnd_protocol_payload_decoder_factory__get_change_auth_response_packet get_change_auth_response_packet; - func_mysqlnd_protocol_payload_decoder_factory__get_ok_packet get_ok_packet; - func_mysqlnd_protocol_payload_decoder_factory__get_command_packet get_command_packet; - func_mysqlnd_protocol_payload_decoder_factory__get_eof_packet get_eof_packet; - func_mysqlnd_protocol_payload_decoder_factory__get_rset_header_packet get_rset_header_packet; - func_mysqlnd_protocol_payload_decoder_factory__get_result_field_packet get_result_field_packet; - func_mysqlnd_protocol_payload_decoder_factory__get_row_packet get_row_packet; - func_mysqlnd_protocol_payload_decoder_factory__get_stats_packet get_stats_packet; - func_mysqlnd_protocol_payload_decoder_factory__get_prepare_response_packet get_prepare_response_packet; - func_mysqlnd_protocol_payload_decoder_factory__get_change_user_response_packet get_change_user_response_packet; - func_mysqlnd_protocol_payload_decoder_factory__get_sha256_pk_request_packet get_sha256_pk_request_packet; - func_mysqlnd_protocol_payload_decoder_factory__get_sha256_pk_request_response_packet get_sha256_pk_request_response_packet; + func_mysqlnd_protocol_payload_decoder_factory__init_greet_packet init_greet_packet; + func_mysqlnd_protocol_payload_decoder_factory__init_auth_packet init_auth_packet; + func_mysqlnd_protocol_payload_decoder_factory__init_auth_response_packet init_auth_response_packet; + func_mysqlnd_protocol_payload_decoder_factory__init_change_auth_response_packet init_change_auth_response_packet; + func_mysqlnd_protocol_payload_decoder_factory__init_ok_packet init_ok_packet; + func_mysqlnd_protocol_payload_decoder_factory__init_command_packet init_command_packet; + func_mysqlnd_protocol_payload_decoder_factory__init_eof_packet init_eof_packet; + func_mysqlnd_protocol_payload_decoder_factory__init_rset_header_packet init_rset_header_packet; + func_mysqlnd_protocol_payload_decoder_factory__init_result_field_packet init_result_field_packet; + func_mysqlnd_protocol_payload_decoder_factory__init_row_packet init_row_packet; + func_mysqlnd_protocol_payload_decoder_factory__init_stats_packet init_stats_packet; + func_mysqlnd_protocol_payload_decoder_factory__init_prepare_response_packet init_prepare_response_packet; + func_mysqlnd_protocol_payload_decoder_factory__init_change_user_response_packet init_change_user_response_packet; + func_mysqlnd_protocol_payload_decoder_factory__init_sha256_pk_request_packet init_sha256_pk_request_packet; + func_mysqlnd_protocol_payload_decoder_factory__init_sha256_pk_request_response_packet init_sha256_pk_request_response_packet; func_mysqlnd_protocol_payload_decoder_factory__send_command send_command; func_mysqlnd_protocol_payload_decoder_factory__send_command_handle_response send_command_handle_response; @@ -1135,30 +1126,19 @@ struct st_mysqlnd_protocol_frame_codec }; - -struct mysqlnd_field_hash_key -{ - zend_bool is_numeric; - zend_ulong key; -}; - - struct st_mysqlnd_result_metadata { MYSQLND_FIELD *fields; - struct mysqlnd_field_hash_key *zend_hash_keys; MYSQLND_CLASS_METHODS_TYPE(mysqlnd_res_meta) * m; unsigned int current_field; unsigned int field_count; - - zend_bool persistent; }; #define def_mysqlnd_buffered_result_parent \ - MYSQLND_MEMORY_POOL_CHUNK **row_buffers; \ + MYSQLND_ROW_BUFFER *row_buffers; \ uint64_t row_count; \ uint64_t initialized_rows; \ \ @@ -1173,7 +1153,6 @@ struct st_mysqlnd_result_metadata \ unsigned int field_count; \ zend_bool ps; \ - zend_bool persistent; \ MYSQLND_CLASS_METHODS_TYPE(mysqlnd_result_buffered) m; \ enum mysqlnd_buffered_type type; \ void * unused1; \ @@ -1212,7 +1191,7 @@ struct st_mysqlnd_unbuffered_result /* For unbuffered (both normal and PS) */ zval *last_row_data; - MYSQLND_MEMORY_POOL_CHUNK *last_row_buffer; + MYSQLND_ROW_BUFFER last_row_buffer; /* Column lengths of current row - both buffered and unbuffered. @@ -1222,15 +1201,13 @@ struct st_mysqlnd_unbuffered_result MYSQLND_MEMORY_POOL *result_set_memory_pool; - struct st_mysqlnd_packet_row * row_packet; + struct st_mysqlnd_packet_row *row_packet; unsigned int field_count; zend_bool eof_reached; zend_bool ps; - zend_bool persistent; - }; @@ -1247,7 +1224,8 @@ struct st_mysqlnd_res MYSQLND_RES_BUFFERED *stored_data; MYSQLND_RES_UNBUFFERED *unbuf; - zend_bool persistent; + MYSQLND_MEMORY_POOL *memory_pool; + MYSQLND_CLASS_METHODS_TYPE(mysqlnd_res) m; }; @@ -1279,7 +1257,6 @@ struct st_mysqlnd_stmt_data MYSQLND_PARAM_BIND *param_bind; MYSQLND_RESULT_BIND *result_bind; zend_bool result_zvals_separated_once; - zend_bool persistent; MYSQLND_UPSERT_STATUS * upsert_status; MYSQLND_UPSERT_STATUS upsert_status_impl; @@ -1307,7 +1284,6 @@ struct st_mysqlnd_stmt { MYSQLND_STMT_DATA * data; MYSQLND_CLASS_METHODS_TYPE(mysqlnd_stmt) * m; - zend_bool persistent; }; diff --git a/ext/mysqlnd/mysqlnd_vio.c b/ext/mysqlnd/mysqlnd_vio.c index 4ca4797966..a6a7f5c4d1 100644 --- a/ext/mysqlnd/mysqlnd_vio.c +++ b/ext/mysqlnd/mysqlnd_vio.c @@ -693,7 +693,6 @@ MYSQLND_METHOD(mysqlnd_vio, dtor)(MYSQLND_VIO * const vio, MYSQLND_STATS * const vio->data->m.free_contents(vio); vio->data->m.close_stream(vio, stats, error_info); - mnd_pefree(vio->data, vio->data->persistent); mnd_pefree(vio, vio->persistent); } DBG_VOID_RETURN; diff --git a/ext/mysqlnd/mysqlnd_wireprotocol.c b/ext/mysqlnd/mysqlnd_wireprotocol.c index 45b31a7210..9d9b84b002 100644 --- a/ext/mysqlnd/mysqlnd_wireprotocol.c +++ b/ext/mysqlnd/mysqlnd_wireprotocol.c @@ -322,18 +322,18 @@ mysqlnd_read_packet_header_and_body(MYSQLND_PACKET_HEADER * packet_header, /* {{{ php_mysqlnd_greet_read */ static enum_func_status -php_mysqlnd_greet_read(void * _packet) +php_mysqlnd_greet_read(MYSQLND_CONN_DATA * conn, void * _packet) { zend_uchar buf[2048]; const zend_uchar * p = buf; const zend_uchar * const begin = buf; const zend_uchar * pad_start = NULL; MYSQLND_PACKET_GREET *packet= (MYSQLND_PACKET_GREET *) _packet; - MYSQLND_ERROR_INFO * error_info = packet->header.error_info; - MYSQLND_PFC * pfc = packet->header.protocol_frame_codec; - MYSQLND_VIO * vio = packet->header.vio; - MYSQLND_STATS * stats = packet->header.stats; - MYSQLND_CONNECTION_STATE * connection_state = packet->header.connection_state; + MYSQLND_ERROR_INFO * error_info = conn->error_info; + MYSQLND_PFC * pfc = conn->protocol_frame_codec; + MYSQLND_VIO * vio = conn->vio; + MYSQLND_STATS * stats = conn->stats; + MYSQLND_CONNECTION_STATE * connection_state = &conn->state; DBG_ENTER("php_mysqlnd_greet_read"); @@ -465,7 +465,7 @@ premature_end: /* {{{ php_mysqlnd_greet_free_mem */ static -void php_mysqlnd_greet_free_mem(void * _packet, zend_bool stack_allocation) +void php_mysqlnd_greet_free_mem(void * _packet) { MYSQLND_PACKET_GREET *p= (MYSQLND_PACKET_GREET *) _packet; if (p->server_version) { @@ -480,9 +480,6 @@ void php_mysqlnd_greet_free_mem(void * _packet, zend_bool stack_allocation) efree(p->auth_protocol); p->auth_protocol = NULL; } - if (!stack_allocation) { - mnd_pefree(p, p->header.persistent); - } } /* }}} */ @@ -491,18 +488,17 @@ void php_mysqlnd_greet_free_mem(void * _packet, zend_bool stack_allocation) /* {{{ php_mysqlnd_auth_write */ static -size_t php_mysqlnd_auth_write(void * _packet) +size_t php_mysqlnd_auth_write(MYSQLND_CONN_DATA * conn, void * _packet) { zend_uchar buffer[AUTH_WRITE_BUFFER_LEN]; zend_uchar *p = buffer + MYSQLND_HEADER_SIZE; /* start after the header */ size_t len; MYSQLND_PACKET_AUTH * packet= (MYSQLND_PACKET_AUTH *) _packet; - MYSQLND_CONN_DATA * conn = packet->header.conn; - MYSQLND_ERROR_INFO * error_info = packet->header.error_info; - MYSQLND_PFC * pfc = packet->header.protocol_frame_codec; - MYSQLND_VIO * vio = packet->header.vio; - MYSQLND_STATS * stats = packet->header.stats; - MYSQLND_CONNECTION_STATE * connection_state = packet->header.connection_state; + MYSQLND_ERROR_INFO * error_info = conn->error_info; + MYSQLND_PFC * pfc = conn->protocol_frame_codec; + MYSQLND_VIO * vio = conn->vio; + MYSQLND_STATS * stats = conn->stats; + MYSQLND_CONNECTION_STATE * connection_state = &conn->state; DBG_ENTER("php_mysqlnd_auth_write"); @@ -538,7 +534,7 @@ size_t php_mysqlnd_auth_write(void * _packet) DBG_RETURN(0); } - int1store(p, packet->auth_data_len); + int1store(p, (int8_t)packet->auth_data_len); ++p; /*!!!!! is the buffer big enough ??? */ if (sizeof(buffer) < (packet->auth_data_len + (p - buffer))) { @@ -623,12 +619,8 @@ size_t php_mysqlnd_auth_write(void * _packet) enum_func_status ret = FAIL; const MYSQLND_CSTRING payload = {(char*) buffer + MYSQLND_HEADER_SIZE, p - (buffer + MYSQLND_HEADER_SIZE)}; const unsigned int silent = packet->silent; - struct st_mysqlnd_protocol_command * command = conn->command_factory(COM_CHANGE_USER, conn, payload, silent); - if (command) { - ret = command->run(command); - command->free_command(command); - } + ret = conn->run_command(COM_CHANGE_USER, conn, payload, silent); DBG_RETURN(ret == PASS? (p - buffer - MYSQLND_HEADER_SIZE) : 0); } else { size_t sent = pfc->data->m.send(pfc, vio, buffer, p - buffer - MYSQLND_HEADER_SIZE, stats, error_info); @@ -641,30 +633,18 @@ size_t php_mysqlnd_auth_write(void * _packet) /* }}} */ -/* {{{ php_mysqlnd_auth_free_mem */ -static -void php_mysqlnd_auth_free_mem(void * _packet, zend_bool stack_allocation) -{ - if (!stack_allocation) { - MYSQLND_PACKET_AUTH * p = (MYSQLND_PACKET_AUTH *) _packet; - mnd_pefree(p, p->header.persistent); - } -} -/* }}} */ - - #define AUTH_RESP_BUFFER_SIZE 2048 /* {{{ php_mysqlnd_auth_response_read */ static enum_func_status -php_mysqlnd_auth_response_read(void * _packet) +php_mysqlnd_auth_response_read(MYSQLND_CONN_DATA * conn, void * _packet) { register MYSQLND_PACKET_AUTH_RESPONSE * packet= (MYSQLND_PACKET_AUTH_RESPONSE *) _packet; - MYSQLND_ERROR_INFO * error_info = packet->header.error_info; - MYSQLND_PFC * pfc = packet->header.protocol_frame_codec; - MYSQLND_VIO * vio = packet->header.vio; - MYSQLND_STATS * stats = packet->header.stats; - MYSQLND_CONNECTION_STATE * connection_state = packet->header.connection_state; + MYSQLND_ERROR_INFO * error_info = conn->error_info; + MYSQLND_PFC * pfc = conn->protocol_frame_codec; + MYSQLND_VIO * vio = conn->vio; + MYSQLND_STATS * stats = conn->stats; + MYSQLND_CONNECTION_STATE * connection_state = &conn->state; zend_uchar local_buf[AUTH_RESP_BUFFER_SIZE]; size_t buf_len = pfc->cmd_buffer.buffer? pfc->cmd_buffer.length: AUTH_RESP_BUFFER_SIZE; zend_uchar *buf = pfc->cmd_buffer.buffer? (zend_uchar *) pfc->cmd_buffer.buffer : local_buf; @@ -756,7 +736,7 @@ premature_end: /* {{{ php_mysqlnd_auth_response_free_mem */ static void -php_mysqlnd_auth_response_free_mem(void * _packet, zend_bool stack_allocation) +php_mysqlnd_auth_response_free_mem(void * _packet) { MYSQLND_PACKET_AUTH_RESPONSE * p = (MYSQLND_PACKET_AUTH_RESPONSE *) _packet; if (p->message) { @@ -774,24 +754,20 @@ php_mysqlnd_auth_response_free_mem(void * _packet, zend_bool stack_allocation) p->new_auth_protocol_data = NULL; } p->new_auth_protocol_data_len = 0; - - if (!stack_allocation) { - mnd_pefree(p, p->header.persistent); - } } /* }}} */ /* {{{ php_mysqlnd_change_auth_response_write */ static size_t -php_mysqlnd_change_auth_response_write(void * _packet) +php_mysqlnd_change_auth_response_write(MYSQLND_CONN_DATA * conn, void * _packet) { MYSQLND_PACKET_CHANGE_AUTH_RESPONSE *packet= (MYSQLND_PACKET_CHANGE_AUTH_RESPONSE *) _packet; - MYSQLND_ERROR_INFO * error_info = packet->header.error_info; - MYSQLND_PFC * pfc = packet->header.protocol_frame_codec; - MYSQLND_VIO * vio = packet->header.vio; - MYSQLND_STATS * stats = packet->header.stats; - MYSQLND_CONNECTION_STATE * connection_state = packet->header.connection_state; + MYSQLND_ERROR_INFO * error_info = conn->error_info; + MYSQLND_PFC * pfc = conn->protocol_frame_codec; + MYSQLND_VIO * vio = conn->vio; + MYSQLND_STATS * stats = conn->stats; + MYSQLND_CONNECTION_STATE * connection_state = &conn->state; zend_uchar * buffer = pfc->cmd_buffer.length >= packet->auth_data_len? pfc->cmd_buffer.buffer : mnd_emalloc(packet->auth_data_len); zend_uchar * p = buffer + MYSQLND_HEADER_SIZE; /* start after the header */ @@ -816,30 +792,18 @@ php_mysqlnd_change_auth_response_write(void * _packet) /* }}} */ -/* {{{ php_mysqlnd_change_auth_response_free_mem */ -static void -php_mysqlnd_change_auth_response_free_mem(void * _packet, zend_bool stack_allocation) -{ - if (!stack_allocation) { - MYSQLND_PACKET_CHANGE_AUTH_RESPONSE * p = (MYSQLND_PACKET_CHANGE_AUTH_RESPONSE *) _packet; - mnd_pefree(p, p->header.persistent); - } -} -/* }}} */ - - #define OK_BUFFER_SIZE 2048 /* {{{ php_mysqlnd_ok_read */ static enum_func_status -php_mysqlnd_ok_read(void * _packet) +php_mysqlnd_ok_read(MYSQLND_CONN_DATA * conn, void * _packet) { register MYSQLND_PACKET_OK *packet= (MYSQLND_PACKET_OK *) _packet; - MYSQLND_ERROR_INFO * error_info = packet->header.error_info; - MYSQLND_PFC * pfc = packet->header.protocol_frame_codec; - MYSQLND_VIO * vio = packet->header.vio; - MYSQLND_STATS * stats = packet->header.stats; - MYSQLND_CONNECTION_STATE * connection_state = packet->header.connection_state; + MYSQLND_ERROR_INFO * error_info = conn->error_info; + MYSQLND_PFC * pfc = conn->protocol_frame_codec; + MYSQLND_VIO * vio = conn->vio; + MYSQLND_STATS * stats = conn->stats; + MYSQLND_CONNECTION_STATE * connection_state = &conn->state; zend_uchar local_buf[OK_BUFFER_SIZE]; size_t buf_len = pfc->cmd_buffer.buffer? pfc->cmd_buffer.length : OK_BUFFER_SIZE; zend_uchar * buf = pfc->cmd_buffer.buffer? (zend_uchar *) pfc->cmd_buffer.buffer : local_buf; @@ -908,23 +872,20 @@ premature_end: /* {{{ php_mysqlnd_ok_free_mem */ static void -php_mysqlnd_ok_free_mem(void * _packet, zend_bool stack_allocation) +php_mysqlnd_ok_free_mem(void * _packet) { MYSQLND_PACKET_OK *p= (MYSQLND_PACKET_OK *) _packet; if (p->message) { mnd_efree(p->message); p->message = NULL; } - if (!stack_allocation) { - mnd_pefree(p, p->header.persistent); - } } /* }}} */ /* {{{ php_mysqlnd_eof_read */ static enum_func_status -php_mysqlnd_eof_read(void * _packet) +php_mysqlnd_eof_read(MYSQLND_CONN_DATA * conn, void * _packet) { /* EOF packet is since 4.1 five bytes long, @@ -933,11 +894,11 @@ php_mysqlnd_eof_read(void * _packet) Error : error_code + '#' + sqlstate + MYSQLND_ERRMSG_SIZE */ MYSQLND_PACKET_EOF *packet= (MYSQLND_PACKET_EOF *) _packet; - MYSQLND_ERROR_INFO * error_info = packet->header.error_info; - MYSQLND_PFC * pfc = packet->header.protocol_frame_codec; - MYSQLND_VIO * vio = packet->header.vio; - MYSQLND_STATS * stats = packet->header.stats; - MYSQLND_CONNECTION_STATE * connection_state = packet->header.connection_state; + MYSQLND_ERROR_INFO * error_info = conn->error_info; + MYSQLND_PFC * pfc = conn->protocol_frame_codec; + MYSQLND_VIO * vio = conn->vio; + MYSQLND_STATS * stats = conn->stats; + MYSQLND_CONNECTION_STATE * connection_state = &conn->state; size_t buf_len = pfc->cmd_buffer.length; zend_uchar * buf = (zend_uchar *) pfc->cmd_buffer.buffer; const zend_uchar * p = buf; @@ -996,27 +957,16 @@ premature_end: /* }}} */ -/* {{{ php_mysqlnd_eof_free_mem */ -static -void php_mysqlnd_eof_free_mem(void * _packet, zend_bool stack_allocation) -{ - if (!stack_allocation) { - mnd_pefree(_packet, ((MYSQLND_PACKET_EOF *)_packet)->header.persistent); - } -} -/* }}} */ - - /* {{{ php_mysqlnd_cmd_write */ -size_t php_mysqlnd_cmd_write(void * _packet) +size_t php_mysqlnd_cmd_write(MYSQLND_CONN_DATA * conn, void * _packet) { /* Let's have some space, which we can use, if not enough, we will allocate new buffer */ MYSQLND_PACKET_COMMAND * packet= (MYSQLND_PACKET_COMMAND *) _packet; - MYSQLND_ERROR_INFO * error_info = packet->header.error_info; - MYSQLND_PFC * pfc = packet->header.protocol_frame_codec; - MYSQLND_VIO * vio = packet->header.vio; - MYSQLND_STATS * stats = packet->header.stats; - MYSQLND_CONNECTION_STATE * connection_state = packet->header.connection_state; + MYSQLND_ERROR_INFO * error_info = conn->error_info; + MYSQLND_PFC * pfc = conn->protocol_frame_codec; + MYSQLND_VIO * vio = conn->vio; + MYSQLND_STATS * stats = conn->stats; + MYSQLND_CONNECTION_STATE * connection_state = &conn->state; unsigned int error_reporting = EG(error_reporting); size_t sent = 0; @@ -1075,28 +1025,16 @@ end: /* }}} */ -/* {{{ php_mysqlnd_cmd_free_mem */ -static -void php_mysqlnd_cmd_free_mem(void * _packet, zend_bool stack_allocation) -{ - if (!stack_allocation) { - MYSQLND_PACKET_COMMAND * p = (MYSQLND_PACKET_COMMAND *) _packet; - mnd_pefree(p, p->header.persistent); - } -} -/* }}} */ - - /* {{{ php_mysqlnd_rset_header_read */ static enum_func_status -php_mysqlnd_rset_header_read(void * _packet) +php_mysqlnd_rset_header_read(MYSQLND_CONN_DATA * conn, void * _packet) { MYSQLND_PACKET_RSET_HEADER * packet= (MYSQLND_PACKET_RSET_HEADER *) _packet; - MYSQLND_ERROR_INFO * error_info = packet->header.error_info; - MYSQLND_PFC * pfc = packet->header.protocol_frame_codec; - MYSQLND_VIO * vio = packet->header.vio; - MYSQLND_STATS * stats = packet->header.stats; - MYSQLND_CONNECTION_STATE * connection_state = packet->header.connection_state; + MYSQLND_ERROR_INFO * error_info = conn->error_info; + MYSQLND_PFC * pfc = conn->protocol_frame_codec; + MYSQLND_VIO * vio = conn->vio; + MYSQLND_STATS * stats = conn->stats; + MYSQLND_CONNECTION_STATE * connection_state = &conn->state; enum_func_status ret = PASS; size_t buf_len = pfc->cmd_buffer.length; zend_uchar * buf = (zend_uchar *) pfc->cmd_buffer.buffer; @@ -1200,7 +1138,7 @@ premature_end: /* {{{ php_mysqlnd_rset_header_free_mem */ static -void php_mysqlnd_rset_header_free_mem(void * _packet, zend_bool stack_allocation) +void php_mysqlnd_rset_header_free_mem(void * _packet) { MYSQLND_PACKET_RSET_HEADER *p= (MYSQLND_PACKET_RSET_HEADER *) _packet; DBG_ENTER("php_mysqlnd_rset_header_free_mem"); @@ -1208,9 +1146,6 @@ void php_mysqlnd_rset_header_free_mem(void * _packet, zend_bool stack_allocation mnd_efree(p->info_or_local_file.s); p->info_or_local_file.s = NULL; } - if (!stack_allocation) { - mnd_pefree(p, p->header.persistent); - } DBG_VOID_RETURN; } /* }}} */ @@ -1234,15 +1169,15 @@ static size_t rset_field_offsets[] = /* {{{ php_mysqlnd_rset_field_read */ static enum_func_status -php_mysqlnd_rset_field_read(void * _packet) +php_mysqlnd_rset_field_read(MYSQLND_CONN_DATA * conn, void * _packet) { /* Should be enough for the metadata of a single row */ MYSQLND_PACKET_RES_FIELD *packet = (MYSQLND_PACKET_RES_FIELD *) _packet; - MYSQLND_ERROR_INFO * error_info = packet->header.error_info; - MYSQLND_PFC * pfc = packet->header.protocol_frame_codec; - MYSQLND_VIO * vio = packet->header.vio; - MYSQLND_STATS * stats = packet->header.stats; - MYSQLND_CONNECTION_STATE * connection_state = packet->header.connection_state; + MYSQLND_ERROR_INFO * error_info = conn->error_info; + MYSQLND_PFC * pfc = conn->protocol_frame_codec; + MYSQLND_VIO * vio = conn->vio; + MYSQLND_STATS * stats = conn->stats; + MYSQLND_CONNECTION_STATE * connection_state = &conn->state; size_t buf_len = pfc->cmd_buffer.length, total_len = 0; zend_uchar * buf = (zend_uchar *) pfc->cmd_buffer.buffer; const zend_uchar * p = buf; @@ -1354,8 +1289,8 @@ php_mysqlnd_rset_field_read(void * _packet) len != MYSQLND_NULL_LENGTH) { BAIL_IF_NO_MORE_DATA; - DBG_INF_FMT("Def found, length %lu, persistent=%u", len, packet->persistent_alloc); - meta->def = mnd_pemalloc(len + 1, packet->persistent_alloc); + DBG_INF_FMT("Def found, length %lu", len); + meta->def = packet->memory_pool->get_chunk(packet->memory_pool, len + 1); if (!meta->def) { SET_OOM_ERROR(error_info); DBG_RETURN(FAIL); @@ -1366,7 +1301,7 @@ php_mysqlnd_rset_field_read(void * _packet) p += len; } - root_ptr = meta->root = mnd_pemalloc(total_len, packet->persistent_alloc); + root_ptr = meta->root = packet->memory_pool->get_chunk(packet->memory_pool, total_len); if (!root_ptr) { SET_OOM_ERROR(error_info); DBG_RETURN(FAIL); @@ -1375,7 +1310,7 @@ php_mysqlnd_rset_field_read(void * _packet) meta->root_len = total_len; if (meta->name != mysqlnd_empty_string) { - meta->sname = zend_string_init(meta->name, meta->name_length, packet->persistent_alloc); + meta->sname = zend_string_init_interned(meta->name, meta->name_length, 0); } else { meta->sname = ZSTR_EMPTY_ALLOC(); } @@ -1418,7 +1353,7 @@ php_mysqlnd_rset_field_read(void * _packet) root_ptr++; } - DBG_INF_FMT("allocing root. persistent=%u", packet->persistent_alloc); + DBG_INF_FMT("allocing root."); DBG_INF_FMT("FIELD=[%s.%s.%s]", meta->db? meta->db:"*NA*", meta->table? meta->table:"*NA*", meta->name? meta->name:"*NA*"); @@ -1439,19 +1374,6 @@ premature_end: /* }}} */ -/* {{{ php_mysqlnd_rset_field_free_mem */ -static -void php_mysqlnd_rset_field_free_mem(void * _packet, zend_bool stack_allocation) -{ - MYSQLND_PACKET_RES_FIELD *p = (MYSQLND_PACKET_RES_FIELD *) _packet; - /* p->metadata was passed to us as temporal buffer */ - if (!stack_allocation) { - mnd_pefree(p, p->header.persistent); - } -} -/* }}} */ - - /* {{{ php_mysqlnd_read_row_ex */ static enum_func_status php_mysqlnd_read_row_ex(MYSQLND_PFC * pfc, @@ -1459,8 +1381,8 @@ php_mysqlnd_read_row_ex(MYSQLND_PFC * pfc, MYSQLND_STATS * stats, MYSQLND_ERROR_INFO * error_info, MYSQLND_MEMORY_POOL * pool, - MYSQLND_MEMORY_POOL_CHUNK ** buffer, - size_t * data_size, zend_bool persistent_alloc) + MYSQLND_ROW_BUFFER * buffer, + size_t * data_size) { enum_func_status ret = PASS; MYSQLND_PACKET_HEADER header; @@ -1469,7 +1391,7 @@ php_mysqlnd_read_row_ex(MYSQLND_PFC * pfc, size_t prealloc_more_bytes; DBG_ENTER("php_mysqlnd_read_row_ex"); - + /* To ease the process the server splits everything in packets up to 2^24 - 1. Even in the case the payload is evenly divisible by this value, the last @@ -1483,7 +1405,7 @@ php_mysqlnd_read_row_ex(MYSQLND_PFC * pfc, needs to be able to append a terminating \0 for atoi/atof. */ prealloc_more_bytes = 1; - + *data_size = 0; while (1) { if (FAIL == mysqlnd_read_header(pfc, vio, &header, stats, error_info)) { @@ -1495,12 +1417,12 @@ php_mysqlnd_read_row_ex(MYSQLND_PFC * pfc, if (first_iteration) { first_iteration = FALSE; - *buffer = pool->get_chunk(pool, *data_size + prealloc_more_bytes); - if (!*buffer) { + buffer->ptr = pool->get_chunk(pool, *data_size + prealloc_more_bytes); + if (!buffer->ptr) { ret = FAIL; break; } - p = (*buffer)->ptr; + p = buffer->ptr; } else if (!first_iteration) { /* Empty packet after MYSQLND_MAX_PACKET_SIZE packet. That's ok, break */ if (!header.size) { @@ -1510,13 +1432,14 @@ php_mysqlnd_read_row_ex(MYSQLND_PFC * pfc, /* We have to realloc the buffer. */ - if (FAIL == pool->resize_chunk(pool, *buffer, *data_size + prealloc_more_bytes)) { + buffer->ptr = pool->resize_chunk(pool, buffer->ptr, *data_size - header.size, *data_size + prealloc_more_bytes); + if (!buffer->ptr) { SET_OOM_ERROR(error_info); ret = FAIL; break; } /* The position could have changed, recalculate */ - p = (*buffer)->ptr + (*data_size - header.size); + p = (zend_uchar *) buffer->ptr + (*data_size - header.size); } if (PASS != (ret = pfc->data->m.receive(pfc, vio, p, header.size, stats, error_info))) { @@ -1529,9 +1452,9 @@ php_mysqlnd_read_row_ex(MYSQLND_PFC * pfc, break; } } - if (ret == FAIL && *buffer) { - pool->free_chunk(pool, *buffer); - *buffer = NULL; + if (ret == FAIL && buffer->ptr) { + pool->free_chunk(pool, buffer->ptr); + buffer->ptr = NULL; } DBG_RETURN(ret); } @@ -1540,7 +1463,7 @@ php_mysqlnd_read_row_ex(MYSQLND_PFC * pfc, /* {{{ php_mysqlnd_rowp_read_binary_protocol */ enum_func_status -php_mysqlnd_rowp_read_binary_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval * fields, +php_mysqlnd_rowp_read_binary_protocol(MYSQLND_ROW_BUFFER * row_buffer, zval * fields, unsigned int field_count, const MYSQLND_FIELD * fields_metadata, zend_bool as_int_or_float, MYSQLND_STATS * stats) { @@ -1631,15 +1554,15 @@ php_mysqlnd_rowp_read_binary_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zv /* {{{ php_mysqlnd_rowp_read_text_protocol */ enum_func_status -php_mysqlnd_rowp_read_text_protocol_aux(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval * fields, +php_mysqlnd_rowp_read_text_protocol_aux(MYSQLND_ROW_BUFFER * row_buffer, zval * fields, unsigned int field_count, const MYSQLND_FIELD * fields_metadata, zend_bool as_int_or_float, MYSQLND_STATS * stats) { unsigned int i; zval *current_field, *end_field, *start_field; zend_uchar * p = row_buffer->ptr; - size_t data_size = row_buffer->app; - const zend_uchar * const packet_end = (zend_uchar*) row_buffer->ptr + data_size; + size_t data_size = row_buffer->size; + const zend_uchar * const packet_end = (zend_uchar*) p + data_size; DBG_ENTER("php_mysqlnd_rowp_read_text_protocol_aux"); @@ -1784,7 +1707,7 @@ php_mysqlnd_rowp_read_text_protocol_aux(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, /* {{{ php_mysqlnd_rowp_read_text_protocol_zval */ enum_func_status -php_mysqlnd_rowp_read_text_protocol_zval(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval * fields, +php_mysqlnd_rowp_read_text_protocol_zval(MYSQLND_ROW_BUFFER * row_buffer, zval * fields, unsigned int field_count, const MYSQLND_FIELD * fields_metadata, zend_bool as_int_or_float, MYSQLND_STATS * stats) { @@ -1798,7 +1721,7 @@ php_mysqlnd_rowp_read_text_protocol_zval(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, /* {{{ php_mysqlnd_rowp_read_text_protocol_c */ enum_func_status -php_mysqlnd_rowp_read_text_protocol_c(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval * fields, +php_mysqlnd_rowp_read_text_protocol_c(MYSQLND_ROW_BUFFER * row_buffer, zval * fields, unsigned int field_count, const MYSQLND_FIELD * fields_metadata, zend_bool as_int_or_float, MYSQLND_STATS * stats) { @@ -1816,13 +1739,13 @@ php_mysqlnd_rowp_read_text_protocol_c(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zv if PS => packet->fields is passed from outside */ static enum_func_status -php_mysqlnd_rowp_read(void * _packet) +php_mysqlnd_rowp_read(MYSQLND_CONN_DATA * conn, void * _packet) { MYSQLND_PACKET_ROW *packet= (MYSQLND_PACKET_ROW *) _packet; - MYSQLND_ERROR_INFO * error_info = packet->header.error_info; - MYSQLND_PFC * pfc = packet->header.protocol_frame_codec; - MYSQLND_VIO * vio = packet->header.vio; - MYSQLND_STATS * stats = packet->header.stats; + MYSQLND_ERROR_INFO * error_info = conn->error_info; + MYSQLND_PFC * pfc = conn->protocol_frame_codec; + MYSQLND_VIO * vio = conn->vio; + MYSQLND_STATS * stats = conn->stats; zend_uchar *p; enum_func_status ret = PASS; size_t data_size = 0; @@ -1830,8 +1753,7 @@ php_mysqlnd_rowp_read(void * _packet) DBG_ENTER("php_mysqlnd_rowp_read"); ret = php_mysqlnd_read_row_ex(pfc, vio, stats, error_info, - packet->result_set_memory_pool, &packet->row_buffer, &data_size, - packet->persistent_alloc); + packet->result_set_memory_pool, &packet->row_buffer, &data_size); if (FAIL == ret) { goto end; } @@ -1850,9 +1772,9 @@ php_mysqlnd_rowp_read(void * _packet) to keep (and copy) the lengths externally. */ packet->header.size = data_size; - packet->row_buffer->app = data_size; + packet->row_buffer.size = data_size; - if (ERROR_MARKER == (*(p = packet->row_buffer->ptr))) { + if (ERROR_MARKER == (*(p = packet->row_buffer.ptr))) { /* Error message as part of the result set, not good but we should not hang. See: @@ -1896,8 +1818,7 @@ php_mysqlnd_rowp_read(void * _packet) but mostly like old-API unbuffered and thus will populate this array with value. */ - packet->fields = mnd_pecalloc(packet->field_count, sizeof(zval), - packet->persistent_alloc); + packet->fields = mnd_ecalloc(packet->field_count, sizeof(zval)); } } else { MYSQLND_INC_CONN_STATISTIC(stats, @@ -1914,17 +1835,16 @@ end: /* {{{ php_mysqlnd_rowp_free_mem */ static void -php_mysqlnd_rowp_free_mem(void * _packet, zend_bool stack_allocation) +php_mysqlnd_rowp_free_mem(void * _packet) { MYSQLND_PACKET_ROW *p; DBG_ENTER("php_mysqlnd_rowp_free_mem"); p = (MYSQLND_PACKET_ROW *) _packet; - if (p->row_buffer) { - p->result_set_memory_pool->free_chunk(p->result_set_memory_pool, p->row_buffer); - p->row_buffer = NULL; + if (p->row_buffer.ptr) { + p->result_set_memory_pool->free_chunk(p->result_set_memory_pool, p->row_buffer.ptr); + p->row_buffer.ptr = NULL; } - DBG_INF_FMT("stack_allocation=%u persistent=%u", (int)stack_allocation, (int)p->header.persistent); /* Don't free packet->fields : - normal queries -> store_result() | fetch_row_unbuffered() will transfer @@ -1932,9 +1852,6 @@ php_mysqlnd_rowp_free_mem(void * _packet, zend_bool stack_allocation) - PS will pass in it the bound variables, we have to use them! and of course not free the array. As it is passed to us, we should not clean it ourselves. */ - if (!stack_allocation) { - mnd_pefree(p, p->header.persistent); - } DBG_VOID_RETURN; } /* }}} */ @@ -1942,14 +1859,14 @@ php_mysqlnd_rowp_free_mem(void * _packet, zend_bool stack_allocation) /* {{{ php_mysqlnd_stats_read */ static enum_func_status -php_mysqlnd_stats_read(void * _packet) +php_mysqlnd_stats_read(MYSQLND_CONN_DATA * conn, void * _packet) { MYSQLND_PACKET_STATS *packet= (MYSQLND_PACKET_STATS *) _packet; - MYSQLND_ERROR_INFO * error_info = packet->header.error_info; - MYSQLND_PFC * pfc = packet->header.protocol_frame_codec; - MYSQLND_VIO * vio = packet->header.vio; - MYSQLND_STATS * stats = packet->header.stats; - MYSQLND_CONNECTION_STATE * connection_state = packet->header.connection_state; + MYSQLND_ERROR_INFO * error_info = conn->error_info; + MYSQLND_PFC * pfc = conn->protocol_frame_codec; + MYSQLND_VIO * vio = conn->vio; + MYSQLND_STATS * stats = conn->stats; + MYSQLND_CONNECTION_STATE * connection_state = &conn->state; size_t buf_len = pfc->cmd_buffer.length; zend_uchar *buf = (zend_uchar *) pfc->cmd_buffer.buffer; @@ -1971,16 +1888,13 @@ php_mysqlnd_stats_read(void * _packet) /* {{{ php_mysqlnd_stats_free_mem */ static -void php_mysqlnd_stats_free_mem(void * _packet, zend_bool stack_allocation) +void php_mysqlnd_stats_free_mem(void * _packet) { MYSQLND_PACKET_STATS *p= (MYSQLND_PACKET_STATS *) _packet; if (p->message.s) { mnd_efree(p->message.s); p->message.s = NULL; } - if (!stack_allocation) { - mnd_pefree(p, p->header.persistent); - } } /* }}} */ @@ -1991,14 +1905,14 @@ void php_mysqlnd_stats_free_mem(void * _packet, zend_bool stack_allocation) /* {{{ php_mysqlnd_prepare_read */ static enum_func_status -php_mysqlnd_prepare_read(void * _packet) +php_mysqlnd_prepare_read(MYSQLND_CONN_DATA * conn, void * _packet) { MYSQLND_PACKET_PREPARE_RESPONSE *packet= (MYSQLND_PACKET_PREPARE_RESPONSE *) _packet; - MYSQLND_ERROR_INFO * error_info = packet->header.error_info; - MYSQLND_PFC * pfc = packet->header.protocol_frame_codec; - MYSQLND_VIO * vio = packet->header.vio; - MYSQLND_STATS * stats = packet->header.stats; - MYSQLND_CONNECTION_STATE * connection_state = packet->header.connection_state; + MYSQLND_ERROR_INFO * error_info = conn->error_info; + MYSQLND_PFC * pfc = conn->protocol_frame_codec; + MYSQLND_VIO * vio = conn->vio; + MYSQLND_STATS * stats = conn->stats; + MYSQLND_CONNECTION_STATE * connection_state = &conn->state; /* In case of an error, we should have place to put it */ size_t buf_len = pfc->cmd_buffer.length; zend_uchar *buf = (zend_uchar *) pfc->cmd_buffer.buffer; @@ -2072,28 +1986,16 @@ premature_end: /* }}} */ -/* {{{ php_mysqlnd_prepare_free_mem */ -static void -php_mysqlnd_prepare_free_mem(void * _packet, zend_bool stack_allocation) -{ - MYSQLND_PACKET_PREPARE_RESPONSE *p= (MYSQLND_PACKET_PREPARE_RESPONSE *) _packet; - if (!stack_allocation) { - mnd_pefree(p, p->header.persistent); - } -} -/* }}} */ - - /* {{{ php_mysqlnd_chg_user_read */ static enum_func_status -php_mysqlnd_chg_user_read(void * _packet) +php_mysqlnd_chg_user_read(MYSQLND_CONN_DATA * conn, void * _packet) { MYSQLND_PACKET_CHG_USER_RESPONSE *packet= (MYSQLND_PACKET_CHG_USER_RESPONSE *) _packet; - MYSQLND_ERROR_INFO * error_info = packet->header.error_info; - MYSQLND_PFC * pfc = packet->header.protocol_frame_codec; - MYSQLND_VIO * vio = packet->header.vio; - MYSQLND_STATS * stats = packet->header.stats; - MYSQLND_CONNECTION_STATE * connection_state = packet->header.connection_state; + MYSQLND_ERROR_INFO * error_info = conn->error_info; + MYSQLND_PFC * pfc = conn->protocol_frame_codec; + MYSQLND_VIO * vio = conn->vio; + MYSQLND_STATS * stats = conn->stats; + MYSQLND_CONNECTION_STATE * connection_state = &conn->state; /* There could be an error message */ size_t buf_len = pfc->cmd_buffer.length; zend_uchar *buf = (zend_uchar *) pfc->cmd_buffer.buffer; @@ -2156,7 +2058,7 @@ premature_end: /* {{{ php_mysqlnd_chg_user_free_mem */ static void -php_mysqlnd_chg_user_free_mem(void * _packet, zend_bool stack_allocation) +php_mysqlnd_chg_user_free_mem(void * _packet) { MYSQLND_PACKET_CHG_USER_RESPONSE * p = (MYSQLND_PACKET_CHG_USER_RESPONSE *) _packet; @@ -2171,23 +2073,18 @@ php_mysqlnd_chg_user_free_mem(void * _packet, zend_bool stack_allocation) p->new_auth_protocol_data = NULL; } p->new_auth_protocol_data_len = 0; - - if (!stack_allocation) { - mnd_pefree(p, p->header.persistent); - } } /* }}} */ /* {{{ php_mysqlnd_sha256_pk_request_write */ static -size_t php_mysqlnd_sha256_pk_request_write(void * _packet) +size_t php_mysqlnd_sha256_pk_request_write(MYSQLND_CONN_DATA * conn, void * _packet) { - MYSQLND_PACKET_SHA256_PK_REQUEST * packet = (MYSQLND_PACKET_SHA256_PK_REQUEST *) _packet; - MYSQLND_ERROR_INFO * error_info = packet->header.error_info; - MYSQLND_PFC * pfc = packet->header.protocol_frame_codec; - MYSQLND_VIO * vio = packet->header.vio; - MYSQLND_STATS * stats = packet->header.stats; + MYSQLND_ERROR_INFO * error_info = conn->error_info; + MYSQLND_PFC * pfc = conn->protocol_frame_codec; + MYSQLND_VIO * vio = conn->vio; + MYSQLND_STATS * stats = conn->stats; zend_uchar buffer[MYSQLND_HEADER_SIZE + 1]; size_t sent; @@ -2201,30 +2098,18 @@ size_t php_mysqlnd_sha256_pk_request_write(void * _packet) /* }}} */ -/* {{{ php_mysqlnd_sha256_pk_request_free_mem */ -static -void php_mysqlnd_sha256_pk_request_free_mem(void * _packet, zend_bool stack_allocation) -{ - if (!stack_allocation) { - MYSQLND_PACKET_SHA256_PK_REQUEST * p = (MYSQLND_PACKET_SHA256_PK_REQUEST *) _packet; - mnd_pefree(p, p->header.persistent); - } -} -/* }}} */ - - #define SHA256_PK_REQUEST_RESP_BUFFER_SIZE 2048 /* {{{ php_mysqlnd_sha256_pk_request_response_read */ static enum_func_status -php_mysqlnd_sha256_pk_request_response_read(void * _packet) +php_mysqlnd_sha256_pk_request_response_read(MYSQLND_CONN_DATA * conn, void * _packet) { MYSQLND_PACKET_SHA256_PK_REQUEST_RESPONSE * packet= (MYSQLND_PACKET_SHA256_PK_REQUEST_RESPONSE *) _packet; - MYSQLND_ERROR_INFO * error_info = packet->header.error_info; - MYSQLND_PFC * pfc = packet->header.protocol_frame_codec; - MYSQLND_VIO * vio = packet->header.vio; - MYSQLND_STATS * stats = packet->header.stats; - MYSQLND_CONNECTION_STATE * connection_state = packet->header.connection_state; + MYSQLND_ERROR_INFO * error_info = conn->error_info; + MYSQLND_PFC * pfc = conn->protocol_frame_codec; + MYSQLND_VIO * vio = conn->vio; + MYSQLND_STATS * stats = conn->stats; + MYSQLND_CONNECTION_STATE * connection_state = &conn->state; zend_uchar buf[SHA256_PK_REQUEST_RESP_BUFFER_SIZE]; zend_uchar *p = buf; const zend_uchar * const begin = buf; @@ -2258,7 +2143,7 @@ premature_end: /* {{{ php_mysqlnd_sha256_pk_request_response_free_mem */ static void -php_mysqlnd_sha256_pk_request_response_free_mem(void * _packet, zend_bool stack_allocation) +php_mysqlnd_sha256_pk_request_response_free_mem(void * _packet) { MYSQLND_PACKET_SHA256_PK_REQUEST_RESPONSE * p = (MYSQLND_PACKET_SHA256_PK_REQUEST_RESPONSE *) _packet; if (p->public_key) { @@ -2266,10 +2151,6 @@ php_mysqlnd_sha256_pk_request_response_free_mem(void * _packet, zend_bool stack_ p->public_key = NULL; } p->public_key_len = 0; - - if (!stack_allocation) { - mnd_pefree(p, p->header.persistent); - } } /* }}} */ @@ -2279,91 +2160,76 @@ static mysqlnd_packet_methods packet_methods[PROT_LAST] = { { - sizeof(MYSQLND_PACKET_GREET), php_mysqlnd_greet_read, NULL, /* write */ php_mysqlnd_greet_free_mem, }, /* PROT_GREET_PACKET */ { - sizeof(MYSQLND_PACKET_AUTH), NULL, /* read */ php_mysqlnd_auth_write, - php_mysqlnd_auth_free_mem, + NULL, }, /* PROT_AUTH_PACKET */ { - sizeof(MYSQLND_PACKET_AUTH_RESPONSE), php_mysqlnd_auth_response_read, /* read */ NULL, /* write */ php_mysqlnd_auth_response_free_mem, }, /* PROT_AUTH_RESP_PACKET */ { - sizeof(MYSQLND_PACKET_CHANGE_AUTH_RESPONSE), NULL, /* read */ php_mysqlnd_change_auth_response_write, /* write */ - php_mysqlnd_change_auth_response_free_mem, + NULL, }, /* PROT_CHANGE_AUTH_RESP_PACKET */ { - sizeof(MYSQLND_PACKET_OK), php_mysqlnd_ok_read, /* read */ NULL, /* write */ php_mysqlnd_ok_free_mem, }, /* PROT_OK_PACKET */ { - sizeof(MYSQLND_PACKET_EOF), php_mysqlnd_eof_read, /* read */ NULL, /* write */ - php_mysqlnd_eof_free_mem, + NULL, }, /* PROT_EOF_PACKET */ { - sizeof(MYSQLND_PACKET_COMMAND), NULL, /* read */ php_mysqlnd_cmd_write, /* write */ - php_mysqlnd_cmd_free_mem, + NULL, }, /* PROT_CMD_PACKET */ { - sizeof(MYSQLND_PACKET_RSET_HEADER), php_mysqlnd_rset_header_read, /* read */ NULL, /* write */ php_mysqlnd_rset_header_free_mem, }, /* PROT_RSET_HEADER_PACKET */ { - sizeof(MYSQLND_PACKET_RES_FIELD), php_mysqlnd_rset_field_read, /* read */ NULL, /* write */ - php_mysqlnd_rset_field_free_mem, + NULL, }, /* PROT_RSET_FLD_PACKET */ { - sizeof(MYSQLND_PACKET_ROW), php_mysqlnd_rowp_read, /* read */ NULL, /* write */ php_mysqlnd_rowp_free_mem, }, /* PROT_ROW_PACKET */ { - sizeof(MYSQLND_PACKET_STATS), php_mysqlnd_stats_read, /* read */ NULL, /* write */ php_mysqlnd_stats_free_mem, }, /* PROT_STATS_PACKET */ { - sizeof(MYSQLND_PACKET_PREPARE_RESPONSE), php_mysqlnd_prepare_read, /* read */ NULL, /* write */ - php_mysqlnd_prepare_free_mem, + NULL, }, /* PROT_PREPARE_RESP_PACKET */ { - sizeof(MYSQLND_PACKET_CHG_USER_RESPONSE), php_mysqlnd_chg_user_read, /* read */ NULL, /* write */ php_mysqlnd_chg_user_free_mem, }, /* PROT_CHG_USER_RESP_PACKET */ { - sizeof(MYSQLND_PACKET_SHA256_PK_REQUEST), NULL, /* read */ php_mysqlnd_sha256_pk_request_write, - php_mysqlnd_sha256_pk_request_free_mem, + NULL, }, /* PROT_SHA256_PK_REQUEST_PACKET */ { - sizeof(MYSQLND_PACKET_SHA256_PK_REQUEST_RESPONSE), php_mysqlnd_sha256_pk_request_response_read, NULL, /* write */ php_mysqlnd_sha256_pk_request_response_free_mem, @@ -2372,349 +2238,182 @@ mysqlnd_packet_methods packet_methods[PROT_LAST] = /* }}} */ -/* {{{ mysqlnd_protocol::get_greet_packet */ -static struct st_mysqlnd_packet_greet * -MYSQLND_METHOD(mysqlnd_protocol, get_greet_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent) +/* {{{ mysqlnd_protocol::init_greet_packet */ +static void +MYSQLND_METHOD(mysqlnd_protocol, init_greet_packet)(struct st_mysqlnd_packet_greet *packet) { - struct st_mysqlnd_packet_greet * packet = mnd_pecalloc(1, packet_methods[PROT_GREET_PACKET].struct_size, persistent); - DBG_ENTER("mysqlnd_protocol::get_greet_packet"); - if (packet) { - packet->header.m = &packet_methods[PROT_GREET_PACKET]; - packet->header.factory = factory; - - packet->header.protocol_frame_codec = factory->conn->protocol_frame_codec; - packet->header.vio = factory->conn->vio; - packet->header.stats = factory->conn->stats; - packet->header.error_info = factory->conn->error_info; - packet->header.connection_state = &factory->conn->state; - - packet->header.persistent = persistent; - } - DBG_RETURN(packet); + DBG_ENTER("mysqlnd_protocol::init_greet_packet"); + memset(packet, 0, sizeof(*packet)); + packet->header.m = &packet_methods[PROT_GREET_PACKET]; + DBG_VOID_RETURN; } /* }}} */ -/* {{{ mysqlnd_protocol::get_auth_packet */ -static struct st_mysqlnd_packet_auth * -MYSQLND_METHOD(mysqlnd_protocol, get_auth_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent) +/* {{{ mysqlnd_protocol::init_auth_packet */ +static void +MYSQLND_METHOD(mysqlnd_protocol, init_auth_packet)(struct st_mysqlnd_packet_auth *packet) { - struct st_mysqlnd_packet_auth * packet = mnd_pecalloc(1, packet_methods[PROT_AUTH_PACKET].struct_size, persistent); - DBG_ENTER("mysqlnd_protocol::get_auth_packet"); - if (packet) { - packet->header.m = &packet_methods[PROT_AUTH_PACKET]; - packet->header.factory = factory; - - packet->header.conn = factory->conn; - packet->header.protocol_frame_codec = factory->conn->protocol_frame_codec; - packet->header.vio = factory->conn->vio; - packet->header.stats = factory->conn->stats; - packet->header.error_info = factory->conn->error_info; - packet->header.connection_state = &factory->conn->state; - - packet->header.persistent = persistent; - } - DBG_RETURN(packet); + DBG_ENTER("mysqlnd_protocol::init_auth_packet"); + memset(packet, 0, sizeof(*packet)); + packet->header.m = &packet_methods[PROT_AUTH_PACKET]; + DBG_VOID_RETURN; } /* }}} */ -/* {{{ mysqlnd_protocol::get_auth_response_packet */ -static struct st_mysqlnd_packet_auth_response * -MYSQLND_METHOD(mysqlnd_protocol, get_auth_response_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent) +/* {{{ mysqlnd_protocol::init_auth_response_packet */ +static void +MYSQLND_METHOD(mysqlnd_protocol, init_auth_response_packet)(struct st_mysqlnd_packet_auth_response *packet) { - struct st_mysqlnd_packet_auth_response * packet = mnd_pecalloc(1, packet_methods[PROT_AUTH_RESP_PACKET].struct_size, persistent); - DBG_ENTER("mysqlnd_protocol::get_auth_response_packet"); - if (packet) { - packet->header.m = &packet_methods[PROT_AUTH_RESP_PACKET]; - packet->header.factory = factory; - - packet->header.protocol_frame_codec = factory->conn->protocol_frame_codec; - packet->header.vio = factory->conn->vio; - packet->header.stats = factory->conn->stats; - packet->header.error_info = factory->conn->error_info; - packet->header.connection_state = &factory->conn->state; - - packet->header.persistent = persistent; - } - DBG_RETURN(packet); + DBG_ENTER("mysqlnd_protocol::init_auth_response_packet"); + memset(packet, 0, sizeof(*packet)); + packet->header.m = &packet_methods[PROT_AUTH_RESP_PACKET]; + DBG_VOID_RETURN; } /* }}} */ -/* {{{ mysqlnd_protocol::get_change_auth_response_packet */ -static struct st_mysqlnd_packet_change_auth_response * -MYSQLND_METHOD(mysqlnd_protocol, get_change_auth_response_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent) +/* {{{ mysqlnd_protocol::init_change_auth_response_packet */ +static void +MYSQLND_METHOD(mysqlnd_protocol, init_change_auth_response_packet)(struct st_mysqlnd_packet_change_auth_response *packet) { - struct st_mysqlnd_packet_change_auth_response * packet = mnd_pecalloc(1, packet_methods[PROT_CHANGE_AUTH_RESP_PACKET].struct_size, persistent); - DBG_ENTER("mysqlnd_protocol::get_change_auth_response_packet"); - if (packet) { - packet->header.m = &packet_methods[PROT_CHANGE_AUTH_RESP_PACKET]; - packet->header.factory = factory; - - packet->header.protocol_frame_codec = factory->conn->protocol_frame_codec; - packet->header.vio = factory->conn->vio; - packet->header.stats = factory->conn->stats; - packet->header.error_info = factory->conn->error_info; - packet->header.connection_state = &factory->conn->state; - - packet->header.persistent = persistent; - } - DBG_RETURN(packet); + DBG_ENTER("mysqlnd_protocol::init_change_auth_response_packet"); + memset(packet, 0, sizeof(*packet)); + packet->header.m = &packet_methods[PROT_CHANGE_AUTH_RESP_PACKET]; + DBG_VOID_RETURN; } /* }}} */ -/* {{{ mysqlnd_protocol::get_ok_packet */ -static struct st_mysqlnd_packet_ok * -MYSQLND_METHOD(mysqlnd_protocol, get_ok_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent) +/* {{{ mysqlnd_protocol::init_ok_packet */ +static void +MYSQLND_METHOD(mysqlnd_protocol, init_ok_packet)(struct st_mysqlnd_packet_ok *packet) { - struct st_mysqlnd_packet_ok * packet = mnd_pecalloc(1, packet_methods[PROT_OK_PACKET].struct_size, persistent); - DBG_ENTER("mysqlnd_protocol::get_ok_packet"); - if (packet) { - packet->header.m = &packet_methods[PROT_OK_PACKET]; - packet->header.factory = factory; - - packet->header.protocol_frame_codec = factory->conn->protocol_frame_codec; - packet->header.vio = factory->conn->vio; - packet->header.stats = factory->conn->stats; - packet->header.error_info = factory->conn->error_info; - packet->header.connection_state = &factory->conn->state; - - packet->header.persistent = persistent; - } - DBG_RETURN(packet); + DBG_ENTER("mysqlnd_protocol::init_ok_packet"); + memset(packet, 0, sizeof(*packet)); + packet->header.m = &packet_methods[PROT_OK_PACKET]; + DBG_VOID_RETURN; } /* }}} */ -/* {{{ mysqlnd_protocol::get_eof_packet */ -static struct st_mysqlnd_packet_eof * -MYSQLND_METHOD(mysqlnd_protocol, get_eof_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent) +/* {{{ mysqlnd_protocol::init_eof_packet */ +static void +MYSQLND_METHOD(mysqlnd_protocol, init_eof_packet)(struct st_mysqlnd_packet_eof *packet) { - struct st_mysqlnd_packet_eof * packet = mnd_pecalloc(1, packet_methods[PROT_EOF_PACKET].struct_size, persistent); - DBG_ENTER("mysqlnd_protocol::get_eof_packet"); - if (packet) { - packet->header.m = &packet_methods[PROT_EOF_PACKET]; - packet->header.factory = factory; - - packet->header.protocol_frame_codec = factory->conn->protocol_frame_codec; - packet->header.vio = factory->conn->vio; - packet->header.stats = factory->conn->stats; - packet->header.error_info = factory->conn->error_info; - packet->header.connection_state = &factory->conn->state; - - packet->header.persistent = persistent; - } - DBG_RETURN(packet); + DBG_ENTER("mysqlnd_protocol::init_eof_packet"); + memset(packet, 0, sizeof(*packet)); + packet->header.m = &packet_methods[PROT_EOF_PACKET]; + DBG_VOID_RETURN; } /* }}} */ -/* {{{ mysqlnd_protocol::get_command_packet */ -static struct st_mysqlnd_packet_command * -MYSQLND_METHOD(mysqlnd_protocol, get_command_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent) +/* {{{ mysqlnd_protocol::init_command_packet */ +static void +MYSQLND_METHOD(mysqlnd_protocol, init_command_packet)(struct st_mysqlnd_packet_command *packet) { - struct st_mysqlnd_packet_command * packet = mnd_pecalloc(1, packet_methods[PROT_CMD_PACKET].struct_size, persistent); - DBG_ENTER("mysqlnd_protocol::get_command_packet"); - if (packet) { - packet->header.m = &packet_methods[PROT_CMD_PACKET]; - packet->header.factory = factory; - - packet->header.protocol_frame_codec = factory->conn->protocol_frame_codec; - packet->header.vio = factory->conn->vio; - packet->header.stats = factory->conn->stats; - packet->header.error_info = factory->conn->error_info; - packet->header.connection_state = &factory->conn->state; - - packet->header.persistent = persistent; - } - DBG_RETURN(packet); + DBG_ENTER("mysqlnd_protocol::init_command_packet"); + memset(packet, 0, sizeof(*packet)); + packet->header.m = &packet_methods[PROT_CMD_PACKET]; + DBG_VOID_RETURN; } /* }}} */ -/* {{{ mysqlnd_protocol::get_rset_packet */ -static struct st_mysqlnd_packet_rset_header * -MYSQLND_METHOD(mysqlnd_protocol, get_rset_header_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent) +/* {{{ mysqlnd_protocol::init_rset_packet */ +static void +MYSQLND_METHOD(mysqlnd_protocol, init_rset_header_packet)(struct st_mysqlnd_packet_rset_header *packet) { - struct st_mysqlnd_packet_rset_header * packet = mnd_pecalloc(1, packet_methods[PROT_RSET_HEADER_PACKET].struct_size, persistent); DBG_ENTER("mysqlnd_protocol::get_rset_header_packet"); - if (packet) { - packet->header.m = &packet_methods[PROT_RSET_HEADER_PACKET]; - packet->header.factory = factory; - - packet->header.protocol_frame_codec = factory->conn->protocol_frame_codec; - packet->header.vio = factory->conn->vio; - packet->header.stats = factory->conn->stats; - packet->header.error_info = factory->conn->error_info; - packet->header.connection_state = &factory->conn->state; - - packet->header.persistent = persistent; - } - DBG_RETURN(packet); + memset(packet, 0, sizeof(*packet)); + packet->header.m = &packet_methods[PROT_RSET_HEADER_PACKET]; + DBG_VOID_RETURN; } /* }}} */ -/* {{{ mysqlnd_protocol::get_result_field_packet */ -static struct st_mysqlnd_packet_res_field * -MYSQLND_METHOD(mysqlnd_protocol, get_result_field_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent) +/* {{{ mysqlnd_protocol::init_result_field_packet */ +static void +MYSQLND_METHOD(mysqlnd_protocol, init_result_field_packet)(struct st_mysqlnd_packet_res_field *packet) { - struct st_mysqlnd_packet_res_field * packet = mnd_pecalloc(1, packet_methods[PROT_RSET_FLD_PACKET].struct_size, persistent); - DBG_ENTER("mysqlnd_protocol::get_result_field_packet"); - if (packet) { - packet->header.m = &packet_methods[PROT_RSET_FLD_PACKET]; - packet->header.factory = factory; - - packet->header.protocol_frame_codec = factory->conn->protocol_frame_codec; - packet->header.vio = factory->conn->vio; - packet->header.stats = factory->conn->stats; - packet->header.error_info = factory->conn->error_info; - packet->header.connection_state = &factory->conn->state; - - packet->header.persistent = persistent; - } - DBG_RETURN(packet); + DBG_ENTER("mysqlnd_protocol::init_result_field_packet"); + memset(packet, 0, sizeof(*packet)); + packet->header.m = &packet_methods[PROT_RSET_FLD_PACKET]; + DBG_VOID_RETURN; } /* }}} */ -/* {{{ mysqlnd_protocol::get_row_packet */ -static struct st_mysqlnd_packet_row * -MYSQLND_METHOD(mysqlnd_protocol, get_row_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent) +/* {{{ mysqlnd_protocol::init_row_packet */ +static void +MYSQLND_METHOD(mysqlnd_protocol, init_row_packet)(struct st_mysqlnd_packet_row *packet) { - struct st_mysqlnd_packet_row * packet = mnd_pecalloc(1, packet_methods[PROT_ROW_PACKET].struct_size, persistent); - DBG_ENTER("mysqlnd_protocol::get_row_packet"); - if (packet) { - packet->header.m = &packet_methods[PROT_ROW_PACKET]; - packet->header.factory = factory; - - packet->header.conn = factory->conn; - packet->header.protocol_frame_codec = factory->conn->protocol_frame_codec; - packet->header.vio = factory->conn->vio; - packet->header.stats = factory->conn->stats; - packet->header.error_info = factory->conn->error_info; - packet->header.connection_state = &factory->conn->state; - - packet->header.persistent = persistent; - } - DBG_RETURN(packet); + DBG_ENTER("mysqlnd_protocol::init_row_packet"); + memset(packet, 0, sizeof(*packet)); + packet->header.m = &packet_methods[PROT_ROW_PACKET]; + DBG_VOID_RETURN; } /* }}} */ -/* {{{ mysqlnd_protocol::get_stats_packet */ -static struct st_mysqlnd_packet_stats * -MYSQLND_METHOD(mysqlnd_protocol, get_stats_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent) +/* {{{ mysqlnd_protocol::init_stats_packet */ +static void +MYSQLND_METHOD(mysqlnd_protocol, init_stats_packet)(struct st_mysqlnd_packet_stats *packet) { - struct st_mysqlnd_packet_stats * packet = mnd_pecalloc(1, packet_methods[PROT_STATS_PACKET].struct_size, persistent); - DBG_ENTER("mysqlnd_protocol::get_stats_packet"); - if (packet) { - packet->header.m = &packet_methods[PROT_STATS_PACKET]; - packet->header.factory = factory; - - packet->header.protocol_frame_codec = factory->conn->protocol_frame_codec; - packet->header.vio = factory->conn->vio; - packet->header.stats = factory->conn->stats; - packet->header.error_info = factory->conn->error_info; - packet->header.connection_state = &factory->conn->state; - - packet->header.persistent = persistent; - } - DBG_RETURN(packet); + DBG_ENTER("mysqlnd_protocol::init_stats_packet"); + memset(packet, 0, sizeof(*packet)); + packet->header.m = &packet_methods[PROT_STATS_PACKET]; + DBG_VOID_RETURN; } /* }}} */ -/* {{{ mysqlnd_protocol::get_prepare_response_packet */ -static struct st_mysqlnd_packet_prepare_response * -MYSQLND_METHOD(mysqlnd_protocol, get_prepare_response_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent) +/* {{{ mysqlnd_protocol::init_prepare_response_packet */ +static void +MYSQLND_METHOD(mysqlnd_protocol, init_prepare_response_packet)(struct st_mysqlnd_packet_prepare_response *packet) { - struct st_mysqlnd_packet_prepare_response * packet = mnd_pecalloc(1, packet_methods[PROT_PREPARE_RESP_PACKET].struct_size, persistent); - DBG_ENTER("mysqlnd_protocol::get_prepare_response_packet"); - if (packet) { - packet->header.m = &packet_methods[PROT_PREPARE_RESP_PACKET]; - packet->header.factory = factory; - - packet->header.protocol_frame_codec = factory->conn->protocol_frame_codec; - packet->header.vio = factory->conn->vio; - packet->header.stats = factory->conn->stats; - packet->header.error_info = factory->conn->error_info; - packet->header.connection_state = &factory->conn->state; - - packet->header.persistent = persistent; - } - DBG_RETURN(packet); + DBG_ENTER("mysqlnd_protocol::init_prepare_response_packet"); + memset(packet, 0, sizeof(*packet)); + packet->header.m = &packet_methods[PROT_PREPARE_RESP_PACKET]; + DBG_VOID_RETURN; } /* }}} */ -/* {{{ mysqlnd_protocol::get_change_user_response_packet */ -static struct st_mysqlnd_packet_chg_user_resp* -MYSQLND_METHOD(mysqlnd_protocol, get_change_user_response_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent) +/* {{{ mysqlnd_protocol::init_change_user_response_packet */ +static void +MYSQLND_METHOD(mysqlnd_protocol, init_change_user_response_packet)(struct st_mysqlnd_packet_chg_user_resp *packet) { - struct st_mysqlnd_packet_chg_user_resp * packet = mnd_pecalloc(1, packet_methods[PROT_CHG_USER_RESP_PACKET].struct_size, persistent); - DBG_ENTER("mysqlnd_protocol::get_change_user_response_packet"); - if (packet) { - packet->header.m = &packet_methods[PROT_CHG_USER_RESP_PACKET]; - packet->header.factory = factory; - - packet->header.protocol_frame_codec = factory->conn->protocol_frame_codec; - packet->header.vio = factory->conn->vio; - packet->header.stats = factory->conn->stats; - packet->header.error_info = factory->conn->error_info; - packet->header.connection_state = &factory->conn->state; - - packet->header.persistent = persistent; - } - DBG_RETURN(packet); + DBG_ENTER("mysqlnd_protocol::init_change_user_response_packet"); + memset(packet, 0, sizeof(*packet)); + packet->header.m = &packet_methods[PROT_CHG_USER_RESP_PACKET]; + DBG_VOID_RETURN; } /* }}} */ -/* {{{ mysqlnd_protocol::get_sha256_pk_request_packet */ -static struct st_mysqlnd_packet_sha256_pk_request * -MYSQLND_METHOD(mysqlnd_protocol, get_sha256_pk_request_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent) +/* {{{ mysqlnd_protocol::init_sha256_pk_request_packet */ +static void +MYSQLND_METHOD(mysqlnd_protocol, init_sha256_pk_request_packet)(struct st_mysqlnd_packet_sha256_pk_request *packet) { - struct st_mysqlnd_packet_sha256_pk_request * packet = mnd_pecalloc(1, packet_methods[PROT_SHA256_PK_REQUEST_PACKET].struct_size, persistent); - DBG_ENTER("mysqlnd_protocol::get_sha256_pk_request_packet"); - if (packet) { - packet->header.m = &packet_methods[PROT_SHA256_PK_REQUEST_PACKET]; - packet->header.factory = factory; - - packet->header.protocol_frame_codec = factory->conn->protocol_frame_codec; - packet->header.vio = factory->conn->vio; - packet->header.stats = factory->conn->stats; - packet->header.error_info = factory->conn->error_info; - packet->header.connection_state = &factory->conn->state; - - packet->header.persistent = persistent; - } - DBG_RETURN(packet); + DBG_ENTER("mysqlnd_protocol::init_sha256_pk_request_packet"); + memset(packet, 0, sizeof(*packet)); + packet->header.m = &packet_methods[PROT_SHA256_PK_REQUEST_PACKET]; + DBG_VOID_RETURN; } /* }}} */ -/* {{{ mysqlnd_protocol::get_sha256_pk_request_response_packet */ -static struct st_mysqlnd_packet_sha256_pk_request_response * -MYSQLND_METHOD(mysqlnd_protocol, get_sha256_pk_request_response_packet)(MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * const factory, const zend_bool persistent) +/* {{{ mysqlnd_protocol::init_sha256_pk_request_response_packet */ +static void +MYSQLND_METHOD(mysqlnd_protocol, init_sha256_pk_request_response_packet)(struct st_mysqlnd_packet_sha256_pk_request_response *packet) { - struct st_mysqlnd_packet_sha256_pk_request_response * packet = mnd_pecalloc(1, packet_methods[PROT_SHA256_PK_REQUEST_RESPONSE_PACKET].struct_size, persistent); - DBG_ENTER("mysqlnd_protocol::get_sha256_pk_request_response_packet"); - if (packet) { - packet->header.m = &packet_methods[PROT_SHA256_PK_REQUEST_RESPONSE_PACKET]; - packet->header.factory = factory; - - packet->header.protocol_frame_codec = factory->conn->protocol_frame_codec; - packet->header.vio = factory->conn->vio; - packet->header.stats = factory->conn->stats; - packet->header.error_info = factory->conn->error_info; - packet->header.connection_state = &factory->conn->state; - - packet->header.persistent = persistent; - } - DBG_RETURN(packet); + DBG_ENTER("mysqlnd_protocol::init_sha256_pk_request_response_packet"); + memset(packet, 0, sizeof(*packet)); + packet->header.m = &packet_methods[PROT_SHA256_PK_REQUEST_RESPONSE_PACKET]; + DBG_VOID_RETURN; } /* }}} */ @@ -2735,7 +2434,7 @@ MYSQLND_METHOD(mysqlnd_protocol, send_command)( void * send_close_ctx) { enum_func_status ret = PASS; - MYSQLND_PACKET_COMMAND * cmd_packet = NULL; + MYSQLND_PACKET_COMMAND cmd_packet; enum mysqlnd_connection_state state; DBG_ENTER("mysqlnd_protocol::send_command"); DBG_INF_FMT("command=%s silent=%u", mysqlnd_command_to_text[command], silent); @@ -2759,21 +2458,17 @@ MYSQLND_METHOD(mysqlnd_protocol, send_command)( UPSERT_STATUS_SET_AFFECTED_ROWS_TO_ERROR(upsert_status); SET_EMPTY_ERROR(error_info); - cmd_packet = payload_decoder_factory->m.get_command_packet(payload_decoder_factory, FALSE); - if (!cmd_packet) { - SET_OOM_ERROR(error_info); - DBG_RETURN(FAIL); - } + payload_decoder_factory->m.init_command_packet(&cmd_packet); - cmd_packet->command = command; + cmd_packet.command = command; if (arg && arg_len) { - cmd_packet->argument.s = (char *) arg; - cmd_packet->argument.l = arg_len; + cmd_packet.argument.s = (char *) arg; + cmd_packet.argument.l = arg_len; } MYSQLND_INC_CONN_STATISTIC(stats, STAT_COM_QUIT + command - 1 /* because of COM_SLEEP */ ); - if (! PACKET_WRITE(cmd_packet)) { + if (! PACKET_WRITE(payload_decoder_factory->conn, &cmd_packet)) { if (!silent) { 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()); @@ -2783,7 +2478,7 @@ MYSQLND_METHOD(mysqlnd_protocol, send_command)( DBG_ERR("Server is gone"); ret = FAIL; } - PACKET_FREE(cmd_packet); + PACKET_FREE(&cmd_packet); DBG_RETURN(ret); } /* }}} */ @@ -2796,26 +2491,22 @@ MYSQLND_METHOD(mysqlnd_protocol, send_command_handle_OK)( MYSQLND_ERROR_INFO * const error_info, MYSQLND_UPSERT_STATUS * const upsert_status, const zend_bool ignore_upsert_status, /* actually used only by LOAD DATA. COM_QUERY and COM_EXECUTE handle the responses themselves */ - MYSQLND_STRING * const last_message, - const zend_bool last_message_persistent) + MYSQLND_STRING * const last_message) { enum_func_status ret = FAIL; - MYSQLND_PACKET_OK * ok_response = payload_decoder_factory->m.get_ok_packet(payload_decoder_factory, FALSE); + MYSQLND_PACKET_OK ok_response; + payload_decoder_factory->m.init_ok_packet(&ok_response); DBG_ENTER("mysqlnd_protocol::send_command_handle_OK"); - if (!ok_response) { - SET_OOM_ERROR(error_info); - DBG_RETURN(FAIL); - } - if (FAIL == (ret = PACKET_READ(ok_response))) { + if (FAIL == (ret = PACKET_READ(payload_decoder_factory->conn, &ok_response))) { DBG_INF("Error while reading OK packet"); SET_CLIENT_ERROR(error_info, CR_MALFORMED_PACKET, UNKNOWN_SQLSTATE, "Malformed packet"); goto end; } DBG_INF_FMT("OK from server"); - if (0xFF == ok_response->field_count) { + if (0xFF == ok_response.field_count) { /* The server signalled error. Set the error */ - SET_CLIENT_ERROR(error_info, ok_response->error_no, ok_response->sqlstate, ok_response->error); + SET_CLIENT_ERROR(error_info, ok_response.error_no, ok_response.sqlstate, ok_response.error); ret = FAIL; /* Cover a protocol design error: error packet does not @@ -2830,20 +2521,19 @@ MYSQLND_METHOD(mysqlnd_protocol, send_command_handle_OK)( UPSERT_STATUS_SET_AFFECTED_ROWS_TO_ERROR(upsert_status); } else { SET_NEW_MESSAGE(last_message->s, last_message->l, - ok_response->message, ok_response->message_len, - last_message_persistent); + ok_response.message, ok_response.message_len); if (!ignore_upsert_status) { UPSERT_STATUS_RESET(upsert_status); - UPSERT_STATUS_SET_WARNINGS(upsert_status, ok_response->warning_count); - UPSERT_STATUS_SET_SERVER_STATUS(upsert_status, ok_response->server_status); - UPSERT_STATUS_SET_AFFECTED_ROWS(upsert_status, ok_response->affected_rows); - UPSERT_STATUS_SET_LAST_INSERT_ID(upsert_status, ok_response->last_insert_id); + UPSERT_STATUS_SET_WARNINGS(upsert_status, ok_response.warning_count); + UPSERT_STATUS_SET_SERVER_STATUS(upsert_status, ok_response.server_status); + UPSERT_STATUS_SET_AFFECTED_ROWS(upsert_status, ok_response.affected_rows); + UPSERT_STATUS_SET_LAST_INSERT_ID(upsert_status, ok_response.last_insert_id); } else { /* LOAD DATA */ } } end: - PACKET_FREE(ok_response); + PACKET_FREE(&ok_response); DBG_INF(ret == PASS ? "PASS":"FAIL"); DBG_RETURN(ret); } @@ -2858,32 +2548,30 @@ MYSQLND_METHOD(mysqlnd_protocol, send_command_handle_EOF)( MYSQLND_UPSERT_STATUS * const upsert_status) { enum_func_status ret = FAIL; - MYSQLND_PACKET_EOF * response = payload_decoder_factory->m.get_eof_packet(payload_decoder_factory, FALSE); + MYSQLND_PACKET_EOF response; + + payload_decoder_factory->m.init_eof_packet(&response); DBG_ENTER("mysqlnd_protocol::send_command_handle_EOF"); - if (!response) { - SET_OOM_ERROR(error_info); - DBG_RETURN(FAIL); - } - if (FAIL == (ret = PACKET_READ(response))) { + if (FAIL == (ret = PACKET_READ(payload_decoder_factory->conn, &response))) { DBG_INF("Error while reading EOF packet"); SET_CLIENT_ERROR(error_info, CR_MALFORMED_PACKET, UNKNOWN_SQLSTATE, "Malformed packet"); - } else if (0xFF == response->field_count) { + } else if (0xFF == response.field_count) { /* The server signalled error. Set the error */ - DBG_INF_FMT("Error_no=%d SQLstate=%s Error=%s", response->error_no, response->sqlstate, response->error); + DBG_INF_FMT("Error_no=%d SQLstate=%s Error=%s", response.error_no, response.sqlstate, response.error); - SET_CLIENT_ERROR(error_info, response->error_no, response->sqlstate, response->error); + SET_CLIENT_ERROR(error_info, response.error_no, response.sqlstate, response.error); UPSERT_STATUS_SET_AFFECTED_ROWS_TO_ERROR(upsert_status); - } else if (0xFE != response->field_count) { + } else if (0xFE != response.field_count) { SET_CLIENT_ERROR(error_info, CR_MALFORMED_PACKET, UNKNOWN_SQLSTATE, "Malformed packet"); - DBG_ERR_FMT("EOF packet expected, field count wasn't 0xFE but 0x%2X", response->field_count); - php_error_docref(NULL, E_WARNING, "EOF packet expected, field count wasn't 0xFE but 0x%2X", response->field_count); + DBG_ERR_FMT("EOF packet expected, field count wasn't 0xFE but 0x%2X", response.field_count); + php_error_docref(NULL, E_WARNING, "EOF packet expected, field count wasn't 0xFE but 0x%2X", response.field_count); } else { DBG_INF_FMT("EOF from server"); } - PACKET_FREE(response); + PACKET_FREE(&response); DBG_INF(ret == PASS ? "PASS":"FAIL"); DBG_RETURN(ret); @@ -2902,8 +2590,7 @@ MYSQLND_METHOD(mysqlnd_protocol, send_command_handle_response)( MYSQLND_ERROR_INFO * error_info, MYSQLND_UPSERT_STATUS * upsert_status, - MYSQLND_STRING * last_message, - zend_bool last_message_persistent + MYSQLND_STRING * last_message ) { enum_func_status ret = FAIL; @@ -2913,7 +2600,7 @@ MYSQLND_METHOD(mysqlnd_protocol, send_command_handle_response)( switch (ok_packet) { case PROT_OK_PACKET: - ret = payload_decoder_factory->m.send_command_handle_OK(payload_decoder_factory, error_info, upsert_status, ignore_upsert_status, last_message, last_message_persistent); + ret = payload_decoder_factory->m.send_command_handle_OK(payload_decoder_factory, error_info, upsert_status, ignore_upsert_status, last_message); break; case PROT_EOF_PACKET: ret = payload_decoder_factory->m.send_command_handle_EOF(payload_decoder_factory, error_info, upsert_status); @@ -2933,21 +2620,21 @@ MYSQLND_METHOD(mysqlnd_protocol, send_command_handle_response)( MYSQLND_CLASS_METHODS_START(mysqlnd_protocol_payload_decoder_factory) - MYSQLND_METHOD(mysqlnd_protocol, get_greet_packet), - MYSQLND_METHOD(mysqlnd_protocol, get_auth_packet), - MYSQLND_METHOD(mysqlnd_protocol, get_auth_response_packet), - MYSQLND_METHOD(mysqlnd_protocol, get_change_auth_response_packet), - MYSQLND_METHOD(mysqlnd_protocol, get_ok_packet), - MYSQLND_METHOD(mysqlnd_protocol, get_command_packet), - MYSQLND_METHOD(mysqlnd_protocol, get_eof_packet), - MYSQLND_METHOD(mysqlnd_protocol, get_rset_header_packet), - MYSQLND_METHOD(mysqlnd_protocol, get_result_field_packet), - MYSQLND_METHOD(mysqlnd_protocol, get_row_packet), - MYSQLND_METHOD(mysqlnd_protocol, get_stats_packet), - MYSQLND_METHOD(mysqlnd_protocol, get_prepare_response_packet), - MYSQLND_METHOD(mysqlnd_protocol, get_change_user_response_packet), - MYSQLND_METHOD(mysqlnd_protocol, get_sha256_pk_request_packet), - MYSQLND_METHOD(mysqlnd_protocol, get_sha256_pk_request_response_packet), + MYSQLND_METHOD(mysqlnd_protocol, init_greet_packet), + MYSQLND_METHOD(mysqlnd_protocol, init_auth_packet), + MYSQLND_METHOD(mysqlnd_protocol, init_auth_response_packet), + MYSQLND_METHOD(mysqlnd_protocol, init_change_auth_response_packet), + MYSQLND_METHOD(mysqlnd_protocol, init_ok_packet), + MYSQLND_METHOD(mysqlnd_protocol, init_command_packet), + MYSQLND_METHOD(mysqlnd_protocol, init_eof_packet), + MYSQLND_METHOD(mysqlnd_protocol, init_rset_header_packet), + MYSQLND_METHOD(mysqlnd_protocol, init_result_field_packet), + MYSQLND_METHOD(mysqlnd_protocol, init_row_packet), + MYSQLND_METHOD(mysqlnd_protocol, init_stats_packet), + MYSQLND_METHOD(mysqlnd_protocol, init_prepare_response_packet), + MYSQLND_METHOD(mysqlnd_protocol, init_change_user_response_packet), + MYSQLND_METHOD(mysqlnd_protocol, init_sha256_pk_request_packet), + MYSQLND_METHOD(mysqlnd_protocol, init_sha256_pk_request_response_packet), MYSQLND_METHOD(mysqlnd_protocol, send_command), MYSQLND_METHOD(mysqlnd_protocol, send_command_handle_response), diff --git a/ext/mysqlnd/mysqlnd_wireprotocol.h b/ext/mysqlnd/mysqlnd_wireprotocol.h index d6855580b4..6e531b0e54 100644 --- a/ext/mysqlnd/mysqlnd_wireprotocol.h +++ b/ext/mysqlnd/mysqlnd_wireprotocol.h @@ -31,13 +31,13 @@ PHPAPI extern const char mysqlnd_read_body_name[]; /* Packet handling */ -#define PACKET_WRITE(packet) ((packet)->header.m->write_to_net((packet))) -#define PACKET_READ(packet) ((packet)->header.m->read_from_net((packet))) +#define PACKET_WRITE(conn, packet) ((packet)->header.m->write_to_net((conn), (packet))) +#define PACKET_READ(conn, packet) ((packet)->header.m->read_from_net((conn), (packet))) #define PACKET_FREE(packet) \ do { \ DBG_INF_FMT("PACKET_FREE(%p)", packet); \ - if ((packet)) { \ - ((packet)->header.m->free_mem((packet), FALSE)); \ + if ((packet)->header.m->free_mem) { \ + ((packet)->header.m->free_mem((packet))); \ } \ } while (0); @@ -45,27 +45,17 @@ PHPAPI extern const char * const mysqlnd_command_to_text[COM_END]; /* Low-level extraction functionality */ typedef struct st_mysqlnd_packet_methods { - size_t struct_size; - enum_func_status (*read_from_net)(void * packet); - size_t (*write_to_net)(void * packet); - void (*free_mem)(void *packet, zend_bool stack_allocation); + enum_func_status (*read_from_net)(MYSQLND_CONN_DATA * conn, void * packet); + size_t (*write_to_net)(MYSQLND_CONN_DATA * conn, void * packet); + void (*free_mem)(void *packet); } mysqlnd_packet_methods; typedef struct st_mysqlnd_packet_header { size_t size; zend_uchar packet_no; - zend_bool persistent; mysqlnd_packet_methods *m; - - MYSQLND_CONN_DATA * conn; - MYSQLND_PFC * protocol_frame_codec; - MYSQLND_VIO * vio; - MYSQLND_ERROR_INFO * error_info; - MYSQLND_STATS * stats; - MYSQLND_PROTOCOL_PAYLOAD_DECODER_FACTORY * factory; - MYSQLND_CONNECTION_STATE * connection_state; } MYSQLND_PACKET_HEADER; /* Server greets the client */ @@ -206,10 +196,10 @@ typedef struct st_mysqlnd_packet_rset_header { /* Result set field packet */ typedef struct st_mysqlnd_packet_res_field { MYSQLND_PACKET_HEADER header; + MYSQLND_MEMORY_POOL *memory_pool; MYSQLND_FIELD *metadata; /* For table definitions, empty for result sets */ zend_bool skip_parsing; - zend_bool persistent_alloc; MYSQLND_ERROR_INFO error_info; } MYSQLND_PACKET_RES_FIELD; @@ -228,12 +218,11 @@ typedef struct st_mysqlnd_packet_row { uint16_t warning_count; uint16_t server_status; - struct st_mysqlnd_memory_pool_chunk *row_buffer; + MYSQLND_ROW_BUFFER row_buffer; MYSQLND_MEMORY_POOL * result_set_memory_pool; zend_bool skip_extraction; zend_bool binary_protocol; - zend_bool persistent_alloc; MYSQLND_FIELD *fields_metadata; /* If error packet, we use these */ @@ -299,16 +288,16 @@ size_t php_mysqlnd_net_store_length_size(uint64_t length); PHPAPI extern const char * const mysqlnd_empty_string; -enum_func_status php_mysqlnd_rowp_read_binary_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval * fields, +enum_func_status php_mysqlnd_rowp_read_binary_protocol(MYSQLND_ROW_BUFFER * row_buffer, zval * fields, unsigned int field_count, const MYSQLND_FIELD * fields_metadata, zend_bool as_int_or_float, MYSQLND_STATS * stats); -enum_func_status php_mysqlnd_rowp_read_text_protocol_zval(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval * fields, +enum_func_status php_mysqlnd_rowp_read_text_protocol_zval(MYSQLND_ROW_BUFFER * row_buffer, zval * fields, unsigned int field_count, const MYSQLND_FIELD * fields_metadata, zend_bool as_int_or_float, MYSQLND_STATS * stats); -enum_func_status php_mysqlnd_rowp_read_text_protocol_c(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval * fields, +enum_func_status php_mysqlnd_rowp_read_text_protocol_c(MYSQLND_ROW_BUFFER * row_buffer, zval * fields, unsigned int field_count, const MYSQLND_FIELD * fields_metadata, zend_bool as_int_or_float, MYSQLND_STATS * stats); |