#define SAFE_STRING(s) ((s)?(s):"")
#if MYSQL_VERSION_ID > 32199 || defined(MYSQL_USE_MYSQLND)
-# define mysql_row_length_type unsigned long
+# define mysql_row_length_type php_uint_t
# define HAVE_MYSQL_ERRNO
#else
# define mysql_row_length_type unsigned int
char *tmp = NULL, *host = NULL;
int user_len = 0, passwd_len = 0, host_len = 0;
int port = MYSQL_PORT;
- long client_flags = 0;
+ php_int_t client_flags = 0;
php_mysql_conn *mysql = NULL;
#if MYSQL_VERSION_ID <= 32230
void (*handler) (int);
#endif
- long connect_timeout;
+ php_int_t connect_timeout;
zend_string *hashed_details = NULL;
zend_bool free_host = 0, new_link = 0;
} else {
/* mysql_pconnect does not support new_link parameter */
if (persistent) {
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!s!s!l", &host_and_port, &host_len,
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!s!s!i", &host_and_port, &host_len,
&user, &user_len, &passwd, &passwd_len,
&client_flags)==FAILURE) {
return;
}
} else {
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!s!s!bl", &host_and_port, &host_len,
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!s!s!bi", &host_and_port, &host_len,
&user, &user_len, &passwd, &passwd_len,
&new_link, &client_flags)==FAILURE) {
return;
PHP_FUNCTION(mysql_result)
{
zval *result, *field=NULL;
- long row;
+ php_int_t row;
MYSQL_RES *mysql_result;
#ifndef MYSQL_USE_MYSQLND
MYSQL_ROW sql_row;
Do 2 zend_parse_parameters calls instead of type "z" and switch below
Q: String or long first?
*/
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|z", &result, &row, &field) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ri|z", &result, &row, &field) == FAILURE) {
return;
}
/* {{{ php_mysql_fetch_hash
*/
-static void php_mysql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, long result_type, int expected_args, int into_object)
+static void php_mysql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, php_int_t result_type, int expected_args, int into_object)
{
MYSQL_RES *mysql_result;
zval *res, *ctor_params = NULL;
} else
#endif
{
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &res, &result_type) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|i", &res, &result_type) == FAILURE) {
return;
}
if (!result_type) {
PHP_FUNCTION(mysql_data_seek)
{
zval *result;
- long offset;
+ php_int_t offset;
MYSQL_RES *mysql_result;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &result, &offset)) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ri", &result, &offset)) {
return;
}
PHP_FUNCTION(mysql_fetch_field)
{
zval *result;
- long field=0;
+ php_int_t field=0;
MYSQL_RES *mysql_result;
const MYSQL_FIELD *mysql_field;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &result, &field) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|i", &result, &field) == FAILURE) {
return;
}
PHP_FUNCTION(mysql_field_seek)
{
zval *result;
- long offset;
+ php_int_t offset;
MYSQL_RES *mysql_result;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &result, &offset) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ri", &result, &offset) == FAILURE) {
return;
}
ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, result, -1, "MySQL result", le_result);
static void php_mysql_field_info(INTERNAL_FUNCTION_PARAMETERS, int entry_type)
{
zval *result;
- long field;
+ php_int_t field;
MYSQL_RES *mysql_result;
const MYSQL_FIELD *mysql_field = {0};
char buf[512];
int len;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &result, &field) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ri", &result, &field) == FAILURE) {
return;
}
ZEND_BEGIN_MODULE_GLOBALS(mysql)
zend_resource *default_link;
- long num_links,num_persistent;
- long max_links,max_persistent;
- long allow_persistent;
- long default_port;
+ php_int_t num_links,num_persistent;
+ php_int_t max_links,max_persistent;
+ php_int_t allow_persistent;
+ php_int_t default_port;
char *default_host, *default_user, *default_password;
char *default_socket;
char *connect_error;
- long connect_errno;
- long connect_timeout;
- long result_allocated;
- long trace_mode;
- long allow_local_infile;
+ php_int_t connect_errno;
+ php_int_t connect_timeout;
+ php_int_t result_allocated;
+ php_int_t trace_mode;
+ php_int_t allow_local_infile;
ZEND_END_MODULE_GLOBALS(mysql)
#ifdef ZTS
MYSQLND_CONN_DATA * conn,
const MYSQLND_PACKET_GREET * const greet_packet,
const MYSQLND_OPTIONS * const options,
- unsigned long mysql_flags
+ php_uint_t mysql_flags
TSRMLS_DC
)
{
const char * const auth_protocol,
unsigned int charset_no,
const MYSQLND_OPTIONS * const options,
- unsigned long mysql_flags,
+ php_uint_t mysql_flags,
zend_bool silent,
zend_bool is_change_user
TSRMLS_DC)
size_t passwd_len,
const MYSQLND_PACKET_GREET * const greet_packet,
const MYSQLND_OPTIONS * const options,
- unsigned long mysql_flags
+ php_uint_t mysql_flags
TSRMLS_DC)
{
enum_func_status ret = FAIL;
/* {{{ mysqlnd_old_escape_string */
-PHPAPI ulong
+PHPAPI php_uint_t
mysqlnd_old_escape_string(char * newstr, const char * escapestr, size_t escapestr_len TSRMLS_DC)
{
DBG_ENTER("mysqlnd_old_escape_string");
/* {{{ mysqlnd_conn_data::escape_string */
-static ulong
+static php_uint_t
MYSQLND_METHOD(mysqlnd_conn_data, escape_string)(MYSQLND_CONN_DATA * const conn, char * newstr, const char * escapestr, size_t escapestr_len TSRMLS_DC)
{
size_t this_func = STRUCT_OFFSET(struct st_mysqlnd_conn_data_methods, escape_string);
- ulong ret = FAIL;
+ php_uint_t ret = FAIL;
DBG_ENTER("mysqlnd_conn_data::escape_string");
DBG_INF_FMT("conn=%llu", conn->thread_id);
/* {{{ mysqlnd_conn_data::get_server_version */
-static unsigned long
+static php_uint_t
MYSQLND_METHOD(mysqlnd_conn_data, get_server_version)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC)
{
- long major, minor, patch;
+ php_int_t major, minor, patch;
char *p;
if (!(p = conn->server_version)) {
return 0;
}
- major = strtol(p, &p, 10);
+ major = ZEND_STRTOI(p, &p, 10);
p += 1; /* consume the dot */
- minor = strtol(p, &p, 10);
+ minor = ZEND_STRTOI(p, &p, 10);
p += 1; /* consume the dot */
- patch = strtol(p, &p, 10);
+ patch = ZEND_STRTOI(p, &p, 10);
- return (unsigned long)(major * 10000L + (unsigned long)(minor * 100L + patch));
+ return (php_uint_t)(major * Z_I(10000) + (php_uint_t)(minor * Z_I(100) + patch));
}
/* }}} */
#define mysqlnd_escape_string(newstr, escapestr, escapestr_len) \
mysqlnd_old_escape_string((newstr), (escapestr), (escapestr_len) TSRMLS_CC)
-PHPAPI ulong mysqlnd_old_escape_string(char * newstr, const char * escapestr, size_t escapestr_len TSRMLS_DC);
+PHPAPI php_uint_t mysqlnd_old_escape_string(char * newstr, const char * escapestr, size_t escapestr_len TSRMLS_DC);
/* PS */
char * trace_alloc_settings; /* The actual string */
MYSQLND_DEBUG * dbg; /* The DBG object for standard tracing */
MYSQLND_DEBUG * trace_alloc; /* The DBG object for allocation tracing */
- long net_cmd_buffer_size;
- long net_read_buffer_size;
- long log_mask;
- long net_read_timeout;
- long mempool_default_size;
- long debug_emalloc_fail_threshold;
- long debug_ecalloc_fail_threshold;
- long debug_erealloc_fail_threshold;
- long debug_malloc_fail_threshold;
- long debug_calloc_fail_threshold;
- long debug_realloc_fail_threshold;
+ php_int_t net_cmd_buffer_size;
+ php_int_t net_read_buffer_size;
+ php_int_t log_mask;
+ php_int_t net_read_timeout;
+ php_int_t mempool_default_size;
+ php_int_t debug_emalloc_fail_threshold;
+ php_int_t debug_ecalloc_fail_threshold;
+ php_int_t debug_erealloc_fail_threshold;
+ php_int_t debug_malloc_fail_threshold;
+ php_int_t debug_calloc_fail_threshold;
+ php_int_t debug_realloc_fail_threshold;
char * sha256_server_public_key;
zend_bool fetch_data_copy;
ZEND_END_MODULE_GLOBALS(mysqlnd)
void *ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
#if PHP_DEBUG
- long * threshold = &MYSQLND_G(debug_emalloc_fail_threshold);
+ php_int_t * threshold = &MYSQLND_G(debug_emalloc_fail_threshold);
#endif
TRACE_ALLOC_ENTER(mysqlnd_emalloc_name);
void *ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
#if PHP_DEBUG
- long * threshold = persistent? &MYSQLND_G(debug_malloc_fail_threshold):&MYSQLND_G(debug_emalloc_fail_threshold);
+ php_int_t * threshold = persistent? &MYSQLND_G(debug_malloc_fail_threshold):&MYSQLND_G(debug_emalloc_fail_threshold);
#endif
TRACE_ALLOC_ENTER(mysqlnd_pemalloc_name);
void *ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
#if PHP_DEBUG
- long * threshold = &MYSQLND_G(debug_ecalloc_fail_threshold);
+ php_int_t * threshold = &MYSQLND_G(debug_ecalloc_fail_threshold);
#endif
TRACE_ALLOC_ENTER(mysqlnd_ecalloc_name);
void *ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
#if PHP_DEBUG
- long * threshold = persistent? &MYSQLND_G(debug_calloc_fail_threshold):&MYSQLND_G(debug_ecalloc_fail_threshold);
+ php_int_t * threshold = persistent? &MYSQLND_G(debug_calloc_fail_threshold):&MYSQLND_G(debug_ecalloc_fail_threshold);
#endif
TRACE_ALLOC_ENTER(mysqlnd_pecalloc_name);
#if PHP_DEBUG
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
size_t old_size = collect_memory_statistics && ptr? *(size_t *) (((char*)ptr) - sizeof(size_t)) : 0;
#if PHP_DEBUG
- long * threshold = &MYSQLND_G(debug_erealloc_fail_threshold);
+ php_int_t * threshold = &MYSQLND_G(debug_erealloc_fail_threshold);
#endif
TRACE_ALLOC_ENTER(mysqlnd_erealloc_name);
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
size_t old_size = collect_memory_statistics && ptr? *(size_t *) (((char*)ptr) - sizeof(size_t)) : 0;
#if PHP_DEBUG
- long * threshold = persistent? &MYSQLND_G(debug_realloc_fail_threshold):&MYSQLND_G(debug_erealloc_fail_threshold);
+ php_int_t * threshold = persistent? &MYSQLND_G(debug_realloc_fail_threshold):&MYSQLND_G(debug_erealloc_fail_threshold);
#endif
TRACE_ALLOC_ENTER(mysqlnd_perealloc_name);
void *ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
#if PHP_DEBUG
- long * threshold = &MYSQLND_G(debug_malloc_fail_threshold);
+ php_int_t * threshold = &MYSQLND_G(debug_malloc_fail_threshold);
#endif
TRACE_ALLOC_ENTER(mysqlnd_malloc_name);
void *ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
#if PHP_DEBUG
- long * threshold = &MYSQLND_G(debug_calloc_fail_threshold);
+ php_int_t * threshold = &MYSQLND_G(debug_calloc_fail_threshold);
#endif
TRACE_ALLOC_ENTER(mysqlnd_calloc_name);
void *ret;
zend_bool collect_memory_statistics = MYSQLND_G(collect_memory_statistics);
#if PHP_DEBUG
- long * threshold = &MYSQLND_G(debug_realloc_fail_threshold);
+ php_int_t * threshold = &MYSQLND_G(debug_realloc_fail_threshold);
#endif
TRACE_ALLOC_ENTER(mysqlnd_realloc_name);
const char * const db,
const size_t db_len,
const MYSQLND_OPTIONS * const options,
- unsigned long mysql_flags,
+ php_uint_t mysql_flags,
unsigned int server_charset_no,
zend_bool use_full_blown_auth_packet,
const char * const auth_protocol,
const size_t passwd_len, zend_uchar * auth_plugin_data, size_t auth_plugin_data_len,
const MYSQLND_OPTIONS * const options,
const MYSQLND_NET_OPTIONS * const net_options,
- unsigned long mysql_flags
+ php_uint_t mysql_flags
TSRMLS_DC)
{
zend_uchar * ret = NULL;
const size_t passwd_len, zend_uchar * auth_plugin_data, size_t auth_plugin_data_len,
const MYSQLND_OPTIONS * const options,
const MYSQLND_NET_OPTIONS * const net_options,
- unsigned long mysql_flags
+ php_uint_t mysql_flags
TSRMLS_DC)
{
zend_uchar * ret = NULL;
const size_t passwd_len, zend_uchar * auth_plugin_data, size_t auth_plugin_data_len,
const MYSQLND_OPTIONS * const options,
const MYSQLND_NET_OPTIONS * const net_options,
- unsigned long mysql_flags
+ php_uint_t mysql_flags
TSRMLS_DC)
{
RSA * server_public_key;
/* {{{ mysqlnd_cset_escape_quotes */
-PHPAPI ulong mysqlnd_cset_escape_quotes(const MYSQLND_CHARSET * const cset, char *newstr,
+PHPAPI php_uint_t mysqlnd_cset_escape_quotes(const MYSQLND_CHARSET * const cset, char *newstr,
const char * escapestr, size_t escapestr_len TSRMLS_DC)
{
const char *newstr_s = newstr;
/* {{{ mysqlnd_cset_escape_slashes */
-PHPAPI ulong mysqlnd_cset_escape_slashes(const MYSQLND_CHARSET * const cset, char *newstr,
+PHPAPI php_uint_t mysqlnd_cset_escape_slashes(const MYSQLND_CHARSET * const cset, char *newstr,
const char * escapestr, size_t escapestr_len TSRMLS_DC)
{
const char *newstr_s = newstr;
#ifndef MYSQLND_CHARSET_H
#define MYSQLND_CHARSET_H
-PHPAPI ulong mysqlnd_cset_escape_quotes(const MYSQLND_CHARSET * const charset, char *newstr,
+PHPAPI php_uint_t mysqlnd_cset_escape_quotes(const MYSQLND_CHARSET * const charset, char *newstr,
const char *escapestr, size_t escapestr_len TSRMLS_DC);
-PHPAPI ulong mysqlnd_cset_escape_slashes(const MYSQLND_CHARSET * const cset, char *newstr,
+PHPAPI php_uint_t mysqlnd_cset_escape_slashes(const MYSQLND_CHARSET * const cset, char *newstr,
const char *escapestr, size_t escapestr_len TSRMLS_DC);
struct st_mysqlnd_plugin_charsets
{
const MYSQLND_CHARSET * (*const find_charset_by_nr)(unsigned int charsetnr);
const MYSQLND_CHARSET * (*const find_charset_by_name)(const char * const name);
- unsigned long (*const escape_quotes)(const MYSQLND_CHARSET * const cset, char * newstr, const char * escapestr, size_t escapestr_len TSRMLS_DC);
- unsigned long (*const escape_slashes)(const MYSQLND_CHARSET * const cset, char * newstr, const char * escapestr, size_t escapestr_len TSRMLS_DC);
+ php_uint_t (*const escape_quotes)(const MYSQLND_CHARSET * const cset, char * newstr, const char * escapestr, size_t escapestr_len TSRMLS_DC);
+ php_uint_t (*const escape_slashes)(const MYSQLND_CHARSET * const cset, char * newstr, const char * escapestr, size_t escapestr_len TSRMLS_DC);
} methods;
};
}
net->compressed_envelope_packet_no++;
#ifdef MYSQLND_DUMP_HEADER_N_BODY
- DBG_INF_FMT("HEADER: hwd_packet_no=%u size=%3u", packet_no, (unsigned long) net_payload_size);
+ DBG_INF_FMT("HEADER: hwd_packet_no=%u size=%3u", packet_no, (php_uint_t) net_payload_size);
#endif
/* Now let's read from the wire, decompress it and fill the read buffer */
net->data->m.read_compressed_packet_from_stream_and_fill_read_buffer(net, net_payload_size, conn_stats, error_info TSRMLS_CC);
(((uint32_t) (zend_uchar) (A)[2]) << 16) |\
(((uint32_t) (zend_uchar) (A)[1]) << 8) | \
((uint32_t) (zend_uchar) (A)[0])))
-#define sint4korr(A) (*((long *) (A)))
+#define sint4korr(A) (*((php_int_t *) (A)))
#define uint2korr(A) (*((uint16_t *) (A)))
#define uint3korr(A) (uint32_t) (((uint32_t) ((zend_uchar) (A)[0])) +\
(((uint32_t) ((zend_uchar) (A)[1])) << 8) +\
(((uint32_t) ((zend_uchar) (A)[2])) << 16))
-#define uint4korr(A) (*((unsigned long *) (A)))
+#define uint4korr(A) (*((php_uint_t *) (A)))
*(T)= (zend_uchar) ((A));\
*(T+1)=(zend_uchar) (((uint32_t) (A) >> 8));\
*(T+2)=(zend_uchar) (((A) >> 16)); }
-#define int4store(T,A) *((long *) (T))= (long) (A)
+#define int4store(T,A) *((php_int_t *) (T))= (php_int_t) (A)
#define int5store(T,A) { \
*((zend_uchar *)(T))= (zend_uchar)((A));\
*(((zend_uchar *)(T))+1)=(zend_uchar) (((A) >> 8));\
typedef union {
double v;
- long m[2];
+ php_int_t m[2];
} float8get_union;
-#define float8get(V,M) { ((float8get_union *)&(V))->m[0] = *((long*) (M)); \
- ((float8get_union *)&(V))->m[1] = *(((long*) (M))+1); }
-#define float8store(T,V) { *((long *) (T)) = ((float8get_union *)&(V))->m[0]; \
- *(((long *) (T))+1) = ((float8get_union *)&(V))->m[1]; }
+#define float8get(V,M) { ((float8get_union *)&(V))->m[0] = *((php_int_t*) (M)); \
+ ((float8get_union *)&(V))->m[1] = *(((php_int_t*) (M))+1); }
+#define float8store(T,V) { *((php_int_t *) (T)) = ((float8get_union *)&(V))->m[0]; \
+ *(((php_int_t *) (T))+1) = ((float8get_union *)&(V))->m[1]; }
#define float4get(V,M) { *((float *) &(V)) = *((float*) (M)); }
/* From Andrey Hristov based on float8get */
#define floatget(V,M) memcpy((char*) &(V),(char*) (M),sizeof(float))
const char * const db,
const size_t db_len,
const MYSQLND_OPTIONS * const options,
- unsigned long mysql_flags,
+ php_uint_t mysql_flags,
unsigned int server_charset_no,
zend_bool use_full_blown_auth_packet,
const char * const auth_protocol,
Thus for NULL and zero-length we are quite efficient.
*/
if (Z_TYPE(current_row[i]) == IS_STRING) {
- unsigned long len = Z_STRSIZE(current_row[i]);
+ php_uint_t len = Z_STRSIZE(current_row[i]);
if (meta->fields[i].max_length < len) {
meta->fields[i].max_length = len;
}
/* {{{ mysqlnd_stmt::send_long_data */
static enum_func_status
MYSQLND_METHOD(mysqlnd_stmt, send_long_data)(MYSQLND_STMT * const s, unsigned int param_no,
- const char * const data, unsigned long length TSRMLS_DC)
+ const char * const data, php_uint_t length TSRMLS_DC)
{
MYSQLND_STMT_DATA * stmt = s? s->data:NULL;
enum_func_status ret = FAIL;
*(zend_bool *) value= stmt->update_max_length;
break;
case STMT_ATTR_CURSOR_TYPE:
- *(unsigned long *) value= stmt->flags;
+ *(php_uint_t *) value= stmt->flags;
break;
case STMT_ATTR_PREFETCH_ROWS:
- *(unsigned long *) value= stmt->prefetch_rows;
+ *(php_uint_t *) value= stmt->prefetch_rows;
break;
default:
DBG_RETURN(FAIL);
struct st_mysqlnd_time
{
unsigned int year, month, day, hour, minute, second;
- unsigned long second_part;
+ php_uint_t second_part;
zend_bool neg;
enum mysqlnd_timestamp_type time_type;
};
case 1:uval = (uint64_t) uint1korr(*row);break;
}
-#if SIZEOF_LONG==4
+#if SIZEOF_ZEND_INT==4
if (uval > INT_MAX) {
DBG_INF("stringify");
tmp_len = sprintf((char *)&tmp, MYSQLND_LLU_SPEC, uval);
#endif /* #if SIZEOF_LONG==4 */
{
if (byte_count < 8 || uval <= L64(9223372036854775807)) {
- ZVAL_INT(zv, (long) uval); /* the cast is safe, we are in the range */
+ ZVAL_INT(zv, (php_int_t) uval); /* the cast is safe, we are in the range */
} else {
DBG_INF("stringify");
tmp_len = sprintf((char *)&tmp, MYSQLND_LLU_SPEC, uval);
case 1:lval = (int64_t) *(int8_t*)*row;break;
}
-#if SIZEOF_LONG==4
+#if SIZEOF_ZEND_INT==4
if ((L64(2147483647) < (int64_t) lval) || (L64(-2147483648) > (int64_t) lval)) {
DBG_INF("stringify");
tmp_len = sprintf((char *)&tmp, MYSQLND_LL_SPEC, lval);
} else
#endif /* SIZEOF */
{
- ZVAL_INT(zv, (long) lval); /* the cast is safe, we are in the range */
+ ZVAL_INT(zv, (php_int_t) lval); /* the cast is safe, we are in the range */
}
}
ps_fetch_time(zval * zv, const MYSQLND_FIELD * const field, unsigned int pack_len, zend_uchar ** row TSRMLS_DC)
{
struct st_mysqlnd_time t;
- unsigned long length; /* First byte encodes the length*/
+ php_uint_t length; /* First byte encodes the length*/
char * value;
DBG_ENTER("ps_fetch_time");
t.time_type = MYSQLND_TIMESTAMP_TIME;
t.neg = (zend_bool) to[0];
- t.day = (unsigned long) sint4korr(to+1);
+ t.day = (php_uint_t) sint4korr(to+1);
t.hour = (unsigned int) to[5];
t.minute = (unsigned int) to[6];
t.second = (unsigned int) to[7];
- t.second_part = (length > 8) ? (unsigned long) sint4korr(to+8) : 0;
+ t.second_part = (length > 8) ? (php_uint_t) sint4korr(to+8) : 0;
t.year = t.month= 0;
if (t.day) {
/* Convert days to hours at once */
ps_fetch_date(zval * zv, const MYSQLND_FIELD * const field, unsigned int pack_len, zend_uchar ** row TSRMLS_DC)
{
struct st_mysqlnd_time t = {0};
- unsigned long length; /* First byte encodes the length*/
+ php_uint_t length; /* First byte encodes the length*/
char * value;
DBG_ENTER("ps_fetch_date");
ps_fetch_datetime(zval * zv, const MYSQLND_FIELD * const field, unsigned int pack_len, zend_uchar ** row TSRMLS_DC)
{
struct st_mysqlnd_time t;
- unsigned long length; /* First byte encodes the length*/
+ php_uint_t length; /* First byte encodes the length*/
char * value;
DBG_ENTER("ps_fetch_datetime");
} else {
t.hour = t.minute = t.second= 0;
}
- t.second_part = (length > 7) ? (unsigned long) sint4korr(to+7) : 0;
+ t.second_part = (length > 7) ? (php_uint_t) sint4korr(to+7) : 0;
(*row)+= length;
} else {
For now just copy, before we make it possible
to write \0 to the row buffer
*/
- const unsigned long length = php_mysqlnd_net_field_length(row);
+ const php_uint_t length = php_mysqlnd_net_field_length(row);
DBG_ENTER("ps_fetch_string");
DBG_INF_FMT("len = %lu", length);
DBG_INF("copying from the row buffer");
static void
ps_fetch_bit(zval * zv, const MYSQLND_FIELD * const field, unsigned int pack_len, zend_uchar ** row TSRMLS_DC)
{
- unsigned long length = php_mysqlnd_net_field_length(row);
+ php_uint_t length = php_mysqlnd_net_field_length(row);
ps_fetch_from_1_to_8_bytes(zv, field, pack_len, row, length TSRMLS_CC);
}
/* }}} */
Check bug #52891 : Wrong data inserted with mysqli/mysqlnd when using bind_param, value > LONG_MAX
We do transformation here, which will be used later when sending types. The code later relies on this.
*/
- if (Z_DVAL(tmp_data_copy) > LONG_MAX || Z_DVAL(tmp_data_copy) < LONG_MIN) {
+ if (Z_DVAL(tmp_data_copy) > PHP_INT_MAX || Z_DVAL(tmp_data_copy) < PHP_INT_MIN) {
stmt->send_types_to_server = *resend_types_next_time = 1;
convert_to_string_ex(tmp_data);
} else {
short current_type = stmt->param_bind[i].type;
zval *parameter = &stmt->param_bind[i].zv;
/* our types are not unsigned */
-#if SIZEOF_LONG==8
+#if SIZEOF_ZEND_INT==8
if (current_type == MYSQL_TYPE_LONG) {
current_type = MYSQL_TYPE_LONGLONG;
}
Thus for NULL and zero-length we are quite efficient.
*/
if (Z_TYPE(data_cursor[i]) == IS_STRING) {
- unsigned long len = Z_STRSIZE(data_cursor[i]);
+ php_uint_t len = Z_STRSIZE(data_cursor[i]);
if (meta->fields[i].max_length < len) {
meta->fields[i].max_length = len;
}
Thus for NULL and zero-length we are quite efficient.
*/
if (Z_TYPE(current_row[i]) == IS_STRING) {
- unsigned long len = Z_STRSIZE(current_row[i]);
+ php_uint_t len = Z_STRSIZE(current_row[i]);
if (meta->fields[i].max_length < len) {
meta->fields[i].max_length = len;
}
of PHP, to be called as separate function. But let's have it for
completeness.
*/
-static unsigned long *
+static php_uint_t *
MYSQLND_METHOD(mysqlnd_result_buffered_zval, fetch_lengths)(MYSQLND_RES_BUFFERED * const result TSRMLS_DC)
{
const MYSQLND_RES_BUFFERED_ZVAL * set = (MYSQLND_RES_BUFFERED_ZVAL *) result;
of PHP, to be called as separate function. But let's have it for
completeness.
*/
-static unsigned long *
+static php_uint_t *
MYSQLND_METHOD(mysqlnd_result_buffered_c, fetch_lengths)(MYSQLND_RES_BUFFERED * const result TSRMLS_DC)
{
const MYSQLND_RES_BUFFERED_C * set = (MYSQLND_RES_BUFFERED_C *) result;
/* {{{ mysqlnd_result_unbuffered::fetch_lengths */
-static unsigned long *
+static php_uint_t *
MYSQLND_METHOD(mysqlnd_result_unbuffered, fetch_lengths)(MYSQLND_RES_UNBUFFERED * const result TSRMLS_DC)
{
/* simulate output of libmysql */
/* {{{ mysqlnd_res::fetch_lengths */
-static unsigned long *
+static php_uint_t *
MYSQLND_METHOD(mysqlnd_res, fetch_lengths)(MYSQLND_RES * const result TSRMLS_DC)
{
- unsigned long * ret;
+ php_uint_t * ret;
DBG_ENTER("mysqlnd_res::fetch_lengths");
ret = result->stored_data && result->stored_data->m.fetch_lengths ?
result->stored_data->m.fetch_lengths(result->stored_data TSRMLS_CC) :
*row = mnd_malloc(field_count * sizeof(char *));
if (*row) {
MYSQLND_FIELD * field = meta->fields;
- unsigned long * lengths = result->unbuf->lengths;
+ php_uint_t * lengths = result->unbuf->lengths;
for (i = 0; i < field_count; i++, field++) {
zval * data = &result->unbuf->last_row_data[i];
{
HashTable * row_ht = Z_ARRVAL_P(row);
MYSQLND_FIELD * field = meta->fields;
- unsigned long * lengths = result->unbuf->lengths;
+ php_uint_t * lengths = result->unbuf->lengths;
for (i = 0; i < field_count; i++, field++) {
zval * data = &result->unbuf->last_row_data[i];
Thus for NULL and zero-length we are quite efficient.
*/
if (Z_TYPE(current_row[i]) == IS_STRING) {
- unsigned long len = Z_STRSIZE(current_row[i]);
+ php_uint_t len = Z_STRSIZE(current_row[i]);
if (meta->fields[i].max_length < len) {
meta->fields[i].max_length = len;
}
Thus for NULL and zero-length we are quite efficient.
*/
if (Z_TYPE(current_row[i]) == IS_STRING) {
- unsigned long len = Z_STRSIZE(current_row[i]);
+ php_uint_t len = Z_STRSIZE(current_row[i]);
if (meta->fields[i].max_length < len) {
meta->fields[i].max_length = len;
}
Thus for NULL and zero-length we are quite efficient.
*/
if (Z_TYPE(current_row[i]) == IS_STRING) {
- unsigned long len = Z_STRSIZE(current_row[i]);
+ php_uint_t len = Z_STRSIZE(current_row[i]);
if (meta->fields[i].max_length < len) {
meta->fields[i].max_length = len;
}
MYSQLND_METHOD(mysqlnd_res, fetch_all)(MYSQLND_RES * result, const unsigned int flags, zval *return_value TSRMLS_DC ZEND_FILE_LINE_DC)
{
zval row;
- ulong i = 0;
+ php_uint_t i = 0;
MYSQLND_RES_BUFFERED *set = result->stored_data;
DBG_ENTER("mysqlnd_res::fetch_all");
DBG_RETURN(NULL);
}
- if (!(ret->lengths = mnd_pecalloc(field_count, sizeof(unsigned long), persistent))) {
+ if (!(ret->lengths = mnd_pecalloc(field_count, sizeof(php_uint_t), persistent))) {
mnd_pefree(ret, persistent);
DBG_RETURN(NULL);
}
if (!ret) {
DBG_RETURN(NULL);
}
- if (!(ret->lengths = mnd_pecalloc(field_count, sizeof(unsigned long), persistent))) {
+ if (!(ret->lengths = mnd_pecalloc(field_count, sizeof(php_uint_t), persistent))) {
mnd_pefree(ret, persistent);
DBG_RETURN(NULL);
}
}
field_packet->persistent_alloc = meta->persistent;
for (;i < meta->field_count; i++) {
- long idx;
+ php_int_t idx;
if (meta->fields[i].root) {
/* We re-read metadata for PS */
const char *db; /* Database for table */
const char *catalog; /* Catalog for table */
char *def; /* Default value (set by mysql_list_fields) */
- unsigned long length; /* Width of column (create length) */
- unsigned long max_length; /* Max width for selected set */
+ php_uint_t length; /* Width of column (create length) */
+ php_uint_t max_length; /* Max width for selected set */
unsigned int name_length;
unsigned int org_name_length;
unsigned int table_length;
typedef enum_func_status (*func_mysqlnd_conn_data__init)(MYSQLND_CONN_DATA * conn TSRMLS_DC);
typedef enum_func_status (*func_mysqlnd_conn_data__connect)(MYSQLND_CONN_DATA * 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_or_pipe, unsigned int mysql_flags TSRMLS_DC);
-typedef ulong (*func_mysqlnd_conn_data__escape_string)(MYSQLND_CONN_DATA * const conn, char *newstr, const char *escapestr, size_t escapestr_len TSRMLS_DC);
+typedef php_int_t (*func_mysqlnd_conn_data__escape_string)(MYSQLND_CONN_DATA * const conn, char *newstr, const char *escapestr, size_t escapestr_len TSRMLS_DC);
typedef enum_func_status (*func_mysqlnd_conn_data__set_charset)(MYSQLND_CONN_DATA * const conn, const char * const charset TSRMLS_DC);
typedef enum_func_status (*func_mysqlnd_conn_data__query)(MYSQLND_CONN_DATA * conn, const char * query, unsigned int query_len TSRMLS_DC);
typedef enum_func_status (*func_mysqlnd_conn_data__send_query)(MYSQLND_CONN_DATA * conn, const char *query, unsigned int query_len TSRMLS_DC);
typedef uint64_t (*func_mysqlnd_conn_data__get_thread_id)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC);
typedef void (*func_mysqlnd_conn_data__get_statistics)(const MYSQLND_CONN_DATA * const conn, zval *return_value TSRMLS_DC ZEND_FILE_LINE_DC);
-typedef unsigned long (*func_mysqlnd_conn_data__get_server_version)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC);
+typedef php_uint_t (*func_mysqlnd_conn_data__get_server_version)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC);
typedef const char * (*func_mysqlnd_conn_data__get_server_information)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC);
typedef enum_func_status (*func_mysqlnd_conn_data__get_server_statistics)(MYSQLND_CONN_DATA * conn, zend_string **message TSRMLS_DC);
typedef const char * (*func_mysqlnd_conn_data__get_host_information)(const MYSQLND_CONN_DATA * const conn TSRMLS_DC);
typedef const MYSQLND_FIELD *(*func_mysqlnd_res__fetch_fields)(MYSQLND_RES * const result TSRMLS_DC);
typedef enum_func_status (*func_mysqlnd_res__read_result_metadata)(MYSQLND_RES * result, MYSQLND_CONN_DATA * conn TSRMLS_DC);
-typedef unsigned long * (*func_mysqlnd_res__fetch_lengths)(MYSQLND_RES * const result TSRMLS_DC);
+typedef php_uint_t * (*func_mysqlnd_res__fetch_lengths)(MYSQLND_RES * const result TSRMLS_DC);
typedef enum_func_status (*func_mysqlnd_res__store_result_fetch_data)(MYSQLND_CONN_DATA * const conn, MYSQLND_RES * result, MYSQLND_RES_METADATA * meta, MYSQLND_MEMORY_POOL_CHUNK *** row_buffers, zend_bool binary_protocol TSRMLS_DC);
typedef void (*func_mysqlnd_res__free_result_buffers)(MYSQLND_RES * result TSRMLS_DC); /* private */
typedef uint64_t (*func_mysqlnd_result_unbuffered__num_rows)(const MYSQLND_RES_UNBUFFERED * const result TSRMLS_DC);
-typedef unsigned long * (*func_mysqlnd_result_unbuffered__fetch_lengths)(MYSQLND_RES_UNBUFFERED * const result TSRMLS_DC);
+typedef php_uint_t * (*func_mysqlnd_result_unbuffered__fetch_lengths)(MYSQLND_RES_UNBUFFERED * const result TSRMLS_DC);
typedef void (*func_mysqlnd_result_unbuffered__free_last_data)(MYSQLND_RES_UNBUFFERED * result, MYSQLND_STATS * const global_stats TSRMLS_DC);
typedef void (*func_mysqlnd_result_unbuffered__free_result)(MYSQLND_RES_UNBUFFERED * const result, MYSQLND_STATS * const global_stats TSRMLS_DC);
typedef uint64_t (*func_mysqlnd_result_buffered__num_rows)(const MYSQLND_RES_BUFFERED * const result TSRMLS_DC);
typedef enum_func_status (*func_mysqlnd_result_buffered__initialize_result_set_rest)(MYSQLND_RES_BUFFERED * const result, MYSQLND_RES_METADATA * const meta,
MYSQLND_STATS * stats, zend_bool int_and_float_native TSRMLS_DC);
-typedef unsigned long * (*func_mysqlnd_result_buffered__fetch_lengths)(MYSQLND_RES_BUFFERED * const result TSRMLS_DC);
+typedef php_uint_t * (*func_mysqlnd_result_buffered__fetch_lengths)(MYSQLND_RES_BUFFERED * const result TSRMLS_DC);
typedef enum_func_status (*func_mysqlnd_result_buffered__data_seek)(MYSQLND_RES_BUFFERED * const result, const uint64_t row TSRMLS_DC);
typedef void (*func_mysqlnd_result_buffered__free_result)(MYSQLND_RES_BUFFERED * const result TSRMLS_DC);
typedef enum_func_status (*func_mysqlnd_stmt__refresh_bind_param)(MYSQLND_STMT * const stmt TSRMLS_DC);
typedef enum_func_status (*func_mysqlnd_stmt__bind_result)(MYSQLND_STMT * const stmt, MYSQLND_RESULT_BIND * const result_bind TSRMLS_DC);
typedef enum_func_status (*func_mysqlnd_stmt__bind_one_result)(MYSQLND_STMT * const stmt, unsigned int param_no TSRMLS_DC);
-typedef enum_func_status (*func_mysqlnd_stmt__send_long_data)(MYSQLND_STMT * const stmt, unsigned int param_num, const char * const data, unsigned long length TSRMLS_DC);
+typedef enum_func_status (*func_mysqlnd_stmt__send_long_data)(MYSQLND_STMT * const stmt, unsigned int param_num, const char * const data, php_uint_t length TSRMLS_DC);
typedef MYSQLND_RES * (*func_mysqlnd_stmt__get_parameter_metadata)(MYSQLND_STMT * const stmt TSRMLS_DC);
typedef MYSQLND_RES * (*func_mysqlnd_stmt__get_result_metadata)(MYSQLND_STMT * const stmt TSRMLS_DC);
typedef uint64_t (*func_mysqlnd_stmt__get_last_insert_id)(const MYSQLND_STMT * const stmt TSRMLS_DC);
unsigned int connect_or_select_db_len;
MYSQLND_INFILE infile;
unsigned int protocol_version;
- unsigned long max_packet_size;
+ php_uint_t max_packet_size;
unsigned int port;
- unsigned long client_flag;
- unsigned long server_capabilities;
+ php_uint_t client_flag;
+ php_uint_t server_capabilities;
/* For UPSERT queries */
MYSQLND_UPSERT_STATUS * upsert_status;
struct mysqlnd_field_hash_key
{
zend_bool is_numeric;
- unsigned long key;
+ php_uint_t key;
};
uint64_t initialized_rows; \
\
/* Column lengths of current row - both buffered and unbuffered. For buffered results it duplicates the data found in **data */ \
- unsigned long *lengths; \
+ php_uint_t *lengths; \
\
MYSQLND_MEMORY_POOL *result_set_memory_pool; \
\
Column lengths of current row - both buffered and unbuffered.
For buffered results it duplicates the data found in **data
*/
- unsigned long *lengths;
+ php_uint_t *lengths;
MYSQLND_MEMORY_POOL *result_set_memory_pool;
struct st_mysqlnd_stmt_data
{
MYSQLND_CONN_DATA *conn;
- unsigned long stmt_id;
- unsigned long flags;/* cursor is set here */
+ php_uint_t stmt_id;
+ php_uint_t flags;/* cursor is set here */
enum_mysqlnd_stmt_state state;
unsigned int warning_count;
MYSQLND_RES *result;
MYSQLND_ERROR_INFO error_info_impl;
zend_bool update_max_length;
- unsigned long prefetch_rows;
+ php_uint_t prefetch_rows;
zend_bool cursor_exists;
mysqlnd_stmt_use_or_store_func default_rset_handler;
{
unsigned int plugin_api_version;
const char * plugin_name;
- unsigned long plugin_version;
+ php_uint_t plugin_version;
const char * plugin_string_version;
const char * plugin_license;
const char * plugin_author;
MYSQLND_CONN_DATA * conn, const char * const user, const char * const passwd,
const size_t passwd_len, zend_uchar * auth_plugin_data, size_t auth_plugin_data_len,
const MYSQLND_OPTIONS * const options,
- const MYSQLND_NET_OPTIONS * const net_options, unsigned long mysql_flags
+ const MYSQLND_NET_OPTIONS * const net_options, php_uint_t mysql_flags
TSRMLS_DC);
struct st_mysqlnd_authentication_plugin
/* {{{ php_mysqlnd_net_field_length
Get next field's length */
-unsigned long
+php_uint_t
php_mysqlnd_net_field_length(zend_uchar **packet)
{
register zend_uchar *p= (zend_uchar *)*packet;
if (*p < 251) {
(*packet)++;
- return (unsigned long) *p;
+ return (php_uint_t) *p;
}
switch (*p) {
return MYSQLND_NULL_LENGTH;
case 252:
(*packet) += 3;
- return (unsigned long) uint2korr(p+1);
+ return (php_uint_t) uint2korr(p+1);
case 253:
(*packet) += 4;
- return (unsigned long) uint3korr(p+1);
+ return (php_uint_t) uint3korr(p+1);
default:
(*packet) += 9;
- return (unsigned long) uint4korr(p+1);
+ return (php_uint_t) uint4korr(p+1);
}
}
/* }}} */
while (SUCCESS == zend_hash_get_current_data_ex(packet->connect_attr, (void **)&entry_value, &pos_value)) {
char *s_key;
unsigned int s_len;
- unsigned long num_key;
+ php_uint_t num_key;
size_t value_len = strlen(*entry_value);
if (HASH_KEY_IS_STRING == zend_hash_get_current_key_ex(packet->connect_attr, &s_key, &s_len, &num_key, 0, &pos_value)) {
{
zend_string * key;
- unsigned long unused_num_key;
+ php_uint_t unused_num_key;
zval * entry_value;
ZEND_HASH_FOREACH_KEY_VAL(packet->connect_attr, unused_num_key, key, entry_value) {
if (key) { /* HASH_KEY_IS_STRING */
while (SUCCESS == zend_hash_get_current_data_ex(packet->connect_attr, (void **)&entry_value, &pos_value)) {
char *s_key;
unsigned int s_len;
- unsigned long num_key;
+ php_uint_t num_key;
size_t value_len = strlen(*entry_value);
if (HASH_KEY_IS_STRING == zend_hash_get_current_key_ex(packet->connect_attr, &s_key, &s_len, &num_key, 0, &pos_value)) {
/* copy key */
#else
{
zend_string * key;
- unsigned long unused_num_key;
+ php_uint_t unused_num_key;
zval * entry_value;
ZEND_HASH_FOREACH_KEY_VAL(packet->connect_attr, unused_num_key, key, entry_value) {
if (key) { /* HASH_KEY_IS_STRING */
zend_uchar *buf = conn->net->cmd_buffer.buffer? (zend_uchar *) conn->net->cmd_buffer.buffer : local_buf;
zend_uchar *p = buf;
zend_uchar *begin = buf;
- unsigned long i;
+ php_uint_t i;
register MYSQLND_PACKET_AUTH_RESPONSE * packet= (MYSQLND_PACKET_AUTH_RESPONSE *) _packet;
DBG_ENTER("php_mysqlnd_auth_response_read");
packet->message_len = 0;
}
- DBG_INF_FMT("OK packet: aff_rows=%lld last_ins_id=%ld server_status=%u warnings=%u",
+ DBG_INF_FMT("OK packet: aff_rows=%lld last_ins_id=%pd server_status=%u warnings=%u",
packet->affected_rows, packet->last_insert_id, packet->server_status,
packet->warning_count);
}
zend_uchar *buf = conn->net->cmd_buffer.buffer? (zend_uchar *) conn->net->cmd_buffer.buffer : local_buf;
zend_uchar *p = buf;
zend_uchar *begin = buf;
- unsigned long i;
+ php_uint_t i;
register MYSQLND_PACKET_OK *packet= (MYSQLND_PACKET_OK *) _packet;
DBG_ENTER("php_mysqlnd_ok_read");
zend_uchar *p = buf;
zend_uchar *begin = buf;
char *root_ptr;
- unsigned long len;
+ php_uint_t len;
MYSQLND_FIELD *meta;
unsigned int i, field_count = sizeof(rset_field_offsets)/sizeof(size_t);
for (i = 0, current_field = start_field; current_field < end_field; current_field++, i++) {
/* php_mysqlnd_net_field_length() call should be after *this_field_len_pos = p; */
- unsigned long len = php_mysqlnd_net_field_length(&p);
+ php_uint_t len = php_mysqlnd_net_field_length(&p);
/* NULL or NOT NULL, this is the question! */
if (len == MYSQLND_NULL_LENGTH) {
zend_uchar save = *(p + len);
/* We have to make it ASCIIZ temporarily */
*(p + len) = '\0';
- if (perm_bind.pack_len < SIZEOF_LONG) {
+ if (perm_bind.pack_len < SIZEOF_ZEND_INT) {
/* direct conversion */
int64_t v =
#ifndef PHP_WIN32
#else
_atoi64((char *) p);
#endif
- ZVAL_INT(current_field, (long) v); /* the cast is safe */
+ ZVAL_INT(current_field, (php_int_t) v); /* the cast is safe */
} else {
uint64_t v =
#ifndef PHP_WIN32
#endif
zend_bool uns = fields_metadata[i].flags & UNSIGNED_FLAG? TRUE:FALSE;
/* We have to make it ASCIIZ temporarily */
-#if SIZEOF_LONG==8
+#if SIZEOF_ZEND_INT==8
if (uns == TRUE && v > 9223372036854775807L)
-#elif SIZEOF_LONG==4
+#elif SIZEOF_ZEND_INT==4
if ((uns == TRUE && v > L64(2147483647)) ||
(uns == FALSE && (( L64(2147483647) < (int64_t) v) ||
(L64(-2147483648) > (int64_t) v))))
{
ZVAL_STRINGL(current_field, (char *)p, len);
} else {
- ZVAL_INT(current_field, (long) v); /* the cast is safe */
+ ZVAL_INT(current_field, (php_int_t) v); /* the cast is safe */
}
}
*(p + len) = save;
*/
p -= len;
if (Z_TYPE_P(current_field) == IS_INT) {
- bit_area += 1 + sprintf((char *)start, "%ld", Z_IVAL_P(current_field));
+ bit_area += 1 + sprintf((char *)start, ZEND_INT_FMT, Z_IVAL_P(current_field));
ZVAL_STRINGL(current_field, (char *) start, bit_area - start - 1);
} else if (Z_TYPE_P(current_field) == IS_STRING){
memcpy(bit_area, Z_STRVAL_P(current_field), Z_STRSIZE_P(current_field));
#define MYSQLND_HEADER_SIZE 4
#define COMPRESSED_HEADER_SIZE 3
-#define MYSQLND_NULL_LENGTH (unsigned long) ~0
+#define MYSQLND_NULL_LENGTH (php_uint_t) ~0
/* Used in mysqlnd_debug.c */
PHPAPI extern const char mysqlnd_read_header_name[];
error_no != 0 => error
others => result set -> Read res_field packets up to field_count
*/
- unsigned long field_count;
+ php_uint_t field_count;
/*
These are filled if no SELECT query. For SELECT warning_count
and server status are in the last row packet, the EOF packet.
MYSQLND_PACKET_HEADER header;
/* also known as field_count 0x00=OK , 0xFF=error */
unsigned char error_code;
- unsigned long stmt_id;
+ php_uint_t stmt_id;
unsigned int field_count;
unsigned int param_count;
unsigned int warning_count;
PHPAPI void php_mysqlnd_scramble(zend_uchar * const buffer, const zend_uchar * const scramble, const zend_uchar * const pass, size_t pass_len);
-unsigned long php_mysqlnd_net_field_length(zend_uchar **packet);
+php_uint_t php_mysqlnd_net_field_length(zend_uchar **packet);
zend_uchar * php_mysqlnd_net_store_length(zend_uchar *packet, uint64_t length);
size_t php_mysqlnd_net_store_length_size(uint64_t length);
#else
"not supported");
#endif
- snprintf(buf, sizeof(buf), "%ld", MYSQLND_G(net_cmd_buffer_size));
+ snprintf(buf, sizeof(buf), "%pd", MYSQLND_G(net_cmd_buffer_size));
php_info_print_table_row(2, "Command buffer size", buf);
- snprintf(buf, sizeof(buf), "%ld", MYSQLND_G(net_read_buffer_size));
+ snprintf(buf, sizeof(buf), "%pd", MYSQLND_G(net_read_buffer_size));
php_info_print_table_row(2, "Read buffer size", buf);
- snprintf(buf, sizeof(buf), "%ld", MYSQLND_G(net_read_timeout));
+ snprintf(buf, sizeof(buf), "%pd", MYSQLND_G(net_read_timeout));
php_info_print_table_row(2, "Read timeout", buf);
php_info_print_table_row(2, "Collecting statistics", MYSQLND_G(collect_statistics)? "Yes":"No");
php_info_print_table_row(2, "Collecting memory statistics", MYSQLND_G(collect_memory_statistics)? "Yes":"No");
*/
static PHP_INI_MH(OnUpdateNetCmdBufferSize)
{
- long long_value = atol(new_value);
+ php_int_t long_value;
+
+ ZEND_ATOI(long_value, new_value);
if (long_value < MYSQLND_NET_CMD_BUFFER_MIN_SIZE) {
return FAILURE;
}
// "test" database must be existed. i.e. "createdb test" before testing
// PostgreSQL uses login name as username, user must have access to "test" database.
-$conn_str = "host=localhost dbname=test port=5432"; // connection string
+$conn_str = "user=test password=test host=localhost dbname=test port=5432"; // connection string
$table_name = "php_pgsql_test"; // test table that will be created
$table_name_92 = "php_pgsql_test_92"; // test table that will be created
$num_test_record = 1000; // Number of records to create
projects / php / commitdiff