MNDR:

- rename the macro for updating the connection state

diff --git a/ext/mysqlnd/mysqlnd.c b/ext/mysqlnd/mysqlnd.c
index 92e85b5fff753a70f0e6be3f3aecae22870e9e32..3af0da8785af6903b737c4407d4354bf30d2ba65 100644 (file)
--- a/ext/mysqlnd/mysqlnd.c
+++ b/ext/mysqlnd/mysqlnd.c
@@ -909,12 +909,12 @@ MYSQLND_METHOD(mysqlnd_conn_data, connect)(MYSQLND_CONN_DATA * conn,
 
        DBG_INF_FMT("host=%s user=%s db=%s port=%u flags=%u persistent=%u state=%u",
                                host?host:"", user?user:"", db?db:"", port, mysql_flags,
-                               conn? conn->persistent:0, conn? CONN_GET_STATE(conn):-1);
+                               conn? conn->persistent:0, conn? GET_CONNECTION_STATE(&conn->state):-1);
 
-       if (CONN_GET_STATE(conn) > CONN_ALLOCED && CONN_GET_STATE(conn) ) {
+       if (GET_CONNECTION_STATE(&conn->state) > CONN_ALLOCED && GET_CONNECTION_STATE(&conn->state) ) {
                DBG_INF("Connecting on a connected handle.");
 
-               if (CONN_GET_STATE(conn) < CONN_QUIT_SENT) {
+               if (GET_CONNECTION_STATE(&conn->state) < CONN_QUIT_SENT) {
                        MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_CLOSE_IMPLICIT);
                        reconnect = TRUE;
                        conn->m->send_close(conn);
@@ -1011,7 +1011,7 @@ MYSQLND_METHOD(mysqlnd_conn_data, connect)(MYSQLND_CONN_DATA * conn,
        }
 
        {
-               CONN_SET_STATE(conn, CONN_READY);
+               SET_CONNECTION_STATE(&conn->state, CONN_READY);
 
                if (saved_compression) {
                        net->data->compressed = TRUE;
@@ -1294,7 +1294,8 @@ MYSQLND ** mysqlnd_stream_array_check_for_readiness(MYSQLND ** conn_array)
        MYSQLND **ret = NULL;
 
        while (*p) {
-               if (CONN_GET_STATE((*p)->data) <= CONN_READY || CONN_GET_STATE((*p)->data) == CONN_QUIT_SENT) {
+               const enum mysqlnd_connection_state conn_state = GET_CONNECTION_STATE(&((*p)->data->state));
+               if (conn_state <= CONN_READY || conn_state == CONN_QUIT_SENT) {
                        cnt++;
                }
                p++;
@@ -1303,7 +1304,8 @@ MYSQLND ** mysqlnd_stream_array_check_for_readiness(MYSQLND ** conn_array)
                MYSQLND **ret_p = ret = ecalloc(cnt + 1, sizeof(MYSQLND *));
                p_p = p = conn_array;
                while (*p) {
-                       if (CONN_GET_STATE((*p)->data) <= CONN_READY || CONN_GET_STATE((*p)->data) == CONN_QUIT_SENT) {
+                       const enum mysqlnd_connection_state conn_state = GET_CONNECTION_STATE(&((*p)->data->state));
+                       if (conn_state <= CONN_READY || conn_state == CONN_QUIT_SENT) {
                                *ret_p = *p;
                                *p = NULL;
                                ret_p++;
@@ -1827,7 +1829,7 @@ MYSQLND_METHOD(mysqlnd_conn_data, kill)(MYSQLND_CONN_DATA * conn, unsigned int p
                                */
                                UPSERT_STATUS_SET_AFFECTED_ROWS_TO_ERROR(conn->upsert_status);
                        } else if (PASS == ret) {
-                               CONN_SET_STATE(conn, CONN_QUIT_SENT);
+                               SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT);
                                conn->m->send_close(conn);
                        }
                }
@@ -1934,13 +1936,13 @@ MYSQLND_METHOD(mysqlnd_conn_data, send_close)(MYSQLND_CONN_DATA * const conn)
        DBG_ENTER("mysqlnd_send_close");
        DBG_INF_FMT("conn=%llu net->data->stream->abstract=%p", conn->thread_id, net_stream? net_stream->abstract:NULL);
 
-       if (CONN_GET_STATE(conn) >= CONN_READY) {
+       if (GET_CONNECTION_STATE(&conn->state) >= CONN_READY) {
                MYSQLND_DEC_CONN_STATISTIC(conn->stats, STAT_OPENED_CONNECTIONS);
                if (conn->persistent) {
                        MYSQLND_DEC_CONN_STATISTIC(conn->stats, STAT_OPENED_PERSISTENT_CONNECTIONS);
                }
        }
-       state = CONN_GET_STATE(conn);
+       state = GET_CONNECTION_STATE(&conn->state);
        DBG_INF_FMT("state=%u", state);
        switch (state) {
                case CONN_READY:
@@ -1953,7 +1955,7 @@ MYSQLND_METHOD(mysqlnd_conn_data, send_close)(MYSQLND_CONN_DATA * const conn)
                                }
                                net->data->m.close_stream(net, conn->stats, conn->error_info);
                        }
-                       CONN_SET_STATE(conn, CONN_QUIT_SENT);
+                       SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT);
                        break;
                case CONN_SENDING_LOAD_DATA:
                        /*
@@ -1977,7 +1979,7 @@ MYSQLND_METHOD(mysqlnd_conn_data, send_close)(MYSQLND_CONN_DATA * const conn)
 
                          Fall-through
                        */
-                       CONN_SET_STATE(conn, CONN_QUIT_SENT);
+                       SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT);
                        /* Fall-through */
                case CONN_QUIT_SENT:
                        /* The user has killed its own connection */
@@ -2182,7 +2184,7 @@ MYSQLND_METHOD(mysqlnd_conn_data, next_result)(MYSQLND_CONN_DATA * const conn)
 
        if (PASS == conn->m->local_tx_start(conn, this_func)) {
                do {
-                       if (CONN_GET_STATE(conn) != CONN_NEXT_RESULT_PENDING) {
+                       if (GET_CONNECTION_STATE(&conn->state) != CONN_NEXT_RESULT_PENDING) {
                                break;
                        }
 
@@ -2200,7 +2202,7 @@ MYSQLND_METHOD(mysqlnd_conn_data, next_result)(MYSQLND_CONN_DATA * const conn)
                                if (!conn->error_info->error_no) {
                                        DBG_ERR_FMT("Serious error. %s::%u", __FILE__, __LINE__);
                                        php_error_docref(NULL, E_WARNING, "Serious error. PID=%d", getpid());
-                                       CONN_SET_STATE(conn, CONN_QUIT_SENT);
+                                       SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT);
                                        conn->m->send_close(conn);
                                } else {
                                        DBG_INF_FMT("Error from the server : (%u) %s", conn->error_info->error_no, conn->error_info->error);
@@ -2557,7 +2559,7 @@ MYSQLND_METHOD(mysqlnd_conn_data, use_result)(MYSQLND_CONN_DATA * const conn, co
                        }
 
                        /* Nothing to store for UPSERT/LOAD DATA */
-                       if (conn->last_query_type != QUERY_SELECT || CONN_GET_STATE(conn) != CONN_FETCHING_DATA) {
+                       if (conn->last_query_type != QUERY_SELECT || GET_CONNECTION_STATE(&conn->state) != CONN_FETCHING_DATA) {
                                SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
                                DBG_ERR("Command out of sync");
                                break;
@@ -2600,7 +2602,7 @@ MYSQLND_METHOD(mysqlnd_conn_data, store_result)(MYSQLND_CONN_DATA * const conn,
                        }
 
                        /* Nothing to store for UPSERT/LOAD DATA*/
-                       if (conn->last_query_type != QUERY_SELECT || CONN_GET_STATE(conn) != CONN_FETCHING_DATA) {
+                       if (conn->last_query_type != QUERY_SELECT || GET_CONNECTION_STATE(&conn->state) != CONN_FETCHING_DATA) {
                                SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
                                DBG_ERR("Command out of sync");
                                break;
@@ -3121,7 +3123,7 @@ MYSQLND_METHOD(mysqlnd_conn, close)(MYSQLND * conn_handle, enum_connection_close
        DBG_INF_FMT("conn=%llu", conn->thread_id);
 
        if (PASS == conn->m->local_tx_start(conn, this_func)) {
-               if (CONN_GET_STATE(conn) >= CONN_READY) {
+               if (GET_CONNECTION_STATE(&conn->state) >= CONN_READY) {
                        static enum_mysqlnd_collected_stats close_type_to_stat_map[MYSQLND_CLOSE_LAST] = {
                                STAT_CLOSE_EXPLICIT,
                                STAT_CLOSE_IMPLICIT,

diff --git a/ext/mysqlnd/mysqlnd_auth.c b/ext/mysqlnd/mysqlnd_auth.c
index a8541e71af827ccf24105a8fc10666e49c088d39..c95238035010dfb27966e6a5a065a6b31148f2a4 100644 (file)
--- a/ext/mysqlnd/mysqlnd_auth.c
+++ b/ext/mysqlnd/mysqlnd_auth.c
@@ -75,7 +75,7 @@ mysqlnd_auth_handshake(MYSQLND_CONN_DATA * conn,
                change_auth_resp_packet->auth_data_len = auth_plugin_data_len;
 
                if (!PACKET_WRITE(change_auth_resp_packet)) {
-                       CONN_SET_STATE(conn, CONN_QUIT_SENT);
+                       SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT);
                        SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone);
                        goto end;
                }
@@ -196,7 +196,7 @@ mysqlnd_auth_change_user(MYSQLND_CONN_DATA * const conn,
                change_auth_resp_packet->auth_data_len = auth_plugin_data_len;
 
                if (!PACKET_WRITE(change_auth_resp_packet)) {
-                       CONN_SET_STATE(conn, CONN_QUIT_SENT);
+                       SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT);
                        SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone);
                        goto end;
                }
@@ -224,7 +224,7 @@ mysqlnd_auth_change_user(MYSQLND_CONN_DATA * const conn,
                }
 
                if (!PACKET_WRITE(auth_packet)) {
-                       CONN_SET_STATE(conn, CONN_QUIT_SENT);
+                       SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT);
                                SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone);
                        goto end;
                }
@@ -514,13 +514,13 @@ mysqlnd_sha256_get_rsa_key(MYSQLND_CONN_DATA * conn,
                        if (! PACKET_WRITE(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());
-                               CONN_SET_STATE(conn, CONN_QUIT_SENT);
+                               SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT);
                                break;
                        }
                        if (FAIL == PACKET_READ(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());
-                               CONN_SET_STATE(conn, CONN_QUIT_SENT);
+                               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);

diff --git a/ext/mysqlnd/mysqlnd_priv.h b/ext/mysqlnd/mysqlnd_priv.h
index f5e05d41d406778f929ff644b0bc04830f356211..d9583b4be70d9888e4a1b0c3c4ba7e79cce2277e 100644 (file)
--- a/ext/mysqlnd/mysqlnd_priv.h
+++ b/ext/mysqlnd/mysqlnd_priv.h
@@ -111,8 +111,8 @@ enum_func_status mysqlnd_error_info_init(MYSQLND_ERROR_INFO * const info, zend_b
 #define SET_OOM_ERROR(info)                                                    SET_CLIENT_ERROR((info), CR_OUT_OF_MEMORY, UNKNOWN_SQLSTATE, mysqlnd_out_of_memory)
 #define COPY_CLIENT_ERROR(dest, source)                                        SET_CLIENT_ERROR((dest), (source).error_no, (source).sqlstate, (source).error)
 
-#define CONN_GET_STATE(c)              (c)->state.m->get(&(c)->state)
-#define CONN_SET_STATE(c, s)   (c)->state.m->set(&(c)->state, (s))
+#define GET_CONNECTION_STATE(state_struct)             (state_struct)->m->get((state_struct))
+#define SET_CONNECTION_STATE(state_struct, s)  (state_struct)->m->set((state_struct), (s))
 
 void mysqlnd_connection_state_init(struct st_mysqlnd_connection_state * const state);
 

diff --git a/ext/mysqlnd/mysqlnd_ps.c b/ext/mysqlnd/mysqlnd_ps.c
index fd2ab354ddbdd3189aa588853465de6bcc889a77..3f1bdb8597ef11e62b04ad2a2c4489646158fb76 100644 (file)
--- a/ext/mysqlnd/mysqlnd_ps.c
+++ b/ext/mysqlnd/mysqlnd_ps.c
@@ -71,7 +71,7 @@ MYSQLND_METHOD(mysqlnd_stmt, store_result)(MYSQLND_STMT * const s)
        }
 
        /* Nothing to store for UPSERT/LOAD DATA*/
-       if (CONN_GET_STATE(conn) != CONN_FETCHING_DATA ||
+       if (GET_CONNECTION_STATE(&conn->state) != CONN_FETCHING_DATA ||
                stmt->state != MYSQLND_STMT_WAITING_USE_OR_STORE)
        {
                SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC,
@@ -167,7 +167,7 @@ MYSQLND_METHOD(mysqlnd_stmt, get_result)(MYSQLND_STMT * const s)
        }
 
        /* Nothing to store for UPSERT/LOAD DATA*/
-       if (CONN_GET_STATE(conn) != CONN_FETCHING_DATA || stmt->state != MYSQLND_STMT_WAITING_USE_OR_STORE) {
+       if (GET_CONNECTION_STATE(&conn->state) != CONN_FETCHING_DATA || stmt->state != MYSQLND_STMT_WAITING_USE_OR_STORE) {
                SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC,
                                                 UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
                DBG_RETURN(NULL);
@@ -238,7 +238,7 @@ MYSQLND_METHOD(mysqlnd_stmt, next_result)(MYSQLND_STMT * s)
        conn = stmt->conn;
        DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
 
-       if (CONN_GET_STATE(conn) != CONN_NEXT_RESULT_PENDING || !(conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS)) {
+       if (GET_CONNECTION_STATE(&conn->state) != CONN_NEXT_RESULT_PENDING || !(conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS)) {
                DBG_RETURN(FAIL);
        }
 
@@ -516,14 +516,14 @@ mysqlnd_stmt_execute_parse_response(MYSQLND_STMT * const s, enum_mysqlnd_parse_e
                DBG_RETURN(FAIL);
        }
        conn = stmt->conn;
-       CONN_SET_STATE(conn, CONN_QUERY_SENT);
+       SET_CONNECTION_STATE(&conn->state, CONN_QUERY_SENT);
 
        ret = stmt->conn->m->query_read_result_set_header(stmt->conn, s);
        if (ret == FAIL) {
                COPY_CLIENT_ERROR(stmt->error_info, *conn->error_info);
                UPSERT_STATUS_RESET(stmt->upsert_status);
                stmt->upsert_status->affected_rows = conn->upsert_status->affected_rows;
-               if (CONN_GET_STATE(conn) == CONN_QUIT_SENT) {
+               if (GET_CONNECTION_STATE(&conn->state) == CONN_QUIT_SENT) {
                        /* close the statement here, the connection has been closed */
                }
                stmt->state = MYSQLND_STMT_PREPARED;
@@ -574,7 +574,7 @@ mysqlnd_stmt_execute_parse_response(MYSQLND_STMT * const s, enum_mysqlnd_parse_e
                        if (stmt->upsert_status->server_status & SERVER_STATUS_CURSOR_EXISTS) {
                                DBG_INF("cursor exists");
                                stmt->cursor_exists = TRUE;
-                               CONN_SET_STATE(conn, CONN_READY);
+                               SET_CONNECTION_STATE(&conn->state, CONN_READY);
                                /* Only cursor read */
                                stmt->default_rset_handler = s->m->use_result;
                                DBG_INF("use_result");
@@ -885,7 +885,7 @@ mysqlnd_stmt_fetch_row_unbuffered(MYSQLND_RES * result, void * param, unsigned i
                DBG_INF("EOF already reached");
                DBG_RETURN(PASS);
        }
-       if (CONN_GET_STATE(result->conn) != CONN_FETCHING_DATA) {
+       if (GET_CONNECTION_STATE(&result->conn->state) != CONN_FETCHING_DATA) {
                SET_CLIENT_ERROR(result->conn->error_info, CR_COMMANDS_OUT_OF_SYNC,
                                                 UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
                DBG_ERR("command out of sync");
@@ -969,7 +969,7 @@ mysqlnd_stmt_fetch_row_unbuffered(MYSQLND_RES * result, void * param, unsigned i
                        COPY_CLIENT_ERROR(stmt->conn->error_info, row_packet->error_info);
                        COPY_CLIENT_ERROR(stmt->error_info, row_packet->error_info);
                }
-               CONN_SET_STATE(result->conn, CONN_READY);
+               SET_CONNECTION_STATE(&result->conn->state, CONN_READY);
                result->unbuf->eof_reached = TRUE; /* so next time we won't get an error */
        } else if (row_packet->eof) {
                DBG_INF("EOF");
@@ -983,9 +983,9 @@ mysqlnd_stmt_fetch_row_unbuffered(MYSQLND_RES * result, void * param, unsigned i
                  destroying the result object
                */
                if (result->conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
-                       CONN_SET_STATE(result->conn, CONN_NEXT_RESULT_PENDING);
+                       SET_CONNECTION_STATE(&result->conn->state, CONN_NEXT_RESULT_PENDING);
                } else {
-                       CONN_SET_STATE(result->conn, CONN_READY);
+                       SET_CONNECTION_STATE(&result->conn->state, CONN_READY);
                }
        }
 
@@ -1012,8 +1012,8 @@ MYSQLND_METHOD(mysqlnd_stmt, use_result)(MYSQLND_STMT * s)
        conn = stmt->conn;
 
        if (!stmt->field_count ||
-               (!stmt->cursor_exists && CONN_GET_STATE(conn) != CONN_FETCHING_DATA) ||
-               (stmt->cursor_exists && CONN_GET_STATE(conn) != CONN_READY) ||
+               (!stmt->cursor_exists && GET_CONNECTION_STATE(&conn->state) != CONN_FETCHING_DATA) ||
+               (stmt->cursor_exists && GET_CONNECTION_STATE(&conn->state) != CONN_READY) ||
                (stmt->state != MYSQLND_STMT_WAITING_USE_OR_STORE))
        {
                SET_CLIENT_ERROR(conn->error_info, CR_COMMANDS_OUT_OF_SYNC,
@@ -1296,7 +1296,7 @@ MYSQLND_METHOD(mysqlnd_stmt, reset)(MYSQLND_STMT * const s)
                  be separated before that.
                */
 
-               if (CONN_GET_STATE(conn) == CONN_READY) {
+               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;
@@ -1409,7 +1409,7 @@ MYSQLND_METHOD(mysqlnd_stmt, send_long_data)(MYSQLND_STMT * const s, unsigned in
                        one by one to the wire.
        */
 
-       if (CONN_GET_STATE(conn) == CONN_READY) {
+       if (GET_CONNECTION_STATE(&conn->state) == CONN_READY) {
                size_t packet_len;
                cmd_buf = mnd_emalloc(packet_len = MYSQLND_STMT_ID_LENGTH + 2 + length);
                if (cmd_buf) {
@@ -2055,7 +2055,7 @@ MYSQLND_METHOD(mysqlnd_stmt, free_result)(MYSQLND_STMT * const s)
        }
 
        /* Line is free! */
-       CONN_SET_STATE(stmt->conn, CONN_READY);
+       SET_CONNECTION_STATE(&stmt->conn->state, CONN_READY);
 
        DBG_RETURN(PASS);
 }
@@ -2246,7 +2246,7 @@ MYSQLND_METHOD_PRIVATE(mysqlnd_stmt, net_close)(MYSQLND_STMT * const s, zend_boo
                MYSQLND_INC_GLOBAL_STATISTIC(implicit == TRUE?  STAT_FREE_RESULT_IMPLICIT:
                                                                                                                STAT_FREE_RESULT_EXPLICIT);
 
-               if (CONN_GET_STATE(conn) == CONN_READY) {
+               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);

diff --git a/ext/mysqlnd/mysqlnd_result.c b/ext/mysqlnd/mysqlnd_result.c
index a5d653b42e88b3ad3ead045a35ae5bb5524981cf..19b302e08df7561c48a80cbf7b73232cb77003e6 100644 (file)
--- a/ext/mysqlnd/mysqlnd_result.c
+++ b/ext/mysqlnd/mysqlnd_result.c
@@ -444,7 +444,7 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s)
                        ret = FAIL;
                        DBG_ERR_FMT("error=%s", rset_header->error_info.error);
                        /* Return back from CONN_QUERY_SENT */
-                       CONN_SET_STATE(conn, CONN_READY);
+                       SET_CONNECTION_STATE(&conn->state, CONN_READY);
                        break;
                }
                conn->error_info->error_no = 0;
@@ -455,9 +455,9 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s)
                                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 */
-                               CONN_SET_STATE(conn, CONN_SENDING_LOAD_DATA);
+                               SET_CONNECTION_STATE(&conn->state, CONN_SENDING_LOAD_DATA);
                                ret = mysqlnd_handle_local_infile(conn, rset_header->info_or_local_file, &is_warning);
-                               CONN_SET_STATE(conn,  (ret == PASS || is_warning == TRUE)? CONN_READY:CONN_QUIT_SENT);
+                               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;
                        }
@@ -475,9 +475,9 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s)
                                                                conn->persistent);
                                /* Result set can follow UPSERT statement, check server_status */
                                if (conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
-                                       CONN_SET_STATE(conn, CONN_NEXT_RESULT_PENDING);
+                                       SET_CONNECTION_STATE(&conn->state, CONN_NEXT_RESULT_PENDING);
                                } else {
-                                       CONN_SET_STATE(conn, CONN_READY);
+                                       SET_CONNECTION_STATE(&conn->state, CONN_READY);
                                }
                                ret = PASS;
                                MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_NON_RSET_QUERY);
@@ -495,7 +495,7 @@ mysqlnd_query_read_result_set_header(MYSQLND_CONN_DATA * conn, MYSQLND_STMT * s)
                                UPSERT_STATUS_SET_AFFECTED_ROWS_TO_ERROR(conn->upsert_status);
 
                                conn->last_query_type = QUERY_SELECT;
-                               CONN_SET_STATE(conn, CONN_FETCHING_DATA);
+                               SET_CONNECTION_STATE(&conn->state, CONN_FETCHING_DATA);
                                /* PS has already allocated it */
                                conn->field_count = rset_header->field_count;
                                if (!stmt) {
@@ -695,7 +695,7 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row_c)(MYSQLND_RES * result, voi
                /* No more rows obviously */
                DBG_RETURN(PASS);
        }
-       if (CONN_GET_STATE(result->conn) != CONN_FETCHING_DATA) {
+       if (GET_CONNECTION_STATE(&result->conn->state) != CONN_FETCHING_DATA) {
                SET_CLIENT_ERROR(result->conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
                DBG_RETURN(FAIL);
        }
@@ -771,7 +771,7 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row_c)(MYSQLND_RES * result, voi
                        COPY_CLIENT_ERROR(result->conn->error_info, row_packet->error_info);
                        DBG_ERR_FMT("errorno=%u error=%s", row_packet->error_info.error_no, row_packet->error_info.error);
                }
-               CONN_SET_STATE(result->conn, CONN_READY);
+               SET_CONNECTION_STATE(&result->conn->state, CONN_READY);
                result->unbuf->eof_reached = TRUE; /* so next time we won't get an error */
        } else if (row_packet->eof) {
                /* Mark the connection as usable again */
@@ -786,9 +786,9 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row_c)(MYSQLND_RES * result, voi
                  destroying the result object
                */
                if (result->conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
-                       CONN_SET_STATE(result->conn, CONN_NEXT_RESULT_PENDING);
+                       SET_CONNECTION_STATE(&result->conn->state, CONN_NEXT_RESULT_PENDING);
                } else {
-                       CONN_SET_STATE(result->conn, CONN_READY);
+                       SET_CONNECTION_STATE(&result->conn->state, CONN_READY);
                }
                result->unbuf->m.free_last_data(result->unbuf, result->conn? result->conn->stats : NULL);
        }
@@ -815,7 +815,7 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row)(MYSQLND_RES * result, void
                /* No more rows obviously */
                DBG_RETURN(PASS);
        }
-       if (CONN_GET_STATE(result->conn) != CONN_FETCHING_DATA) {
+       if (GET_CONNECTION_STATE(&result->conn->state) != CONN_FETCHING_DATA) {
                SET_CLIENT_ERROR(result->conn->error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
                DBG_RETURN(FAIL);
        }
@@ -898,7 +898,7 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row)(MYSQLND_RES * result, void
                        COPY_CLIENT_ERROR(result->conn->error_info, row_packet->error_info);
                        DBG_ERR_FMT("errorno=%u error=%s", row_packet->error_info.error_no, row_packet->error_info.error);
                }
-               CONN_SET_STATE(result->conn, CONN_READY);
+               SET_CONNECTION_STATE(&result->conn->state, CONN_READY);
                result->unbuf->eof_reached = TRUE; /* so next time we won't get an error */
        } else if (row_packet->eof) {
                /* Mark the connection as usable again */
@@ -913,9 +913,9 @@ MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_row)(MYSQLND_RES * result, void
                  destroying the result object
                */
                if (result->conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
-                       CONN_SET_STATE(result->conn, CONN_NEXT_RESULT_PENDING);
+                       SET_CONNECTION_STATE(&result->conn->state, CONN_NEXT_RESULT_PENDING);
                } else {
-                       CONN_SET_STATE(result->conn, CONN_READY);
+                       SET_CONNECTION_STATE(&result->conn->state, CONN_READY);
                }
                result->unbuf->m.free_last_data(result->unbuf, result->conn? result->conn->stats : NULL);
        }
@@ -1377,9 +1377,9 @@ MYSQLND_METHOD(mysqlnd_res, store_result_fetch_data)(MYSQLND_CONN_DATA * const c
        }
 
        if (conn->upsert_status->server_status & SERVER_MORE_RESULTS_EXISTS) {
-               CONN_SET_STATE(conn, CONN_NEXT_RESULT_PENDING);
+               SET_CONNECTION_STATE(&conn->state, CONN_NEXT_RESULT_PENDING);
        } else {
-               CONN_SET_STATE(conn, CONN_READY);
+               SET_CONNECTION_STATE(&conn->state, CONN_READY);
        }
 
        if (ret == FAIL) {
@@ -1414,7 +1414,7 @@ MYSQLND_METHOD(mysqlnd_res, store_result)(MYSQLND_RES * result,
        result->conn = conn->m->get_reference(conn);
        result->type = MYSQLND_RES_NORMAL;
 
-       CONN_SET_STATE(conn, CONN_FETCHING_DATA);
+       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);

diff --git a/ext/mysqlnd/mysqlnd_wireprotocol.c b/ext/mysqlnd/mysqlnd_wireprotocol.c
index eb4b4fa45986e9aa2e21d9ce2512991aeb267d3e..4cce44742e7b691b8c8be0f224e2fe25e000aa31 100644 (file)
--- a/ext/mysqlnd/mysqlnd_wireprotocol.c
+++ b/ext/mysqlnd/mysqlnd_wireprotocol.c
@@ -295,7 +295,7 @@ mysqlnd_read_packet_header_and_body(MYSQLND_PACKET_HEADER * packet_header, MYSQL
        DBG_ENTER("mysqlnd_read_packet_header_and_body");
        DBG_INF_FMT("buf=%p size=%u", buf, buf_size);
        if (FAIL == mysqlnd_read_header(conn->net, packet_header, conn->stats, conn->error_info)) {
-               CONN_SET_STATE(conn, CONN_QUIT_SENT);
+               SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT);
                SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone);
                php_error_docref(NULL, E_WARNING, "%s", mysqlnd_server_gone);
                DBG_ERR_FMT("Can't read %s's header", packet_type_as_text);
@@ -307,7 +307,7 @@ mysqlnd_read_packet_header_and_body(MYSQLND_PACKET_HEADER * packet_header, MYSQL
                DBG_RETURN(FAIL);
        }
        if (FAIL == conn->net->data->m.receive_ex(conn->net, buf, packet_header->size, conn->stats, conn->error_info)) {
-               CONN_SET_STATE(conn, CONN_QUIT_SENT);
+               SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT);
                SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone);
                php_error_docref(NULL, E_WARNING, "%s", mysqlnd_server_gone);
                DBG_ERR_FMT("Empty '%s' packet body", packet_type_as_text);
@@ -668,7 +668,7 @@ size_t php_mysqlnd_auth_write(void * _packet)
        } else {
                size_t sent = conn->net->data->m.send_ex(conn->net, buffer, p - buffer - MYSQLND_HEADER_SIZE, conn->stats, conn->error_info);
                if (!sent) {
-                       CONN_SET_STATE(conn, CONN_QUIT_SENT);
+                       SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT);
                }
                DBG_RETURN(sent);
        }
@@ -837,7 +837,7 @@ php_mysqlnd_change_auth_response_write(void * _packet)
                        mnd_efree(buffer);
                }
                if (!sent) {
-                       CONN_SET_STATE(conn, CONN_QUIT_SENT);
+                       SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT);
                }
                DBG_RETURN(sent);
        }
@@ -1091,7 +1091,7 @@ end:
                EG(error_reporting) = error_reporting;
        }
        if (!sent) {
-               CONN_SET_STATE(conn, CONN_QUIT_SENT);
+               SET_CONNECTION_STATE(&conn->state, CONN_QUIT_SENT);
        }
        DBG_RETURN(sent);
 }
@@ -2660,7 +2660,7 @@ mysqlnd_protocol_payload_decoder_factory_free(MYSQLND_PROTOCOL_PAYLOAD_DECODER_F
 
 
 
-/* {{{ mysqlnd_conn_data::send_command_do_request */
+/* {{{ send_command_do_request */
 static enum_func_status
 send_command_do_request(
                MYSQLND_CONN_DATA * const conn,
@@ -2669,7 +2669,7 @@ send_command_do_request(
                const zend_bool silent,
                const zend_bool ignore_upsert_status,
 
-               enum mysqlnd_connection_state conn_state,
+               struct st_mysqlnd_connection_state * connection_state,
                MYSQLND_ERROR_INFO      * error_info,
                MYSQLND_UPSERT_STATUS * upsert_status,
                MYSQLND_STATS * stats,
@@ -2682,8 +2682,9 @@ send_command_do_request(
        DBG_INF_FMT("command=%s silent=%u", mysqlnd_command_to_text[command], silent);
        DBG_INF_FMT("server_status=%u", upsert_status->server_status);
        DBG_INF_FMT("sending %u bytes", arg_len + 1); /* + 1 is for the command */
+       enum mysqlnd_connection_state state = connection_state->m->get(connection_state);
 
-       switch (conn_state) {
+       switch (state) {
                case CONN_READY:
                        break;
                case CONN_QUIT_SENT:
@@ -2692,7 +2693,7 @@ send_command_do_request(
                        DBG_RETURN(FAIL);
                default:
                        SET_CLIENT_ERROR(error_info, CR_COMMANDS_OUT_OF_SYNC, UNKNOWN_SQLSTATE, mysqlnd_out_of_sync);
-                       DBG_ERR_FMT("Command out of sync. State=%u", conn_state);
+                       DBG_ERR_FMT("Command out of sync. State=%u", state);
                        DBG_RETURN(FAIL);
        }
 
@@ -2718,7 +2719,7 @@ send_command_do_request(
                        DBG_ERR_FMT("Error while sending %s packet", mysqlnd_command_to_text[command]);
                        php_error(E_WARNING, "Error while sending %s packet. PID=%d", mysqlnd_command_to_text[command], getpid());
                }
-               CONN_SET_STATE(conn, CONN_QUIT_SENT);
+               connection_state->m->set(connection_state, CONN_QUIT_SENT);
                conn->m->send_close(conn);
                DBG_ERR("Server is gone");
                ret = FAIL;
@@ -2778,7 +2779,7 @@ mysqlnd_com_set_option_run(void *cmd)
        int2store(buffer, (unsigned int) option);
 
        ret = send_command_do_request(conn, COM_SET_OPTION, buffer, sizeof(buffer), FALSE, TRUE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
        if (PASS == ret) {
                ret = conn->m->send_command_handle_response(conn, PROT_EOF_PACKET, FALSE, COM_SET_OPTION, TRUE);
        }
@@ -2820,7 +2821,7 @@ mysqlnd_com_debug_run(void *cmd)
        DBG_ENTER("mysqlnd_com_debug_run");
 
        ret = send_command_do_request(conn, COM_DEBUG, NULL, 0, FALSE, TRUE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
        if (PASS == ret) {
                ret = conn->m->send_command_handle_response(conn, PROT_EOF_PACKET, COM_DEBUG, COM_DEBUG, TRUE);
        }
@@ -2872,7 +2873,7 @@ mysqlnd_com_init_db_run(void *cmd)
        DBG_ENTER("mysqlnd_com_init_db_run");
 
        ret = send_command_do_request(conn, COM_INIT_DB, (zend_uchar*) command->context.db.s, command->context.db.l, FALSE, TRUE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
        if (PASS == ret) {
                ret = conn->m->send_command_handle_response(conn, PROT_OK_PACKET, FALSE, COM_INIT_DB, TRUE);
        }
@@ -2914,7 +2915,7 @@ mysqlnd_com_ping_run(void *cmd)
        DBG_ENTER("mysqlnd_com_ping_run");
 
        ret = send_command_do_request(conn, COM_PING, NULL, 0, TRUE, TRUE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
        if (PASS == ret) {
                ret = conn->m->send_command_handle_response(conn, PROT_OK_PACKET, TRUE, COM_PING, TRUE);
        }
@@ -2982,7 +2983,7 @@ mysqlnd_com_field_list_run(void *cmd)
        }
 
        ret = send_command_do_request(conn, COM_FIELD_LIST, buff, p - buff, FALSE, TRUE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
 
        DBG_RETURN(ret);
 }
@@ -3022,7 +3023,7 @@ mysqlnd_com_statistics_run(void *cmd)
        DBG_ENTER("mysqlnd_com_statistics_run");
 
        ret = send_command_do_request(conn, COM_STATISTICS, NULL, 0, FALSE, TRUE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
 
        DBG_RETURN(ret);
 }
@@ -3073,7 +3074,7 @@ mysqlnd_com_process_kill_run(void *cmd)
        int4store(buff, command->context.process_id);
 
        ret = send_command_do_request(conn, COM_PROCESS_KILL, buff, 4, FALSE, TRUE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
        if (PASS == ret && command->context.read_response) {
                ret = conn->m->send_command_handle_response(conn, PROT_OK_PACKET, FALSE, COM_PROCESS_KILL, TRUE);
        }
@@ -3128,7 +3129,7 @@ mysqlnd_com_refresh_run(void *cmd)
        int1store(bits, command->context.options);
 
        ret = send_command_do_request(conn, COM_REFRESH, bits, 1, FALSE, TRUE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
        if (PASS == ret) {
                ret = conn->m->send_command_handle_response(conn, PROT_OK_PACKET, FALSE, COM_REFRESH, TRUE);
        }
@@ -3183,7 +3184,7 @@ mysqlnd_com_shutdown_run(void *cmd)
        int1store(bits, command->context.level);
 
        ret = send_command_do_request(conn, COM_SHUTDOWN, bits, 1, FALSE, TRUE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
        if (PASS == ret) {
                ret = conn->m->send_command_handle_response(conn, PROT_OK_PACKET, FALSE, COM_SHUTDOWN, TRUE);
        }
@@ -3235,7 +3236,7 @@ mysqlnd_com_quit_run(void *cmd)
        DBG_ENTER("mysqlnd_com_quit_run");
 
        ret = send_command_do_request(conn, COM_QUIT, NULL, 0, TRUE, TRUE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
 
        DBG_RETURN(ret);
 }
@@ -3283,10 +3284,10 @@ mysqlnd_com_query_run(void *cmd)
        DBG_ENTER("mysqlnd_com_query_run");
 
        ret = send_command_do_request(conn, COM_QUERY, (zend_uchar*) command->context.query.s, command->context.query.l, FALSE, FALSE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
 
        if (PASS == ret) {
-               CONN_SET_STATE(conn, CONN_QUERY_SENT);
+               SET_CONNECTION_STATE(&conn->state, CONN_QUERY_SENT);
        }
 
        DBG_RETURN(ret);
@@ -3337,7 +3338,7 @@ mysqlnd_com_change_user_run(void *cmd)
        DBG_ENTER("mysqlnd_com_change_user_run");
 
        ret = send_command_do_request(conn, COM_CHANGE_USER, (zend_uchar*) command->context.payload.s, command->context.payload.l, command->context.silent, TRUE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
 
        DBG_RETURN(ret);
 }
@@ -3383,7 +3384,7 @@ mysqlnd_com_reap_result_run(void *cmd)
        struct st_mysqlnd_protocol_com_reap_result_command * command = (struct st_mysqlnd_protocol_com_reap_result_command *) cmd;
        enum_func_status ret = FAIL;
        MYSQLND_CONN_DATA * conn = command->context.conn;
-       const enum_mysqlnd_connection_state state = CONN_GET_STATE(conn);
+       const enum_mysqlnd_connection_state state = GET_CONNECTION_STATE(&conn->state);
 
        DBG_ENTER("mysqlnd_com_reap_result_run");
        if (state <= CONN_READY || state == CONN_QUIT_SENT) {
@@ -3440,7 +3441,7 @@ mysqlnd_com_stmt_prepare_run(void *cmd)
        DBG_ENTER("mysqlnd_com_stmt_prepare_run");
 
        ret = send_command_do_request(conn, COM_STMT_PREPARE, (zend_uchar*) command->context.query.s, command->context.query.l, FALSE, TRUE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
 
        DBG_RETURN(ret);
 }
@@ -3490,7 +3491,7 @@ mysqlnd_com_stmt_execute_run(void *cmd)
        DBG_ENTER("mysqlnd_com_stmt_execute_run");
 
        ret = send_command_do_request(conn, COM_STMT_EXECUTE, (zend_uchar*) command->context.payload.s, command->context.payload.l, FALSE, FALSE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
 
        DBG_RETURN(ret);
 }
@@ -3540,7 +3541,7 @@ mysqlnd_com_stmt_fetch_run(void *cmd)
        DBG_ENTER("mysqlnd_com_stmt_fetch_run");
 
        ret = send_command_do_request(conn, COM_STMT_FETCH, (zend_uchar*) command->context.payload.s, command->context.payload.l, FALSE, TRUE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
 
        DBG_RETURN(ret);
 }
@@ -3592,7 +3593,7 @@ mysqlnd_com_stmt_reset_run(void *cmd)
 
        int4store(cmd_buf, command->context.stmt_id);
        ret = send_command_do_request(conn, COM_STMT_RESET, cmd_buf, sizeof(cmd_buf), FALSE, TRUE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
 
        DBG_RETURN(ret);
 }
@@ -3642,7 +3643,7 @@ mysqlnd_com_stmt_send_long_data_run(void *cmd)
        DBG_ENTER("mysqlnd_com_stmt_send_long_data_run");
 
        ret = send_command_do_request(conn, COM_STMT_SEND_LONG_DATA, (zend_uchar*) command->context.payload.s, command->context.payload.l, FALSE, TRUE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
 
        DBG_RETURN(ret);
 }
@@ -3694,7 +3695,7 @@ mysqlnd_com_stmt_close_run(void *cmd)
 
        int4store(cmd_buf, command->context.stmt_id);
        ret = send_command_do_request(conn, COM_STMT_CLOSE, cmd_buf, sizeof(cmd_buf), FALSE, TRUE,
-                                                                       CONN_GET_STATE(conn), conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
+                                                                       &conn->state, conn->error_info, conn->upsert_status, conn->stats, conn->payload_decoder_factory);
 
        DBG_RETURN(ret);
 }
@@ -3819,7 +3820,7 @@ end:
        DBG_RETURN(ret);
 
 close_conn:
-       CONN_SET_STATE(conn, CONN_QUIT_SENT);
+       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);