292528 Unify. The typedef-ed structs in mysqlnd are always capitalized. (andrey)
293076 The internal zval cache has been removed and not been reintroduced... remove cor (uw)
293080 Tweaking test. Andrey, you once requested such a test, please have a look if it (uw)
293084 Fixing test(uw)
293085 The internal zval cache has been removed and not been reintroduced... remove cor (uw)
292986 Updating test to new libmysql feature set (first introduced in MySQL 6.0 but now (uw)
293229 Change of way the packet objects are created/initialised (andrey)
293273 add restart_psession and end_psession hooks (andrey)
293286 improve the stats subsystem. Reduce the number of macro definitions (andrey)
293287 export some calls to init/deinit code outside of the module (andrey)
293402 missed to commit to the branch (andrey)
293407 Rework the statistics macros to be reusable by external entities. (andrey)
293418 missed to commit in 5_3, here it comes, reusability of stats (andrey)
293424 remove extern defintion of a variable that is no more (andrey)
293428 cosmetics. typedef-ed types should be in capital case (andrey)
293429 removed stale export (andrey)
293430 more typedef cosmetics (andrey)
293504 make mysqlnd's tracing API more reusable (andrey)
293512 more PHPAPI for phpize-d builds (andrey)
293535 Fix build of mysqli when libmysql is used, mysqlnd_portability.h (andrey)
293537 removed redefinition of bit_uint8korr (andrey)
293539 Fix compiler warning (andrey)
293542 Fix compiler warning, copy&paste error (andrey)
293723 fix windows (andrey)
293725 Make it GCC only feature (tracing). VC7 and up do the work (andrey)
--TEST--
phpinfo() mysql section
--SKIPIF--
-<?php
-require_once('skipif.inc');
+<?php
+require_once('skipif.inc');
require_once('skipifconnectfailure.inc');
?>
--FILE--
'connect_failure', 'connection_reused', 'explicit_close', 'implicit_close',
'disconnect_close', 'in_middle_of_command_close', 'explicit_free_result',
'implicit_free_result', 'explicit_stmt_close', 'implicit_stmt_close',
- 'put_hits', 'put_misses', 'get_hits', 'get_misses',
- 'size', 'free_items', 'references', 'mysql.cache_size',
+ 'size',
);
foreach ($expected as $k => $entry)
if (!stristr($phpinfo, $entry))
#include "ext/standard/php_string.h"
#include "php_mysqli_structs.h"
#include "zend_exceptions.h"
-#include "ext/mysqlnd/mysqlnd_portability.h"
ZEND_DECLARE_MODULE_GLOBALS(mysqli)
static PHP_GINIT_FUNCTION(mysqli);
#include "php_globals.h"
#include "ext/standard/info.h"
#include "php_mysqli_structs.h"
-#include "ext/mysqlnd/mysqlnd_portability.h"
/* {{{ proto mixed mysqli_affected_rows(object link)
Get number of affected rows in previous MySQL operation */
memcpy(last_error, stmt->stmt->last_error, MYSQL_ERRMSG_SIZE);
memcpy(sqlstate, mysql->mysql->net.sqlstate, SQLSTATE_LENGTH+1);
#else
- mysqlnd_error_info error_info = mysql->mysql->error_info;
+ MYSQLND_ERROR_INFO error_info = mysql->mysql->error_info;
#endif
mysqli_stmt_close(stmt->stmt, FALSE);
stmt->stmt = NULL;
/*
- +----------------------------------------------------------------------+
+ ----------------------------------------------------------------------
| PHP Version 6 |
- +----------------------------------------------------------------------+
+ ----------------------------------------------------------------------
| Copyright (c) 2007 The PHP Group |
- +----------------------------------------------------------------------+
+ ----------------------------------------------------------------------
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
- +----------------------------------------------------------------------+
+ ----------------------------------------------------------------------
| Authors: Georg Richter <georg@mysql.com> |
| Andrey Hristov <andrey@mysql.com> |
| Ulf Wendel <uwendel@mysql.com> |
- +----------------------------------------------------------------------+
+ ----------------------------------------------------------------------
*/
+#ifndef MYSQLI_LIBMYSQL_H
+#define MYSQLI_LIBMYSQL_H
+
/* These are unused */
#define MYSQLI_CLOSE_EXPLICIT 0
#define MYSQLI_CLOSE_IMPLICIT 1
#define mysqli_free_result(r, is_forced) mysql_free_result((r))
#define mysqli_change_user_silent(c, u, p, d) mysql_change_user((c), (u), (p), (d))
+
+/*
+ These functions also reside in ext/mysqlnd/mysqlnd_portability.h but since it is only made
+ available if one wants to build mysqli against mysqlnd and they are useful for libmysql as
+ well, we check whether they're not defined [build with libmysql is desired] and define them.
+
+ Bit values are sent in reverted order of bytes, compared to normal !!!
+*/
+
+
+#ifndef uint1korr
+#define uint1korr(A) (*(((uint8_t*)(A))))
+#endif
+
+#ifndef bit_uint2korr
+#define bit_uint2korr(A) ((uint16_t) (((uint16_t) (((unsigned char*) (A))[1])) +\
+ ((uint16_t) (((unsigned char*) (A))[0]) << 8)))
+#endif
+
+#ifndef bit_uint3korr
+#define bit_uint3korr(A) ((uint32_t) (((uint32_t) (((unsigned char*) (A))[2])) +\
+ (((uint32_t) (((unsigned char*) (A))[1])) << 8) +\
+ (((uint32_t) (((unsigned char*) (A))[0])) << 16)))
+#endif
+
+#ifndef bit_uint4korr
+#define bit_uint4korr(A) ((uint32_t) (((uint32_t) (((unsigned char*) (A))[3])) +\
+ (((uint32_t) (((unsigned char*) (A))[2])) << 8) +\
+ (((uint32_t) (((unsigned char*) (A))[1])) << 16) +\
+ (((uint32_t) (((unsigned char*) (A))[0])) << 24)))
+#endif
+
+#ifndef bit_uint5korr
+#define bit_uint5korr(A) ((uint64_t)(((uint32_t) (((unsigned char*) (A))[4])) +\
+ (((uint32_t) (((unsigned char*) (A))[3])) << 8) +\
+ (((uint32_t) (((unsigned char*) (A))[2])) << 16) +\
+ (((uint32_t) (((unsigned char*) (A))[1])) << 24)) +\
+ (((uint64_t) (((unsigned char*) (A))[0])) << 32))
+#endif
+
+#ifndef bit_uint6korr
+#define bit_uint6korr(A) ((uint64_t)(((uint32_t) (((unsigned char*) (A))[5])) +\
+ (((uint32_t) (((unsigned char*) (A))[4])) << 8) +\
+ (((uint32_t) (((unsigned char*) (A))[3])) << 16) +\
+ (((uint32_t) (((unsigned char*) (A))[2])) << 24)) +\
+ (((uint64_t) (((uint32_t) (((unsigned char*) (A))[1])) +\
+ (((uint32_t) (((unsigned char*) (A))[0]) << 8)))) <<\
+ 32))
+#endif
+
+#ifndef bit_uint7korr
+#define bit_uint7korr(A) ((uint64_t)(((uint32_t) (((unsigned char*) (A))[6])) +\
+ (((uint32_t) (((unsigned char*) (A))[5])) << 8) +\
+ (((uint32_t) (((unsigned char*) (A))[4])) << 16) +\
+ (((uint32_t) (((unsigned char*) (A))[3])) << 24)) +\
+ (((uint64_t) (((uint32_t) (((unsigned char*) (A))[2])) +\
+ (((uint32_t) (((unsigned char*) (A))[1])) << 8) +\
+ (((uint32_t) (((unsigned char*) (A))[0])) << 16))) <<\
+ 32))
+#endif
+
+#ifndef bit_uint8korr
+#define bit_uint8korr(A) ((uint64_t)(((uint32_t) (((unsigned char*) (A))[7])) +\
+ (((uint32_t) (((unsigned char*) (A))[6])) << 8) +\
+ (((uint32_t) (((unsigned char*) (A))[5])) << 16) +\
+ (((uint32_t) (((unsigned char*) (A))[4])) << 24)) +\
+ (((uint64_t) (((uint32_t) (((unsigned char*) (A))[3])) +\
+ (((uint32_t) (((unsigned char*) (A))[2])) << 8) +\
+ (((uint32_t) (((unsigned char*) (A))[1])) << 16) +\
+ (((uint32_t) (((unsigned char*) (A))[0])) << 24))) <<\
+ 32))
+#endif
+
+#endif /* MYSQLI_LIBMYSQL_H */
+
#define MYSQLI_MYSQLND_H
#include "ext/mysqlnd/mysqlnd_libmysql_compat.h"
+#include "ext/mysqlnd/mysqlnd_portability.h"
/* Here comes non-libmysql API to have less ifdefs in mysqli*/
#define MYSQLI_CLOSE_EXPLICIT MYSQLND_CLOSE_EXPLICIT
strcpy(s_sqlstate, mysql_sqlstate(mysql->mysql));
s_errno = mysql_errno(mysql->mysql);
#else
- mysqlnd_error_info error_info = mysql->mysql->error_info;
+ MYSQLND_ERROR_INFO error_info = mysql->mysql->error_info;
#endif
MYSQLI_REPORT_MYSQL_ERROR(mysql->mysql);
MYSQLI_DISABLE_MQ;
if (!$res = $mysqli->query("SELECT 'mysqli.default_socket' AS testing"))
printf("[001] [%d] %s\n", $mysqli->errno, $mysqli->error);
- var_dump($res->fetch_assoc());
+ $tmp = $res->fetch_assoc();
$res->free_result();
+ if (!isset($tmp['testing']) || $tmp['testing'] != $socket) {
+ printf("[002] mysqli.default_socket not properly set?\n");
+ var_dump($tmp);
+ }
+
$mysqli->close();
} catch (mysqli_sql_exception $e) {
print "done!";
?>
--EXPECTF--
-array(1) {
- [%u|b%"testing"]=>
- %unicode|string%(21) "mysqli.default_socket"
-}
array(1) {
[%u|b%"testing"]=>
%unicode|string%(19) "mysqli.default_port"
if (($version > 51122 && $version < 60000) || ($version > 60003) || $IS_MYSQLND) {
$expected_constants['MYSQLI_ON_UPDATE_NOW_FLAG'] = true;
}
- if ($version > 60005 || $IS_MYSQLND) {
+
+ /* First introduced in MySQL 6.0, backported to MySQL 5.5 */
+ if ($version >= 50500 || $IS_MYSQLND) {
$expected_constants['MYSQLI_SERVER_QUERY_WAS_SLOW'] = true;
}
+++ /dev/null
---TEST--
-mysqli_get_cache_stats()
---XFAIL--
-zval caching has been temporarily disabled for the 5.3.0 release
---INI--
-mysqlnd.collect_statistics="1"
-mysqlnd.collect_memory_statistics="1"
---SKIPIF--
-<?PHP
-require_once('skipif.inc');
-require_once('skipifemb.inc');
-require_once('skipifconnectfailure.inc');
-if (!function_exists('mysqli_get_cache_stats')) {
- die("skip only available with mysqlnd");
-}
-?>
---FILE--
-<?php
- $tmp = $link = null;
- if (!is_null($tmp = @mysqli_get_cache_stats($link)))
- printf("[001] Expecting NULL, got %s/%s\n", gettype($tmp), $tmp);
-
- require_once("connect.inc");
-
- if (!is_array($info = mysqli_get_cache_stats()) || empty($info))
- printf("[002] Expecting array/any_non_empty, got %s/%s\n", gettype($info), $info);
-
- var_dump($info);
-
- if ($info["size"] !== $info['free_items'])
- printf("[003] Unused cache should have size (%d) == free_items (%d)\n",
- $info["size"], $info['free_items']);
-
- require_once('table.inc');
-
- if (!is_array($new_info = mysqli_get_cache_stats()) || empty($new_info))
- printf("[004] Expecting array/any_non_empty, got %s/%s\n", gettype($new_info), $new_info);
-
- if ($info['size'] !== $new_info['size'])
- printf("[005] Cache size should not have changes! Expecting int/%d, got %s/%d\n",
- $info['size'], gettype($new_info['size']), $new_info['size']);
-
- if (count($info) != count($new_info)) {
- printf("[006] Both arrays should have the same number of entries\n");
- var_dump($info);
- var_dump($new_info);
- }
-
- if (!$res = mysqli_real_query($link, "SELECT id, label FROM test ORDER BY id"))
- printf("[007] [%d] %s\n", mysqli_errno($link), mysqli_error($link));
-
- if (!is_object($res = mysqli_use_result($link)))
- printf("[008] Expecting object, got %s/%s. [%d] %s\n",
- gettype($res), $res, mysqli_errno($link), mysqli_error($link));
-
- if (!$row = mysqli_fetch_assoc($res))
- printf("[009] There should be at least one row in the test table for this test, [%d] %s\n",
- mysqli_errno($link), mysqli_error($link));
-
- if (!is_array($new_info = mysqli_get_cache_stats()) || empty($new_info))
- printf("[010] Expecting array/any_non_empty, got %s/%s\n", gettype($new_info), $new_info);
-
- if ($new_info['get_hits'] <= $info['get_hits'])
- printf("[011] get_hits should have increased, %d (new) <= %d (old)!\n",
- $new_info['get_hits'], $info['get_hits']);
-
- if (!$row = mysqli_fetch_assoc($res))
- printf("[012] There should be two rows in the test table for this test, [%d] %s\n",
- mysqli_errno($link), mysqli_error($link));
-
- if (!is_array($new_info = mysqli_get_cache_stats()) || empty($new_info))
- printf("[013] Expecting array/any_non_empty, got %s/%s\n", gettype($new_info), $new_info);
-
- if ($new_info['put_misses'] <= $info['put_misses'])
- printf("[014] put_misses should have increased, %d (new) <= %d (old)!\n",
- $new_info['put_misses'], $info['put_misses']);
-
- if ($new_info['references'] < $info['references'] + 2)
- printf("[015] reference counter should have increased, %d (new) < %d + 2 (old)!\n",
- $new_info['references'], $info['references']);
-
- unset($row);
- mysqli_free_result($res);
-
- if (!is_array($info = mysqli_get_cache_stats()) || empty($info))
- printf("[016] Expecting array/any_non_empty, got %s/%s\n", gettype($info), $info);
-
- if ($info['free_items'] <= $new_info['free_items'])
- printf("[017] Looks like cached entries never get free'd.\n");
-
- mysqli_close($link);
-
- print "done!";
-?>
---CLEAN--
-<?php
- require_once("clean_table.inc");
-?>
---EXPECTF--
-array(7) {
- [%u|b%"put_hits"]=>
- int(0)
- [%u|b%"put_misses"]=>
- int(0)
- [%u|b%"get_hits"]=>
- int(0)
- [%u|b%"get_misses"]=>
- int(0)
- [%u|b%"size"]=>
- int(%d)
- [%u|b%"free_items"]=>
- int(%d)
- [%u|b%"references"]=>
- int(%d)
-}
-done!
\ No newline at end of file
+++ /dev/null
---TEST--
-mysqli_get_cache_stats() - freeing for buffered result sets
---XFAIL--
-zval caching has been temporarily disabled for the 5.3.0 release
---INI--
-mysqlnd.collect_statistics="1"
-mysqlnd.collect_memory_statistics="1"
---SKIPIF--
-<?PHP
-require_once('skipif.inc');
-require_once('skipifemb.inc');
-require_once('skipifconnectfailure.inc');
-if (!function_exists('mysqli_get_cache_stats')) {
- die("skip only available with mysqlnd");
-}
-?>
---FILE--
-<?php
- require_once('table.inc');
-
- if (!is_array($info = mysqli_get_cache_stats()) || empty($info))
- printf("[001] Expecting array/any_non_empty, got %s/%s\n", gettype($info), $info);
-
- if (!$res = mysqli_query($link, "SELECT id, label FROM test ORDER BY id"))
- printf("[002] [%d] %s\n", mysqli_errno($link), mysqli_error($link));
-
- $rows = array();
- while ($rows[] = mysqli_fetch_assoc($res))
- ;
- mysqli_free_result($res);
-
- if (!is_array($new_info = mysqli_get_cache_stats()) || empty($new_info))
- printf("[003] Expecting array/any_non_empty, got %s/%s\n", gettype($new_info), $new_info);
-
- if ($new_info['free_items'] >= $info['free_items']) {
- printf("[004] mysqli_free_result() should not yet have free slots again, because \$rows still exists\n");
- var_dump($info);
- var_dump($new_info);
- }
-
- /* nothing should change because GC will happen some time after free_result */
- unset($rows);
-
- if (!is_array($new_info = mysqli_get_cache_stats()) || empty($new_info))
- printf("[005] Expecting array/any_non_empty, got %s/%s\n", gettype($new_info), $new_info);
-
- if (defined("WE_HAVE_GARBAGE_COLLECTOR_TO_FREE_AFTER_ON_UNSET_AFTER_FREE_RESULT")) {
- /*
- For now we can't reclaim the slots after the free_result is called.
- unset() should happen before free_result().
- */
- if ($new_info['free_items'] < $info['free_items']) {
- printf("[006] \$rows has been unset, free item count should be back to the original value\n");
- var_dump($info);
- var_dump($new_info);
- }
- } else {
- /* We have to reset $info */
- $info = mysqli_get_cache_stats();
- }
-
- if (!$res = mysqli_query($link, "SELECT id, label FROM test ORDER BY id"))
- printf("[007] [%d] %s\n", mysqli_errno($link), mysqli_error($link));
-
- $rows = array();
- while ($rows[] = mysqli_fetch_assoc($res))
- ;
- unset($rows);
- mysqli_free_result($res);
-
- if (!is_array($new_info = mysqli_get_cache_stats()) || empty($new_info))
- printf("[008] Expecting array/any_non_empty, got %s/%s\n", gettype($new_info), $new_info);
-
- if ($new_info['free_items'] < $info['free_items']) {
- printf("[009] \$rows has been unset, mysqli_free_result() has been called, free item count should be back to the original value\n");
- var_dump($info);
- var_dump($new_info);
- }
-
- mysqli_close($link);
-
- if (!is_array($new_info = mysqli_get_cache_stats()) || empty($new_info))
- printf("[010] Expecting array/any_non_empty, got %s/%s\n", gettype($new_info), $new_info);
-
- if ($new_info['free_items'] < $info['free_items']) {
- printf("[011] connection has been closed, free item count should be back to the original value\n");
- var_dump($info);
- var_dump($new_info);
- }
-
- print "done!";
-?>
---CLEAN--
-<?php
- require_once("clean_table.inc");
-?>
---EXPECTF--
-done!
\ No newline at end of file
<?php
require_once('skipif.inc');
require_once('skipifconnectfailure.inc');
+
+if (!$link = my_mysqli_connect($host, $user, $passwd, $db, $port, $socket))
+ die(sprintf("SKIP [%d] %s\n", mysqli_connect_errno(), mysqli_connect_error()));
+
+$max_len = pow(2, 24);
+if (!$res = mysqli_query($link, "SHOW GLOBAL VARIABLES LIKE 'max_allowed_packet'"))
+ die(sprintf("SKIP [%d] %s\n", mysqli_errno($link), mysqli_error($link)));
+
+if (!mysqli_query($link, "SET NAMES 'latin1'"))
+ die(sprintf("SKIP [%d] %s\n", mysqli_errno($link), mysqli_error($link)));
+
+mysqli_close($link);
?>
--INI--
memory_limit=256M
if (!$link = my_mysqli_connect($host, $user, $passwd, $db, $port, $socket))
printf("[006] [%d] %s\n", mysqli_connect_errno(), mysqli_connect_error());
+ if (!mysqli_query($link, "SET NAMES 'latin1'"))
+ printf("[007] [%d] %s\n", mysqli_connect_errno(), mysqli_connect_error());
+
if (!$res = mysqli_query($link, "SHOW GLOBAL VARIABLES LIKE 'max_allowed_packet'"))
- printf("[007] [%d] %s\n", mysqli_errno($link), mysqli_error($link));
+ printf("[008] [%d] %s\n", mysqli_errno($link), mysqli_error($link));
if (!$row = mysqli_fetch_assoc($res))
- printf("[008] [%d] %s\n", mysqli_errno($link), mysqli_error($link));
+ printf("[009] [%d] %s\n", mysqli_errno($link), mysqli_error($link));
mysqli_free_result($res);
if (0 === ($max_allowed_packet = (int)$row['Value']))
- printf("[009] Cannot determine max_allowed_packet size and/or bogus max_allowed_packet setting used.\n");
+ printf("[010] Cannot determine max_allowed_packet size and/or bogus max_allowed_packet setting used.\n");
$max_len = pow(2, 24);
if ($max_allowed_packet < $max_len) {
- printf("[010] Failed to change max_allowed_packet");
+ printf("[011] Failed to change max_allowed_packet");
}
if (!mysqli_query($link, "CREATE TABLE test(col_blob LONGBLOB) ENGINE=" . $engine))
- printf("[011] [%d] %s\n", mysqli_errno($link), mysqli_error($link));
+ printf("[012] [%d] %s\n", mysqli_errno($link), mysqli_error($link));
$query_prefix = 'INSERT INTO test(col_blob) VALUES ("';
$query_postfix = '")';
$query_len = strlen($query_prefix) + strlen($query_postfix);
- $com_query_len = 1;
+ $com_query_len = 2;
$blob = str_repeat('a', $max_len - $com_query_len - $query_len);
$query = sprintf("%s%s%s", $query_prefix, $blob, $query_postfix);
if (!mysqli_query($link, $query))
- printf("[012] [%d] %s\n", mysqli_errno($link), mysqli_error($link));
+ printf("[013] max_allowed_packet = %d, strlen(query) = %d, [%d] %s\n", $max_allowed_packet, strlen($query), mysqli_errno($link), mysqli_error($link));
if (!$res = mysqli_query($link, "SELECT col_blob FROM test"))
- printf("[013] [%d] %s\n", mysqli_errno($link), mysqli_error($link));
+ printf("[014] [%d] %s\n", mysqli_errno($link), mysqli_error($link));
if (!$row = mysqli_fetch_assoc($res)) {
- printf("[014] [%d] %s\n", mysqli_errno($link), mysqli_error($link));
+ printf("[015] [%d] %s\n", mysqli_errno($link), mysqli_error($link));
} else {
if ($row['col_blob'] != $blob) {
- printf("[015] Blob seems wrong, dumping data\n");
+ printf("[016] Blob seems wrong, dumping data\n");
var_dump(strlen($row['col_blob']));
var_dump(strlen($blob));
}
}
if (!mysqli_query($link, "SET GLOBAL max_allowed_packet = " . $org_max_allowed_packet))
- printf("[016] [%d] %s\n", mysqli_errno($link), mysqli_error($link));
+ printf("[017] [%d] %s\n", mysqli_errno($link), mysqli_error($link));
mysqli_close($link);
'connect_failure', 'connection_reused', 'explicit_close', 'implicit_close',
'disconnect_close', 'in_middle_of_command_close', 'explicit_free_result',
'implicit_free_result', 'explicit_stmt_close', 'implicit_stmt_close',
- 'put_hits', 'put_misses', 'get_hits', 'get_misses',
- 'size', 'free_items', 'references', 'mysqli.cache_size',
+ 'size',
'mysqli.allow_local_infile',
'mysqli.allow_persistent', 'mysqli.max_persistent'
);
-const char * const mysqlnd_old_passwd = "mysqlnd cannot connect to MySQL 4.1+ using old authentication";
-const char * const mysqlnd_server_gone = "MySQL server has gone away";
-const char * const mysqlnd_out_of_sync = "Commands out of sync; you can't run this command now";
+PHPAPI const char * const mysqlnd_old_passwd = "mysqlnd cannot connect to MySQL 4.1+ using old authentication";
+PHPAPI const char * const mysqlnd_server_gone = "MySQL server has gone away";
+PHPAPI const char * const mysqlnd_out_of_sync = "Commands out of sync; you can't run this command now";
-MYSQLND_STATS *mysqlnd_global_stats = NULL;
+PHPAPI MYSQLND_STATS *mysqlnd_global_stats = NULL;
static zend_bool mysqlnd_library_initted = FALSE;
static enum_func_status mysqlnd_send_close(MYSQLND * conn TSRMLS_DC);
static struct st_mysqlnd_conn_methods *mysqlnd_conn_methods;
/* {{{ mysqlnd_library_end */
-void mysqlnd_library_end(TSRMLS_D)
+PHPAPI void mysqlnd_library_end(TSRMLS_D)
{
if (mysqlnd_library_initted == TRUE) {
mysqlnd_stats_end(mysqlnd_global_stats);
conn->net = NULL;
}
+ if (conn->protocol) {
+ DBG_INF("Freeing protocol");
+ mysqlnd_protocol_free(conn->protocol TSRMLS_CC);
+ conn->protocol = NULL;
+ }
+
+ if (conn->stats) {
+ mysqlnd_stats_end(conn->stats);
+ }
+
mnd_pefree(conn, conn->persistent);
DBG_VOID_RETURN;
/* {{{ mysqlnd_conn::simple_command_handle_response */
static enum_func_status
-MYSQLND_METHOD(mysqlnd_conn, simple_command_handle_response)(MYSQLND *conn, enum php_mysql_packet_type ok_packet,
+MYSQLND_METHOD(mysqlnd_conn, simple_command_handle_response)(MYSQLND *conn, enum mysqlnd_packet_type ok_packet,
zend_bool silent, enum php_mysqlnd_server_command command,
zend_bool ignore_upsert_status TSRMLS_DC)
{
switch (ok_packet) {
case PROT_OK_PACKET:{
- php_mysql_packet_ok ok_response;
- PACKET_INIT_ALLOCA(ok_response, PROT_OK_PACKET);
- if (FAIL == (ret = PACKET_READ_ALLOCA(ok_response, conn))) {
+ MYSQLND_PACKET_OK * ok_response = conn->protocol->m.get_ok_packet(conn->protocol, FALSE TSRMLS_CC);
+ if (FAIL == (ret = PACKET_READ(ok_response, conn))) {
if (!silent) {
DBG_ERR_FMT("Error while reading %s's OK packet", mysqlnd_command_to_text[command]);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading %s's OK packet. PID=%d",
}
} else {
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(conn->error_info, ok_response.error_no,
- ok_response.sqlstate, ok_response.error);
+ SET_CLIENT_ERROR(conn->error_info, ok_response->error_no, ok_response->sqlstate, ok_response->error);
ret = FAIL;
/*
Cover a protocol design error: error packet does not
SET_ERROR_AFF_ROWS(conn);
} else {
SET_NEW_MESSAGE(conn->last_message, conn->last_message_len,
- ok_response.message, ok_response.message_len,
+ ok_response->message, ok_response->message_len,
conn->persistent);
if (!ignore_upsert_status) {
- conn->upsert_status.warning_count = ok_response.warning_count;
- conn->upsert_status.server_status = ok_response.server_status;
- conn->upsert_status.affected_rows = ok_response.affected_rows;
- conn->upsert_status.last_insert_id = ok_response.last_insert_id;
+ conn->upsert_status.warning_count = ok_response->warning_count;
+ conn->upsert_status.server_status = ok_response->server_status;
+ conn->upsert_status.affected_rows = ok_response->affected_rows;
+ conn->upsert_status.last_insert_id = ok_response->last_insert_id;
}
}
}
- PACKET_FREE_ALLOCA(ok_response);
+ PACKET_FREE(ok_response);
break;
}
case PROT_EOF_PACKET:{
- php_mysql_packet_eof ok_response;
- PACKET_INIT_ALLOCA(ok_response, PROT_EOF_PACKET);
- if (FAIL == (ret = PACKET_READ_ALLOCA(ok_response, conn))) {
+ MYSQLND_PACKET_EOF * ok_response = conn->protocol->m.get_eof_packet(conn->protocol, FALSE TSRMLS_CC);
+ if (FAIL == (ret = PACKET_READ(ok_response, conn))) {
SET_CLIENT_ERROR(conn->error_info, CR_MALFORMED_PACKET, UNKNOWN_SQLSTATE,
"Malformed packet");
if (!silent) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading %s's EOF packet. PID=%d",
mysqlnd_command_to_text[command], getpid());
}
- } else if (0xFF == ok_response.field_count) {
+ } else if (0xFF == ok_response->field_count) {
/* The server signalled error. Set the error */
- SET_CLIENT_ERROR(conn->error_info, ok_response.error_no,
- ok_response.sqlstate, ok_response.error);
+ SET_CLIENT_ERROR(conn->error_info, ok_response->error_no, ok_response->sqlstate, ok_response->error);
SET_ERROR_AFF_ROWS(conn);
- } else if (0xFE != ok_response.field_count) {
+ } else if (0xFE != ok_response->field_count) {
SET_CLIENT_ERROR(conn->error_info, CR_MALFORMED_PACKET, UNKNOWN_SQLSTATE,
"Malformed packet");
if (!silent) {
- DBG_ERR_FMT("EOF packet expected, field count wasn't 0xFE but 0x%2X", ok_response.field_count);
+ DBG_ERR_FMT("EOF packet expected, field count wasn't 0xFE but 0x%2X", ok_response->field_count);
php_error_docref(NULL TSRMLS_CC, E_WARNING,
"EOF packet expected, field count wasn't 0xFE but 0x%2X",
- ok_response.field_count);
+ ok_response->field_count);
}
} else {
DBG_INF_FMT("OK from server");
}
- PACKET_FREE_ALLOCA(ok_response);
+ PACKET_FREE(ok_response);
break;
}
default:
/* {{{ mysqlnd_conn::simple_command */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn, simple_command)(MYSQLND *conn, enum php_mysqlnd_server_command command,
- const char * const arg, size_t arg_len, enum php_mysql_packet_type ok_packet, zend_bool silent,
+ const char * const arg, size_t arg_len, enum mysqlnd_packet_type ok_packet, zend_bool silent,
zend_bool ignore_upsert_status TSRMLS_DC)
{
enum_func_status ret = PASS;
- php_mysql_packet_command cmd_packet;
+ MYSQLND_PACKET_COMMAND * cmd_packet;
DBG_ENTER("mysqlnd_conn::simple_command");
DBG_INF_FMT("command=%s ok_packet=%d silent=%d", mysqlnd_command_to_text[command], ok_packet, silent);
SET_ERROR_AFF_ROWS(conn);
SET_EMPTY_ERROR(conn->error_info);
- PACKET_INIT_ALLOCA(cmd_packet, PROT_CMD_PACKET);
- cmd_packet.command = command;
+ cmd_packet = conn->protocol->m.get_command_packet(conn->protocol, FALSE TSRMLS_CC);
+ cmd_packet->command = command;
if (arg && arg_len) {
- cmd_packet.argument = arg;
- cmd_packet.arg_len = arg_len;
+ cmd_packet->argument = arg;
+ cmd_packet->arg_len = arg_len;
}
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_COM_QUIT + command - 1 /* because of COM_SLEEP */ );
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_COM_QUIT + command - 1 /* because of COM_SLEEP */ );
- if (! PACKET_WRITE_ALLOCA(cmd_packet, conn)) {
+ if (! PACKET_WRITE(cmd_packet, conn)) {
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());
ret = conn->m->simple_command_handle_response(conn, ok_packet, silent, command, ignore_upsert_status TSRMLS_CC);
}
- /*
- There is no need to call FREE_ALLOCA on cmd_packet as the
- only allocated string is cmd_packet.argument and it was passed
- to us. We should not free it.
- */
-
+ PACKET_FREE(cmd_packet);
DBG_INF(ret == PASS ? "PASS":"FAIL");
DBG_RETURN(ret);
}
PHPAPI void _mysqlnd_restart_psession(MYSQLND *conn TSRMLS_DC)
{
DBG_ENTER("_mysqlnd_restart_psession");
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_CONNECT_REUSED);
- /* Free here what should not be seen by the next script */
- if (conn->last_message) {
- mnd_pefree(conn->last_message, conn->persistent);
- conn->last_message = NULL;
- }
- /*
- The thd zval cache is always freed on request shutdown, so this has happened already.
- Don't touch the old value! Get new reference
- */
+ conn->m->restart_psession(conn TSRMLS_CC);
DBG_VOID_RETURN;
}
/* }}} */
PHPAPI void _mysqlnd_end_psession(MYSQLND *conn TSRMLS_DC)
{
DBG_ENTER("_mysqlnd_end_psession");
+ conn->m->end_psession(conn TSRMLS_CC);
DBG_VOID_RETURN;
}
/* }}} */
+/* {{{ mysqlnd_conn::restart_psession */
+static enum_func_status
+MYSQLND_METHOD(mysqlnd_conn, restart_psession)(MYSQLND * conn TSRMLS_DC)
+{
+ DBG_ENTER("mysqlnd_conn::restart_psession");
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_CONNECT_REUSED);
+ /* Free here what should not be seen by the next script */
+ if (conn->last_message) {
+ mnd_pefree(conn->last_message, conn->persistent);
+ conn->last_message = NULL;
+ }
+ DBG_RETURN(PASS);
+}
+/* }}} */
+
+
+/* {{{ mysqlnd_conn::end_psession */
+static enum_func_status
+MYSQLND_METHOD(mysqlnd_conn, end_psession)(MYSQLND * conn TSRMLS_DC)
+{
+ DBG_ENTER("mysqlnd_conn::end_psession");
+ DBG_RETURN(PASS);
+}
+/* }}} */
+
/* {{{ mysqlnd_conn::connect */
static enum_func_status
zend_bool reconnect = FALSE;
zend_bool saved_compression = FALSE;
- php_mysql_packet_greet greet_packet;
- php_mysql_packet_auth *auth_packet;
- php_mysql_packet_ok ok_packet;
+ MYSQLND_PACKET_GREET * greet_packet = NULL;
+ MYSQLND_PACKET_AUTH * auth_packet = NULL;
+ MYSQLND_PACKET_OK * ok_packet = NULL;
DBG_ENTER("mysqlnd_conn::connect");
DBG_INF("Connecting on a connected handle.");
if (CONN_GET_STATE(conn) < CONN_QUIT_SENT) {
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_CLOSE_IMPLICIT);
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_CLOSE_IMPLICIT);
reconnect = TRUE;
mysqlnd_send_close(conn TSRMLS_CC);
}
conn->m->free_contents(conn TSRMLS_CC);
- MYSQLND_DEC_CONN_STATISTIC(&conn->stats, STAT_OPENED_CONNECTIONS);
+ MYSQLND_DEC_CONN_STATISTIC(conn->stats, STAT_OPENED_CONNECTIONS);
if (conn->persistent) {
- MYSQLND_DEC_CONN_STATISTIC(&conn->stats, STAT_OPENED_PERSISTENT_CONNECTIONS);
+ MYSQLND_DEC_CONN_STATISTIC(conn->stats, STAT_OPENED_PERSISTENT_CONNECTIONS);
}
/* Now reconnect using the same handle */
if (conn->net->compressed) {
DBG_INF_FMT("transport=%s", transport);
- PACKET_INIT_ALLOCA(greet_packet, PROT_GREET_PACKET);
- PACKET_INIT(auth_packet, PROT_AUTH_PACKET, php_mysql_packet_auth *, FALSE);
- PACKET_INIT_ALLOCA(ok_packet, PROT_OK_PACKET);
+ greet_packet = conn->protocol->m.get_greet_packet(conn->protocol, FALSE TSRMLS_CC);
+ auth_packet = conn->protocol->m.get_auth_packet(conn->protocol, FALSE TSRMLS_CC);
+ ok_packet = conn->protocol->m.get_ok_packet(conn->protocol, FALSE TSRMLS_CC);
if (conn->persistent) {
conn->scheme = pestrndup(transport, transport_len, 1);
DBG_INF_FMT("stream=%p", conn->net->stream);
- if (FAIL == PACKET_READ_ALLOCA(greet_packet, conn)) {
+ if (FAIL == PACKET_READ(greet_packet, conn)) {
DBG_ERR("Error while reading greeting packet");
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading greeting packet. PID=%d", getpid());
goto err;
- } else if (greet_packet.error_no) {
- DBG_ERR_FMT("errorno=%d error=%s", greet_packet.error_no, greet_packet.error);
- SET_CLIENT_ERROR(conn->error_info, greet_packet.error_no,
- greet_packet.sqlstate, greet_packet.error);
+ } else if (greet_packet->error_no) {
+ DBG_ERR_FMT("errorno=%d error=%s", greet_packet->error_no, greet_packet->error);
+ SET_CLIENT_ERROR(conn->error_info, greet_packet->error_no, greet_packet->sqlstate, greet_packet->error);
goto err;
- } else if (greet_packet.pre41) {
- DBG_ERR_FMT("Connecting to 3.22, 3.23 & 4.0 is not supported. Server is %-.32s",
- greet_packet.server_version);
+ } else if (greet_packet->pre41) {
+ DBG_ERR_FMT("Connecting to 3.22, 3.23 & 4.0 is not supported. Server is %-.32s", greet_packet->server_version);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Connecting to 3.22, 3.23 & 4.0 "
- " is not supported. Server is %-.32s", greet_packet.server_version);
+ " is not supported. Server is %-.32s", greet_packet->server_version);
SET_CLIENT_ERROR(conn->error_info, CR_NOT_IMPLEMENTED, UNKNOWN_SQLSTATE,
"Connecting to 3.22, 3.23 & 4.0 servers is not supported");
goto err;
}
- conn->thread_id = greet_packet.thread_id;
- conn->protocol_version = greet_packet.protocol_version;
- conn->server_version = pestrdup(greet_packet.server_version, conn->persistent);
+ conn->thread_id = greet_packet->thread_id;
+ conn->protocol_version = greet_packet->protocol_version;
+ conn->server_version = pestrdup(greet_packet->server_version, conn->persistent);
- conn->greet_charset = mysqlnd_find_charset_nr(greet_packet.charset_no);
+ conn->greet_charset = mysqlnd_find_charset_nr(greet_packet->charset_no);
/* we allow load data local infile by default */
mysql_flags |= CLIENT_LOCAL_FILES | CLIENT_PS_MULTI_RESULTS;
#ifndef MYSQLND_COMPRESSION_ENABLED
#if PHP_MAJOR_VERSION >= 6
auth_packet->charset_no = 200;/* utf8 - swedish collation, check mysqlnd_charset.c */
#else
- auth_packet->charset_no = greet_packet.charset_no;
+ auth_packet->charset_no = greet_packet->charset_no;
#endif
}
auth_packet->db = db;
auth_packet->client_flags= mysql_flags;
conn->scramble = auth_packet->server_scramble_buf = mnd_pemalloc(SCRAMBLE_LENGTH, conn->persistent);
- memcpy(auth_packet->server_scramble_buf, greet_packet.scramble_buf, SCRAMBLE_LENGTH);
+ memcpy(auth_packet->server_scramble_buf, greet_packet->scramble_buf, SCRAMBLE_LENGTH);
if (!PACKET_WRITE(auth_packet, conn)) {
CONN_SET_STATE(conn, CONN_QUIT_SENT);
SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone);
goto err;
}
- if (FAIL == PACKET_READ_ALLOCA(ok_packet, conn) || ok_packet.field_count >= 0xFE) {
- if (ok_packet.field_count == 0xFE) {
+ if (FAIL == PACKET_READ(ok_packet, conn) || ok_packet->field_count >= 0xFE) {
+ if (ok_packet->field_count == 0xFE) {
/* old authentication with new server !*/
DBG_ERR(mysqlnd_old_passwd);
SET_CLIENT_ERROR(conn->error_info, CR_UNKNOWN_ERROR, UNKNOWN_SQLSTATE, mysqlnd_old_passwd);
- } else if (ok_packet.field_count == 0xFF) {
- if (ok_packet.sqlstate[0]) {
+ } else if (ok_packet->field_count == 0xFF) {
+ if (ok_packet->sqlstate[0]) {
if (!self_alloced) {
- strlcpy(conn->error_info.sqlstate, ok_packet.sqlstate, sizeof(conn->error_info.sqlstate));
+ strlcpy(conn->error_info.sqlstate, ok_packet->sqlstate, sizeof(conn->error_info.sqlstate));
}
- DBG_ERR_FMT("ERROR:%d [SQLSTATE:%s] %s",
- ok_packet.error_no, ok_packet.sqlstate, ok_packet.error);
+ DBG_ERR_FMT("ERROR:%d [SQLSTATE:%s] %s", ok_packet->error_no, ok_packet->sqlstate, ok_packet->error);
}
if (!self_alloced) {
- conn->error_info.error_no = ok_packet.error_no;
- strlcpy(conn->error_info.error, ok_packet.error, sizeof(conn->error_info.error));
+ conn->error_info.error_no = ok_packet->error_no;
+ strlcpy(conn->error_info.error, ok_packet->error, sizeof(conn->error_info.error));
}
}
} else {
conn->max_packet_size = auth_packet->max_packet_size;
/* todo: check if charset is available */
conn->charset = mysqlnd_find_charset_nr(auth_packet->charset_no);
- conn->server_capabilities = greet_packet.server_capabilities;
+ conn->server_capabilities = greet_packet->server_capabilities;
conn->upsert_status.warning_count = 0;
- conn->upsert_status.server_status = greet_packet.server_status;
+ conn->upsert_status.server_status = greet_packet->server_status;
conn->upsert_status.affected_rows = 0;
SET_NEW_MESSAGE(conn->last_message, conn->last_message_len,
- ok_packet.message, ok_packet.message_len,
+ ok_packet->message, ok_packet->message_len,
conn->persistent);
SET_EMPTY_ERROR(conn->error_info);
conn->m->set_client_option(conn, MYSQLND_OPT_NET_CMD_BUFFER_SIZE, (char *)&buf_size TSRMLS_CC);
}
- MYSQLND_INC_CONN_STATISTIC_W_VALUE2(&conn->stats, STAT_CONNECT_SUCCESS, 1, STAT_OPENED_CONNECTIONS, 1);
+ MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn->stats, STAT_CONNECT_SUCCESS, 1, STAT_OPENED_CONNECTIONS, 1);
if (reconnect) {
MYSQLND_INC_GLOBAL_STATISTIC(STAT_RECONNECT);
}
if (conn->persistent) {
- MYSQLND_INC_CONN_STATISTIC_W_VALUE2(&conn->stats, STAT_PCONNECT_SUCCESS, 1, STAT_OPENED_PERSISTENT_CONNECTIONS, 1);
+ MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn->stats, STAT_PCONNECT_SUCCESS, 1, STAT_OPENED_PERSISTENT_CONNECTIONS, 1);
}
DBG_INF_FMT("connection_id=%llu", conn->thread_id);
int current_command = 0;
for (; current_command < conn->options.num_commands; ++current_command) {
const char * const command = conn->options.init_commands[current_command];
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_INIT_COMMAND_EXECUTED_COUNT);
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_INIT_COMMAND_EXECUTED_COUNT);
if (PASS != conn->m->query(conn, command, strlen(command) TSRMLS_CC)) {
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_INIT_COMMAND_FAILED_COUNT);
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_INIT_COMMAND_FAILED_COUNT);
goto err;
}
if (conn->last_query_type == QUERY_SELECT) {
}
}
- PACKET_FREE_ALLOCA(greet_packet);
+ PACKET_FREE(greet_packet);
PACKET_FREE(auth_packet);
- PACKET_FREE_ALLOCA(ok_packet);
+ PACKET_FREE(ok_packet);
DBG_RETURN(PASS);
}
err:
- PACKET_FREE_ALLOCA(greet_packet);
+ PACKET_FREE(greet_packet);
PACKET_FREE(auth_packet);
- PACKET_FREE_ALLOCA(ok_packet);
+ PACKET_FREE(ok_packet);
if (errstr) {
DBG_ERR_FMT("[%d] %.64s (trying to connect via %s)", errcode, errstr, conn->scheme);
conn->scheme = NULL;
}
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_CONNECT_FAILURE);
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_CONNECT_FAILURE);
DBG_RETURN(FAIL);
}
*/
ret = conn->m->query_read_result_set_header(conn, NULL TSRMLS_CC);
if (ret == PASS && conn->last_query_type == QUERY_UPSERT && conn->upsert_status.affected_rows) {
- MYSQLND_INC_CONN_STATISTIC_W_VALUE(&conn->stats, STAT_ROWS_AFFECTED_NORMAL, conn->upsert_status.affected_rows);
+ MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn->stats, STAT_ROWS_AFFECTED_NORMAL, conn->upsert_status.affected_rows);
}
DBG_RETURN(ret);
}
/* }}} */
-/* {{{ mysqlnd_conn::send_query */
+
+/* {{{ mysqlnd_conn::reap_query */
static enum_func_status
MYSQLND_METHOD(mysqlnd_conn, reap_query)(MYSQLND * conn TSRMLS_DC)
{
if (state <= CONN_READY || state == CONN_QUIT_SENT) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Connection not opened, clear or has been closed");
+ DBG_ERR_FMT("Connection not opened, clear or has been closed. State=%d", state);
DBG_RETURN(FAIL);
}
DBG_RETURN(conn->m->query_read_result_set_header(conn, NULL TSRMLS_CC));
if (!sets) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, *dont_poll ? "All arrays passed are clear":"No stream arrays were passed");
+ DBG_ERR_FMT(*dont_poll ? "All arrays passed are clear":"No stream arrays were passed");
DBG_RETURN(FAIL);
}
MYSQLND_METHOD(mysqlnd_conn, stat)(MYSQLND *conn, char **message, unsigned int * message_len TSRMLS_DC)
{
enum_func_status ret;
- php_mysql_packet_stats stats_header;
+ MYSQLND_PACKET_STATS * stats_header;
DBG_ENTER("mysqlnd_conn::stat");
DBG_INF_FMT("conn=%llu", conn->thread_id);
if (FAIL == ret) {
DBG_RETURN(FAIL);
}
- PACKET_INIT_ALLOCA(stats_header, PROT_STATS_PACKET);
- if (FAIL == (ret = PACKET_READ_ALLOCA(stats_header, conn))) {
+ stats_header = conn->protocol->m.get_stats_packet(conn->protocol, FALSE TSRMLS_CC);
+ if (FAIL == (ret = PACKET_READ(stats_header, conn))) {
DBG_RETURN(FAIL);
}
- *message = stats_header.message;
- *message_len = stats_header.message_len;
+ *message = stats_header->message;
+ *message_len = stats_header->message_len;
/* Ownership transfer */
- stats_header.message = NULL;
- PACKET_FREE_ALLOCA(stats_header);
+ stats_header->message = NULL;
+ PACKET_FREE(stats_header);
DBG_INF(*message);
DBG_RETURN(PASS);
DBG_INF_FMT("conn=%llu", conn->thread_id);
if (conn->state >= CONN_READY) {
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, stat);
- MYSQLND_DEC_CONN_STATISTIC(&conn->stats, STAT_OPENED_CONNECTIONS);
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, stat);
+ MYSQLND_DEC_CONN_STATISTIC(conn->stats, STAT_OPENED_CONNECTIONS);
if (conn->persistent) {
- MYSQLND_DEC_CONN_STATISTIC(&conn->stats, STAT_OPENED_PERSISTENT_CONNECTIONS);
+ MYSQLND_DEC_CONN_STATISTIC(conn->stats, STAT_OPENED_PERSISTENT_CONNECTIONS);
}
}
*/
size_t user_len;
enum_func_status ret;
- php_mysql_packet_chg_user_resp chg_user_resp;
+ MYSQLND_PACKET_CHG_USER_RESPONSE * chg_user_resp;
char buffer[MYSQLND_MAX_ALLOWED_USER_LEN + 1 + SCRAMBLE_LENGTH + MYSQLND_MAX_ALLOWED_DB_LEN + 1];
char *p = buffer;
DBG_RETURN(FAIL);
}
- PACKET_INIT_ALLOCA(chg_user_resp, PROT_CHG_USER_PACKET);
- ret = PACKET_READ_ALLOCA(chg_user_resp, conn);
- conn->error_info = chg_user_resp.error_info;
- PACKET_FREE_ALLOCA(chg_user_resp);
+ chg_user_resp = conn->protocol->m.get_change_user_response_packet(conn->protocol, FALSE TSRMLS_CC);
+ ret = PACKET_READ(chg_user_resp, conn);
+ conn->error_info = chg_user_resp->error_info;
+ PACKET_FREE(chg_user_resp);
if (conn->error_info.error_no) {
ret = FAIL;
if (mysqlnd_get_server_version(conn) > 50113L &&
mysqlnd_get_server_version(conn) < 50118L)
{
- php_mysql_packet_ok redundant_error_packet;
- PACKET_INIT_ALLOCA(redundant_error_packet, PROT_OK_PACKET);
- PACKET_READ_ALLOCA(redundant_error_packet, conn);
- PACKET_FREE_ALLOCA(redundant_error_packet);
+ MYSQLND_PACKET_OK * redundant_error_packet = conn->protocol->m.get_ok_packet(conn->protocol, FALSE TSRMLS_CC);
+ PACKET_READ(redundant_error_packet, conn);
+ PACKET_FREE(redundant_error_packet);
DBG_INF_FMT("Server is %d, buggy, sends two ERR messages", mysqlnd_get_server_version(conn));
}
}
DBG_RETURN(NULL);
}
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_UNBUFFERED_SETS);
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_UNBUFFERED_SETS);
result = conn->current_result;
conn->current_result = NULL;
DBG_RETURN(NULL);
}
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_BUFFERED_SETS);
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_BUFFERED_SETS);
result = conn->current_result;
conn->current_result = NULL;
{
DBG_ENTER("mysqlnd_conn::get_connection_stats");
DBG_INF_FMT("conn=%llu", conn->thread_id);
- mysqlnd_fill_stats_hash(&(conn->stats), return_value TSRMLS_CC ZEND_FILE_LINE_CC);
+ mysqlnd_fill_stats_hash(conn->stats, mysqlnd_stats_values_names, return_value TSRMLS_CC ZEND_FILE_LINE_CC);
DBG_VOID_RETURN;
}
/* }}} */
MYSQLND_STMT * _mysqlnd_stmt_init(MYSQLND * const conn TSRMLS_DC);
+static void MYSQLND_METHOD(mysqlnd_conn, init)(MYSQLND * conn TSRMLS_DC);
+static
MYSQLND_CLASS_METHODS_START(mysqlnd_conn)
+ MYSQLND_METHOD(mysqlnd_conn, init),
MYSQLND_METHOD(mysqlnd_conn, connect),
MYSQLND_METHOD(mysqlnd_conn, escape_string),
MYSQLND_METHOD_PRIVATE(mysqlnd_conn, set_state),
MYSQLND_METHOD(mysqlnd_conn, simple_command),
- MYSQLND_METHOD(mysqlnd_conn, simple_command_handle_response)
+ MYSQLND_METHOD(mysqlnd_conn, simple_command_handle_response),
+ MYSQLND_METHOD(mysqlnd_conn, restart_psession),
+ MYSQLND_METHOD(mysqlnd_conn, end_psession)
MYSQLND_CLASS_METHODS_END;
+/* {{{ mysqlnd_conn::init */
+static void
+MYSQLND_METHOD(mysqlnd_conn, init)(MYSQLND * conn TSRMLS_DC)
+{
+ DBG_ENTER("mysqlnd_conn::init");
+ conn->net = mysqlnd_net_init(conn->persistent TSRMLS_CC);
+ conn->protocol = mysqlnd_protocol_init(conn->persistent TSRMLS_CC);
+ mysqlnd_stats_init(&conn->stats, STAT_LAST);
+
+ SET_ERROR_AFF_ROWS(conn);
+
+ DBG_VOID_RETURN;
+}
+/* }}} */
+
+
/* {{{ mysqlnd_init */
-PHPAPI MYSQLND *_mysqlnd_init(zend_bool persistent TSRMLS_DC)
+PHPAPI MYSQLND * _mysqlnd_init(zend_bool persistent TSRMLS_DC)
{
size_t alloc_size = sizeof(MYSQLND) + mysqlnd_plugin_count() * sizeof(void *);
MYSQLND *ret = mnd_pecalloc(1, alloc_size, persistent);
DBG_ENTER("mysqlnd_init");
DBG_INF_FMT("persistent=%d", persistent);
- SET_ERROR_AFF_ROWS(ret);
ret->persistent = persistent;
-
ret->m = mysqlnd_conn_methods;
+ CONN_SET_STATE(ret, CONN_ALLOCED);
ret->m->get_reference(ret TSRMLS_CC);
- ret->net = mysqlnd_net_init(persistent TSRMLS_CC);
-
- CONN_SET_STATE(ret, CONN_ALLOCED);
+ ret->m->init(ret TSRMLS_CC);
DBG_RETURN(ret);
}
/* }}} */
+
/* {{{ mysqlnd_library_init */
-void mysqlnd_library_init(TSRMLS_D)
+PHPAPI void mysqlnd_library_init(TSRMLS_D)
{
if (mysqlnd_library_initted == FALSE) {
mysqlnd_library_initted = TRUE;
mysqlnd_conn_methods = &MYSQLND_CLASS_METHOD_TABLE_NAME(mysqlnd_conn);
_mysqlnd_init_ps_subsystem();
/* Should be calloc, as mnd_calloc will reference LOCK_access*/
- mysqlnd_stats_init(&mysqlnd_global_stats);
+ mysqlnd_stats_init(&mysqlnd_global_stats, STAT_LAST);
}
}
/* }}} */
/* Library related */
-void mysqlnd_library_init(TSRMLS_D);
-void mysqlnd_library_end(TSRMLS_D);
+PHPAPI void mysqlnd_library_init(TSRMLS_D);
+PHPAPI void mysqlnd_library_end(TSRMLS_D);
PHPAPI unsigned int mysqlnd_plugin_register();
PHPAPI unsigned int mysqlnd_plugin_count();
PHPAPI void ** _mysqlnd_plugin_get_plugin_stmt_data(const MYSQLND_STMT * stmt, unsigned int plugin_id TSRMLS_DC);
#define mysqlnd_plugin_get_plugin_stmt_data(s, p_id) _mysqlnd_plugin_get_plugin_stmt_data((s), (p_id) TSRMLS_CC)
+PHPAPI void ** _mysqlnd_plugin_get_plugin_protocol_data(const MYSQLND_PROTOCOL * protocol, unsigned int plugin_id TSRMLS_DC);
+#define mysqlnd_plugin_get_plugin_protocol_data(p, p_id) _mysqlnd_plugin_get_plugin_protocol_data((p), (p_id) TSRMLS_CC)
+
PHPAPI struct st_mysqlnd_conn_methods * mysqlnd_conn_get_methods();
PHPAPI void mysqlnd_conn_set_methods(struct st_mysqlnd_conn_methods *methods);
#endif
+PHPAPI void mysqlnd_minfo_print_hash(zval *values);
+
#endif /* MYSQLND_H */
/* {{{ mysqlnd_mempool_create */
-MYSQLND_MEMORY_POOL *
+PHPAPI MYSQLND_MEMORY_POOL *
mysqlnd_mempool_create(size_t arena_size TSRMLS_DC)
{
/* We calloc, because we free(). We don't mnd_calloc() for a reason. */
/* {{{ mysqlnd_mempool_destroy */
-void
+PHPAPI void
mysqlnd_mempool_destroy(MYSQLND_MEMORY_POOL * pool TSRMLS_DC)
{
DBG_ENTER("mysqlnd_mempool_destroy");
#ifndef MYSQLND_BLOCK_ALLOC_H
#define MYSQLND_BLOCK_ALLOC_H
-MYSQLND_MEMORY_POOL * mysqlnd_mempool_create(size_t arena_size TSRMLS_DC);
-void mysqlnd_mempool_destroy(MYSQLND_MEMORY_POOL * pool TSRMLS_DC);
+PHPAPI MYSQLND_MEMORY_POOL * mysqlnd_mempool_create(size_t arena_size TSRMLS_DC);
+PHPAPI void mysqlnd_mempool_destroy(MYSQLND_MEMORY_POOL * pool TSRMLS_DC);
#endif /* MYSQLND_BLOCK_ALLOC_H */
#define MYSQLND_DEBUG_FLUSH 128
#define MYSQLND_DEBUG_TRACE_MEMORY_CALLS 256
-static char * mysqlnd_emalloc_name = "_mysqlnd_emalloc";
-static char * mysqlnd_pemalloc_name = "_mysqlnd_pemalloc";
-static char * mysqlnd_ecalloc_name = "_mysqlnd_ecalloc";
-static char * mysqlnd_pecalloc_name = "_mysqlnd_pecalloc";
-static char * mysqlnd_erealloc_name = "_mysqlnd_erealloc";
-static char * mysqlnd_perealloc_name= "_mysqlnd_perealloc";
-static char * mysqlnd_efree_name = "_mysqlnd_efree";
-static char * mysqlnd_pefree_name = "_mysqlnd_pefree";
-static char * mysqlnd_malloc_name = "_mysqlnd_malloc";
-static char * mysqlnd_calloc_name = "_mysqlnd_calloc";
-static char * mysqlnd_realloc_name = "_mysqlnd_realloc";
-static char * mysqlnd_free_name = "_mysqlnd_free";
+static const char mysqlnd_emalloc_name[] = "_mysqlnd_emalloc";
+static const char mysqlnd_pemalloc_name[] = "_mysqlnd_pemalloc";
+static const char mysqlnd_ecalloc_name[] = "_mysqlnd_ecalloc";
+static const char mysqlnd_pecalloc_name[] = "_mysqlnd_pecalloc";
+static const char mysqlnd_erealloc_name[] = "_mysqlnd_erealloc";
+static const char mysqlnd_perealloc_name[] = "_mysqlnd_perealloc";
+static const char mysqlnd_efree_name[] = "_mysqlnd_efree";
+static const char mysqlnd_pefree_name[] = "_mysqlnd_pefree";
+static const char mysqlnd_malloc_name[] = "_mysqlnd_malloc";
+static const char mysqlnd_calloc_name[] = "_mysqlnd_calloc";
+static const char mysqlnd_realloc_name[] = "_mysqlnd_realloc";
+static const char mysqlnd_free_name[] = "_mysqlnd_free";
+
+const char * mysqlnd_debug_std_no_trace_funcs[] =
+{
+ mysqlnd_emalloc_name,
+ mysqlnd_ecalloc_name,
+ mysqlnd_efree_name,
+ mysqlnd_erealloc_name,
+ mysqlnd_pemalloc_name,
+ mysqlnd_pecalloc_name,
+ mysqlnd_pefree_name,
+ mysqlnd_perealloc_name,
+ mysqlnd_malloc_name,
+ mysqlnd_calloc_name,
+ mysqlnd_realloc_name,
+ mysqlnd_free_name,
+ mysqlnd_read_header_name,
+ mysqlnd_read_body_name,
+ NULL /* must be always last */
+};
/* {{{ mysqlnd_debug::open */
static enum_func_status
static zend_bool
MYSQLND_METHOD(mysqlnd_debug, func_enter)(MYSQLND_DEBUG * self,
unsigned int line, const char * const file,
- char * func_name, unsigned int func_name_len)
+ const char * const func_name, unsigned int func_name_len)
{
if ((self->flags & MYSQLND_DEBUG_DUMP_TRACE) == 0 || self->file_name == NULL) {
return FALSE;
return FALSE;
}
- if ((self->flags & MYSQLND_DEBUG_TRACE_MEMORY_CALLS) == 0 &&
- (func_name == mysqlnd_emalloc_name || func_name == mysqlnd_pemalloc_name ||
- func_name == mysqlnd_ecalloc_name || func_name == mysqlnd_pecalloc_name ||
- func_name == mysqlnd_erealloc_name || func_name == mysqlnd_perealloc_name ||
- func_name == mysqlnd_efree_name || func_name == mysqlnd_pefree_name ||
- func_name == mysqlnd_malloc_name || func_name == mysqlnd_calloc_name ||
- func_name == mysqlnd_realloc_name || func_name == mysqlnd_free_name ||
- func_name == mysqlnd_read_header_name || func_name == mysqlnd_read_body_name)) {
- zend_stack_push(&self->call_stack, "", sizeof(""));
- return FALSE;
+ if ((self->flags & MYSQLND_DEBUG_TRACE_MEMORY_CALLS) == 0 && self->skip_functions) {
+ const char ** p = self->skip_functions;
+ while (*p) {
+ if (*p == func_name) {
+ zend_stack_push(&self->call_stack, "", sizeof(""));
+ return FALSE;
+ }
+ p++;
+ }
}
zend_stack_push(&self->call_stack, func_name, func_name_len + 1);
/* {{{ mysqlnd_debug_init */
-PHPAPI MYSQLND_DEBUG *mysqlnd_debug_init(TSRMLS_D)
+PHPAPI MYSQLND_DEBUG *
+mysqlnd_debug_init(const char * skip_functions[] TSRMLS_DC)
{
MYSQLND_DEBUG *ret = ecalloc(1, sizeof(MYSQLND_DEBUG));
#ifdef ZTS
zend_hash_init(&ret->not_filtered_functions, 0, NULL, NULL, 0);
ret->m = & mysqlnd_mysqlnd_debug_methods;
+ ret->skip_functions = skip_functions;
return ret;
}
/* {{{ _mysqlnd_debug */
-PHPAPI void _mysqlnd_debug(const char *mode TSRMLS_DC)
+PHPAPI void _mysqlnd_debug(const char * mode TSRMLS_DC)
{
#ifdef PHP_DEBUG
MYSQLND_DEBUG *dbg = MYSQLND_G(dbg);
if (!dbg) {
- MYSQLND_G(dbg) = dbg = mysqlnd_debug_init(TSRMLS_C);
+ MYSQLND_G(dbg) = dbg = mysqlnd_debug_init(mysqlnd_debug_std_no_trace_funcs TSRMLS_CC);
if (!dbg) {
return;
}
enum_func_status (*log_va)(MYSQLND_DEBUG *self, unsigned int line, const char * const file,
unsigned int level, const char * type, const char *format, ...);
zend_bool (*func_enter)(MYSQLND_DEBUG *self, unsigned int line, const char * const file,
- char * func_name, unsigned int func_name_len);
+ const char * const func_name, unsigned int func_name_len);
enum_func_status (*func_leave)(MYSQLND_DEBUG *self, unsigned int line, const char * const file);
enum_func_status (*close)(MYSQLND_DEBUG *self);
enum_func_status (*free_handle)(MYSQLND_DEBUG *self);
zend_stack call_stack;
HashTable not_filtered_functions;
struct st_mysqlnd_debug_methods *m;
+ const char ** skip_functions;
};
+PHPAPI extern const char * mysqlnd_debug_std_no_trace_funcs[];
-PHPAPI MYSQLND_DEBUG *mysqlnd_debug_init(TSRMLS_D);
+PHPAPI MYSQLND_DEBUG * mysqlnd_debug_init(const char * skip_functions[] TSRMLS_DC);
#define MYSQLND_MEM_D TSRMLS_DC ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC
-void * _mysqlnd_emalloc(size_t size MYSQLND_MEM_D);
-void * _mysqlnd_pemalloc(size_t size, zend_bool persistent MYSQLND_MEM_D);
-void * _mysqlnd_ecalloc(unsigned int nmemb, size_t size MYSQLND_MEM_D);
-void * _mysqlnd_pecalloc(unsigned int nmemb, size_t size, zend_bool persistent MYSQLND_MEM_D);
-void * _mysqlnd_erealloc(void *ptr, size_t new_size MYSQLND_MEM_D);
-void * _mysqlnd_perealloc(void *ptr, size_t new_size, zend_bool persistent MYSQLND_MEM_D);
-void _mysqlnd_efree(void *ptr MYSQLND_MEM_D);
-void _mysqlnd_pefree(void *ptr, zend_bool persistent MYSQLND_MEM_D);
-void * _mysqlnd_malloc(size_t size MYSQLND_MEM_D);
-void * _mysqlnd_calloc(unsigned int nmemb, size_t size MYSQLND_MEM_D);
-void * _mysqlnd_realloc(void *ptr, size_t new_size MYSQLND_MEM_D);
-void _mysqlnd_free(void *ptr MYSQLND_MEM_D);
+PHPAPI void * _mysqlnd_emalloc(size_t size MYSQLND_MEM_D);
+PHPAPI void * _mysqlnd_pemalloc(size_t size, zend_bool persistent MYSQLND_MEM_D);
+PHPAPI void * _mysqlnd_ecalloc(unsigned int nmemb, size_t size MYSQLND_MEM_D);
+PHPAPI void * _mysqlnd_pecalloc(unsigned int nmemb, size_t size, zend_bool persistent MYSQLND_MEM_D);
+PHPAPI void * _mysqlnd_erealloc(void *ptr, size_t new_size MYSQLND_MEM_D);
+PHPAPI void * _mysqlnd_perealloc(void *ptr, size_t new_size, zend_bool persistent MYSQLND_MEM_D);
+PHPAPI void _mysqlnd_efree(void *ptr MYSQLND_MEM_D);
+PHPAPI void _mysqlnd_pefree(void *ptr, zend_bool persistent MYSQLND_MEM_D);
+PHPAPI void * _mysqlnd_malloc(size_t size MYSQLND_MEM_D);
+PHPAPI void * _mysqlnd_calloc(unsigned int nmemb, size_t size MYSQLND_MEM_D);
+PHPAPI void * _mysqlnd_realloc(void *ptr, size_t new_size MYSQLND_MEM_D);
+PHPAPI void _mysqlnd_free(void *ptr MYSQLND_MEM_D);
-char * mysqlnd_get_backtrace(TSRMLS_D);
+PHPAPI char * mysqlnd_get_backtrace(TSRMLS_D);
+
+#if defined(__GNUC__)
+#define DBG_INF_EX(dbg_obj, msg) do { if (dbg_skip_trace == FALSE) (dbg_obj)->m->log((dbg_obj), __LINE__, __FILE__, -1, "info : ", (msg)); } while (0)
+#define DBG_ERR_EX(dbg_obj, msg) do { if (dbg_skip_trace == FALSE) (dbg_obj)->m->log((dbg_obj), __LINE__, __FILE__, -1, "error: ", (msg)); } while (0)
+#define DBG_INF_FMT_EX(dbg_obj, ...) do { if (dbg_skip_trace == FALSE) (dbg_obj)->m->log_va((dbg_obj), __LINE__, __FILE__, -1, "info : ", __VA_ARGS__); } while (0)
+#define DBG_ERR_FMT_EX(dbg_obj, ...) do { if (dbg_skip_trace == FALSE) (dbg_obj)->m->log_va((dbg_obj), __LINE__, __FILE__, -1, "error: ", __VA_ARGS__); } while (0)
+
+#define DBG_ENTER_EX(dbg_obj, func_name) zend_bool dbg_skip_trace = TRUE; if ((dbg_obj)) dbg_skip_trace = !(dbg_obj)->m->func_enter((dbg_obj), __LINE__, __FILE__, func_name, strlen(func_name));
+#define DBG_RETURN_EX(dbg_obj, value) do { if ((dbg_obj)) (dbg_obj)->m->func_leave((dbg_obj), __LINE__, __FILE__); return (value); } while (0)
+#define DBG_VOID_RETURN_EX(dbg_obj) do { if ((dbg_obj)) (dbg_obj)->m->func_leave((dbg_obj), __LINE__, __FILE__); return; } while (0)
+
+#else
+static inline void DBG_INF_EX(MYSQLND_DEBUG * dbg_obj, const char * const msg) {}
+static inline void DBG_ERR_EX(MYSQLND_DEBUG * dbg_obj, const char * const msg) {}
+static inline void DBG_INF_FMT_EX(MYSQLND_DEBUG * dbg_obj, ...) {}
+static inline void DBG_ERR_FMT_EX(MYSQLND_DEBUG * dbg_obj, ...) {}
+static inline void DBG_ENTER_EX(MYSQLND_DEBUG * dbg_obj, const char * const func_name) {}
+#define DBG_RETURN_EX(dbg_obj, value) return (value)
+#define DBG_VOID_RETURN_EX(dbg_obj) return
+
+#endif
#if MYSQLND_DBG_ENABLED == 1
-#define DBG_INF(msg) do { if (dbg_skip_trace == FALSE) MYSQLND_G(dbg)->m->log(MYSQLND_G(dbg), __LINE__, __FILE__, -1, "info : ", (msg)); } while (0)
-#define DBG_ERR(msg) do { if (dbg_skip_trace == FALSE) MYSQLND_G(dbg)->m->log(MYSQLND_G(dbg), __LINE__, __FILE__, -1, "error: ", (msg)); } while (0)
-#define DBG_INF_FMT(...) do { if (dbg_skip_trace == FALSE) MYSQLND_G(dbg)->m->log_va(MYSQLND_G(dbg), __LINE__, __FILE__, -1, "info : ", __VA_ARGS__); } while (0)
-#define DBG_ERR_FMT(...) do { if (dbg_skip_trace == FALSE) MYSQLND_G(dbg)->m->log_va(MYSQLND_G(dbg), __LINE__, __FILE__, -1, "error: ", __VA_ARGS__); } while (0)
+#define DBG_INF(msg) DBG_INF_EX(MYSQLND_G(dbg), (msg))
+#define DBG_ERR(msg) DBG_ERR_EX(MYSQLND_G(dbg), (msg))
+#define DBG_INF_FMT(...) DBG_INF_FMT_EX(MYSQLND_G(dbg), __VA_ARGS__)
+#define DBG_ERR_FMT(...) DBG_ERR_FMT_EX(MYSQLND_G(dbg), __VA_ARGS__)
-#define DBG_ENTER(func_name) zend_bool dbg_skip_trace = TRUE; if (MYSQLND_G(dbg)) dbg_skip_trace = !MYSQLND_G(dbg)->m->func_enter(MYSQLND_G(dbg), __LINE__, __FILE__, func_name, strlen(func_name));
-#define DBG_RETURN(value) do { if (MYSQLND_G(dbg)) MYSQLND_G(dbg)->m->func_leave(MYSQLND_G(dbg), __LINE__, __FILE__); return (value); } while (0)
-#define DBG_VOID_RETURN do { if (MYSQLND_G(dbg)) MYSQLND_G(dbg)->m->func_leave(MYSQLND_G(dbg), __LINE__, __FILE__); return; } while (0)
+#define DBG_ENTER(func_name) DBG_ENTER_EX(MYSQLND_G(dbg), (func_name))
+#define DBG_RETURN(value) DBG_RETURN_EX(MYSQLND_G(dbg), (value))
+#define DBG_VOID_RETURN DBG_VOID_RETURN_EX(MYSQLND_G(dbg))
#elif MYSQLND_DBG_ENABLED == 0
+
static inline void DBG_INF(const char * const msg) {}
static inline void DBG_ERR(const char * const msg) {}
static inline void DBG_INF_FMT(const char * const format, ...) {}
static inline void DBG_ENTER(const char * const func_name) {}
#define DBG_RETURN(value) return (value)
#define DBG_VOID_RETURN return
+
#endif
/* Enums */
-enum php_mysql_packet_type
+enum mysqlnd_packet_type
{
PROT_GREET_PACKET= 0,
PROT_AUTH_PACKET,
PROT_ROW_PACKET,
PROT_STATS_PACKET,
PROT_PREPARE_RESP_PACKET,
- PROT_CHG_USER_PACKET,
+ PROT_CHG_USER_RESP_PACKET,
PROT_LAST, /* should always be last */
};
buffer += ret;
to_read -= ret;
}
- MYSQLND_INC_CONN_STATISTIC_W_VALUE(&conn->stats, STAT_BYTES_RECEIVED, count);
+ MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn->stats, STAT_BYTES_RECEIVED, count);
conn->net->stream->chunk_size = old_chunk_size;
DBG_RETURN(PASS);
}
SET_CLIENT_ERROR(conn->error_info, CR_SERVER_GONE_ERROR, UNKNOWN_SQLSTATE, mysqlnd_server_gone);
}
- MYSQLND_INC_CONN_STATISTIC_W_VALUE3(&conn->stats,
+ MYSQLND_INC_CONN_STATISTIC_W_VALUE3(conn->stats,
STAT_BYTES_SENT, count + packets_sent * MYSQLND_HEADER_SIZE,
STAT_PROTOCOL_OVERHEAD_OUT, packets_sent * MYSQLND_HEADER_SIZE,
STAT_PACKETS_SENT, packets_sent);
/* {{{ mysqlnd_net::receive */
-static enum_func_status
+static size_t
MYSQLND_METHOD(mysqlnd_net, receive)(MYSQLND * conn, zend_uchar * buffer, size_t count TSRMLS_DC)
{
size_t to_read = count;
/* {{{ mysqlnd_net_init */
-MYSQLND_NET *
+PHPAPI MYSQLND_NET *
mysqlnd_net_init(zend_bool persistent TSRMLS_DC)
{
- MYSQLND_NET * net = mnd_pecalloc(1, sizeof(MYSQLND_NET), persistent);
+ size_t alloc_size = sizeof(MYSQLND_NET) + mysqlnd_plugin_count() * sizeof(void *);
+ MYSQLND_NET * net = mnd_pecalloc(1, alloc_size, persistent);
DBG_ENTER("mysqlnd_net_init");
DBG_INF_FMT("persistent=%d", persistent);
/* }}} */
-/* {{{ mysqlnd_net_init */
-void
-mysqlnd_net_free(MYSQLND_NET * net TSRMLS_DC)
+/* {{{ mysqlnd_net_free */
+PHPAPI void
+mysqlnd_net_free(MYSQLND_NET * const net TSRMLS_DC)
{
zend_bool pers = net->persistent;
/* }}} */
+/* {{{ _mysqlnd_plugin_get_plugin_net_data */
+PHPAPI void ** _mysqlnd_plugin_get_plugin_net_data(const MYSQLND_NET * net, unsigned int plugin_id TSRMLS_DC)
+{
+ DBG_ENTER("_mysqlnd_plugin_get_plugin_net_data");
+ DBG_INF_FMT("plugin_id=%u", plugin_id);
+ if (!net || plugin_id >= mysqlnd_plugin_count()) {
+ return NULL;
+ }
+ DBG_RETURN((void *)((char *)net + sizeof(MYSQLND_NET) + plugin_id * sizeof(void *)));
+}
+/* }}} */
+
+
+
/*
* Local variables:
* tab-width: 4
#ifndef MYSQLND_NET_H
#define MYSQLND_NET_H
-MYSQLND_NET * mysqlnd_net_init(zend_bool persistent TSRMLS_DC);
-void mysqlnd_net_free(MYSQLND_NET * net TSRMLS_DC);
+PHPAPI MYSQLND_NET * mysqlnd_net_init(zend_bool persistent TSRMLS_DC);
+PHPAPI void mysqlnd_net_free(MYSQLND_NET * const net TSRMLS_DC);
#endif /* MYSQLND_NET_H */
(((uint32_t) ((zend_uchar) (A)[2])) << 16) +\
(((uint32_t) ((zend_uchar) (A)[3])) << 24))
-
-#define bit_uint8korr(A) ((uint64_t)(((uint32_t) (((zend_uchar*) (A))[7])) +\
- (((uint32_t) (((zend_uchar*) (A))[6])) << 8) +\
- (((uint32_t) (((zend_uchar*) (A))[5])) << 16) +\
- (((uint32_t) (((zend_uchar*) (A))[4])) << 24)) +\
- (((uint64_t) (((uint32_t) (((zend_uchar*) (A))[3])) +\
- (((uint32_t) (((zend_uchar*) (A))[2])) << 8) +\
- (((uint32_t) (((zend_uchar*) (A))[1])) << 16) +\
- (((uint32_t) (((zend_uchar*) (A))[0])) << 24))) << 32))
-
#define uint8korr(A) ((uint64_t)(((uint32_t) ((zend_uchar) (A)[0])) +\
(((uint32_t) ((zend_uchar) (A)[1])) << 8) +\
(((uint32_t) ((zend_uchar) (A)[2])) << 16) +\
extern struct st_mysqlnd_perm_bind mysqlnd_ps_fetch_functions[MYSQL_TYPE_LAST + 1];
-extern const char * const mysqlnd_old_passwd;
-extern const char * const mysqlnd_out_of_sync;
-extern const char * const mysqlnd_server_gone;
+PHPAPI extern const char * const mysqlnd_old_passwd;
+PHPAPI extern const char * const mysqlnd_out_of_sync;
+PHPAPI extern const char * const mysqlnd_server_gone;
enum_func_status mysqlnd_handle_local_infile(MYSQLND *conn, const char *filename, zend_bool *is_warning TSRMLS_DC);
SET_EMPTY_ERROR(stmt->error_info);
SET_EMPTY_ERROR(stmt->conn->error_info);
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_PS_BUFFERED_SETS);
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_PS_BUFFERED_SETS);
result = stmt->result;
result->type = MYSQLND_RES_PS_BUF;
SET_EMPTY_ERROR(stmt->error_info);
SET_EMPTY_ERROR(stmt->conn->error_info);
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_BUFFERED_SETS);
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_BUFFERED_SETS);
result = mysqlnd_result_init(stmt->result->field_count TSRMLS_CC);
/* Follows parameter metadata, we have just to skip it, as libmysql does */
unsigned int i = 0;
enum_func_status ret = PASS;
- php_mysql_packet_res_field field_packet;
+ MYSQLND_PACKET_RES_FIELD * field_packet;
DBG_ENTER("mysqlnd_stmt_skip_metadata");
DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
- PACKET_INIT_ALLOCA(field_packet, PROT_RSET_FLD_PACKET);
- field_packet.skip_parsing = TRUE;
+ field_packet = stmt->conn->protocol->m.get_result_field_packet(stmt->conn->protocol, FALSE TSRMLS_CC);
+ field_packet->skip_parsing = TRUE;
for (;i < stmt->param_count; i++) {
- if (FAIL == PACKET_READ_ALLOCA(field_packet, stmt->conn)) {
+ if (FAIL == PACKET_READ(field_packet, stmt->conn)) {
ret = FAIL;
break;
}
}
- PACKET_FREE_ALLOCA(field_packet);
+ PACKET_FREE(field_packet);
DBG_RETURN(ret);
}
static enum_func_status
mysqlnd_stmt_read_prepare_response(MYSQLND_STMT *stmt TSRMLS_DC)
{
- php_mysql_packet_prepare_response prepare_resp;
+ MYSQLND_PACKET_PREPARE_RESPONSE * prepare_resp;
enum_func_status ret = PASS;
DBG_ENTER("mysqlnd_stmt_read_prepare_response");
DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
- PACKET_INIT_ALLOCA(prepare_resp, PROT_PREPARE_RESP_PACKET);
- if (FAIL == PACKET_READ_ALLOCA(prepare_resp, stmt->conn)) {
+ prepare_resp = stmt->conn->protocol->m.get_prepare_response_packet(stmt->conn->protocol, FALSE TSRMLS_CC);
+ if (FAIL == PACKET_READ(prepare_resp, stmt->conn)) {
ret = FAIL;
goto done;
}
- if (0xFF == prepare_resp.error_code) {
- stmt->error_info = stmt->conn->error_info = prepare_resp.error_info;
+ if (0xFF == prepare_resp->error_code) {
+ stmt->error_info = stmt->conn->error_info = prepare_resp->error_info;
ret = FAIL;
goto done;
}
- stmt->stmt_id = prepare_resp.stmt_id;
- stmt->warning_count = stmt->conn->upsert_status.warning_count = prepare_resp.warning_count;
- stmt->field_count = stmt->conn->field_count = prepare_resp.field_count;
- stmt->param_count = prepare_resp.param_count;
- PACKET_FREE_ALLOCA(prepare_resp);
-
+ stmt->stmt_id = prepare_resp->stmt_id;
+ stmt->warning_count = stmt->conn->upsert_status.warning_count = prepare_resp->warning_count;
+ stmt->field_count = stmt->conn->field_count = prepare_resp->field_count;
+ stmt->param_count = prepare_resp->param_count;
done:
+ PACKET_FREE(prepare_resp);
+
DBG_RETURN(ret);
}
/* }}} */
static enum_func_status
mysqlnd_stmt_prepare_read_eof(MYSQLND_STMT *stmt TSRMLS_DC)
{
- php_mysql_packet_eof fields_eof;
+ MYSQLND_PACKET_EOF * fields_eof;
enum_func_status ret;
DBG_ENTER("mysqlnd_stmt_prepare_read_eof");
DBG_INF_FMT("stmt=%lu", stmt->stmt_id);
- PACKET_INIT_ALLOCA(fields_eof, PROT_EOF_PACKET);
- if (FAIL == (ret = PACKET_READ_ALLOCA(fields_eof, stmt->conn))) {
+ fields_eof = stmt->conn->protocol->m.get_eof_packet(stmt->conn->protocol, FALSE TSRMLS_CC);
+ if (FAIL == (ret = PACKET_READ(fields_eof, stmt->conn))) {
if (stmt->result) {
stmt->result->m.free_result_contents(stmt->result TSRMLS_CC);
mnd_efree(stmt->result);
stmt->state = MYSQLND_STMT_INITTED;
}
} else {
- stmt->upsert_status.server_status = fields_eof.server_status;
- stmt->upsert_status.warning_count = fields_eof.warning_count;
+ stmt->upsert_status.server_status = fields_eof->server_status;
+ stmt->upsert_status.warning_count = fields_eof->warning_count;
stmt->state = MYSQLND_STMT_PREPARED;
}
- PACKET_FREE_ALLOCA(fields_eof);
+ PACKET_FREE(fields_eof);
DBG_RETURN(ret);
}
ret = mysqlnd_stmt_execute_parse_response(stmt TSRMLS_CC);
if (ret == PASS && conn->last_query_type == QUERY_UPSERT && stmt->upsert_status.affected_rows) {
- MYSQLND_INC_CONN_STATISTIC_W_VALUE(&conn->stats, STAT_ROWS_AFFECTED_PS, stmt->upsert_status.affected_rows);
+ MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn->stats, STAT_ROWS_AFFECTED_PS, stmt->upsert_status.affected_rows);
}
DBG_RETURN(ret);
}
result->stored_data->persistent,
result->conn->options.numeric_and_datetime_as_unicode,
result->conn->options.int_and_float_native,
- &result->conn->stats TSRMLS_CC);
+ result->conn->stats TSRMLS_CC);
if (stmt->update_max_length) {
for (i = 0; i < result->field_count; i++) {
/*
{
enum_func_status ret;
MYSQLND_STMT *stmt = (MYSQLND_STMT *) param;
- php_mysql_packet_row *row_packet = result->row_packet;
+ MYSQLND_PACKET_ROW *row_packet = result->row_packet;
DBG_ENTER("mysqlnd_stmt_fetch_row_unbuffered");
FALSE,
result->conn->options.numeric_and_datetime_as_unicode,
result->conn->options.int_and_float_native,
- &result->conn->stats TSRMLS_CC);
+ result->conn->stats TSRMLS_CC);
for (i = 0; i < field_count; i++) {
if (stmt->result_bind[i].bound == TRUE) {
result->meta->fields[i].max_length = Z_STRLEN_P(data);
}
stmt->result_bind[i].zv->value = data->value;
- // copied data, thus also the ownership. Thus null data
+ /* copied data, thus also the ownership. Thus null data */
ZVAL_NULL(data);
}
}
}
- MYSQLND_INC_CONN_STATISTIC(&stmt->conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_PS_UNBUF);
+ MYSQLND_INC_CONN_STATISTIC(stmt->conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_PS_UNBUF);
} else {
DBG_INF("skipping extraction");
/*
SET_EMPTY_ERROR(stmt->error_info);
- MYSQLND_INC_CONN_STATISTIC(&stmt->conn->stats, STAT_PS_UNBUFFERED_SETS);
+ MYSQLND_INC_CONN_STATISTIC(stmt->conn->stats, STAT_PS_UNBUFFERED_SETS);
result = stmt->result;
DBG_INF_FMT("%scursor exists", stmt->cursor_exists? "":"no ");
enum_func_status ret;
MYSQLND_STMT *stmt = (MYSQLND_STMT *) param;
zend_uchar buf[STMT_ID_LENGTH /* statement id */ + 4 /* number of rows to fetch */];
- php_mysql_packet_row *row_packet = result->row_packet;
+ MYSQLND_PACKET_ROW *row_packet = result->row_packet;
DBG_ENTER("mysqlnd_fetch_stmt_row_cursor");
FALSE,
result->conn->options.numeric_and_datetime_as_unicode,
result->conn->options.int_and_float_native,
- &result->conn->stats TSRMLS_CC);
+ result->conn->stats TSRMLS_CC);
/* If no result bind, do nothing. We consumed the data */
for (i = 0; i < field_count; i++) {
result->meta->fields[i].max_length = Z_STRLEN_P(data);
}
stmt->result_bind[i].zv->value = data->value;
- // copied data, thus also the ownership. Thus null data
+ /* copied data, thus also the ownership. Thus null data */
ZVAL_NULL(data);
}
}
row_packet->row_buffer->free_chunk(row_packet->row_buffer, TRUE TSRMLS_CC);
row_packet->row_buffer = NULL;
}
- MYSQLND_INC_CONN_STATISTIC(&stmt->conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_PS_CURSOR);
+ MYSQLND_INC_CONN_STATISTIC(stmt->conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_PS_CURSOR);
} else {
*fetched_anything = FALSE;
break;
}
if (stat != STAT_LAST) {
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, stat);
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, stat);
}
if (stmt->execute_cmd_buffer.buffer) {
result->stored_data->persistent,
result->conn->options.numeric_and_datetime_as_unicode,
result->conn->options.int_and_float_native,
- &result->conn->stats TSRMLS_CC);
+ result->conn->stats TSRMLS_CC);
for (i = 0; i < result->field_count; i++) {
/*
NULL fields are 0 length, 0 is not more than 0
if (unbuf->last_row_data) {
unsigned int i, ctor_called_count = 0;
zend_bool copy_ctor_called;
- MYSQLND_STATS *global_stats = result->conn? &result->conn->stats:NULL;
+ MYSQLND_STATS *global_stats = result->conn? result->conn->stats:NULL;
DBG_INF_FMT("%u columns to free", result->field_count);
for (i = 0; i < result->field_count; i++) {
mysqlnd_query_read_result_set_header(MYSQLND *conn, MYSQLND_STMT *stmt TSRMLS_DC)
{
enum_func_status ret;
- php_mysql_packet_rset_header rset_header;
+ MYSQLND_PACKET_RSET_HEADER * rset_header;
DBG_ENTER("mysqlnd_query_read_result_set_header");
DBG_INF_FMT("stmt=%d", stmt? stmt->stmt_id:0);
ret = FAIL;
- PACKET_INIT_ALLOCA(rset_header, PROT_RSET_HEADER_PACKET);
+ rset_header = conn->protocol->m.get_rset_header_packet(conn->protocol, FALSE TSRMLS_CC);
do {
SET_ERROR_AFF_ROWS(conn);
- if (FAIL == (ret = PACKET_READ_ALLOCA(rset_header, conn))) {
+ if (FAIL == (ret = PACKET_READ(rset_header, conn))) {
php_error_docref(NULL TSRMLS_CC, 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
*/
- conn->error_info = rset_header.error_info;
+ conn->error_info = rset_header->error_info;
ret = FAIL;
/* Return back from CONN_QUERY_SENT */
CONN_SET_STATE(conn, CONN_READY);
}
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_SET_STATE(conn, CONN_SENDING_LOAD_DATA);
- ret = mysqlnd_handle_local_infile(conn, rset_header.info_or_local_file, &is_warning TSRMLS_CC);
+ ret = mysqlnd_handle_local_infile(conn, rset_header->info_or_local_file, &is_warning TSRMLS_CC);
CONN_SET_STATE(conn, (ret == PASS || is_warning == TRUE)? CONN_READY:CONN_QUIT_SENT);
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_NON_RSET_QUERY);
+ 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->upsert_status.warning_count = rset_header.warning_count;
- conn->upsert_status.server_status = rset_header.server_status;
- conn->upsert_status.affected_rows = rset_header.affected_rows;
- conn->upsert_status.last_insert_id = rset_header.last_insert_id;
+ conn->field_count = rset_header->field_count;
+ conn->upsert_status.warning_count = rset_header->warning_count;
+ conn->upsert_status.server_status = rset_header->server_status;
+ conn->upsert_status.affected_rows = rset_header->affected_rows;
+ conn->upsert_status.last_insert_id = rset_header->last_insert_id;
SET_NEW_MESSAGE(conn->last_message, conn->last_message_len,
- rset_header.info_or_local_file, rset_header.info_or_local_file_len,
+ rset_header->info_or_local_file, rset_header->info_or_local_file_len,
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_READY);
}
ret = PASS;
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_NON_RSET_QUERY);
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_NON_RSET_QUERY);
break;
default:{ /* Result set */
- php_mysql_packet_eof fields_eof;
+ MYSQLND_PACKET_EOF * fields_eof;
MYSQLND_RES *result;
enum_mysqlnd_collected_stats stat = STAT_LAST;
DBG_INF("Result set pending");
SET_EMPTY_MESSAGE(conn->last_message, conn->last_message_len, conn->persistent);
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_RSET_QUERY);
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_RSET_QUERY);
memset(&conn->upsert_status, 0, sizeof(conn->upsert_status));
/* restore after zeroing */
SET_ERROR_AFF_ROWS(conn);
conn->last_query_type = QUERY_SELECT;
CONN_SET_STATE(conn, 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 = mysqlnd_result_init(rset_header.field_count TSRMLS_CC);
+ result = conn->current_result = mysqlnd_result_init(rset_header->field_count TSRMLS_CC);
} 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 = mysqlnd_result_init(rset_header.field_count TSRMLS_CC);
+ result = stmt->result = mysqlnd_result_init(rset_header->field_count TSRMLS_CC);
} else {
/*
Update result set metadata if it for some reason changed between
}
/* Check for SERVER_STATUS_MORE_RESULTS if needed */
- PACKET_INIT_ALLOCA(fields_eof, PROT_EOF_PACKET);
- if (FAIL == (ret = PACKET_READ_ALLOCA(fields_eof, conn))) {
+ fields_eof = conn->protocol->m.get_eof_packet(conn->protocol, FALSE TSRMLS_CC);
+ if (FAIL == (ret = PACKET_READ(fields_eof, conn))) {
DBG_ERR("Error ocurred while reading the EOF packet");
result->m.free_result_contents(result TSRMLS_CC);
mnd_efree(result);
}
} else {
unsigned int to_log = MYSQLND_G(log_mask);
- to_log &= fields_eof.server_status;
- DBG_INF_FMT("warnings=%u server_status=%u", fields_eof.warning_count, fields_eof.server_status);
- conn->upsert_status.warning_count = fields_eof.warning_count;
+ to_log &= fields_eof->server_status;
+ DBG_INF_FMT("warnings=%u server_status=%u", fields_eof->warning_count, fields_eof->server_status);
+ conn->upsert_status.warning_count = 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).
*/
- conn->upsert_status.server_status = fields_eof.server_status;
- if (fields_eof.server_status & SERVER_QUERY_NO_GOOD_INDEX_USED) {
+ conn->upsert_status.server_status = fields_eof->server_status;
+ if (fields_eof->server_status & SERVER_QUERY_NO_GOOD_INDEX_USED) {
stat = 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) {
stat = STAT_NO_INDEX_USED;
- } else if (fields_eof.server_status & SERVER_QUERY_WAS_SLOW) {
+ } else if (fields_eof->server_status & SERVER_QUERY_WAS_SLOW) {
stat = STAT_QUERY_WAS_SLOW;
}
if (to_log) {
efree(backtrace);
#endif
}
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, stat);
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, stat);
}
- PACKET_FREE_ALLOCA(fields_eof);
+ PACKET_FREE(fields_eof);
break;
}
}
} while (0);
- PACKET_FREE_ALLOCA(rset_header);
+ PACKET_FREE(rset_header);
DBG_INF(ret == PASS? "PASS":"FAIL");
DBG_RETURN(ret);
MYSQLND_ROW_C retrow = NULL;
unsigned int i,
field_count = result->field_count;
- php_mysql_packet_row *row_packet = result->row_packet;
+ MYSQLND_PACKET_ROW *row_packet = result->row_packet;
unsigned long *lengths = result->lengths;
DBG_ENTER("mysqlnd_fetch_row_unbuffered_c");
row_packet->fields = NULL;
row_packet->row_buffer = NULL;
- MYSQLND_INC_CONN_STATISTIC(&result->conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_NORMAL_UNBUF);
+ MYSQLND_INC_CONN_STATISTIC(result->conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_NORMAL_UNBUF);
if (!row_packet->skip_extraction) {
MYSQLND_FIELD *field = result->meta->fields;
FALSE,
result->conn->options.numeric_and_datetime_as_unicode,
result->conn->options.int_and_float_native,
- &result->conn->stats TSRMLS_CC);
+ result->conn->stats TSRMLS_CC);
retrow = mnd_malloc(result->field_count * sizeof(char *));
{
enum_func_status ret;
zval *row = (zval *) param;
- php_mysql_packet_row *row_packet = result->row_packet;
+ MYSQLND_PACKET_ROW *row_packet = result->row_packet;
DBG_ENTER("mysqlnd_fetch_row_unbuffered");
DBG_INF_FMT("flags=%d", flags);
row_packet->row_buffer = NULL;
- MYSQLND_INC_CONN_STATISTIC(&result->conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_NORMAL_UNBUF);
+ MYSQLND_INC_CONN_STATISTIC(result->conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_NORMAL_UNBUF);
if (!row_packet->skip_extraction) {
HashTable *row_ht = Z_ARRVAL_P(row);
FALSE,
result->conn->options.numeric_and_datetime_as_unicode,
result->conn->options.int_and_float_native,
- &result->conn->stats TSRMLS_CC);
+ result->conn->stats TSRMLS_CC);
for (i = 0; i < field_count; i++, field++, zend_hash_key++) {
zval *data = result->unbuf->last_row_data[i];
this to be not NULL.
*/
/* FALSE = non-persistent */
- PACKET_INIT(result->row_packet, PROT_ROW_PACKET, php_mysql_packet_row *, FALSE);
+ result->row_packet = result->conn->protocol->m.get_row_packet(result->conn->protocol, FALSE TSRMLS_CC);
result->row_packet->result_set_memory_pool = result->result_set_memory_pool;
result->row_packet->field_count = result->field_count;
result->row_packet->binary_protocol = ps;
FALSE,
result->conn->options.numeric_and_datetime_as_unicode,
result->conn->options.int_and_float_native,
- &result->conn->stats TSRMLS_CC);
+ result->conn->stats TSRMLS_CC);
for (i = 0; i < result->field_count; i++) {
/*
NULL fields are 0 length, 0 is not more than 0
result->stored_data->persistent,
result->conn->options.numeric_and_datetime_as_unicode,
result->conn->options.int_and_float_native,
- &result->conn->stats TSRMLS_CC);
+ result->conn->stats TSRMLS_CC);
for (i = 0; i < result->field_count; i++) {
/*
NULL fields are 0 length, 0 is not more than 0
zend_bool to_cache TSRMLS_DC)
{
enum_func_status ret;
- php_mysql_packet_row *row_packet;
+ MYSQLND_PACKET_ROW *row_packet;
unsigned int next_extend = STORE_RESULT_PREALLOCATED_SET_IF_NOT_EMPTY, free_rows = 1;
MYSQLND_RES_BUFFERED *set;
php_mysqlnd_rowp_read_text_protocol;
/* non-persistent */
- PACKET_INIT(row_packet, PROT_ROW_PACKET, php_mysql_packet_row *, FALSE);
+ row_packet = conn->protocol->m.get_row_packet(conn->protocol, FALSE TSRMLS_CC);
row_packet->result_set_memory_pool = result->result_set_memory_pool;
row_packet->field_count = meta->field_count;
row_packet->binary_protocol = binary_protocol;
memset(set->data, 0, set->row_count * meta->field_count * sizeof(zval *));
}
- MYSQLND_INC_CONN_STATISTIC_W_VALUE(&conn->stats,
+ MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn->stats,
binary_protocol? STAT_ROWS_BUFFERED_FROM_CLIENT_PS:
STAT_ROWS_BUFFERED_FROM_CLIENT_NORMAL,
set->row_count);
{
DBG_INF("skipping result");
/* We have to fetch all data to clean the line */
- MYSQLND_INC_CONN_STATISTIC(&result->conn->stats,
+ MYSQLND_INC_CONN_STATISTIC(result->conn->stats,
result->type == MYSQLND_RES_NORMAL? STAT_FLUSHED_NORMAL_SETS:
STAT_FLUSHED_PS_SETS);
DBG_INF_FMT("implicit=%d", implicit);
result->m.skip_result(result TSRMLS_CC);
- MYSQLND_INC_CONN_STATISTIC(result->conn? &result->conn->stats : NULL,
+ MYSQLND_INC_CONN_STATISTIC(result->conn? result->conn->stats : NULL,
implicit == TRUE? STAT_FREE_RESULT_IMPLICIT:
STAT_FREE_RESULT_EXPLICIT);
/* {{{ mysqlnd_result_init */
-MYSQLND_RES *mysqlnd_result_init(unsigned int field_count TSRMLS_DC)
+PHPAPI MYSQLND_RES *
+mysqlnd_result_init(unsigned int field_count TSRMLS_DC)
{
size_t alloc_size = sizeof(MYSQLND_RES) + mysqlnd_plugin_count() * sizeof(void *);
MYSQLND_RES *ret = mnd_ecalloc(1, alloc_size);
#ifndef MYSQLND_RESULT_H
#define MYSQLND_RESULT_H
-MYSQLND_RES *mysqlnd_result_init(unsigned int field_count TSRMLS_DC);
+PHPAPI MYSQLND_RES * mysqlnd_result_init(unsigned int field_count TSRMLS_DC);
enum_func_status mysqlnd_query_read_result_set_header(MYSQLND *conn, MYSQLND_STMT *stmt TSRMLS_DC);
MYSQLND *conn TSRMLS_DC)
{
unsigned int i = 0;
- php_mysql_packet_res_field field_packet;
+ MYSQLND_PACKET_RES_FIELD * field_packet;
#if PHP_MAJOR_VERSION >= 6
UChar *ustr;
int ulen;
DBG_ENTER("mysqlnd_res_meta::read_metadata");
- PACKET_INIT_ALLOCA(field_packet, PROT_RSET_FLD_PACKET);
+ field_packet = conn->protocol->m.get_result_field_packet(conn->protocol, FALSE TSRMLS_CC);
for (;i < meta->field_count; i++) {
long idx;
meta->fields[i].root = NULL;
}
- field_packet.metadata = &(meta->fields[i]);
- if (FAIL == PACKET_READ_ALLOCA(field_packet, conn)) {
- PACKET_FREE_ALLOCA(field_packet);
+ field_packet->metadata = &(meta->fields[i]);
+ if (FAIL == PACKET_READ(field_packet, conn)) {
+ PACKET_FREE(field_packet);
DBG_RETURN(FAIL);
}
- if (field_packet.error_info.error_no) {
- conn->error_info = field_packet.error_info;
+ if (field_packet->error_info.error_no) {
+ conn->error_info = field_packet->error_info;
/* Return back from CONN_QUERY_SENT */
- PACKET_FREE_ALLOCA(field_packet);
+ PACKET_FREE(field_packet);
DBG_RETURN(FAIL);
}
- if (field_packet.stupid_list_fields_eof == TRUE) {
+ if (field_packet->stupid_list_fields_eof == TRUE) {
meta->field_count = i;
break;
}
"Unknown type %d sent by the server. "
"Please send a report to the developers",
meta->fields[i].type);
- PACKET_FREE_ALLOCA(field_packet);
+ PACKET_FREE(field_packet);
DBG_RETURN(FAIL);
}
if (meta->fields[i].type == MYSQL_TYPE_BIT) {
#else
/* For BC we have to check whether the key is numeric and use it like this */
if ((meta->zend_hash_keys[i].is_numeric =
- mysqlnd_is_key_numeric(field_packet.metadata->name,
- field_packet.metadata->name_length + 1,
+ mysqlnd_is_key_numeric(field_packet->metadata->name,
+ field_packet->metadata->name_length + 1,
&idx)))
{
meta->zend_hash_keys[i].key = idx;
} else {
meta->zend_hash_keys[i].key =
- zend_get_hash_value(field_packet.metadata->name,
- field_packet.metadata->name_length + 1);
+ zend_get_hash_value(field_packet->metadata->name,
+ field_packet->metadata->name_length + 1);
}
#endif
}
- PACKET_FREE_ALLOCA(field_packet);
+ PACKET_FREE(field_packet);
DBG_RETURN(PASS);
}
/* {{{ mysqlnd_result_meta_init */
-MYSQLND_RES_METADATA *
+PHPAPI MYSQLND_RES_METADATA *
mysqlnd_result_meta_init(unsigned int field_count TSRMLS_DC)
{
MYSQLND_RES_METADATA *ret;
#define MYSQLND_RESULT_META_H
-MYSQLND_RES_METADATA *mysqlnd_result_meta_init(unsigned int field_count TSRMLS_DC);
+PHPAPI MYSQLND_RES_METADATA * mysqlnd_result_meta_init(unsigned int field_count TSRMLS_DC);
/* {{{ mysqlnd_fill_stats_hash */
-void
-mysqlnd_fill_stats_hash(const MYSQLND_STATS * const stats, zval *return_value TSRMLS_DC ZEND_FILE_LINE_DC)
+PHPAPI void
+mysqlnd_fill_stats_hash(const MYSQLND_STATS * const stats, const MYSQLND_STRING * names, zval *return_value TSRMLS_DC ZEND_FILE_LINE_DC)
{
unsigned int i;
- mysqlnd_array_init(return_value, STAT_LAST);
- for (i = 0; i < STAT_LAST; i++) {
+ mysqlnd_array_init(return_value, stats->count);
+ for (i = 0; i < stats->count; i++) {
#if PHP_MAJOR_VERSION >= 6
UChar *ustr, *tstr;
int ulen, tlen;
sprintf((char *)&tmp, MYSQLND_LLU_SPEC, stats->values[i]);
#if PHP_MAJOR_VERSION >= 6
- zend_string_to_unicode(UG(utf8_conv), &ustr, &ulen, mysqlnd_stats_values_names[i].s,
- mysqlnd_stats_values_names[i].l + 1 TSRMLS_CC);
+ zend_string_to_unicode(UG(utf8_conv), &ustr, &ulen, names[i].s, names[i].l + 1 TSRMLS_CC);
zend_string_to_unicode(UG(utf8_conv), &tstr, &tlen, tmp, strlen(tmp) + 1 TSRMLS_CC);
add_u_assoc_unicode_ex(return_value, IS_UNICODE, ZSTR(ustr), ulen, tstr, 1);
efree(ustr);
efree(tstr);
#else
- add_assoc_string_ex(return_value, mysqlnd_stats_values_names[i].s,
- mysqlnd_stats_values_names[i].l + 1, tmp, 1);
+ add_assoc_string_ex(return_value, names[i].s, names[i].l + 1, tmp, 1);
#endif
}
}
memset(&stats, 0, sizeof(stats));
stats_ptr = &stats;
}
- mysqlnd_fill_stats_hash(stats_ptr, return_value TSRMLS_CC ZEND_FILE_LINE_CC);
+ mysqlnd_fill_stats_hash(stats_ptr, mysqlnd_stats_values_names, return_value TSRMLS_CC ZEND_FILE_LINE_CC);
DBG_VOID_RETURN;
}
/* }}} */
/* {{{ mysqlnd_stats_init */
-void
-mysqlnd_stats_init(MYSQLND_STATS ** stats)
+PHPAPI void
+mysqlnd_stats_init(MYSQLND_STATS ** stats, size_t statistic_count)
{
*stats = calloc(1, sizeof(MYSQLND_STATS));
+ (*stats)->values = calloc(statistic_count, sizeof(uint64_t));
+ (*stats)->triggers = calloc(statistic_count, sizeof(mysqlnd_stat_trigger));
+ (*stats)->in_trigger = FALSE;
+ (*stats)->count = statistic_count;
#ifdef ZTS
(*stats)->LOCK_access = tsrm_mutex_alloc();
#endif
/* {{{ mysqlnd_stats_end */
-void
+PHPAPI void
mysqlnd_stats_end(MYSQLND_STATS * stats)
{
#ifdef ZTS
tsrm_mutex_free(stats->LOCK_access);
#endif
+ free(stats->triggers);
+ free(stats->values);
/* mnd_free will reference LOCK_access and crash...*/
free(stats);
}
/* }}} */
+/* {{{ mysqlnd_stats_set_trigger */
+PHPAPI mysqlnd_stat_trigger
+mysqlnd_stats_set_trigger(MYSQLND_STATS * const stats, enum_mysqlnd_collected_stats stat, mysqlnd_stat_trigger trigger TSRMLS_DC)
+{
+ mysqlnd_stat_trigger ret = NULL;
+ DBG_ENTER("mysqlnd_stats_set_trigger");
+ if (stats) {
+ MYSQLND_STATS_LOCK(stats);
+ ret = stats->triggers[stat];
+ stats->triggers[stat] = trigger;
+ MYSQLND_STATS_UNLOCK(stats);
+ }
+ DBG_RETURN(ret);
+}
+/* }}} */
+
+
+/* {{{ mysqlnd_stats_set_handler */
+PHPAPI mysqlnd_stat_trigger
+mysqlnd_stats_reset_triggers(MYSQLND_STATS * const stats TSRMLS_DC)
+{
+ mysqlnd_stat_trigger ret = NULL;
+ DBG_ENTER("mysqlnd_stats_reset_trigger");
+ if (stats) {
+ MYSQLND_STATS_LOCK(stats);
+ memset(stats->triggers, 0, stats->count * sizeof(mysqlnd_stat_trigger));
+ MYSQLND_STATS_UNLOCK(stats);
+ }
+ DBG_RETURN(ret);
+}
+/* }}} */
+
+
/*
* Local variables:
* tab-width: 4
#define MYSQLND_STATISTICS_H
-extern MYSQLND_STATS *mysqlnd_global_stats;
+PHPAPI extern MYSQLND_STATS * mysqlnd_global_stats;
typedef struct st_mysqlnd_string
{
extern const MYSQLND_STRING mysqlnd_stats_values_names[];
#ifdef ZTS
+#define MYSQLND_STATS_LOCK(stats) tsrm_mutex_lock((stats)->LOCK_access)
+#define MYSQLND_STATS_UNLOCK(stats) tsrm_mutex_unlock((stats)->LOCK_access)
+#else
+#define MYSQLND_STATS_LOCK(stats)
+#define MYSQLND_STATS_UNLOCK(stats)
+#endif
-#define MYSQLND_INC_GLOBAL_STATISTIC(statistic) \
- { \
- if (MYSQLND_G(collect_statistics) && (statistic) != STAT_LAST) { \
- DBG_INF_FMT("Global stat increase [%s]", mysqlnd_stats_values_names[(statistic)].s); \
- \
- tsrm_mutex_lock(mysqlnd_global_stats->LOCK_access); \
- mysqlnd_global_stats->values[(statistic)]++; \
- tsrm_mutex_unlock(mysqlnd_global_stats->LOCK_access); \
- }\
- }
-
-#define MYSQLND_DEC_CONN_STATISTIC(conn_stats, statistic) \
- { \
- if (MYSQLND_G(collect_statistics) && (statistic) != STAT_LAST) { \
- DBG_INF_FMT("Global&conn stat decrease [%s]", mysqlnd_stats_values_names[(statistic)].s); \
- \
- tsrm_mutex_lock(mysqlnd_global_stats->LOCK_access); \
- mysqlnd_global_stats->values[(statistic)]--; \
- tsrm_mutex_unlock(mysqlnd_global_stats->LOCK_access); \
- if ((conn_stats)) { \
- ((MYSQLND_STATS *) conn_stats)->values[(statistic)]--; \
- } \
- }\
- }
-
-#define MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(statistic1, value1, statistic2, value2) \
+#define MYSQLND_CHECK_AND_CALL_HANDLER(stats, statistic, value) \
+ { \
+ if ((stats)->triggers[(statistic)] && (stats)->in_trigger == FALSE) { \
+ (stats)->in_trigger = TRUE; \
+ (stats)->triggers[(statistic)]((stats), (statistic), (value) TSRMLS_CC); \
+ (stats)->in_trigger = FALSE; \
+ } \
+ } \
+
+#define MYSQLND_DEC_STATISTIC(enabler, stats, statistic) \
{ \
- if (MYSQLND_G(collect_statistics)) { \
- uint64_t v1 = (uint64_t) (value1); \
- uint64_t v2 = (uint64_t) (value2); \
- enum_mysqlnd_collected_stats _s1 = (statistic1);\
- enum_mysqlnd_collected_stats _s2 = (statistic2);\
- \
- if (_s1 != STAT_LAST) DBG_INF_FMT("Global stat increase1 [%s]", mysqlnd_stats_values_names[_s1].s); \
- if (_s2 != STAT_LAST) DBG_INF_FMT("Global stat increase2 [%s]", mysqlnd_stats_values_names[_s2].s); \
- \
- tsrm_mutex_lock(mysqlnd_global_stats->LOCK_access); \
- if (_s1 != STAT_LAST) mysqlnd_global_stats->values[_s1]+= v1; \
- if (_s2 != STAT_LAST) mysqlnd_global_stats->values[_s2]+= v2; \
- tsrm_mutex_unlock(mysqlnd_global_stats->LOCK_access); \
+ enum_mysqlnd_collected_stats _s = (statistic);\
+ MYSQLND_STATS * _p_s = (MYSQLND_STATS *) (stats); \
+ if ((enabler) && _p_s && _s != _p_s->count) { \
+ MYSQLND_STATS_LOCK(_p_s); \
+ MYSQLND_CHECK_AND_CALL_HANDLER(_p_s, _s, -1); \
+ _p_s->values[_s]--; \
+ MYSQLND_STATS_UNLOCK(_p_s); \
}\
}
-#define MYSQLND_INC_CONN_STATISTIC(conn_stats, statistic) \
+#define MYSQLND_INC_STATISTIC(enabler, stats, statistic) \
{ \
- if (MYSQLND_G(collect_statistics) && (statistic) != STAT_LAST) { \
- DBG_INF_FMT("Global&Conn stat increase [%s]", mysqlnd_stats_values_names[(statistic)].s); \
- \
- tsrm_mutex_lock(mysqlnd_global_stats->LOCK_access); \
- mysqlnd_global_stats->values[(statistic)]++; \
- tsrm_mutex_unlock(mysqlnd_global_stats->LOCK_access); \
- if ((conn_stats)) { \
- ((MYSQLND_STATS *) conn_stats)->values[(statistic)]++; \
- } \
+ enum_mysqlnd_collected_stats _s = (statistic);\
+ MYSQLND_STATS * _p_s = (MYSQLND_STATS *) (stats); \
+ if ((enabler) && _p_s && _s != _p_s->count) { \
+ MYSQLND_STATS_LOCK(_p_s); \
+ MYSQLND_CHECK_AND_CALL_HANDLER(_p_s, _s, 1); \
+ _p_s->values[_s]++; \
+ MYSQLND_STATS_UNLOCK(_p_s); \
}\
}
-#define MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn_stats, statistic, value) \
+#define MYSQLND_INC_STATISTIC_W_VALUE(enabler, stats, statistic, value) \
{ \
- if (MYSQLND_G(collect_statistics) && (statistic) != STAT_LAST) { \
+ enum_mysqlnd_collected_stats _s = (statistic);\
+ MYSQLND_STATS * _p_s = (MYSQLND_STATS *) (stats); \
+ if ((enabler) && _p_s && _s != _p_s->count) { \
uint64_t v = (uint64_t) (value); \
- DBG_INF_FMT("Global&Conn stat increase w value [%s]", mysqlnd_stats_values_names[(statistic)].s); \
- \
- tsrm_mutex_lock(mysqlnd_global_stats->LOCK_access); \
- mysqlnd_global_stats->values[(statistic)] += v; \
- tsrm_mutex_unlock(mysqlnd_global_stats->LOCK_access); \
- if ((conn_stats)) { \
- ((MYSQLND_STATS *) conn_stats)->values[(statistic)]+= v; \
- } \
+ MYSQLND_STATS_LOCK(_p_s); \
+ MYSQLND_CHECK_AND_CALL_HANDLER(_p_s, _s, v); \
+ _p_s->values[_s] += v; \
+ MYSQLND_STATS_UNLOCK(_p_s); \
}\
}
-#define MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn_stats, statistic1, value1, statistic2, value2) \
+#define MYSQLND_INC_STATISTIC_W_VALUE2(enabler, stats, statistic1, value1, statistic2, value2) \
{ \
- if (MYSQLND_G(collect_statistics)) { \
+ MYSQLND_STATS * _p_s = (MYSQLND_STATS *) (stats); \
+ if ((enabler) && _p_s) { \
uint64_t v1 = (uint64_t) (value1); \
uint64_t v2 = (uint64_t) (value2); \
enum_mysqlnd_collected_stats _s1 = (statistic1);\
enum_mysqlnd_collected_stats _s2 = (statistic2);\
- \
- if (_s1 != STAT_LAST) DBG_INF_FMT("Global stat increase1 [%s]", mysqlnd_stats_values_names[_s1].s); \
- if (_s2 != STAT_LAST) DBG_INF_FMT("Global stat increase2 [%s]", mysqlnd_stats_values_names[_s2].s); \
- \
- tsrm_mutex_lock(mysqlnd_global_stats->LOCK_access); \
- if (_s1 != STAT_LAST) mysqlnd_global_stats->values[_s1]+= v1; \
- if (_s2 != STAT_LAST) mysqlnd_global_stats->values[_s2]+= v2; \
- tsrm_mutex_unlock(mysqlnd_global_stats->LOCK_access); \
- if ((conn_stats)) { \
- if (_s1 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[_s1]+= v1; \
- if (_s2 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[_s2]+= v2; \
+ MYSQLND_STATS_LOCK(_p_s); \
+ if (_s1 != _p_s->count) { \
+ MYSQLND_CHECK_AND_CALL_HANDLER(_p_s, _s1, v1); \
+ _p_s->values[_s1]+= v1; \
} \
- } \
+ if (_s2 != _p_s->count) { \
+ MYSQLND_CHECK_AND_CALL_HANDLER(_p_s, _s2, v2); \
+ _p_s->values[_s2]+= v2; \
+ } \
+ MYSQLND_STATS_UNLOCK(_p_s); \
+ }\
}
-
-#define MYSQLND_INC_CONN_STATISTIC_W_VALUE3(conn_stats, statistic1, value1, statistic2, value2, statistic3, value3) \
+#define MYSQLND_INC_STATISTIC_W_VALUE3(enabler, stats, statistic1, value1, statistic2, value2, statistic3, value3) \
{ \
- if (MYSQLND_G(collect_statistics)) { \
+ MYSQLND_STATS * _p_s = (MYSQLND_STATS *) (stats); \
+ if ((enabler) && _p_s) { \
uint64_t v1 = (uint64_t) (value1); \
uint64_t v2 = (uint64_t) (value2); \
uint64_t v3 = (uint64_t) (value3); \
- enum_mysqlnd_collected_stats _s1 = (statistic1); \
- enum_mysqlnd_collected_stats _s2 = (statistic2); \
- enum_mysqlnd_collected_stats _s3 = (statistic3); \
- \
- if (_s1 != STAT_LAST) DBG_INF_FMT("Global stat increase1 [%s]", mysqlnd_stats_values_names[_s1].s); \
- if (_s2 != STAT_LAST) DBG_INF_FMT("Global stat increase2 [%s]", mysqlnd_stats_values_names[_s2].s); \
- if (_s3 != STAT_LAST) DBG_INF_FMT("Global stat increase3 [%s]", mysqlnd_stats_values_names[_s3].s); \
- \
- tsrm_mutex_lock(mysqlnd_global_stats->LOCK_access); \
- if (_s1 != STAT_LAST) mysqlnd_global_stats->values[_s1]+= v1; \
- if (_s2 != STAT_LAST) mysqlnd_global_stats->values[_s2]+= v2; \
- if (_s3 != STAT_LAST) mysqlnd_global_stats->values[_s3]+= v3; \
- tsrm_mutex_unlock(mysqlnd_global_stats->LOCK_access); \
- if ((conn_stats)) { \
- if (_s1 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[_s1]+= v1; \
- if (_s2 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[_s2]+= v2; \
- if (_s3 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[_s3]+= v3; \
+ enum_mysqlnd_collected_stats _s1 = (statistic1);\
+ enum_mysqlnd_collected_stats _s2 = (statistic2);\
+ enum_mysqlnd_collected_stats _s3 = (statistic3);\
+ MYSQLND_STATS_LOCK(_p_s); \
+ if (_s1 != _p_s->count) { \
+ MYSQLND_CHECK_AND_CALL_HANDLER(_p_s, _s1, v1); \
+ _p_s->values[_s1]+= v1; \
} \
- } \
+ if (_s2 != _p_s->count) { \
+ MYSQLND_CHECK_AND_CALL_HANDLER(_p_s, _s2, v2); \
+ _p_s->values[_s2]+= v2; \
+ } \
+ if (_s3 != _p_s->count) { \
+ MYSQLND_CHECK_AND_CALL_HANDLER(_p_s, _s3, v3); \
+ _p_s->values[_s3]+= v3; \
+ } \
+ MYSQLND_STATS_UNLOCK(_p_s); \
+ }\
}
-#else /* NON-ZTS */
-
#define MYSQLND_INC_GLOBAL_STATISTIC(statistic) \
- { \
- if (MYSQLND_G(collect_statistics) && (statistic) != STAT_LAST) { \
- DBG_INF_FMT("Global stat increase [%s]", mysqlnd_stats_values_names[(statistic)].s); \
- mysqlnd_global_stats->values[(statistic)]++; \
- } \
- }
-
+ MYSQLND_INC_STATISTIC(MYSQLND_G(collect_statistics), mysqlnd_global_stats, (statistic))
#define MYSQLND_DEC_CONN_STATISTIC(conn_stats, statistic) \
- { \
- if (MYSQLND_G(collect_statistics) && (statistic) != STAT_LAST) { \
- DBG_INF_FMT("Global&Conn stat decrease [%s]", mysqlnd_stats_values_names[(statistic)].s); \
- mysqlnd_global_stats->values[(statistic)]--; \
- if ((conn_stats)) { \
- ((MYSQLND_STATS *) conn_stats)->values[(statistic)]--; \
- } \
- } \
- }
+ MYSQLND_DEC_STATISTIC(MYSQLND_G(collect_statistics), mysqlnd_global_stats, (statistic))
#define MYSQLND_INC_GLOBAL_STATISTIC_W_VALUE2(statistic1, value1, statistic2, value2) \
- { \
- if (MYSQLND_G(collect_statistics)) { \
- uint64_t v1 = (uint64_t) (value1); \
- uint64_t v2 = (uint64_t) (value2); \
- enum_mysqlnd_collected_stats _s1 = (statistic1);\
- enum_mysqlnd_collected_stats _s2 = (statistic2);\
- \
- if (_s1 != STAT_LAST) DBG_INF_FMT("Global stat increase1 [%s]", mysqlnd_stats_values_names[_s1].s); \
- if (_s2 != STAT_LAST) DBG_INF_FMT("Global stat increase2 [%s]", mysqlnd_stats_values_names[_s2].s); \
- \
- if (_s1 != STAT_LAST) mysqlnd_global_stats->values[_s1]+= v1; \
- if (_s2 != STAT_LAST) mysqlnd_global_stats->values[_s2]+= v2; \
- }\
- }
+ MYSQLND_INC_STATISTIC_W_VALUE2(MYSQLND_G(collect_statistics), mysqlnd_global_stats, (statistic1), (value1), (statistic2), (value2))
#define MYSQLND_INC_CONN_STATISTIC(conn_stats, statistic) \
- { \
- if (MYSQLND_G(collect_statistics) && (statistic) != STAT_LAST) { \
- DBG_INF_FMT("Global&Conn stat increase [%s]", mysqlnd_stats_values_names[(statistic)].s); \
- mysqlnd_global_stats->values[(statistic)]++; \
- if ((conn_stats)) { \
- ((MYSQLND_STATS *) conn_stats)->values[(statistic)]++; \
- } \
- } \
- }
+ MYSQLND_INC_STATISTIC(MYSQLND_G(collect_statistics), mysqlnd_global_stats, (statistic)); \
+ MYSQLND_INC_STATISTIC(MYSQLND_G(collect_statistics), (conn_stats), (statistic));
#define MYSQLND_INC_CONN_STATISTIC_W_VALUE(conn_stats, statistic, value) \
- { \
- if (MYSQLND_G(collect_statistics) && (statistic) != STAT_LAST) { \
- uint64_t v = (uint64_t) (value); \
- DBG_INF_FMT("Global&Conn stats increase w value [%s]", mysqlnd_stats_values_names[(statistic)].s); \
- mysqlnd_global_stats->values[(statistic)] += v; \
- if ((conn_stats)) { \
- ((MYSQLND_STATS *) conn_stats)->values[(statistic)] += v; \
- } \
- } \
- }
+ MYSQLND_INC_STATISTIC_W_VALUE(MYSQLND_G(collect_statistics), mysqlnd_global_stats, (statistic), (value)); \
+ MYSQLND_INC_STATISTIC_W_VALUE(MYSQLND_G(collect_statistics), (conn_stats), (statistic), (value));
#define MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn_stats, statistic1, value1, statistic2, value2) \
- { \
- if (MYSQLND_G(collect_statistics)) { \
- uint64_t v1 = (uint64_t) (value1); \
- uint64_t v2 = (uint64_t) (value2); \
- enum_mysqlnd_collected_stats _s1 = (statistic1);\
- enum_mysqlnd_collected_stats _s2 = (statistic2);\
- if (_s1 != STAT_LAST) DBG_INF_FMT("Global stat increase1 [%s]", mysqlnd_stats_values_names[_s1].s); \
- if (_s2 != STAT_LAST) DBG_INF_FMT("Global stat increase2 [%s]", mysqlnd_stats_values_names[_s2].s); \
- \
- if (_s1 != STAT_LAST) mysqlnd_global_stats->values[_s1]+= v1; \
- if (_s2 != STAT_LAST) mysqlnd_global_stats->values[_s2]+= v2; \
- if ((conn_stats)) { \
- if (_s1 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[_s1]+= v1; \
- if (_s2 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[_s2]+= v2; \
- } \
- } \
- }
+ MYSQLND_INC_STATISTIC_W_VALUE2(MYSQLND_G(collect_statistics), mysqlnd_global_stats, (statistic1), (value1), (statistic2), (value2)); \
+ MYSQLND_INC_STATISTIC_W_VALUE2(MYSQLND_G(collect_statistics), (conn_stats), (statistic1), (value1), (statistic2), (value2));
#define MYSQLND_INC_CONN_STATISTIC_W_VALUE3(conn_stats, statistic1, value1, statistic2, value2, statistic3, value3) \
- { \
- if (MYSQLND_G(collect_statistics)) { \
- uint64_t v1 = (uint64_t) (value1); \
- uint64_t v2 = (uint64_t) (value2); \
- uint64_t v3 = (uint64_t) (value3); \
- enum_mysqlnd_collected_stats _s1 = (statistic1); \
- enum_mysqlnd_collected_stats _s2 = (statistic2); \
- enum_mysqlnd_collected_stats _s3 = (statistic3); \
- \
- if (_s1 != STAT_LAST) DBG_INF_FMT("Global stat increase1 [%s]", mysqlnd_stats_values_names[_s1].s); \
- if (_s2 != STAT_LAST) DBG_INF_FMT("Global stat increase2 [%s]", mysqlnd_stats_values_names[_s2].s); \
- if (_s3 != STAT_LAST) DBG_INF_FMT("Global stat increase3 [%s]", mysqlnd_stats_values_names[_s3].s); \
- \
- if (_s1 != STAT_LAST) mysqlnd_global_stats->values[_s1]+= v1; \
- if (_s2 != STAT_LAST) mysqlnd_global_stats->values[_s2]+= v2; \
- if (_s3 != STAT_LAST) mysqlnd_global_stats->values[_s3]+= v3; \
- if ((conn_stats)) { \
- if (_s1 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[_s1]+= v1; \
- if (_s2 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[_s2]+= v2; \
- if (_s3 != STAT_LAST) ((MYSQLND_STATS *) conn_stats)->values[_s3]+= v3; \
- } \
- } \
- }
+ MYSQLND_INC_STATISTIC_W_VALUE3(MYSQLND_G(collect_statistics), mysqlnd_global_stats, (statistic1), (value1), (statistic2), (value2), (statistic3), (value3)); \
+ MYSQLND_INC_STATISTIC_W_VALUE3(MYSQLND_G(collect_statistics), (conn_stats), (statistic1), (value1), (statistic2), (value2), (statistic3), (value3));
-#endif
-void mysqlnd_fill_stats_hash(const MYSQLND_STATS * const stats, zval *return_value
- TSRMLS_DC ZEND_FILE_LINE_DC);
+PHPAPI void mysqlnd_fill_stats_hash(const MYSQLND_STATS * const stats, const MYSQLND_STRING * names, zval *return_value TSRMLS_DC ZEND_FILE_LINE_DC);
+
+PHPAPI void mysqlnd_stats_init(MYSQLND_STATS ** stats, size_t statistic_count);
+PHPAPI void mysqlnd_stats_end(MYSQLND_STATS * stats);
+PHPAPI mysqlnd_stat_trigger mysqlnd_stats_set_trigger(MYSQLND_STATS * const stats, enum_mysqlnd_collected_stats stat, mysqlnd_stat_trigger trigger TSRMLS_DC);
+PHPAPI mysqlnd_stat_trigger mysqlnd_stats_reset_triggers(MYSQLND_STATS * const stats TSRMLS_DC);
-void mysqlnd_stats_init(MYSQLND_STATS ** stats);
-void mysqlnd_stats_end(MYSQLND_STATS * stats);
#endif /* MYSQLND_STATISTICS_H */
unsigned int server_status;
uint64_t affected_rows;
uint64_t last_insert_id;
-} mysqlnd_upsert_status;
+} MYSQLND_UPSERT_STATUS;
typedef struct st_mysqlnd_error_info
char error[MYSQLND_ERRMSG_SIZE+1];
char sqlstate[MYSQLND_SQLSTATE_LENGTH + 1];
unsigned int error_no;
-} mysqlnd_error_info;
+} MYSQLND_ERROR_INFO;
typedef struct st_mysqlnd_infile_info
typedef struct st_mysqlnd_connection MYSQLND;
typedef struct st_mysqlnd_net MYSQLND_NET;
+typedef struct st_mysqlnd_protocol MYSQLND_PROTOCOL;
typedef struct st_mysqlnd_res MYSQLND_RES;
typedef char** MYSQLND_ROW_C; /* return data as array of strings */
typedef struct st_mysqlnd_stmt MYSQLND_STMT;
zend_bool *fetched_anything
TSRMLS_DC);
-typedef struct st_mysqlnd_stats
+typedef struct st_mysqlnd_stats MYSQLND_STATS;
+
+typedef void (*mysqlnd_stat_trigger)(MYSQLND_STATS * stats, enum_mysqlnd_collected_stats stat, int64_t change TSRMLS_DC);
+
+struct st_mysqlnd_stats
{
- uint64_t values[STAT_LAST];
+ uint64_t *values;
+ mysqlnd_stat_trigger *triggers;
+ size_t count;
+ zend_bool in_trigger;
#ifdef ZTS
MUTEX_T LOCK_access;
#endif
-} MYSQLND_STATS;
+};
typedef struct st_mysqlnd_read_buffer {
};
+struct st_mysqlnd_packet_greet;
+struct st_mysqlnd_packet_greet;
+struct st_mysqlnd_packet_auth;
+struct st_mysqlnd_packet_ok;
+struct st_mysqlnd_packet_command;
+struct st_mysqlnd_packet_eof;
+struct st_mysqlnd_packet_rset_header;
+struct st_mysqlnd_packet_res_field;
+struct st_mysqlnd_packet_row;
+struct st_mysqlnd_packet_stats;
+struct st_mysqlnd_packet_prepare_response;
+struct st_mysqlnd_packet_chg_user_resp;
+
+struct st_mysqlnd_protocol_methods
+{
+ struct st_mysqlnd_packet_greet * (*get_greet_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC);
+ struct st_mysqlnd_packet_auth * (*get_auth_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC);
+ struct st_mysqlnd_packet_ok * (*get_ok_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC);
+ struct st_mysqlnd_packet_command * (*get_command_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC);
+ struct st_mysqlnd_packet_eof * (*get_eof_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC);
+ struct st_mysqlnd_packet_rset_header *(*get_rset_header_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC);
+ struct st_mysqlnd_packet_res_field * (*get_result_field_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC);
+ struct st_mysqlnd_packet_row * (*get_row_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC);
+ struct st_mysqlnd_packet_stats * (*get_stats_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC);
+ struct st_mysqlnd_packet_prepare_response *(*get_prepare_response_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC);
+ struct st_mysqlnd_packet_chg_user_resp*(*get_change_user_response_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC);
+};
+
+
struct st_mysqlnd_conn_methods
{
enum_func_status (*connect)(MYSQLND *conn, const char *host, const char * user, const char * passwd, unsigned int passwd_len, const char * db, unsigned int db_len, unsigned int port, const char * socket, unsigned int mysql_flags TSRMLS_DC);
enum mysqlnd_connection_state (*get_state)(MYSQLND * const conn TSRMLS_DC);
void (*set_state)(MYSQLND * const conn, enum mysqlnd_connection_state new_state TSRMLS_DC);
- enum_func_status (*simple_command)(MYSQLND *conn, enum php_mysqlnd_server_command command, const char * const arg, size_t arg_len, enum php_mysql_packet_type ok_packet, zend_bool silent, zend_bool ignore_upsert_status TSRMLS_DC);
- enum_func_status (*simple_command_handle_response)(MYSQLND *conn, enum php_mysql_packet_type ok_packet, zend_bool silent, enum php_mysqlnd_server_command command, zend_bool ignore_upsert_status TSRMLS_DC);
+ enum_func_status (*simple_command)(MYSQLND *conn, enum php_mysqlnd_server_command command, const char * const arg, size_t arg_len, enum mysqlnd_packet_type ok_packet, zend_bool silent, zend_bool ignore_upsert_status TSRMLS_DC);
+ enum_func_status (*simple_command_handle_response)(MYSQLND *conn, enum mysqlnd_packet_type ok_packet, zend_bool silent, enum php_mysqlnd_server_command command, zend_bool ignore_upsert_status TSRMLS_DC);
+
+ enum_func_status (*restart_psession)(MYSQLND *conn TSRMLS_DC);
+ enum_func_status (*end_psession)(MYSQLND *conn TSRMLS_DC);
};
};
+struct st_mysqlnd_protocol
+{
+ struct st_mysqlnd_protocol_methods m;
+ zend_bool persistent;
+};
+
+
struct st_mysqlnd_connection
{
/* Operation related */
MYSQLND_NET * net;
+ MYSQLND_PROTOCOL * protocol;
/* Information related */
char *host;
unsigned long server_capabilities;
/* For UPSERT queries */
- mysqlnd_upsert_status upsert_status;
+ MYSQLND_UPSERT_STATUS upsert_status;
char *last_message;
unsigned int last_message_len;
/* If error packet, we use these */
- mysqlnd_error_info error_info;
+ MYSQLND_ERROR_INFO error_info;
/*
To prevent queries during unbuffered fetches. Also to
MYSQLND_OPTIONS options;
/* stats */
- MYSQLND_STATS stats;
+ MYSQLND_STATS * stats;
struct st_mysqlnd_conn_methods *m;
};
-typedef struct st_php_mysql_packet_row php_mysql_packet_row;
-
struct mysqlnd_field_hash_key
{
unsigned int references;
- mysqlnd_error_info error_info;
+ MYSQLND_ERROR_INFO error_info;
};
*/
unsigned long *lengths;
- php_mysql_packet_row *row_packet;
+ struct st_mysqlnd_packet_row * row_packet;
MYSQLND_MEMORY_POOL * result_set_memory_pool;
};
MYSQLND_RESULT_BIND *result_bind;
zend_bool result_zvals_separated_once;
- mysqlnd_upsert_status upsert_status;
+ MYSQLND_UPSERT_STATUS upsert_status;
- mysqlnd_error_info error_info;
+ MYSQLND_ERROR_INFO error_info;
zend_bool update_max_length;
unsigned long prefetch_rows;
DBG_ERR_FMT("Empty '%s' packet body", (packet_type_as_text)); \
DBG_RETURN(FAIL);\
} \
- MYSQLND_INC_CONN_STATISTIC_W_VALUE2(&conn->stats, packet_type_to_statistic_byte_count[packet_type], \
+ MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn->stats, packet_type_to_statistic_byte_count[packet_type], \
MYSQLND_HEADER_SIZE + (packet)->header.size, \
packet_type_to_statistic_packet_count[packet_type], \
1); \
}
-extern mysqlnd_packet_methods packet_methods[];
-
static const char *unknown_sqlstate= "HY000";
char * const mysqlnd_empty_string = "";
/* Used in mysqlnd_debug.c */
-char * mysqlnd_read_header_name = "mysqlnd_read_header";
-char * mysqlnd_read_body_name = "mysqlnd_read_body";
+const char mysqlnd_read_header_name[] = "mysqlnd_read_header";
+const char mysqlnd_read_body_name[] = "mysqlnd_read_body";
#define ERROR_MARKER 0xFF
/* {{{ mysqlnd_read_header */
static enum_func_status
-mysqlnd_read_header(MYSQLND * conn, mysqlnd_packet_header * header TSRMLS_DC)
+mysqlnd_read_header(MYSQLND * conn, MYSQLND_PACKET_HEADER * header TSRMLS_DC)
{
MYSQLND_NET * net = conn->net;
zend_uchar buffer[MYSQLND_HEADER_SIZE];
#ifdef MYSQLND_DUMP_HEADER_N_BODY
DBG_INF_FMT("HEADER: prot_packet_no=%d size=%3d", header->packet_no, header->size);
#endif
- MYSQLND_INC_CONN_STATISTIC_W_VALUE2(&conn->stats,
+ MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn->stats,
STAT_PROTOCOL_OVERHEAD_IN, MYSQLND_HEADER_SIZE,
STAT_PACKETS_RECEIVED, 1);
zend_uchar buf[2048];
zend_uchar *p = buf;
zend_uchar *begin = buf;
- php_mysql_packet_greet *packet= (php_mysql_packet_greet *) _packet;
+ MYSQLND_PACKET_GREET *packet= (MYSQLND_PACKET_GREET *) _packet;
DBG_ENTER("php_mysqlnd_greet_read");
static
void php_mysqlnd_greet_free_mem(void *_packet, zend_bool alloca TSRMLS_DC)
{
- php_mysql_packet_greet *p= (php_mysql_packet_greet *) _packet;
+ MYSQLND_PACKET_GREET *p= (MYSQLND_PACKET_GREET *) _packet;
if (p->server_version) {
mnd_efree(p->server_version);
p->server_version = NULL;
char buffer[1024];
register char *p= buffer + MYSQLND_HEADER_SIZE; /* start after the header */
int len;
- register php_mysql_packet_auth *packet= (php_mysql_packet_auth *) _packet;
+ register MYSQLND_PACKET_AUTH *packet= (MYSQLND_PACKET_AUTH *) _packet;
DBG_ENTER("php_mysqlnd_auth_write");
void php_mysqlnd_auth_free_mem(void *_packet, zend_bool alloca TSRMLS_DC)
{
if (!alloca) {
- mnd_pefree((php_mysql_packet_auth *) _packet, ((php_mysql_packet_auth *)_packet)->header.persistent);
+ mnd_pefree((MYSQLND_PACKET_AUTH *) _packet, ((MYSQLND_PACKET_AUTH *)_packet)->header.persistent);
}
}
/* }}} */
zend_uchar *p = buf;
zend_uchar *begin = buf;
unsigned long i;
- register php_mysql_packet_ok *packet= (php_mysql_packet_ok *) _packet;
+ register MYSQLND_PACKET_OK *packet= (MYSQLND_PACKET_OK *) _packet;
DBG_ENTER("php_mysqlnd_ok_read");
static
void php_mysqlnd_ok_free_mem(void *_packet, zend_bool alloca TSRMLS_DC)
{
- php_mysql_packet_ok *p= (php_mysql_packet_ok *) _packet;
+ MYSQLND_PACKET_OK *p= (MYSQLND_PACKET_OK *) _packet;
if (p->message) {
mnd_efree(p->message);
p->message = NULL;
Error : error_code + '#' + sqlstate + MYSQLND_ERRMSG_SIZE
*/
- php_mysql_packet_eof *packet= (php_mysql_packet_eof *) _packet;
+ MYSQLND_PACKET_EOF *packet= (MYSQLND_PACKET_EOF *) _packet;
size_t buf_len = conn->net->cmd_buffer.length;
zend_uchar *buf = (zend_uchar *) conn->net->cmd_buffer.buffer;
zend_uchar *p = buf;
void php_mysqlnd_eof_free_mem(void *_packet, zend_bool alloca TSRMLS_DC)
{
if (!alloca) {
- mnd_pefree(_packet, ((php_mysql_packet_eof *)_packet)->header.persistent);
+ mnd_pefree(_packet, ((MYSQLND_PACKET_EOF *)_packet)->header.persistent);
}
}
/* }}} */
size_t php_mysqlnd_cmd_write(void *_packet, MYSQLND *conn TSRMLS_DC)
{
/* Let's have some space, which we can use, if not enough, we will allocate new buffer */
- php_mysql_packet_command *packet= (php_mysql_packet_command *) _packet;
+ MYSQLND_PACKET_COMMAND *packet= (MYSQLND_PACKET_COMMAND *) _packet;
MYSQLND_NET *net = conn->net;
unsigned int error_reporting = EG(error_reporting);
size_t written;
EG(error_reporting) = 0;
}
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_PACKETS_SENT_CMD);
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_PACKETS_SENT_CMD);
#ifdef MYSQLND_DO_WIRE_CHECK_BEFORE_COMMAND
net->m.consume_uneaten_data(net, packet->command TSRMLS_CC);
ret = conn->net->m.send(conn, (char *)tmp, tmp_len - MYSQLND_HEADER_SIZE TSRMLS_CC);
if (tmp != net->cmd_buffer.buffer) {
- MYSQLND_INC_CONN_STATISTIC(&conn->stats, STAT_CMD_BUFFER_TOO_SMALL);
+ MYSQLND_INC_CONN_STATISTIC(conn->stats, STAT_CMD_BUFFER_TOO_SMALL);
mnd_efree(tmp);
}
written = ret;
void php_mysqlnd_cmd_free_mem(void *_packet, zend_bool alloca TSRMLS_DC)
{
if (!alloca) {
- mnd_pefree(_packet, ((php_mysql_packet_command *)_packet)->header.persistent);
+ mnd_pefree(_packet, ((MYSQLND_PACKET_COMMAND *)_packet)->header.persistent);
}
}
/* }}} */
zend_uchar *p = buf;
zend_uchar *begin = buf;
size_t len;
- php_mysql_packet_rset_header *packet= (php_mysql_packet_rset_header *) _packet;
+ MYSQLND_PACKET_RSET_HEADER *packet= (MYSQLND_PACKET_RSET_HEADER *) _packet;
DBG_ENTER("php_mysqlnd_rset_header_read");
static
void php_mysqlnd_rset_header_free_mem(void *_packet, zend_bool alloca TSRMLS_DC)
{
- php_mysql_packet_rset_header *p= (php_mysql_packet_rset_header *) _packet;
+ MYSQLND_PACKET_RSET_HEADER *p= (MYSQLND_PACKET_RSET_HEADER *) _packet;
DBG_ENTER("php_mysqlnd_rset_header_free_mem");
if (p->info_or_local_file) {
mnd_efree(p->info_or_local_file);
php_mysqlnd_rset_field_read(void *_packet, MYSQLND *conn TSRMLS_DC)
{
/* Should be enough for the metadata of a single row */
- php_mysql_packet_res_field *packet= (php_mysql_packet_res_field *) _packet;
+ MYSQLND_PACKET_RES_FIELD *packet= (MYSQLND_PACKET_RES_FIELD *) _packet;
size_t buf_len = conn->net->cmd_buffer.length, total_len = 0;
zend_uchar *buf = (zend_uchar *) conn->net->cmd_buffer.buffer;
zend_uchar *p = buf;
static
void php_mysqlnd_rset_field_free_mem(void *_packet, zend_bool alloca TSRMLS_DC)
{
- php_mysql_packet_res_field *p= (php_mysql_packet_res_field *) _packet;
+ MYSQLND_PACKET_RES_FIELD *p= (MYSQLND_PACKET_RES_FIELD *) _packet;
/* p->metadata was passed to us as temporal buffer */
if (!alloca) {
unsigned int prealloc_more_bytes TSRMLS_DC)
{
enum_func_status ret = PASS;
- mysqlnd_packet_header header;
+ MYSQLND_PACKET_HEADER header;
zend_uchar *p = NULL;
zend_bool first_iteration = TRUE;
zend_uchar *p;
enum_func_status ret = PASS;
size_t old_chunk_size = net->stream->chunk_size;
- php_mysql_packet_row *packet= (php_mysql_packet_row *) _packet;
+ MYSQLND_PACKET_ROW *packet= (MYSQLND_PACKET_ROW *) _packet;
size_t post_alloc_for_bit_fields = 0;
uint64_t data_size = 0;
if (FAIL == ret) {
goto end;
}
- MYSQLND_INC_CONN_STATISTIC_W_VALUE2(&conn->stats, packet_type_to_statistic_byte_count[PROT_ROW_PACKET],
+ MYSQLND_INC_CONN_STATISTIC_W_VALUE2(conn->stats, packet_type_to_statistic_byte_count[PROT_ROW_PACKET],
MYSQLND_HEADER_SIZE + packet->header.size,
packet_type_to_statistic_packet_count[PROT_ROW_PACKET],
1);
packet->server_status, packet->warning_count);
}
} else {
- MYSQLND_INC_CONN_STATISTIC(&conn->stats,
+ MYSQLND_INC_CONN_STATISTIC(conn->stats,
packet->binary_protocol? STAT_ROWS_FETCHED_FROM_SERVER_PS:
STAT_ROWS_FETCHED_FROM_SERVER_NORMAL);
packet->persistent_alloc);
}
} else {
- MYSQLND_INC_CONN_STATISTIC(&conn->stats,
+ MYSQLND_INC_CONN_STATISTIC(conn->stats,
packet->binary_protocol? STAT_ROWS_SKIPPED_PS:
STAT_ROWS_SKIPPED_NORMAL);
}
static
void php_mysqlnd_rowp_free_mem(void *_packet, zend_bool alloca TSRMLS_DC)
{
- php_mysql_packet_row *p;
+ MYSQLND_PACKET_ROW *p;
DBG_ENTER("php_mysqlnd_rowp_free_mem");
- p = (php_mysql_packet_row *) _packet;
+ p = (MYSQLND_PACKET_ROW *) _packet;
if (p->row_buffer) {
p->row_buffer->free_chunk(p->row_buffer, TRUE TSRMLS_CC);
p->row_buffer = NULL;
static enum_func_status
php_mysqlnd_stats_read(void *_packet, MYSQLND *conn TSRMLS_DC)
{
- php_mysql_packet_stats *packet= (php_mysql_packet_stats *) _packet;
+ MYSQLND_PACKET_STATS *packet= (MYSQLND_PACKET_STATS *) _packet;
size_t buf_len = conn->net->cmd_buffer.length;
zend_uchar *buf = (zend_uchar *) conn->net->cmd_buffer.buffer;
static
void php_mysqlnd_stats_free_mem(void *_packet, zend_bool alloca TSRMLS_DC)
{
- php_mysql_packet_stats *p= (php_mysql_packet_stats *) _packet;
+ MYSQLND_PACKET_STATS *p= (MYSQLND_PACKET_STATS *) _packet;
if (p->message) {
mnd_efree(p->message);
p->message = NULL;
zend_uchar *p = buf;
zend_uchar *begin = buf;
unsigned int data_size;
- php_mysql_packet_prepare_response *packet= (php_mysql_packet_prepare_response *) _packet;
+ MYSQLND_PACKET_PREPARE_RESPONSE *packet= (MYSQLND_PACKET_PREPARE_RESPONSE *) _packet;
DBG_ENTER("php_mysqlnd_prepare_read");
static
void php_mysqlnd_prepare_free_mem(void *_packet, zend_bool alloca TSRMLS_DC)
{
- php_mysql_packet_prepare_response *p= (php_mysql_packet_prepare_response *) _packet;
+ MYSQLND_PACKET_PREPARE_RESPONSE *p= (MYSQLND_PACKET_PREPARE_RESPONSE *) _packet;
if (!alloca) {
mnd_pefree(p, p->header.persistent);
}
zend_uchar *buf = (zend_uchar *) conn->net->cmd_buffer.buffer;
zend_uchar *p = buf;
zend_uchar *begin = buf;
- php_mysql_packet_chg_user_resp *packet= (php_mysql_packet_chg_user_resp *) _packet;
+ MYSQLND_PACKET_CHG_USER_RESPONSE *packet= (MYSQLND_PACKET_CHG_USER_RESPONSE *) _packet;
DBG_ENTER("php_mysqlnd_chg_user_read");
- PACKET_READ_HEADER_AND_BODY(packet, conn, buf, buf_len, "change user response", PROT_CHG_USER_PACKET);
+ PACKET_READ_HEADER_AND_BODY(packet, conn, buf, buf_len, "change user response", PROT_CHG_USER_RESP_PACKET);
/*
Don't increment. First byte is ERROR_MARKER on error, but otherwise is starting byte
void php_mysqlnd_chg_user_free_mem(void *_packet, zend_bool alloca TSRMLS_DC)
{
if (!alloca) {
- mnd_pefree(_packet, ((php_mysql_packet_chg_user_resp *)_packet)->header.persistent);
+ mnd_pefree(_packet, ((MYSQLND_PACKET_CHG_USER_RESPONSE *)_packet)->header.persistent);
}
}
/* }}} */
/* {{{ packet_methods
*/
+static
mysqlnd_packet_methods packet_methods[PROT_LAST] =
{
{
- sizeof(php_mysql_packet_greet),
+ sizeof(MYSQLND_PACKET_GREET),
php_mysqlnd_greet_read,
NULL, /* write */
php_mysqlnd_greet_free_mem,
}, /* PROT_GREET_PACKET */
{
- sizeof(php_mysql_packet_auth),
+ sizeof(MYSQLND_PACKET_AUTH),
NULL, /* read */
php_mysqlnd_auth_write,
php_mysqlnd_auth_free_mem,
}, /* PROT_AUTH_PACKET */
{
- sizeof(php_mysql_packet_ok),
+ sizeof(MYSQLND_PACKET_OK),
php_mysqlnd_ok_read, /* read */
NULL, /* write */
php_mysqlnd_ok_free_mem,
}, /* PROT_OK_PACKET */
{
- sizeof(php_mysql_packet_eof),
+ sizeof(MYSQLND_PACKET_EOF),
php_mysqlnd_eof_read, /* read */
NULL, /* write */
php_mysqlnd_eof_free_mem,
}, /* PROT_EOF_PACKET */
{
- sizeof(php_mysql_packet_command),
+ sizeof(MYSQLND_PACKET_COMMAND),
NULL, /* read */
php_mysqlnd_cmd_write, /* write */
php_mysqlnd_cmd_free_mem,
}, /* PROT_CMD_PACKET */
{
- sizeof(php_mysql_packet_rset_header),
+ sizeof(MYSQLND_PACKET_RSET_HEADER),
php_mysqlnd_rset_header_read, /* read */
NULL, /* write */
php_mysqlnd_rset_header_free_mem,
}, /* PROT_RSET_HEADER_PACKET */
{
- sizeof(php_mysql_packet_res_field),
+ sizeof(MYSQLND_PACKET_RES_FIELD),
php_mysqlnd_rset_field_read, /* read */
NULL, /* write */
php_mysqlnd_rset_field_free_mem,
}, /* PROT_RSET_FLD_PACKET */
{
- sizeof(php_mysql_packet_row),
+ sizeof(MYSQLND_PACKET_ROW),
php_mysqlnd_rowp_read, /* read */
NULL, /* write */
php_mysqlnd_rowp_free_mem,
}, /* PROT_ROW_PACKET */
{
- sizeof(php_mysql_packet_stats),
+ sizeof(MYSQLND_PACKET_STATS),
php_mysqlnd_stats_read, /* read */
NULL, /* write */
php_mysqlnd_stats_free_mem,
}, /* PROT_STATS_PACKET */
{
- sizeof(php_mysql_packet_prepare_response),
+ sizeof(MYSQLND_PACKET_PREPARE_RESPONSE),
php_mysqlnd_prepare_read, /* read */
NULL, /* write */
php_mysqlnd_prepare_free_mem,
}, /* PROT_PREPARE_RESP_PACKET */
{
- sizeof(php_mysql_packet_chg_user_resp),
+ sizeof(MYSQLND_PACKET_CHG_USER_RESPONSE),
php_mysqlnd_chg_user_read, /* read */
NULL, /* write */
php_mysqlnd_chg_user_free_mem,
- } /* PROT_CHG_USER_PACKET */
+ } /* PROT_CHG_USER_RESP_PACKET */
};
/* }}} */
+
+/* {{{ mysqlnd_protocol::get_greet_packet */
+static struct st_mysqlnd_packet_greet *
+MYSQLND_METHOD(mysqlnd_protocol, get_greet_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
+{
+ struct st_mysqlnd_packet_greet * packet = pecalloc(1, packet_methods[PROT_GREET_PACKET].struct_size, persistent);
+ DBG_ENTER("mysqlnd_protocol::get_greet_packet");
+ packet->header.m = &packet_methods[PROT_GREET_PACKET];
+ packet->header.persistent = persistent;
+ DBG_RETURN(packet);
+}
+/* }}} */
+
+
+/* {{{ mysqlnd_protocol::get_auth_packet */
+static struct st_mysqlnd_packet_auth *
+MYSQLND_METHOD(mysqlnd_protocol, get_auth_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
+{
+ struct st_mysqlnd_packet_auth * packet = pecalloc(1, packet_methods[PROT_AUTH_PACKET].struct_size, persistent);
+ DBG_ENTER("mysqlnd_protocol::get_auth_packet");
+ packet->header.m = &packet_methods[PROT_AUTH_PACKET];
+ packet->header.persistent = persistent;
+ DBG_RETURN(packet);
+}
+/* }}} */
+
+
+/* {{{ mysqlnd_protocol::get_ok_packet */
+static struct st_mysqlnd_packet_ok *
+MYSQLND_METHOD(mysqlnd_protocol, get_ok_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
+{
+ struct st_mysqlnd_packet_ok * packet = pecalloc(1, packet_methods[PROT_OK_PACKET].struct_size, persistent);
+ DBG_ENTER("mysqlnd_protocol::get_ok_packet");
+ packet->header.m = &packet_methods[PROT_OK_PACKET];
+ packet->header.persistent = persistent;
+ DBG_RETURN(packet);
+}
+/* }}} */
+
+
+/* {{{ mysqlnd_protocol::get_eof_packet */
+static struct st_mysqlnd_packet_eof *
+MYSQLND_METHOD(mysqlnd_protocol, get_eof_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
+{
+ struct st_mysqlnd_packet_eof * packet = pecalloc(1, packet_methods[PROT_EOF_PACKET].struct_size, persistent);
+ DBG_ENTER("mysqlnd_protocol::get_eof_packet");
+ packet->header.m = &packet_methods[PROT_EOF_PACKET];
+ packet->header.persistent = persistent;
+ DBG_RETURN(packet);
+}
+/* }}} */
+
+
+/* {{{ mysqlnd_protocol::get_command_packet */
+static struct st_mysqlnd_packet_command *
+MYSQLND_METHOD(mysqlnd_protocol, get_command_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
+{
+ struct st_mysqlnd_packet_command * packet = pecalloc(1, packet_methods[PROT_CMD_PACKET].struct_size, persistent);
+ DBG_ENTER("mysqlnd_protocol::get_command_packet");
+ packet->header.m = &packet_methods[PROT_CMD_PACKET];
+ packet->header.persistent = persistent;
+ DBG_RETURN(packet);
+}
+/* }}} */
+
+
+/* {{{ mysqlnd_protocol::get_rset_packet */
+static struct st_mysqlnd_packet_rset_header *
+MYSQLND_METHOD(mysqlnd_protocol, get_rset_header_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
+{
+ struct st_mysqlnd_packet_rset_header * packet = pecalloc(1, packet_methods[PROT_RSET_HEADER_PACKET].struct_size, persistent);
+ DBG_ENTER("mysqlnd_protocol::get_rset_header_packet");
+ packet->header.m = &packet_methods[PROT_RSET_HEADER_PACKET];
+ packet->header.persistent = persistent;
+ DBG_RETURN(packet);
+}
+/* }}} */
+
+
+/* {{{ mysqlnd_protocol::get_result_field_packet */
+static struct st_mysqlnd_packet_res_field *
+MYSQLND_METHOD(mysqlnd_protocol, get_result_field_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
+{
+ struct st_mysqlnd_packet_res_field * packet = pecalloc(1, packet_methods[PROT_RSET_FLD_PACKET].struct_size, persistent);
+ DBG_ENTER("mysqlnd_protocol::get_result_field_packet");
+ packet->header.m = &packet_methods[PROT_RSET_FLD_PACKET];
+ packet->header.persistent = persistent;
+ DBG_RETURN(packet);
+}
+/* }}} */
+
+
+/* {{{ mysqlnd_protocol::get_row_packet */
+static struct st_mysqlnd_packet_row *
+MYSQLND_METHOD(mysqlnd_protocol, get_row_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
+{
+ struct st_mysqlnd_packet_row * packet = pecalloc(1, packet_methods[PROT_ROW_PACKET].struct_size, persistent);
+ DBG_ENTER("mysqlnd_protocol::get_row_packet");
+ packet->header.m = &packet_methods[PROT_ROW_PACKET];
+ packet->header.persistent = persistent;
+ DBG_RETURN(packet);
+}
+/* }}} */
+
+
+/* {{{ mysqlnd_protocol::get_stats_packet */
+static struct st_mysqlnd_packet_stats *
+MYSQLND_METHOD(mysqlnd_protocol, get_stats_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
+{
+ struct st_mysqlnd_packet_stats * packet = pecalloc(1, packet_methods[PROT_STATS_PACKET].struct_size, persistent);
+ DBG_ENTER("mysqlnd_protocol::get_stats_packet");
+ packet->header.m = &packet_methods[PROT_STATS_PACKET];
+ packet->header.persistent = persistent;
+ DBG_RETURN(packet);
+}
+/* }}} */
+
+
+/* {{{ mysqlnd_protocol::get_prepare_response_packet */
+static struct st_mysqlnd_packet_prepare_response *
+MYSQLND_METHOD(mysqlnd_protocol, get_prepare_response_packet)(MYSQLND_PROTOCOL * const protocol, zend_bool persistent TSRMLS_DC)
+{
+ struct st_mysqlnd_packet_prepare_response * packet = pecalloc(1, packet_methods[PROT_PREPARE_RESP_PACKET].struct_size, persistent);
+ DBG_ENTER("mysqlnd_protocol::get_prepare_response_packet");
+ packet->header.m = &packet_methods[PROT_PREPARE_RESP_PACKET];
+ packet->header.persistent = persistent;
+ DBG_RETURN(packet);
+}
+/* }}} */
+
+
+/* {{{ 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 * const protocol, zend_bool persistent TSRMLS_DC)
+{
+ struct st_mysqlnd_packet_chg_user_resp * packet = pecalloc(1, packet_methods[PROT_CHG_USER_RESP_PACKET].struct_size, persistent);
+ DBG_ENTER("mysqlnd_protocol::get_change_user_response_packet");
+ packet->header.m = &packet_methods[PROT_CHG_USER_RESP_PACKET];
+ packet->header.persistent = persistent;
+ DBG_RETURN(packet);
+}
+/* }}} */
+
+
+/* {{{ mysqlnd_protocol_init */
+PHPAPI MYSQLND_PROTOCOL *
+mysqlnd_protocol_init(zend_bool persistent TSRMLS_DC)
+{
+ size_t alloc_size = sizeof(MYSQLND_PROTOCOL) + mysqlnd_plugin_count() * sizeof(void *);
+ MYSQLND_PROTOCOL *ret = mnd_pecalloc(1, alloc_size, persistent);
+
+ DBG_ENTER("mysqlnd_protocol_init");
+ DBG_INF_FMT("persistent=%d", persistent);
+ ret->persistent = persistent;
+
+ ret->m.get_greet_packet = MYSQLND_METHOD(mysqlnd_protocol, get_greet_packet);
+ ret->m.get_auth_packet = MYSQLND_METHOD(mysqlnd_protocol, get_auth_packet);
+ ret->m.get_ok_packet = MYSQLND_METHOD(mysqlnd_protocol, get_ok_packet);
+ ret->m.get_command_packet = MYSQLND_METHOD(mysqlnd_protocol, get_command_packet);
+ ret->m.get_eof_packet = MYSQLND_METHOD(mysqlnd_protocol, get_eof_packet);
+ ret->m.get_rset_header_packet = MYSQLND_METHOD(mysqlnd_protocol, get_rset_header_packet);
+ ret->m.get_result_field_packet = MYSQLND_METHOD(mysqlnd_protocol, get_result_field_packet);
+ ret->m.get_row_packet = MYSQLND_METHOD(mysqlnd_protocol, get_row_packet);
+ ret->m.get_stats_packet = MYSQLND_METHOD(mysqlnd_protocol, get_stats_packet);
+ ret->m.get_prepare_response_packet = MYSQLND_METHOD(mysqlnd_protocol, get_prepare_response_packet);
+ ret->m.get_change_user_response_packet = MYSQLND_METHOD(mysqlnd_protocol, get_change_user_response_packet);
+
+ DBG_RETURN(ret);
+}
+/* }}} */
+
+
+/* {{{ mysqlnd_protocol_free */
+PHPAPI void
+mysqlnd_protocol_free(MYSQLND_PROTOCOL * const protocol TSRMLS_DC)
+{
+ zend_bool pers = protocol->persistent;
+
+ DBG_ENTER("mysqlnd_protocol_free");
+
+ if (protocol) {
+ mnd_pefree(protocol, pers);
+ }
+ DBG_VOID_RETURN;
+}
+/* }}} */
+
+
+/* {{{ _mysqlnd_plugin_get_plugin_protocol_data */
+PHPAPI void ** _mysqlnd_plugin_get_plugin_protocol_data(const MYSQLND_PROTOCOL * protocol, unsigned int plugin_id TSRMLS_DC)
+{
+ DBG_ENTER("_mysqlnd_plugin_get_plugin_protocol_data");
+ DBG_INF_FMT("plugin_id=%u", plugin_id);
+ if (!protocol || plugin_id >= mysqlnd_plugin_count()) {
+ return NULL;
+ }
+ DBG_RETURN((void *)((char *)protocol + sizeof(MYSQLND_PROTOCOL) + plugin_id * sizeof(void *)));
+}
+/* }}} */
+
+
/*
* Local variables:
* tab-width: 4
#define MYSQLND_NULL_LENGTH (unsigned long) ~0
/* Used in mysqlnd_debug.c */
-extern char * mysqlnd_read_header_name;
-extern char * mysqlnd_read_body_name;
+PHPAPI extern const char mysqlnd_read_header_name[];
+PHPAPI extern const char mysqlnd_read_body_name[];
/* Packet handling */
-#define PACKET_INIT(packet, enum_type, c_type, pers) \
- { \
- packet = (c_type) pecalloc(1, packet_methods[(enum_type)].struct_size, (pers)); \
- ((c_type) (packet))->header.m = &packet_methods[(enum_type)]; \
- ((c_type) (packet))->header.persistent = (pers); \
- DBG_INF_FMT("PACKET_INIT(%p, %d, %d)", packet, (int) enum_type, (int) pers); \
- }
#define PACKET_WRITE(packet, conn) ((packet)->header.m->write_to_net((packet), (conn) TSRMLS_CC))
#define PACKET_READ(packet, conn) ((packet)->header.m->read_from_net((packet), (conn) TSRMLS_CC))
#define PACKET_FREE(packet) \
((packet)->header.m->free_mem((packet), FALSE TSRMLS_CC)); \
} while (0);
-#define PACKET_INIT_ALLOCA(packet, enum_type) \
- { \
- memset(&(packet), 0, packet_methods[enum_type].struct_size); \
- (packet).header.m = &packet_methods[enum_type]; \
- }
-#define PACKET_WRITE_ALLOCA(packet, conn) PACKET_WRITE(&(packet), (conn))
-#define PACKET_READ_ALLOCA(packet, conn) PACKET_READ(&(packet), (conn))
-#define PACKET_FREE_ALLOCA(packet) (packet.header.m->free_mem(&(packet), TRUE TSRMLS_CC))
-
-extern const char * const mysqlnd_command_to_text[COM_END];
+PHPAPI extern const char * const mysqlnd_command_to_text[COM_END];
/* Low-level extraction functionality */
typedef struct st_mysqlnd_packet_methods {
void (*free_mem)(void *packet, zend_bool alloca TSRMLS_DC);
} mysqlnd_packet_methods;
-extern mysqlnd_packet_methods packet_methods[];
-
typedef struct st_mysqlnd_packet_header {
size_t size;
mysqlnd_packet_methods *m;
zend_uchar packet_no;
zend_bool persistent;
-} mysqlnd_packet_header;
+} MYSQLND_PACKET_HEADER;
/* Server greets the client */
-typedef struct st_php_mysql_packet_greet {
- mysqlnd_packet_header header;
+typedef struct st_mysqlnd_packet_greet {
+ MYSQLND_PACKET_HEADER header;
uint8_t protocol_version;
char *server_version;
uint32_t thread_id;
char error[MYSQLND_ERRMSG_SIZE+1];
char sqlstate[MYSQLND_SQLSTATE_LENGTH + 1];
unsigned int error_no;
-} php_mysql_packet_greet;
+} MYSQLND_PACKET_GREET;
/* Client authenticates */
-typedef struct st_php_mysql_packet_auth {
- mysqlnd_packet_header header;
+typedef struct st_mysqlnd_packet_auth {
+ MYSQLND_PACKET_HEADER header;
uint32_t client_flags;
uint32_t max_packet_size;
uint8_t charset_no;
/* +1 for \0 because of scramble() */
unsigned char *server_scramble_buf;
size_t db_len;
-} php_mysql_packet_auth;
+} MYSQLND_PACKET_AUTH;
/* OK packet */
-typedef struct st_php_mysql_packet_ok {
- mysqlnd_packet_header header;
+typedef struct st_mysqlnd_packet_ok {
+ MYSQLND_PACKET_HEADER header;
uint8_t field_count; /* always 0x0 */
uint64_t affected_rows;
uint64_t last_insert_id;
char error[MYSQLND_ERRMSG_SIZE+1];
char sqlstate[MYSQLND_SQLSTATE_LENGTH + 1];
unsigned int error_no;
-} php_mysql_packet_ok;
+} MYSQLND_PACKET_OK;
/* Command packet */
-typedef struct st_php_mysql_packet_command {
- mysqlnd_packet_header header;
+typedef struct st_mysqlnd_packet_command {
+ MYSQLND_PACKET_HEADER header;
enum php_mysqlnd_server_command command;
const char *argument;
size_t arg_len;
-} php_mysql_packet_command;
+} MYSQLND_PACKET_COMMAND;
/* EOF packet */
-typedef struct st_php_mysql_packet_eof {
- mysqlnd_packet_header header;
+typedef struct st_mysqlnd_packet_eof {
+ MYSQLND_PACKET_HEADER header;
uint8_t field_count; /* 0xFE */
uint16_t warning_count;
uint16_t server_status;
char error[MYSQLND_ERRMSG_SIZE+1];
char sqlstate[MYSQLND_SQLSTATE_LENGTH + 1];
unsigned int error_no;
-} php_mysql_packet_eof;
+} MYSQLND_PACKET_EOF;
/* EOF packet */
/* Result Set header*/
-typedef struct st_php_mysql_packet_rset_header {
- mysqlnd_packet_header header;
+typedef struct st_mysqlnd_packet_rset_header {
+ MYSQLND_PACKET_HEADER header;
/*
0x00 => ok
~0 => LOAD DATA LOCAL
char *info_or_local_file;
size_t info_or_local_file_len;
/* If error packet, we use these */
- mysqlnd_error_info error_info;
-} php_mysql_packet_rset_header;
+ MYSQLND_ERROR_INFO error_info;
+} MYSQLND_PACKET_RSET_HEADER;
/* Result set field packet */
-typedef struct st_php_mysql_packet_res_field {
- mysqlnd_packet_header header;
+typedef struct st_mysqlnd_packet_res_field {
+ MYSQLND_PACKET_HEADER header;
MYSQLND_FIELD *metadata;
/* For table definitions, empty for result sets */
zend_bool skip_parsing;
zend_bool stupid_list_fields_eof;
- mysqlnd_error_info error_info;
-} php_mysql_packet_res_field;
+ MYSQLND_ERROR_INFO error_info;
+} MYSQLND_PACKET_RES_FIELD;
/* Row packet */
-struct st_php_mysql_packet_row {
- mysqlnd_packet_header header;
+typedef struct st_mysqlnd_packet_row {
+ MYSQLND_PACKET_HEADER header;
zval **fields;
uint32_t field_count;
zend_bool eof;
size_t bit_fields_total_len; /* trailing \0 not counted */
/* If error packet, we use these */
- mysqlnd_error_info error_info;
-};
+ MYSQLND_ERROR_INFO error_info;
+} MYSQLND_PACKET_ROW;
/* Statistics packet */
-typedef struct st_php_mysql_packet_stats {
- mysqlnd_packet_header header;
+typedef struct st_mysqlnd_packet_stats {
+ MYSQLND_PACKET_HEADER header;
char *message;
/* message_len is not part of the packet*/
size_t message_len;
-} php_mysql_packet_stats;
+} MYSQLND_PACKET_STATS;
/* COM_PREPARE response packet */
-typedef struct st_php_mysql_packet_prepare_response {
- mysqlnd_packet_header header;
+typedef struct st_mysqlnd_packet_prepare_response {
+ MYSQLND_PACKET_HEADER header;
/* also known as field_count 0x00=OK , 0xFF=error */
unsigned char error_code;
unsigned long stmt_id;
unsigned int warning_count;
/* present in case of error */
- mysqlnd_error_info error_info;
-} php_mysql_packet_prepare_response;
+ MYSQLND_ERROR_INFO error_info;
+} MYSQLND_PACKET_PREPARE_RESPONSE;
/* Statistics packet */
-typedef struct st_php_mysql_packet_chg_user_resp {
- mysqlnd_packet_header header;
+typedef struct st_mysqlnd_packet_chg_user_resp {
+ MYSQLND_PACKET_HEADER header;
uint32_t field_count;
/* message_len is not part of the packet*/
uint16_t server_capabilities;
/* If error packet, we use these */
- mysqlnd_error_info error_info;
-} php_mysql_packet_chg_user_resp;
-
+ MYSQLND_ERROR_INFO error_info;
+} MYSQLND_PACKET_CHG_USER_RESPONSE;
-size_t mysqlnd_stream_write_w_header(MYSQLND * const conn, char * const buf, size_t count TSRMLS_DC);
-void php_mysqlnd_scramble(zend_uchar * const buffer, const zend_uchar * const scramble, const zend_uchar * const pass);
+PHPAPI void php_mysqlnd_scramble(zend_uchar * const buffer, const zend_uchar * const scramble, const zend_uchar * const pass);
unsigned long php_mysqlnd_net_field_length(zend_uchar **packet);
zend_uchar * php_mysqlnd_net_store_length(zend_uchar *packet, uint64_t length);
-extern char * const mysqlnd_empty_string;
+PHPAPI extern char * const mysqlnd_empty_string;
void php_mysqlnd_rowp_read_binary_protocol(MYSQLND_MEMORY_POOL_CHUNK * row_buffer, zval ** fields,
zend_bool as_unicode, zend_bool as_int_or_float,
MYSQLND_STATS * stats TSRMLS_DC);
+
+PHPAPI MYSQLND_PROTOCOL * mysqlnd_protocol_init(zend_bool persistent TSRMLS_DC);
+PHPAPI void mysqlnd_protocol_free(MYSQLND_PROTOCOL * net TSRMLS_DC);
+
+
#endif /* MYSQLND_WIREPROTOCOL_H */
/*
}
}
#else
-void mysqlnd_minfo_print_hash(zval *values)
+PHPAPI void mysqlnd_minfo_print_hash(zval *values)
{
zval **values_entry;
HashPosition pos_values;
{
#if defined(PHP_DEBUG)
if (MYSQLND_G(debug)) {
- MYSQLND_DEBUG *dbg = mysqlnd_debug_init(TSRMLS_C);
+ MYSQLND_DEBUG *dbg = mysqlnd_debug_init(mysqlnd_debug_std_no_trace_funcs TSRMLS_CC);
if (!dbg) {
return FAILURE;
}
{
#if PDO_DBG_ENABLED
if (PDO_MYSQL_G(debug)) {
- MYSQLND_DEBUG *dbg = mysqlnd_debug_init(TSRMLS_C);
+ MYSQLND_DEBUG *dbg = mysqlnd_debug_init(mysqlnd_debug_std_no_trace_funcs TSRMLS_CC);
if (!dbg) {
return FAILURE;
}
projects / php / commitdiff