{
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;
+
+ 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;
- auth_packet->client_flags = mysql_flags;
- auth_packet->max_packet_size = session_options->max_allowed_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;
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);
+ 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);
}
/* }}} */
{
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;
- 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;
- 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;
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) {
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);
}
/* }}} */
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);
/* 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;
}
{
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;
+ 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
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;
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);
+ 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);
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);
+ result = conn->current_result = conn->m->result_init(rset_header.field_count);
} else {
if (!stmt->result) {
DBG_INF("This is 'SHOW'/'EXPLAIN'-like query.");
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);
+ result = stmt->result = conn->m->result_init(rset_header.field_count);
} else {
/*
Update result set metadata if it for some reason changed between
}
/* 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);
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
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);
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;
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;
*/
/* 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;
enum_func_status ret;
unsigned int next_extend = STORE_RESULT_PREALLOCATED_SET_IF_NOT_EMPTY, free_rows = 1;
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) {
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;
- }
+
+ 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;
if (total_allocated_rows * sizeof(MYSQLND_MEMORY_POOL_CHUNK *) > SIZE_MAX) {
SET_OOM_ERROR(conn->error_info);
ret = FAIL;
- goto end;
+ goto free_end;
}
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 = NULL;
/*
No need to FREE_ALLOCA as we can reuse the
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) {
if (set->row_count * sizeof(MYSQLND_MEMORY_POOL_CHUNK *) > 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);
}
}
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);
(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);
}
/* {{{ 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");
/* {{{ 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) {
efree(p->auth_protocol);
p->auth_protocol = NULL;
}
- if (!stack_allocation) {
- mnd_pefree(p, p->header.persistent);
- }
}
/* }}} */
/* {{{ 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");
/* }}} */
-/* {{{ 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;
/* {{{ 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) {
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 */
/* }}} */
-/* {{{ 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;
/* {{{ 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,
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;
/* }}} */
-/* {{{ 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;
/* }}} */
-/* {{{ 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;
/* {{{ 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");
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;
}
/* }}} */
/* {{{ 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;
/* }}} */
-/* {{{ 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,
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;
/* {{{ 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;
p->result_set_memory_pool->free_chunk(p->result_set_memory_pool, p->row_buffer);
p->row_buffer = 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
- 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;
}
/* }}} */
/* {{{ 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;
/* {{{ 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);
- }
}
/* }}} */
/* {{{ 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;
/* }}} */
-/* {{{ 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;
/* {{{ 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;
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;
/* }}} */
-/* {{{ 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;
/* {{{ 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) {
p->public_key = NULL;
}
p->public_key_len = 0;
-
- if (!stack_allocation) {
- mnd_pefree(p, p->header.persistent);
- }
}
/* }}} */
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,
/* }}} */
-/* {{{ 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");
+ packet->header.m = &packet_methods[PROT_SHA256_PK_REQUEST_RESPONSE_PACKET];
+ memset(packet, 0, sizeof(*packet));
+ DBG_VOID_RETURN;
}
/* }}} */
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);
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());
DBG_ERR("Server is gone");
ret = FAIL;
}
- PACKET_FREE(cmd_packet);
+ PACKET_FREE(&cmd_packet);
DBG_RETURN(ret);
}
/* }}} */
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
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);
+ 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);
}
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);
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),
projects / php / commitdiff