PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/mysqli - mysqli_api.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 651 691 94.2 %
Date: 2014-12-15 Functions: 81 83 97.6 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :   +----------------------------------------------------------------------+
       3             :   | PHP Version 5                                                        |
       4             :   +----------------------------------------------------------------------+
       5             :   | Copyright (c) 1997-2014 The PHP Group                                |
       6             :   +----------------------------------------------------------------------+
       7             :   | This source file is subject to version 3.01 of the PHP license,      |
       8             :   | that is bundled with this package in the file LICENSE, and is        |
       9             :   | available through the world-wide-web at the following url:           |
      10             :   | http://www.php.net/license/3_01.txt                                  |
      11             :   | If you did not receive a copy of the PHP license and are unable to   |
      12             :   | obtain it through the world-wide-web, please send a note to          |
      13             :   | license@php.net so we can mail you a copy immediately.               |
      14             :   +----------------------------------------------------------------------+
      15             :   | Authors: Georg Richter <georg@php.net>                               |
      16             :   |          Andrey Hristov <andrey@php.net>                             |
      17             :   |          Ulf Wendel <uw@php.net>                                     |
      18             :   +----------------------------------------------------------------------+
      19             : 
      20             :   $Id$
      21             : */
      22             : 
      23             : #ifdef HAVE_CONFIG_H
      24             : #include "config.h"
      25             : #endif
      26             : 
      27             : #include <signal.h>
      28             : 
      29             : #include "php.h"
      30             : #include "php_ini.h"
      31             : #include "php_globals.h"
      32             : #include "ext/standard/info.h"
      33             : #include "php_mysqli_structs.h"
      34             : #include "mysqli_priv.h"
      35             : 
      36             : /* {{{ proto mixed mysqli_affected_rows(object link)
      37             :    Get number of affected rows in previous MySQL operation */
      38          27 : PHP_FUNCTION(mysqli_affected_rows)
      39             : {
      40             :         MY_MYSQL                *mysql;
      41             :         zval                    *mysql_link;
      42             :         my_ulonglong    rc;
      43             : 
      44          27 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
      45           3 :                 return;
      46             :         }
      47             : 
      48          24 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
      49             : 
      50          17 :         rc = mysql_affected_rows(mysql->mysql);
      51          17 :         if (rc == (my_ulonglong) -1) {
      52           1 :                 RETURN_LONG(-1);
      53             :         }
      54          16 :         MYSQLI_RETURN_LONG_LONG(rc);
      55             : }
      56             : /* }}} */
      57             : 
      58             : 
      59             : /* {{{ proto bool mysqli_autocommit(object link, bool mode)
      60             :    Turn auto commit on or of */
      61          30 : PHP_FUNCTION(mysqli_autocommit)
      62             : {
      63             :         MY_MYSQL        *mysql;
      64             :         zval            *mysql_link;
      65             :         zend_bool       automode;
      66             : 
      67          30 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ob", &mysql_link, mysqli_link_class_entry, &automode) == FAILURE) {
      68           3 :                 return;
      69             :         }
      70          27 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
      71             : 
      72          25 :         if (mysql_autocommit(mysql->mysql, (my_bool)automode)) {
      73           0 :                 RETURN_FALSE;
      74             :         }
      75          25 :         RETURN_TRUE;
      76             : }
      77             : /* }}} */
      78             : 
      79             : /* {{{ mysqli_stmt_bind_param_do_bind */
      80             : #ifndef MYSQLI_USE_MYSQLND
      81             : static
      82             : int mysqli_stmt_bind_param_do_bind(MY_STMT *stmt, unsigned int argc, unsigned int num_vars,
      83             :                                                                    zval ***args, unsigned int start, const char * const types TSRMLS_DC)
      84             : {
      85             :         int                             i, ofs;
      86             :         MYSQL_BIND              *bind;
      87             :         unsigned long   rc;
      88             : 
      89             :         /* prevent leak if variables are already bound */
      90             :         if (stmt->param.var_cnt) {
      91             :                 php_free_stmt_bind_buffer(stmt->param, FETCH_SIMPLE);
      92             :         }
      93             : 
      94             :         stmt->param.is_null = ecalloc(num_vars, sizeof(char));
      95             :         bind = (MYSQL_BIND *) ecalloc(num_vars, sizeof(MYSQL_BIND));
      96             : 
      97             :         ofs = 0;
      98             :         for (i = start; i < argc; i++) {
      99             : 
     100             :                 /* set specified type */
     101             :                 switch (types[ofs]) {
     102             :                         case 'd': /* Double */
     103             :                                 bind[ofs].buffer_type = MYSQL_TYPE_DOUBLE;
     104             :                                 bind[ofs].buffer = &Z_DVAL_PP(args[i]);
     105             :                                 bind[ofs].is_null = &stmt->param.is_null[ofs];
     106             :                                 break;
     107             : 
     108             :                         case 'i': /* Integer */
     109             : #if SIZEOF_LONG==8
     110             :                                 bind[ofs].buffer_type = MYSQL_TYPE_LONGLONG;
     111             : #elif SIZEOF_LONG==4
     112             :                                 bind[ofs].buffer_type = MYSQL_TYPE_LONG;
     113             : #endif
     114             :                                 bind[ofs].buffer = &Z_LVAL_PP(args[i]);
     115             :                                 bind[ofs].is_null = &stmt->param.is_null[ofs];
     116             :                                 break;
     117             : 
     118             :                         case 'b': /* Blob (send data) */
     119             :                                 bind[ofs].buffer_type = MYSQL_TYPE_LONG_BLOB;
     120             :                                 /* don't initialize is_null and length to 0 because we use ecalloc */
     121             :                                 break;
     122             : 
     123             :                         case 's': /* string */
     124             :                                 bind[ofs].buffer_type = MYSQL_TYPE_VAR_STRING;
     125             :                                 /* don't initialize buffer and buffer_length because we use ecalloc */
     126             :                                 bind[ofs].is_null = &stmt->param.is_null[ofs];
     127             :                                 break;
     128             : 
     129             :                         default:
     130             :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Undefined fieldtype %c (parameter %d)", types[ofs], i+1);
     131             :                                 rc = 1;
     132             :                                 goto end_1;
     133             :                 }
     134             :                 ofs++;
     135             :         }
     136             :         rc = mysql_stmt_bind_param(stmt->stmt, bind);
     137             : 
     138             : end_1:
     139             :         if (rc) {
     140             :                 efree(stmt->param.is_null);
     141             :         } else {
     142             :                 stmt->param.var_cnt = num_vars;
     143             :                 stmt->param.vars = (zval **)safe_emalloc(num_vars, sizeof(zval), 0);
     144             :                 for (i = 0; i < num_vars; i++) {
     145             :                         if (bind[i].buffer_type  != MYSQL_TYPE_LONG_BLOB) {
     146             :                                 Z_ADDREF_P(*args[i+start]);
     147             :                                 stmt->param.vars[i] = *args[i+start];
     148             :                         } else {
     149             :                                 stmt->param.vars[i] = NULL;
     150             :                         }
     151             :                 }
     152             :         }
     153             :         efree(bind);
     154             : 
     155             :         return rc;
     156             : }
     157             : #else
     158             : static
     159       20879 : int mysqli_stmt_bind_param_do_bind(MY_STMT *stmt, unsigned int argc, unsigned int num_vars,
     160             :                                                                    zval ***args, unsigned int start, const char * const types TSRMLS_DC)
     161             : {
     162             :         unsigned int i;
     163             :         MYSQLND_PARAM_BIND      *params;
     164       20879 :         enum_func_status        ret = FAIL;
     165             : 
     166             :         /* If no params -> skip binding and return directly */
     167       20879 :         if (argc == start) {
     168           0 :                 return PASS;
     169             :         }
     170       20879 :         params = mysqlnd_stmt_alloc_param_bind(stmt->stmt);
     171       20879 :         if (!params) {
     172           0 :                 goto end;
     173             :         }
     174      195680 :         for (i = 0; i < (argc - start); i++) {
     175             :                 zend_uchar type;
     176      174803 :                 switch (types[i]) {
     177             :                         case 'd': /* Double */
     178         976 :                                 type = MYSQL_TYPE_DOUBLE;
     179         976 :                                 break;
     180             :                         case 'i': /* Integer */
     181             : #if SIZEOF_LONG==8
     182      153547 :                                 type = MYSQL_TYPE_LONGLONG;
     183             : #elif SIZEOF_LONG==4
     184             :                                 type = MYSQL_TYPE_LONG;
     185             : #endif
     186      153547 :                                 break;
     187             :                         case 'b': /* Blob (send data) */
     188          24 :                                 type = MYSQL_TYPE_LONG_BLOB;
     189          24 :                                 break;
     190             :                         case 's': /* string */
     191       20254 :                                 type = MYSQL_TYPE_VAR_STRING;
     192       20254 :                                 break;
     193             :                         default:
     194             :                                 /* We count parameters from 1 */
     195           2 :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Undefined fieldtype %c (parameter %d)", types[i], i + start + 1);
     196           2 :                                 ret = FAIL;
     197           2 :                                 mysqlnd_stmt_free_param_bind(stmt->stmt, params);
     198           2 :                                 goto end;
     199             :                 }
     200      174801 :                 params[i].zv = *(args[i + start]);
     201      174801 :                 params[i].type = type;
     202             :         }
     203       20877 :         ret = mysqlnd_stmt_bind_param(stmt->stmt, params);
     204             : 
     205             : end:
     206       20879 :         return ret;
     207             : }
     208             : #endif
     209             : /* }}} */
     210             : 
     211             : /* {{{ proto bool mysqli_stmt_bind_param(object stmt, string types, mixed variable [,mixed,....]) U
     212             :    Bind variables to a prepared statement as parameters */
     213       20890 : PHP_FUNCTION(mysqli_stmt_bind_param)
     214             : {
     215             :         zval                    ***args;
     216       20890 :         int                             argc = ZEND_NUM_ARGS();
     217             :         int                             num_vars;
     218       20890 :         int                             start = 2;
     219             :         MY_STMT                 *stmt;
     220             :         zval                    *mysql_stmt;
     221             :         char                    *types;
     222             :         int                             types_len;
     223             :         unsigned long   rc;
     224             : 
     225             :         /* calculate and check number of parameters */
     226       20890 :         if (argc < 2) {
     227             :                 /* there has to be at least one pair */
     228           3 :                 WRONG_PARAM_COUNT;
     229             :         }
     230             : 
     231       20887 :         if (zend_parse_method_parameters((getThis()) ? 1:2 TSRMLS_CC, getThis(), "Os", &mysql_stmt, mysqli_stmt_class_entry,
     232             :                                                                         &types, &types_len) == FAILURE) {
     233           1 :                 return;
     234             :         }
     235             : 
     236       20886 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
     237             : 
     238       20886 :         num_vars = argc - 1;
     239       20886 :         if (getThis()) {
     240          24 :                 start = 1;
     241             :         } else {
     242             :                 /* ignore handle parameter in procedural interface*/
     243       20862 :                 --num_vars;
     244             :         }
     245       20886 :         if (!types_len) {
     246           1 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid type or no types specified");
     247           1 :                 RETURN_FALSE;
     248             :         }
     249             : 
     250       20885 :         if (types_len != argc - start) {
     251             :                 /* number of bind variables doesn't match number of elements in type definition string */
     252           3 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number of elements in type definition string doesn't match number of bind variables");
     253           3 :                 RETURN_FALSE;
     254             :         }
     255             : 
     256       20882 :         if (types_len != mysql_stmt_param_count(stmt->stmt)) {
     257           3 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number of variables doesn't match number of parameters in prepared statement");
     258           3 :                 RETURN_FALSE;
     259             :         }
     260             : 
     261       20879 :         args = (zval ***)safe_emalloc(argc, sizeof(zval **), 0);
     262             : 
     263       20879 :         if (zend_get_parameters_array_ex(argc, args) == FAILURE) {
     264           0 :                 zend_wrong_param_count(TSRMLS_C);
     265           0 :                 rc = 1;
     266             :         } else {
     267       20879 :                 rc = mysqli_stmt_bind_param_do_bind(stmt, argc, num_vars, args, start, types TSRMLS_CC);
     268       20879 :                 MYSQLI_REPORT_STMT_ERROR(stmt->stmt);
     269             :         }
     270             : 
     271       20879 :         efree(args);
     272             : 
     273       20879 :         RETURN_BOOL(!rc);
     274             : }
     275             : /* }}} */
     276             : 
     277             : /* {{{ mysqli_stmt_bind_result_do_bind */
     278             : #ifndef MYSQLI_USE_MYSQLND
     279             : /* TODO:
     280             :    do_alloca, free_alloca
     281             : */
     282             : static int
     283             : mysqli_stmt_bind_result_do_bind(MY_STMT *stmt, zval ***args, unsigned int argc, unsigned int start TSRMLS_DC)
     284             : {
     285             :         MYSQL_BIND      *bind;
     286             :         int                     i, ofs;
     287             :         int                     var_cnt = argc - start;
     288             :         long            col_type;
     289             :         ulong           rc;
     290             : 
     291             :         /* prevent leak if variables are already bound */
     292             :         if (stmt->result.var_cnt) {
     293             :                 php_free_stmt_bind_buffer(stmt->result, FETCH_RESULT);
     294             :         }
     295             : 
     296             :         bind = (MYSQL_BIND *)ecalloc(var_cnt, sizeof(MYSQL_BIND));
     297             :         {
     298             :                 int size;
     299             :                 char *p= emalloc(size= var_cnt * (sizeof(char) + sizeof(VAR_BUFFER)));
     300             :                 stmt->result.buf = (VAR_BUFFER *) p;
     301             :                 stmt->result.is_null = p + var_cnt * sizeof(VAR_BUFFER);
     302             :                 memset(p, 0, size);
     303             :         }
     304             : 
     305             :         for (i=start; i < var_cnt + start ; i++) {
     306             :                 ofs = i - start;
     307             :                 col_type = (stmt->stmt->fields) ? stmt->stmt->fields[ofs].type : MYSQL_TYPE_STRING;
     308             : 
     309             :                 switch (col_type) {
     310             :                         case MYSQL_TYPE_DOUBLE:
     311             :                         case MYSQL_TYPE_FLOAT:
     312             :                                 convert_to_double_ex(args[i]);
     313             :                                 stmt->result.buf[ofs].type = IS_DOUBLE;
     314             :                                 stmt->result.buf[ofs].buflen = sizeof(double);
     315             : 
     316             :                                 /* allocate buffer for double */
     317             :                                 stmt->result.buf[ofs].val = (char *)emalloc(sizeof(double));
     318             :                                 bind[ofs].buffer_type = MYSQL_TYPE_DOUBLE;
     319             :                                 bind[ofs].buffer = stmt->result.buf[ofs].val;
     320             :                                 bind[ofs].is_null = &stmt->result.is_null[ofs];
     321             :                                 break;
     322             : 
     323             :                         case MYSQL_TYPE_NULL:
     324             :                                 stmt->result.buf[ofs].type = IS_NULL;
     325             :                                 /*
     326             :                                   don't initialize to 0 :
     327             :                                   1. stmt->result.buf[ofs].buflen
     328             :                                   2. bind[ofs].buffer
     329             :                                   3. bind[ofs].buffer_length
     330             :                                   because memory was allocated with ecalloc
     331             :                                 */
     332             :                                 bind[ofs].buffer_type = MYSQL_TYPE_NULL;
     333             :                                 bind[ofs].is_null = &stmt->result.is_null[ofs];
     334             :                                 break;
     335             : 
     336             :                         case MYSQL_TYPE_SHORT:
     337             :                         case MYSQL_TYPE_TINY:
     338             :                         case MYSQL_TYPE_LONG:
     339             :                         case MYSQL_TYPE_INT24:
     340             :                         case MYSQL_TYPE_YEAR:
     341             :                                 convert_to_long_ex(args[i]);
     342             :                                 stmt->result.buf[ofs].type = IS_LONG;
     343             :                                 /* don't set stmt->result.buf[ofs].buflen to 0, we used ecalloc */
     344             :                                 stmt->result.buf[ofs].val = (char *)emalloc(sizeof(int));
     345             :                                 bind[ofs].buffer_type = MYSQL_TYPE_LONG;
     346             :                                 bind[ofs].buffer = stmt->result.buf[ofs].val;
     347             :                                 bind[ofs].is_null = &stmt->result.is_null[ofs];
     348             :                                 bind[ofs].is_unsigned = (stmt->stmt->fields[ofs].flags & UNSIGNED_FLAG) ? 1 : 0;
     349             :                                 break;
     350             : 
     351             :                         case MYSQL_TYPE_LONGLONG:
     352             : #if MYSQL_VERSION_ID > 50002 || defined(MYSQLI_USE_MYSQLND)
     353             :                         case MYSQL_TYPE_BIT:
     354             : #endif
     355             :                                 stmt->result.buf[ofs].type = IS_STRING;
     356             :                                 stmt->result.buf[ofs].buflen = sizeof(my_ulonglong);
     357             :                                 stmt->result.buf[ofs].val = (char *)emalloc(stmt->result.buf[ofs].buflen);
     358             :                                 bind[ofs].buffer_type = col_type;
     359             :                                 bind[ofs].buffer = stmt->result.buf[ofs].val;
     360             :                                 bind[ofs].is_null = &stmt->result.is_null[ofs];
     361             :                                 bind[ofs].buffer_length = stmt->result.buf[ofs].buflen;
     362             :                                 bind[ofs].is_unsigned = (stmt->stmt->fields[ofs].flags & UNSIGNED_FLAG) ? 1 : 0;
     363             :                                 bind[ofs].length = &stmt->result.buf[ofs].output_len;
     364             :                                 break;
     365             : 
     366             :                         case MYSQL_TYPE_DATE:
     367             :                         case MYSQL_TYPE_TIME:
     368             :                         case MYSQL_TYPE_DATETIME:
     369             :                         case MYSQL_TYPE_NEWDATE:
     370             :                         case MYSQL_TYPE_VAR_STRING:
     371             :                         case MYSQL_TYPE_STRING:
     372             :                         case MYSQL_TYPE_TINY_BLOB:
     373             :                         case MYSQL_TYPE_BLOB:
     374             :                         case MYSQL_TYPE_MEDIUM_BLOB:
     375             :                         case MYSQL_TYPE_LONG_BLOB:
     376             :                         case MYSQL_TYPE_TIMESTAMP:
     377             :                         case MYSQL_TYPE_DECIMAL:
     378             :                         case MYSQL_TYPE_GEOMETRY:
     379             : #ifdef FIELD_TYPE_NEWDECIMAL
     380             :                         case MYSQL_TYPE_NEWDECIMAL:
     381             : #endif
     382             :                         {
     383             : #if MYSQL_VERSION_ID >= 50107
     384             :                                 /* Changed to my_bool in MySQL 5.1. See MySQL Bug #16144 */
     385             :                                 my_bool tmp;
     386             : #else
     387             :                                 ulong tmp = 0;
     388             : #endif
     389             :                                 stmt->result.buf[ofs].type = IS_STRING;
     390             :                                 /*
     391             :                                         If the user has called $stmt->store_result() then we have asked
     392             :                                         max_length to be updated. this is done only for BLOBS because we don't want to allocate
     393             :                                         big chunkgs of memory 2^16 or 2^24
     394             :                                 */
     395             :                                 if (stmt->stmt->fields[ofs].max_length == 0 &&
     396             :                                         !mysql_stmt_attr_get(stmt->stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &tmp) && !tmp)
     397             :                                 {
     398             :                                         /*
     399             :                                           Allocate directly 256 because it's easier to allocate a bit more
     400             :                                           than update max length even for text columns. Try SELECT UNION SELECT UNION with
     401             :                                           different lengths and you will see that we get different lengths in stmt->stmt->fields[ofs].length
     402             :                                           The just take 256 and saves us from realloc-ing.
     403             :                                         */
     404             :                                         stmt->result.buf[ofs].buflen =
     405             :                                                 (stmt->stmt->fields) ? (stmt->stmt->fields[ofs].length) ? stmt->stmt->fields[ofs].length + 1: 256: 256;
     406             : 
     407             :                                 } else {
     408             :                                         /*
     409             :                                                 the user has called store_result(). if he does not there is no way to determine the
     410             :                                                 libmysql does not allow us to allocate 0 bytes for a buffer so we try 1
     411             :                                         */
     412             :                                         if (!(stmt->result.buf[ofs].buflen = stmt->stmt->fields[ofs].max_length))
     413             :                                                 ++stmt->result.buf[ofs].buflen;
     414             :                                 }
     415             :                                 stmt->result.buf[ofs].val = (char *)emalloc(stmt->result.buf[ofs].buflen);
     416             :                                 bind[ofs].buffer_type = MYSQL_TYPE_STRING;
     417             :                                 bind[ofs].buffer = stmt->result.buf[ofs].val;
     418             :                                 bind[ofs].is_null = &stmt->result.is_null[ofs];
     419             :                                 bind[ofs].buffer_length = stmt->result.buf[ofs].buflen;
     420             :                                 bind[ofs].length = &stmt->result.buf[ofs].output_len;
     421             :                                 break;
     422             :                         }
     423             :                         default:
     424             :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Server returned unknown type %ld. Probably your client library is incompatible with the server version you use!", col_type);
     425             :                                 break;
     426             :                 }
     427             :         }
     428             : 
     429             :         rc = mysql_stmt_bind_result(stmt->stmt, bind);
     430             :         MYSQLI_REPORT_STMT_ERROR(stmt->stmt);
     431             : 
     432             :         if (rc) {
     433             :                 /* dont close the statement or subsequent usage (for example ->execute()) will lead to crash */
     434             :                 for (i=0; i < var_cnt ; i++) {
     435             :                         if (stmt->result.buf[i].val) {
     436             :                                 efree(stmt->result.buf[i].val);
     437             :                         }
     438             :                 }
     439             :                 /* Don't free stmt->result.is_null because is_null & buf are one block of memory  */
     440             :                 efree(stmt->result.buf);
     441             :         } else {
     442             :                 stmt->result.var_cnt = var_cnt;
     443             :                 stmt->result.vars = (zval **)safe_emalloc((var_cnt), sizeof(zval), 0);
     444             :                 for (i = start; i < var_cnt+start; i++) {
     445             :                         ofs = i-start;
     446             :                         Z_ADDREF_PP(args[i]);
     447             :                         stmt->result.vars[ofs] = *args[i];
     448             :                 }
     449             :         }
     450             :         efree(bind);
     451             : 
     452             :         return rc;
     453             : }
     454             : #else
     455             : static int
     456        1269 : mysqli_stmt_bind_result_do_bind(MY_STMT *stmt, zval ***args, unsigned int argc, unsigned int start TSRMLS_DC)
     457             : {
     458             :         unsigned int i;
     459        1269 :         MYSQLND_RESULT_BIND * params = mysqlnd_stmt_alloc_result_bind(stmt->stmt);
     460        1269 :         if (params) {
     461        6791 :                 for (i = 0; i < (argc - start); i++) {
     462        5522 :                         params[i].zv = *(args[i + start]);
     463             :                 }
     464        1269 :                 return mysqlnd_stmt_bind_result(stmt->stmt, params);
     465             :         }
     466           0 :         return FAIL;
     467             : }
     468             : #endif
     469             : /* }}} */
     470             : 
     471             : /* {{{ proto bool mysqli_stmt_bind_result(object stmt, mixed var, [,mixed, ...]) U
     472             :    Bind variables to a prepared statement for result storage */
     473        1277 : PHP_FUNCTION(mysqli_stmt_bind_result)
     474             : {
     475             :         zval            ***args;
     476        1277 :         int                     argc = ZEND_NUM_ARGS();
     477        1277 :         int                     start = 1;
     478             :         ulong           rc;
     479             :         MY_STMT         *stmt;
     480             :         zval            *mysql_stmt;
     481             : 
     482        1277 :         if (getThis()) {
     483          43 :                 start = 0;
     484             :         }
     485             : 
     486        1277 :         if (zend_parse_method_parameters((getThis()) ? 0:1 TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
     487           3 :                 return;
     488             :         }
     489             : 
     490        1274 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
     491             : 
     492        1273 :         if (argc < (getThis() ? 1 : 2)) {
     493           1 :                 WRONG_PARAM_COUNT;
     494             :         }
     495             : 
     496        1272 :         if ((argc - start) != mysql_stmt_field_count(stmt->stmt)) {
     497           3 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number of bind variables doesn't match number of fields in prepared statement");
     498           3 :                 RETURN_FALSE;
     499             :         }
     500             : 
     501        1269 :         args = (zval ***)safe_emalloc(argc, sizeof(zval **), 0);
     502             : 
     503        1269 :         if (zend_get_parameters_array_ex(argc, args) == FAILURE) {
     504           0 :                 efree(args);
     505           0 :                 WRONG_PARAM_COUNT;
     506             :         }
     507             : 
     508        1269 :         rc = mysqli_stmt_bind_result_do_bind(stmt, args, argc, start TSRMLS_CC);
     509             : 
     510        1269 :         efree(args);
     511             : 
     512        1269 :         RETURN_BOOL(!rc);
     513             : }
     514             : /* }}} */
     515             : 
     516             : /* {{{ proto bool mysqli_change_user(object link, string user, string password, string database)
     517             :    Change logged-in user of the active connection */
     518          31 : PHP_FUNCTION(mysqli_change_user)
     519             : {
     520             :         MY_MYSQL        *mysql;
     521          31 :         zval            *mysql_link = NULL;
     522             :         char            *user, *password, *dbname;
     523             :         int                     user_len, password_len, dbname_len;
     524             :         ulong           rc;
     525             : #if !defined(MYSQLI_USE_MYSQLND) && defined(HAVE_MYSQLI_SET_CHARSET)
     526             :         const           CHARSET_INFO * old_charset;
     527             : #endif
     528             : 
     529          31 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Osss", &mysql_link, mysqli_link_class_entry, &user, &user_len, &password, &password_len, &dbname, &dbname_len) == FAILURE) {
     530           9 :                 return;
     531             :         }
     532          22 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
     533             : 
     534             : #if !defined(MYSQLI_USE_MYSQLND) && defined(HAVE_MYSQLI_SET_CHARSET)
     535             :         old_charset = mysql->mysql->charset;
     536             : #endif
     537             : 
     538             : #if defined(MYSQLI_USE_MYSQLND)
     539          20 :         rc = mysqlnd_change_user_ex(mysql->mysql, user, password, dbname, FALSE, (size_t) password_len);
     540             : #else
     541             :         rc = mysql_change_user(mysql->mysql, user, password, dbname);
     542             : #endif
     543          20 :         MYSQLI_REPORT_MYSQL_ERROR(mysql->mysql);
     544             : 
     545          20 :         if (rc) {
     546          12 :                 RETURN_FALSE;
     547             :         }
     548             : #if !defined(MYSQLI_USE_MYSQLND) && defined(HAVE_MYSQLI_SET_CHARSET)
     549             :         if (mysql_get_server_version(mysql->mysql) < 501023L) {
     550             :                 /*
     551             :                   Request the current charset, or it will be reset to the system one.
     552             :                   5.0 doesn't support it. Support added in 5.1.23 by fixing the following bug :
     553             :                   Bug #30472 libmysql doesn't reset charset, insert_id after succ. mysql_change_user() call
     554             :                 */
     555             :                 rc = mysql_set_character_set(mysql->mysql, old_charset->csname);
     556             :         }
     557             : #endif
     558             : 
     559           8 :         RETURN_TRUE;
     560             : }
     561             : /* }}} */
     562             : 
     563             : /* {{{ proto string mysqli_character_set_name(object link)
     564             :    Returns the name of the character set used for this connection */
     565          18 : PHP_FUNCTION(mysqli_character_set_name)
     566             : {
     567             :         MY_MYSQL        *mysql;
     568             :         zval            *mysql_link;
     569             : 
     570          18 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
     571           5 :                 return;
     572             :         }
     573             : 
     574          13 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
     575             : 
     576          10 :         RETURN_STRING((char *)mysql_character_set_name(mysql->mysql), 1);
     577             : }
     578             : /* }}} */
     579             : 
     580             : 
     581             : /* {{{ php_mysqli_close */
     582        1218 : void php_mysqli_close(MY_MYSQL * mysql, int close_type, int resource_status TSRMLS_DC)
     583             : {
     584        1218 :         if (resource_status > MYSQLI_STATUS_INITIALIZED) {
     585        1178 :                 MyG(num_links)--;
     586             :         }
     587             : 
     588        1218 :         if (!mysql->persistent) {
     589        1135 :                 mysqli_close(mysql->mysql, close_type);
     590             :         } else {
     591             :                 zend_rsrc_list_entry *le;
     592          83 :                 if (zend_hash_find(&EG(persistent_list), mysql->hash_key, strlen(mysql->hash_key) + 1, (void **)&le) == SUCCESS) {
     593          83 :                         if (Z_TYPE_P(le) == php_le_pmysqli()) {
     594          83 :                                 mysqli_plist_entry *plist = (mysqli_plist_entry *) le->ptr;
     595             : #if defined(MYSQLI_USE_MYSQLND)
     596          83 :                                 mysqlnd_end_psession(mysql->mysql);
     597             : #endif
     598          83 :                                 zend_ptr_stack_push(&plist->free_links, mysql->mysql);
     599             : 
     600          83 :                                 MyG(num_active_persistent)--;
     601          83 :                                 MyG(num_inactive_persistent)++;
     602             :                         }
     603             :                 }
     604          83 :                 mysql->persistent = FALSE;
     605             :         }
     606        1218 :         mysql->mysql = NULL;
     607             : 
     608        1218 :         php_clear_mysql(mysql);
     609        1218 : }
     610             : /* }}} */
     611             : 
     612             : 
     613             : /* {{{ proto bool mysqli_close(object link)
     614             :    Close connection */
     615        1050 : PHP_FUNCTION(mysqli_close)
     616             : {
     617             :         zval            *mysql_link;
     618             :         MY_MYSQL        *mysql;
     619             : 
     620        1050 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
     621           9 :                 return;
     622             :         }
     623             : 
     624        1041 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_INITIALIZED);
     625             : 
     626        1039 :         php_mysqli_close(mysql, MYSQLI_CLOSE_EXPLICIT, ((MYSQLI_RESOURCE *)((mysqli_object *)zend_object_store_get_object(mysql_link TSRMLS_CC))->ptr)->status TSRMLS_CC);
     627        1039 :         ((MYSQLI_RESOURCE *)((mysqli_object *)zend_object_store_get_object(mysql_link TSRMLS_CC))->ptr)->status = MYSQLI_STATUS_UNKNOWN;
     628             : 
     629        1039 :         MYSQLI_CLEAR_RESOURCE(&mysql_link);
     630        1039 :         efree(mysql);
     631        1039 :         RETURN_TRUE;
     632             : }
     633             : /* }}} */
     634             : 
     635             : /* {{{ proto bool mysqli_commit(object link)
     636             :    Commit outstanding actions and close transaction */
     637          13 : PHP_FUNCTION(mysqli_commit)
     638             : {
     639             :         MY_MYSQL        *mysql;
     640             :         zval            *mysql_link;
     641             : 
     642          13 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
     643           4 :                 return;
     644             :         }
     645           9 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
     646           6 :         if (mysql_commit(mysql->mysql)) {
     647           0 :                 RETURN_FALSE;
     648             :         }
     649           6 :         RETURN_TRUE;
     650             : }
     651             : /* }}} */
     652             : 
     653             : /* {{{ proto bool mysqli_data_seek(object result, int offset)
     654             :    Move internal result pointer */
     655         132 : PHP_FUNCTION(mysqli_data_seek)
     656             : {
     657             :         MYSQL_RES       *result;
     658             :         zval            *mysql_result;
     659             :         long            offset;
     660             : 
     661         132 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &mysql_result, mysqli_result_class_entry, &offset) == FAILURE) {
     662           6 :                 return;
     663             :         }
     664             : 
     665         126 :         MYSQLI_FETCH_RESOURCE(result, MYSQL_RES *, &mysql_result, "mysqli_result", MYSQLI_STATUS_VALID);
     666             : 
     667         121 :         if (mysqli_result_is_unbuffered(result)) {
     668           3 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Function cannot be used with MYSQL_USE_RESULT");
     669           3 :                 RETURN_FALSE;
     670             :         }
     671             : 
     672         118 :         if (offset < 0 || offset >= mysql_num_rows(result)) {
     673          63 :                 RETURN_FALSE;
     674             :         }
     675             : 
     676          55 :         mysql_data_seek(result, offset);
     677          55 :         RETURN_TRUE;
     678             : }
     679             : /* }}} */
     680             : 
     681             : /* {{{ proto void mysqli_debug(string debug) U
     682             : */
     683           0 : PHP_FUNCTION(mysqli_debug)
     684             : {
     685             :         char    *debug;
     686             :         int             debug_len;
     687             : 
     688           0 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &debug, &debug_len) == FAILURE) {
     689           0 :                 return;
     690             :         }
     691             : 
     692           0 :         mysql_debug(debug);
     693           0 :         RETURN_TRUE;
     694             : }
     695             : /* }}} */
     696             : 
     697             : 
     698             : /* {{{ proto bool mysqli_dump_debug_info(object link)
     699             : */
     700           7 : PHP_FUNCTION(mysqli_dump_debug_info)
     701             : {
     702             :         MY_MYSQL        *mysql;
     703             :         zval            *mysql_link;
     704             : 
     705           7 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
     706           3 :                 return;
     707             :         }
     708           4 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
     709             : 
     710           2 :         RETURN_BOOL(!mysql_dump_debug_info(mysql->mysql))
     711             : }
     712             : /* }}} */
     713             : 
     714             : /* {{{ proto int mysqli_errno(object link)
     715             :    Returns the numerical value of the error message from previous MySQL operation */
     716          71 : PHP_FUNCTION(mysqli_errno)
     717             : {
     718             :         MY_MYSQL        *mysql;
     719             :         zval            *mysql_link;
     720             : 
     721          71 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
     722           5 :                 return;
     723             :         }
     724          66 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
     725          59 :         RETURN_LONG(mysql_errno(mysql->mysql));
     726             : }
     727             : /* }}} */
     728             : 
     729             : /* {{{ proto string mysqli_error(object link)
     730             :    Returns the text of the error message from previous MySQL operation */
     731          54 : PHP_FUNCTION(mysqli_error)
     732             : {
     733             :         MY_MYSQL        *mysql;
     734             :         zval            *mysql_link;
     735             : 
     736          54 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
     737           7 :                 return;
     738             :         }
     739          47 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
     740          39 :         RETURN_STRING((char *)mysql_error(mysql->mysql),1);
     741             : }
     742             : /* }}} */
     743             : 
     744             : #ifndef MYSQLI_USE_MYSQLND
     745             : /* {{{ php_mysqli_stmt_copy_it */
     746             : static void
     747             : php_mysqli_stmt_copy_it(zval *** copies, zval *original, uint param_count, uint current)
     748             : {
     749             :         if (!*copies) {
     750             :                 *copies = ecalloc(param_count, sizeof(zval *));
     751             :         }
     752             :         MAKE_STD_ZVAL((*copies)[current]);
     753             :         *(*copies)[current] = *original;
     754             :         Z_SET_REFCOUNT_P((*copies)[current], 1);
     755             :         zval_copy_ctor((*copies)[current]);
     756             : }
     757             : /* }}} */
     758             : #endif
     759             : 
     760             : /* {{{ proto bool mysqli_stmt_execute(object stmt)
     761             :    Execute a prepared statement */
     762        4167 : PHP_FUNCTION(mysqli_stmt_execute)
     763             : {
     764             :         MY_STMT         *stmt;
     765             :         zval            *mysql_stmt;
     766             : #ifndef MYSQLI_USE_MYSQLND
     767             :         unsigned int    i;
     768             :         zval            **copies = NULL;
     769             : #endif
     770             : 
     771        4167 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
     772           2 :                 return;
     773             :         }
     774        4165 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
     775             : 
     776             : #ifndef MYSQLI_USE_MYSQLND
     777             :         if (stmt->param.var_cnt) {
     778             :                 int j;
     779             :                 for (i = 0; i < stmt->param.var_cnt; i++) {
     780             :                         for (j = i + 1; j < stmt->param.var_cnt; j++) {
     781             :                                 /* Oops, someone binding the same variable - clone */
     782             :                                 if (stmt->param.vars[j] == stmt->param.vars[i] && stmt->param.vars[i]) {
     783             :                                         php_mysqli_stmt_copy_it(&copies, stmt->param.vars[i], stmt->param.var_cnt, i);
     784             :                                         break;
     785             :                                 }
     786             :                         }
     787             :                 }
     788             :         }
     789             :         for (i = 0; i < stmt->param.var_cnt; i++) {
     790             :                 if (stmt->param.vars[i]) {
     791             :                         if ( !(stmt->param.is_null[i] = (stmt->param.vars[i]->type == IS_NULL)) ) {
     792             :                                 zval *the_var = copies && copies[i]? copies[i]:stmt->param.vars[i];
     793             :                                 switch (stmt->stmt->params[i].buffer_type) {
     794             :                                         case MYSQL_TYPE_VAR_STRING:
     795             :                                                 if (the_var == stmt->param.vars[i] && Z_TYPE_P(stmt->param.vars[i]) != IS_STRING) {
     796             :                                                         php_mysqli_stmt_copy_it(&copies, stmt->param.vars[i], stmt->param.var_cnt, i);
     797             :                                                         the_var = copies[i];
     798             :                                                 }
     799             :                                                 convert_to_string_ex(&the_var);
     800             :                                                 stmt->stmt->params[i].buffer = Z_STRVAL_P(the_var);
     801             :                                                 stmt->stmt->params[i].buffer_length = Z_STRLEN_P(the_var);
     802             :                                                 break;
     803             :                                         case MYSQL_TYPE_DOUBLE:
     804             :                                                 if (the_var == stmt->param.vars[i] && Z_TYPE_P(stmt->param.vars[i]) != IS_DOUBLE) {
     805             :                                                         php_mysqli_stmt_copy_it(&copies, stmt->param.vars[i], stmt->param.var_cnt, i);
     806             :                                                         the_var = copies[i];
     807             :                                                 }
     808             :                                                 convert_to_double_ex(&the_var);
     809             :                                                 stmt->stmt->params[i].buffer = &Z_DVAL_P(the_var);
     810             :                                                 break;
     811             :                                         case MYSQL_TYPE_LONGLONG:
     812             :                                         case MYSQL_TYPE_LONG:
     813             :                                                 if (the_var == stmt->param.vars[i] && Z_TYPE_P(stmt->param.vars[i]) != IS_LONG) {
     814             :                                                         php_mysqli_stmt_copy_it(&copies, stmt->param.vars[i], stmt->param.var_cnt, i);
     815             :                                                         the_var = copies[i];
     816             :                                                 }
     817             :                                                 convert_to_long_ex(&the_var);
     818             :                                                 stmt->stmt->params[i].buffer = &Z_LVAL_P(the_var);
     819             :                                                 break;
     820             :                                         default:
     821             :                                                 break;
     822             :                                 }
     823             :                         }
     824             :                 }
     825             :         }
     826             : #endif
     827             : 
     828        4162 :         if (mysql_stmt_execute(stmt->stmt)) {
     829          10 :                 MYSQLI_REPORT_STMT_ERROR(stmt->stmt);
     830          10 :                 RETVAL_FALSE;
     831             :         } else {
     832        4152 :                 RETVAL_TRUE;
     833             :         }
     834             : 
     835             : #ifndef MYSQLI_USE_MYSQLND
     836             :         if (copies) {
     837             :                 for (i = 0; i < stmt->param.var_cnt; i++) {
     838             :                         if (copies[i]) {
     839             :                                 zval_ptr_dtor(&copies[i]);
     840             :                         }
     841             :                 }
     842             :                 efree(copies);
     843             :         }
     844             : #endif
     845             : 
     846        4162 :         if (MyG(report_mode) & MYSQLI_REPORT_INDEX) {
     847           0 :                 php_mysqli_report_index(stmt->query, mysqli_stmt_server_status(stmt->stmt) TSRMLS_CC);
     848             :         }
     849             : }
     850             : /* }}} */
     851             : 
     852             : #ifndef MYSQLI_USE_MYSQLND
     853             : /* {{{ void mysqli_stmt_fetch_libmysql
     854             :    Fetch results from a prepared statement into the bound variables */
     855             : void mysqli_stmt_fetch_libmysql(INTERNAL_FUNCTION_PARAMETERS)
     856             : {
     857             :         MY_STMT         *stmt;
     858             :         zval                    *mysql_stmt;
     859             :         unsigned int    i;
     860             :         ulong                   ret;
     861             :         unsigned int    uval;
     862             :         my_ulonglong    llval;
     863             : 
     864             : 
     865             :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
     866             :                 return;
     867             :         }
     868             :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
     869             : 
     870             :         /* reset buffers */
     871             :         for (i = 0; i < stmt->result.var_cnt; i++) {
     872             :                 if (stmt->result.buf[i].type == IS_STRING) {
     873             :                         memset(stmt->result.buf[i].val, 0, stmt->result.buf[i].buflen);
     874             :                 }
     875             :         }
     876             :         ret = mysql_stmt_fetch(stmt->stmt);
     877             : #ifdef MYSQL_DATA_TRUNCATED
     878             :         if (!ret || ret == MYSQL_DATA_TRUNCATED) {
     879             : #else
     880             :         if (!ret) {
     881             : #endif
     882             :                 for (i = 0; i < stmt->result.var_cnt; i++) {
     883             :                         /*
     884             :                           QQ: Isn't it quite better to call zval_dtor(). What if the user has
     885             :                           assigned a resource, or an array to the bound variable? We are going
     886             :                           to leak probably. zval_dtor() will handle also Unicode/Non-unicode mode.
     887             :                         */
     888             :                         /* Even if the string is of length zero there is one byte alloced so efree() in all cases */
     889             :                         if (Z_TYPE_P(stmt->result.vars[i]) == IS_STRING) {
     890             :                                 STR_FREE(stmt->result.vars[i]->value.str.val);
     891             :                         }
     892             :                         if (!stmt->result.is_null[i]) {
     893             :                                 switch (stmt->result.buf[i].type) {
     894             :                                         case IS_LONG:
     895             :                                                 if ((stmt->stmt->fields[i].type == MYSQL_TYPE_LONG)
     896             :                                                     && (stmt->stmt->fields[i].flags & UNSIGNED_FLAG))
     897             :                                                 {
     898             :                                                         /* unsigned int (11) */
     899             :                                                         uval= *(unsigned int *) stmt->result.buf[i].val;
     900             : #if SIZEOF_LONG==4
     901             :                                                         if (uval > INT_MAX) {
     902             :                                                                 char *tmp, *p;
     903             :                                                                 int j=10;
     904             :                                                                 tmp= emalloc(11);
     905             :                                                                 p= &tmp[9];
     906             :                                                                 do {
     907             :                                                                         *p-- = (uval % 10) + 48;
     908             :                                                                         uval = uval / 10;
     909             :                                                                 } while (--j > 0);
     910             :                                                                 tmp[10]= '\0';
     911             :                                                                 /* unsigned int > INT_MAX is 10 digits - ALWAYS */
     912             :                                                                 ZVAL_STRINGL(stmt->result.vars[i], tmp, 10, 0);
     913             :                                                                 break;
     914             :                                                         }
     915             : #endif
     916             :                                                 }
     917             :                                                 if (stmt->stmt->fields[i].flags & UNSIGNED_FLAG) {
     918             :                                                         ZVAL_LONG(stmt->result.vars[i], *(unsigned int *)stmt->result.buf[i].val);
     919             :                                                 } else {
     920             :                                                         ZVAL_LONG(stmt->result.vars[i], *(int *)stmt->result.buf[i].val);
     921             :                                                 }
     922             :                                                 break;
     923             :                                         case IS_DOUBLE:
     924             :                                                 ZVAL_DOUBLE(stmt->result.vars[i], *(double *)stmt->result.buf[i].val);
     925             :                                                 break;
     926             :                                         case IS_STRING:
     927             :                                                 if (stmt->stmt->bind[i].buffer_type == MYSQL_TYPE_LONGLONG
     928             : #if MYSQL_VERSION_ID > 50002
     929             :                                                  || stmt->stmt->bind[i].buffer_type == MYSQL_TYPE_BIT
     930             : #endif
     931             :                                                  ) {
     932             :                                                         my_bool uns= (stmt->stmt->fields[i].flags & UNSIGNED_FLAG)? 1:0;
     933             : #if MYSQL_VERSION_ID > 50002
     934             :                                                         if (stmt->stmt->bind[i].buffer_type == MYSQL_TYPE_BIT) {
     935             :                                                                 switch (stmt->result.buf[i].output_len) {
     936             :                                                                         case 8:llval = (my_ulonglong)  bit_uint8korr(stmt->result.buf[i].val);break;
     937             :                                                                         case 7:llval = (my_ulonglong)  bit_uint7korr(stmt->result.buf[i].val);break;
     938             :                                                                         case 6:llval = (my_ulonglong)  bit_uint6korr(stmt->result.buf[i].val);break;
     939             :                                                                         case 5:llval = (my_ulonglong)  bit_uint5korr(stmt->result.buf[i].val);break;
     940             :                                                                         case 4:llval = (my_ulonglong)  bit_uint4korr(stmt->result.buf[i].val);break;
     941             :                                                                         case 3:llval = (my_ulonglong)  bit_uint3korr(stmt->result.buf[i].val);break;
     942             :                                                                         case 2:llval = (my_ulonglong)  bit_uint2korr(stmt->result.buf[i].val);break;
     943             :                                                                         case 1:llval = (my_ulonglong)  uint1korr(stmt->result.buf[i].val);break;
     944             :                                                                 }
     945             :                                                         } else
     946             : #endif
     947             :                                                         {
     948             :                                                                 llval= *(my_ulonglong *) stmt->result.buf[i].val;
     949             :                                                         }
     950             : #if SIZEOF_LONG==8
     951             :                                                         if (uns && llval > 9223372036854775807L) {
     952             : #elif SIZEOF_LONG==4
     953             :                                                         if ((uns && llval > L64(2147483647)) ||
     954             :                                                                 (!uns && (( L64(2147483647) < (my_longlong) llval) ||
     955             :                                                                 (L64(-2147483648) > (my_longlong) llval))))
     956             :                                                         {
     957             : #endif
     958             :                                                                 char tmp[22];
     959             :                                                                 /* even though lval is declared as unsigned, the value
     960             :                                                                  * may be negative. Therefor we cannot use MYSQLI_LLU_SPEC and must
     961             :                                                                  * use MYSQLI_LL_SPEC.
     962             :                                                                  */
     963             :                                                                 snprintf(tmp, sizeof(tmp), (stmt->stmt->fields[i].flags & UNSIGNED_FLAG)? MYSQLI_LLU_SPEC : MYSQLI_LL_SPEC, llval);
     964             :                                                                 ZVAL_STRING(stmt->result.vars[i], tmp, 1);
     965             :                                                         } else {
     966             :                                                                 ZVAL_LONG(stmt->result.vars[i], llval);
     967             :                                                         }
     968             :                                                 } else {
     969             : #if defined(MYSQL_DATA_TRUNCATED) && MYSQL_VERSION_ID > 50002
     970             :                                                         if (ret == MYSQL_DATA_TRUNCATED && *(stmt->stmt->bind[i].error) != 0) {
     971             :                                                                 /* result was truncated */
     972             :                                                                 ZVAL_STRINGL(stmt->result.vars[i], stmt->result.buf[i].val,
     973             :                                                                                          stmt->stmt->bind[i].buffer_length, 1);
     974             :                                                         } else {
     975             : #else
     976             :                                                         {
     977             : #endif
     978             :                                                                 ZVAL_STRINGL(stmt->result.vars[i], stmt->result.buf[i].val,
     979             :                                                                                          stmt->result.buf[i].output_len, 1);
     980             :                                                         }
     981             :                                                 }
     982             :                                                 break;
     983             :                                         default:
     984             :                                                 break;
     985             :                                 }
     986             :                         } else {
     987             :                                 ZVAL_NULL(stmt->result.vars[i]);
     988             :                         }
     989             :                 }
     990             :         } else {
     991             :                 MYSQLI_REPORT_STMT_ERROR(stmt->stmt);
     992             :         }
     993             : 
     994             :         switch (ret) {
     995             :                 case 0:
     996             : #ifdef MYSQL_DATA_TRUNCATED
     997             :                 /* according to SQL standard truncation (e.g. loss of precision is
     998             :                    not an error) - for detecting possible truncation you have to
     999             :                    check mysqli_stmt_warning
    1000             :                 */
    1001             :                 case MYSQL_DATA_TRUNCATED:
    1002             : #endif
    1003             :                         RETURN_TRUE;
    1004             :                 break;
    1005             :                 case 1:
    1006             :                         RETURN_FALSE;
    1007             :                 break;
    1008             :                 default:
    1009             :                         RETURN_NULL();
    1010             :                 break;
    1011             :         }
    1012             : }
    1013             : /* }}} */
    1014             : #else
    1015             : /* {{{ mixed mysqli_stmt_fetch_mysqlnd */
    1016       19038 : void mysqli_stmt_fetch_mysqlnd(INTERNAL_FUNCTION_PARAMETERS)
    1017             : {
    1018             :         MY_STMT         *stmt;
    1019             :         zval            *mysql_stmt;
    1020             :         zend_bool       fetched_anything;
    1021             : 
    1022       19038 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
    1023           3 :                 return;
    1024             :         }
    1025       19035 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    1026             : 
    1027       19030 :         if (FAIL  == mysqlnd_stmt_fetch(stmt->stmt, &fetched_anything)) {
    1028           8 :                 RETURN_BOOL(FALSE);
    1029       19022 :         } else if (fetched_anything == TRUE) {
    1030       18866 :                 RETURN_BOOL(TRUE);
    1031             :         } else {
    1032         156 :                 RETURN_NULL();
    1033             :         }
    1034             : }
    1035             : #endif
    1036             : /* }}} */
    1037             : 
    1038             : 
    1039             : /* {{{ proto mixed mysqli_stmt_fetch(object stmt) U
    1040             :    Fetch results from a prepared statement into the bound variables */
    1041       19038 : PHP_FUNCTION(mysqli_stmt_fetch)
    1042             : {
    1043             : #if !defined(MYSQLI_USE_MYSQLND)
    1044             :         mysqli_stmt_fetch_libmysql(INTERNAL_FUNCTION_PARAM_PASSTHRU);
    1045             : #else
    1046       19038 :         mysqli_stmt_fetch_mysqlnd(INTERNAL_FUNCTION_PARAM_PASSTHRU);
    1047             : #endif
    1048       19038 : }
    1049             : /* }}} */
    1050             : 
    1051             : /* {{{  php_add_field_properties */
    1052        1253 : static void php_add_field_properties(zval *value, const MYSQL_FIELD *field TSRMLS_DC)
    1053             : {
    1054        1253 :         add_property_string(value, "name",(field->name ? field->name : ""), 1);
    1055        1253 :         add_property_string(value, "orgname",(field->org_name ? field->org_name : ""), 1);
    1056        1253 :         add_property_string(value, "table",(field->table ? field->table : ""), 1);
    1057        1253 :         add_property_string(value, "orgtable",(field->org_table ? field->org_table : ""), 1);
    1058        1253 :         add_property_string(value, "def",(field->def ? field->def : ""), 1);
    1059        1253 :         add_property_string(value, "db",(field->db ? field->db : ""), 1);
    1060             : 
    1061             :         /* FIXME: manually set the catalog to "def" due to bug in
    1062             :          * libmysqlclient which does not initialize field->catalog
    1063             :          * and in addition, the catalog is always be "def"
    1064             :          */
    1065        1253 :         add_property_string(value, "catalog", "def", 1);
    1066             : 
    1067        1253 :         add_property_long(value, "max_length", field->max_length);
    1068        1253 :         add_property_long(value, "length", field->length);
    1069        1253 :         add_property_long(value, "charsetnr", field->charsetnr);
    1070        1253 :         add_property_long(value, "flags", field->flags);
    1071        1253 :         add_property_long(value, "type", field->type);
    1072        1253 :         add_property_long(value, "decimals", field->decimals);
    1073        1253 : }
    1074             : /* }}} */
    1075             : 
    1076             : /* {{{ proto mixed mysqli_fetch_field (object result)
    1077             :    Get column information from a result and return as an object */
    1078         195 : PHP_FUNCTION(mysqli_fetch_field)
    1079             : {
    1080             :         MYSQL_RES       *result;
    1081             :         zval            *mysql_result;
    1082             :         const MYSQL_FIELD       *field;
    1083             : 
    1084         195 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_result, mysqli_result_class_entry) == FAILURE) {
    1085           3 :                 return;
    1086             :         }
    1087             : 
    1088         192 :         MYSQLI_FETCH_RESOURCE(result, MYSQL_RES *, &mysql_result, "mysqli_result", MYSQLI_STATUS_VALID);
    1089             : 
    1090         186 :         if (!(field = mysql_fetch_field(result))) {
    1091           9 :                 RETURN_FALSE;
    1092             :         }
    1093             : 
    1094         177 :         object_init(return_value);
    1095         177 :         php_add_field_properties(return_value, field TSRMLS_CC);
    1096             : }
    1097             : /* }}} */
    1098             : 
    1099             : /* {{{ proto mixed mysqli_fetch_fields (object result)
    1100             :    Return array of objects containing field meta-data */
    1101         514 : PHP_FUNCTION(mysqli_fetch_fields)
    1102             : {
    1103             :         MYSQL_RES       *result;
    1104             :         zval            *mysql_result;
    1105             :         zval            *obj;
    1106             : 
    1107             :         unsigned int i;
    1108             : 
    1109         514 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_result, mysqli_result_class_entry) == FAILURE) {
    1110           2 :                 return;
    1111             :         }
    1112             : 
    1113         512 :         MYSQLI_FETCH_RESOURCE(result, MYSQL_RES *, &mysql_result, "mysqli_result", MYSQLI_STATUS_VALID);
    1114             : 
    1115         511 :         array_init(return_value);
    1116             : 
    1117        1549 :         for (i = 0; i < mysql_num_fields(result); i++) {
    1118        1038 :                 const MYSQL_FIELD *field = mysql_fetch_field_direct(result, i);
    1119             : 
    1120        1038 :                 MAKE_STD_ZVAL(obj);
    1121        1038 :                 object_init(obj);
    1122             : 
    1123        1038 :                 php_add_field_properties(obj, field TSRMLS_CC);
    1124        1038 :                 add_index_zval(return_value, i, obj);
    1125             :         }
    1126             : }
    1127             : /* }}} */
    1128             : 
    1129             : /* {{{ proto mixed mysqli_fetch_field_direct (object result, int offset)
    1130             :    Fetch meta-data for a single field */
    1131          51 : PHP_FUNCTION(mysqli_fetch_field_direct)
    1132             : {
    1133             :         MYSQL_RES       *result;
    1134             :         zval            *mysql_result;
    1135             :         const MYSQL_FIELD       *field;
    1136             :         long            offset;
    1137             : 
    1138          51 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &mysql_result, mysqli_result_class_entry, &offset) == FAILURE) {
    1139           7 :                 return;
    1140             :         }
    1141             : 
    1142          44 :         MYSQLI_FETCH_RESOURCE(result, MYSQL_RES *, &mysql_result, "mysqli_result", MYSQLI_STATUS_VALID);
    1143             : 
    1144          42 :         if (offset < 0 || offset >= (long) mysql_num_fields(result)) {
    1145           4 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field offset is invalid for resultset");
    1146           4 :                 RETURN_FALSE;
    1147             :         }
    1148             : 
    1149          38 :         if (!(field = mysql_fetch_field_direct(result,offset))) {
    1150           0 :                 RETURN_FALSE;
    1151             :         }
    1152             : 
    1153          38 :         object_init(return_value);
    1154          38 :         php_add_field_properties(return_value, field TSRMLS_CC);
    1155             : }
    1156             : /* }}} */
    1157             : 
    1158             : /* {{{ proto mixed mysqli_fetch_lengths (object result)
    1159             :    Get the length of each output in a result */
    1160          11 : PHP_FUNCTION(mysqli_fetch_lengths)
    1161             : {
    1162             :         MYSQL_RES               *result;
    1163             :         zval                    *mysql_result;
    1164             :         unsigned int    i;
    1165             :         unsigned long   *ret;
    1166             : 
    1167          11 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_result, mysqli_result_class_entry) == FAILURE) {
    1168           2 :                 return;
    1169             :         }
    1170             : 
    1171           9 :         MYSQLI_FETCH_RESOURCE(result, MYSQL_RES *, &mysql_result, "mysqli_result", MYSQLI_STATUS_VALID);
    1172             : 
    1173           8 :         if (!(ret = mysql_fetch_lengths(result))) {
    1174           3 :                 RETURN_FALSE;
    1175             :         }
    1176             : 
    1177           5 :         array_init(return_value);
    1178             : 
    1179          15 :         for (i = 0; i < mysql_num_fields(result); i++) {
    1180          10 :                 add_index_long(return_value, i, ret[i]);
    1181             :         }
    1182             : }
    1183             : /* }}} */
    1184             : 
    1185             : /* {{{ proto array mysqli_fetch_row (object result)
    1186             :    Get a result row as an enumerated array */
    1187          55 : PHP_FUNCTION(mysqli_fetch_row)
    1188             : {
    1189          55 :         php_mysqli_fetch_into_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, MYSQLI_NUM, 0);
    1190          55 : }
    1191             : /* }}} */
    1192             : 
    1193             : /* {{{ proto int mysqli_field_count(object link)
    1194             :    Fetch the number of fields returned by the last query for the given link
    1195             : */
    1196          24 : PHP_FUNCTION(mysqli_field_count)
    1197             : {
    1198             :         MY_MYSQL        *mysql;
    1199             :         zval            *mysql_link;
    1200             : 
    1201          24 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    1202           2 :                 return;
    1203             :         }
    1204          22 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1205             : 
    1206          15 :         RETURN_LONG(mysql_field_count(mysql->mysql));
    1207             : }
    1208             : /* }}} */
    1209             : 
    1210             : /* {{{ proto int mysqli_field_seek(object result, int fieldnr)
    1211             :    Set result pointer to a specified field offset
    1212             : */
    1213         215 : PHP_FUNCTION(mysqli_field_seek)
    1214             : {
    1215             :         MYSQL_RES               *result;
    1216             :         zval                    *mysql_result;
    1217             :         unsigned long   fieldnr;
    1218             : 
    1219         215 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &mysql_result, mysqli_result_class_entry, &fieldnr) == FAILURE) {
    1220           4 :                 return;
    1221             :         }
    1222         211 :         MYSQLI_FETCH_RESOURCE(result, MYSQL_RES *, &mysql_result, "mysqli_result", MYSQLI_STATUS_VALID);
    1223             : 
    1224         210 :         if (fieldnr < 0 || fieldnr >= mysql_num_fields(result)) {
    1225          77 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid field offset");
    1226          77 :                 RETURN_FALSE;
    1227             :         }
    1228             : 
    1229         133 :         mysql_field_seek(result, fieldnr);
    1230         133 :         RETURN_TRUE;
    1231             : }
    1232             : /* }}} */
    1233             : 
    1234             : /* {{{ proto int mysqli_field_tell(object result)
    1235             :    Get current field offset of result pointer */
    1236         142 : PHP_FUNCTION(mysqli_field_tell)
    1237             : {
    1238             :         MYSQL_RES       *result;
    1239             :         zval            *mysql_result;
    1240             : 
    1241         142 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_result, mysqli_result_class_entry) == FAILURE) {
    1242           3 :                 return;
    1243             :         }
    1244         139 :         MYSQLI_FETCH_RESOURCE(result, MYSQL_RES *, &mysql_result, "mysqli_result", MYSQLI_STATUS_VALID);
    1245             : 
    1246         138 :         RETURN_LONG(mysql_field_tell(result));
    1247             : }
    1248             : /* }}} */
    1249             : 
    1250             : /* {{{ proto void mysqli_free_result(object result)
    1251             :    Free query result memory for the given result handle */
    1252        1277 : PHP_FUNCTION(mysqli_free_result)
    1253             : {
    1254             :         MYSQL_RES       *result;
    1255             :         zval            *mysql_result;
    1256             : 
    1257        1277 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_result, mysqli_result_class_entry) == FAILURE) {
    1258           6 :                 return;
    1259             :         }
    1260        1271 :         MYSQLI_FETCH_RESOURCE(result, MYSQL_RES *, &mysql_result, "mysqli_result", MYSQLI_STATUS_VALID);
    1261             : 
    1262        1270 :         mysqli_free_result(result, FALSE);
    1263        1270 :         MYSQLI_CLEAR_RESOURCE(&mysql_result);
    1264             : }
    1265             : /* }}} */
    1266             : 
    1267             : /* {{{ proto string mysqli_get_client_info(void)
    1268             :    Get MySQL client info */
    1269        2718 : PHP_FUNCTION(mysqli_get_client_info)
    1270             : {
    1271        2718 :         RETURN_STRING((char *)mysql_get_client_info(), 1);
    1272             : }
    1273             : /* }}} */
    1274             : 
    1275             : /* {{{ proto int mysqli_get_client_version(void)
    1276             :    Get MySQL client info */
    1277          18 : PHP_FUNCTION(mysqli_get_client_version)
    1278             : {
    1279          18 :         RETURN_LONG((long)mysql_get_client_version());
    1280             : }
    1281             : /* }}} */
    1282             : 
    1283             : /* {{{ proto string mysqli_get_host_info (object link)
    1284             :    Get MySQL host info */
    1285          13 : PHP_FUNCTION(mysqli_get_host_info)
    1286             : {
    1287             :         MY_MYSQL        *mysql;
    1288          13 :         zval            *mysql_link = NULL;
    1289             : 
    1290          13 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    1291           2 :                 return;
    1292             :         }
    1293          11 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1294             : #if !defined(MYSQLI_USE_MYSQLND)
    1295             :         RETURN_STRING((mysql->mysql->host_info) ? mysql->mysql->host_info : "", 1);
    1296             : #else
    1297           5 :         RETURN_STRING((mysql->mysql->data->host_info) ? mysql->mysql->data->host_info : "", 1);
    1298             : #endif
    1299             : }
    1300             : /* }}} */
    1301             : 
    1302             : /* {{{ proto int mysqli_get_proto_info(object link)
    1303             :    Get MySQL protocol information */
    1304          14 : PHP_FUNCTION(mysqli_get_proto_info)
    1305             : {
    1306             :         MY_MYSQL        *mysql;
    1307          14 :         zval            *mysql_link = NULL;
    1308             : 
    1309          14 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    1310           3 :                 return;
    1311             :         }
    1312          11 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1313           5 :         RETURN_LONG(mysql_get_proto_info(mysql->mysql));
    1314             : }
    1315             : /* }}} */
    1316             : 
    1317             : /* {{{ proto string mysqli_get_server_info(object link)
    1318             :    Get MySQL server info */
    1319          14 : PHP_FUNCTION(mysqli_get_server_info)
    1320             : {
    1321             :         MY_MYSQL        *mysql;
    1322          14 :         zval            *mysql_link = NULL;
    1323             : 
    1324          14 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    1325           3 :                 return;
    1326             :         }
    1327          11 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1328             : 
    1329           5 :         RETURN_STRING((char *)mysql_get_server_info(mysql->mysql), 1);
    1330             : }
    1331             : 
    1332             : /* }}} */
    1333             : 
    1334             : /* {{{ proto int mysqli_get_server_version(object link)
    1335             :    Return the MySQL version for the server referenced by the given link */
    1336          51 : PHP_FUNCTION(mysqli_get_server_version)
    1337             : {
    1338             :         MY_MYSQL        *mysql;
    1339          51 :         zval            *mysql_link = NULL;
    1340             : 
    1341          51 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    1342           2 :                 return;
    1343             :         }
    1344          49 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1345             : 
    1346          43 :         RETURN_LONG(mysql_get_server_version(mysql->mysql));
    1347             : }
    1348             : /* }}} */
    1349             : 
    1350             : /* {{{ proto string mysqli_info(object link)
    1351             :    Get information about the most recent query */
    1352          21 : PHP_FUNCTION(mysqli_info)
    1353             : {
    1354             :         MY_MYSQL        *mysql;
    1355          21 :         zval            *mysql_link = NULL;
    1356             :         const char      *info;
    1357             : 
    1358          21 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    1359           2 :                 return;
    1360             :         }
    1361          19 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1362             : 
    1363          13 :         info = mysql_info(mysql->mysql);
    1364          13 :         RETURN_STRING((info) ? (char *)info : "", 1);
    1365             : }
    1366             : /* }}} */
    1367             : 
    1368             : 
    1369             : /* {{{ php_mysqli_init() */
    1370        1153 : void php_mysqli_init(INTERNAL_FUNCTION_PARAMETERS)
    1371             : {
    1372             :         MYSQLI_RESOURCE *mysqli_resource;
    1373             :         MY_MYSQL *mysql;
    1374             : 
    1375        1153 :         if (getThis() && ((mysqli_object *) zend_object_store_get_object(getThis() TSRMLS_CC))->ptr) {
    1376           2 :                 return;
    1377             :         }
    1378             : 
    1379        1151 :         mysql = (MY_MYSQL *)ecalloc(1, sizeof(MY_MYSQL));
    1380             : 
    1381             : #if !defined(MYSQLI_USE_MYSQLND)
    1382             :         if (!(mysql->mysql = mysql_init(NULL)))
    1383             : #else
    1384             :         /*
    1385             :           We create always persistent, as if the user want to connecto
    1386             :           to p:somehost, we can't convert the handle then
    1387             :         */
    1388        1151 :         if (!(mysql->mysql = mysql_init(TRUE)))
    1389             : #endif
    1390             :         {
    1391           0 :                 efree(mysql);
    1392           0 :                 RETURN_FALSE;
    1393             :         }
    1394             : 
    1395        1151 :         mysqli_resource = (MYSQLI_RESOURCE *)ecalloc (1, sizeof(MYSQLI_RESOURCE));
    1396        1151 :         mysqli_resource->ptr = (void *)mysql;
    1397        1151 :         mysqli_resource->status = MYSQLI_STATUS_INITIALIZED;
    1398             : 
    1399        2244 :         if (!getThis() || !instanceof_function(Z_OBJCE_P(getThis()), mysqli_link_class_entry TSRMLS_CC)) {
    1400        1093 :                 MYSQLI_RETURN_RESOURCE(mysqli_resource, mysqli_link_class_entry);
    1401             :         } else {
    1402          58 :                 ((mysqli_object *) zend_object_store_get_object(getThis() TSRMLS_CC))->ptr = mysqli_resource;
    1403             :         }
    1404             : }
    1405             : /* }}} */
    1406             : 
    1407             : 
    1408             : /* {{{ proto resource mysqli_init(void)
    1409             :    Initialize mysqli and return a resource for use with mysql_real_connect */
    1410        1137 : PHP_FUNCTION(mysqli_init)
    1411             : {
    1412        1137 :         php_mysqli_init(INTERNAL_FUNCTION_PARAM_PASSTHRU);
    1413        1137 : }
    1414             : /* }}} */
    1415             : 
    1416             : /* {{{ proto mixed mysqli_insert_id(object link)
    1417             :    Get the ID generated from the previous INSERT operation */
    1418          28 : PHP_FUNCTION(mysqli_insert_id)
    1419             : {
    1420             :         MY_MYSQL                *mysql;
    1421             :         my_ulonglong    rc;
    1422             :         zval                    *mysql_link;
    1423             : 
    1424          28 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    1425           3 :                 return;
    1426             :         }
    1427          25 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1428          18 :         rc = mysql_insert_id(mysql->mysql);
    1429          18 :         MYSQLI_RETURN_LONG_LONG(rc)
    1430             : }
    1431             : /* }}} */
    1432             : 
    1433             : /* {{{ proto bool mysqli_kill(object link, int processid)
    1434             :    Kill a mysql process on the server */
    1435          26 : PHP_FUNCTION(mysqli_kill)
    1436             : {
    1437             :         MY_MYSQL        *mysql;
    1438             :         zval            *mysql_link;
    1439             :         long            processid;
    1440             : 
    1441          26 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &mysql_link, mysqli_link_class_entry, &processid) == FAILURE) {
    1442           2 :                 return;
    1443             :         }
    1444          24 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1445             : 
    1446          24 :         if (processid <= 0) {
    1447           7 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "processid should have positive value");
    1448           7 :                 RETURN_FALSE;
    1449             :         }
    1450             : 
    1451          17 :         if (mysql_kill(mysql->mysql, processid)) {
    1452           3 :                 MYSQLI_REPORT_MYSQL_ERROR(mysql->mysql);
    1453           3 :                 RETURN_FALSE;
    1454             :         }
    1455          14 :         RETURN_TRUE;
    1456             : }
    1457             : /* }}} */
    1458             : 
    1459             : /* {{{ proto void mysqli_set_local_infile_default(object link)
    1460             :    unsets user defined handler for load local infile command */
    1461             : #if !defined(MYSQLI_USE_MYSQLND)
    1462             : PHP_FUNCTION(mysqli_set_local_infile_default)
    1463             : {
    1464             :         MY_MYSQL        *mysql;
    1465             :         zval            *mysql_link;
    1466             : 
    1467             :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    1468             :                 return;
    1469             :         }
    1470             : 
    1471             :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1472             : 
    1473             :         if (mysql->li_read) {
    1474             :                 zval_ptr_dtor(&(mysql->li_read));
    1475             :                 mysql->li_read = NULL;
    1476             :         }
    1477             : }
    1478             : /* }}} */
    1479             : 
    1480             : /* {{{ proto bool mysqli_set_local_infile_handler(object link, callback read_func)
    1481             :    Set callback functions for LOAD DATA LOCAL INFILE */
    1482             : PHP_FUNCTION(mysqli_set_local_infile_handler)
    1483             : {
    1484             :         MY_MYSQL        *mysql;
    1485             :         zval            *mysql_link;
    1486             :         char            *callback_name;
    1487             :         zval            *callback_func;
    1488             : 
    1489             :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oz", &mysql_link, mysqli_link_class_entry,
    1490             :                         &callback_func) == FAILURE) {
    1491             :                 return;
    1492             :         }
    1493             : 
    1494             :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1495             : 
    1496             :         /* check callback function */
    1497             :         if (!zend_is_callable(callback_func, 0, &callback_name TSRMLS_CC)) {
    1498             :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback function %s", callback_name);
    1499             :                 efree(callback_name);
    1500             :                 RETURN_FALSE;
    1501             :         }
    1502             :         efree(callback_name);
    1503             : 
    1504             :         /* save callback function */
    1505             :         if (!mysql->li_read) {
    1506             :                 MAKE_STD_ZVAL(mysql->li_read);
    1507             :         } else {
    1508             :                 zval_dtor(mysql->li_read);
    1509             :         }
    1510             :         ZVAL_ZVAL(mysql->li_read, callback_func, 1, 0);
    1511             : 
    1512             :         RETURN_TRUE;
    1513             : }
    1514             : #endif
    1515             : /* }}} */
    1516             : 
    1517             : /* {{{ proto bool mysqli_more_results(object link)
    1518             :    check if there any more query results from a multi query */
    1519          34 : PHP_FUNCTION(mysqli_more_results)
    1520             : {
    1521             :         MY_MYSQL        *mysql;
    1522             :         zval            *mysql_link;
    1523             : 
    1524          34 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    1525           2 :                 return;
    1526             :         }
    1527          32 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1528             : 
    1529          31 :         RETURN_BOOL(mysql_more_results(mysql->mysql));
    1530             : }
    1531             : /* }}} */
    1532             : 
    1533             : /* {{{ proto bool mysqli_next_result(object link)
    1534             :    read next result from multi_query */
    1535          42 : PHP_FUNCTION(mysqli_next_result) {
    1536             :         MY_MYSQL        *mysql;
    1537             :         zval            *mysql_link;
    1538             : 
    1539          42 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    1540           2 :                 return;
    1541             :         }
    1542          40 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1543             : 
    1544          39 :         if (!mysql_more_results(mysql->mysql)) {
    1545          12 :                 php_error_docref(NULL TSRMLS_CC, E_STRICT, "There is no next result set. "
    1546             :                                                 "Please, call mysqli_more_results()/mysqli::more_results() to check "
    1547             :                                                 "whether to call this function/method");
    1548             :         }
    1549             : 
    1550          39 :         RETURN_BOOL(!mysql_next_result(mysql->mysql));
    1551             : }
    1552             : /* }}} */
    1553             : 
    1554             : #if defined(HAVE_STMT_NEXT_RESULT) && defined(MYSQLI_USE_MYSQLND)
    1555             : /* {{{ proto bool mysqli_stmt_next_result(object link)
    1556             :    check if there any more query results from a multi query */
    1557           3 : PHP_FUNCTION(mysqli_stmt_more_results)
    1558             : {
    1559             :         MY_STMT         *stmt;
    1560             :         zval            *mysql_stmt;
    1561             : 
    1562           3 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
    1563           0 :                 return;
    1564             :         }
    1565           3 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    1566             : 
    1567           3 :         RETURN_BOOL(mysqlnd_stmt_more_results(stmt->stmt));
    1568             : }
    1569             : /* }}} */
    1570             : 
    1571             : 
    1572             : /* {{{ proto bool mysqli_stmt_next_result(object link)
    1573             :    read next result from multi_query */
    1574           2 : PHP_FUNCTION(mysqli_stmt_next_result) {
    1575             :         MY_STMT         *stmt;
    1576             :         zval            *mysql_stmt;
    1577             : 
    1578           2 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
    1579           0 :                 return;
    1580             :         }
    1581           2 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    1582             : 
    1583           2 :         if (!mysqlnd_stmt_more_results(stmt->stmt)) {
    1584           0 :                 php_error_docref(NULL TSRMLS_CC, E_STRICT, "There is no next result set. "
    1585             :                                                 "Please, call mysqli_stmt_more_results()/mysqli_stmt::more_results() to check "
    1586             :                                                 "whether to call this function/method");
    1587             :         }
    1588             : 
    1589           2 :         RETURN_BOOL(!mysql_stmt_next_result(stmt->stmt));
    1590             : }
    1591             : /* }}} */
    1592             : #endif
    1593             : 
    1594             : 
    1595             : /* {{{ proto int mysqli_num_fields(object result)
    1596             :    Get number of fields in result */
    1597          12 : PHP_FUNCTION(mysqli_num_fields)
    1598             : {
    1599             :         MYSQL_RES       *result;
    1600             :         zval            *mysql_result;
    1601             : 
    1602          12 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_result, mysqli_result_class_entry) == FAILURE) {
    1603           2 :                 return;
    1604             :         }
    1605          10 :         MYSQLI_FETCH_RESOURCE(result, MYSQL_RES *, &mysql_result, "mysqli_result", MYSQLI_STATUS_VALID);
    1606             : 
    1607           9 :         RETURN_LONG(mysql_num_fields(result));
    1608             : }
    1609             : /* }}} */
    1610             : 
    1611             : /* {{{ proto mixed mysqli_num_rows(object result)
    1612             :    Get number of rows in result */
    1613          29 : PHP_FUNCTION(mysqli_num_rows)
    1614             : {
    1615             :         MYSQL_RES       *result;
    1616             :         zval            *mysql_result;
    1617             : 
    1618          29 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_result, mysqli_result_class_entry) == FAILURE) {
    1619           3 :                 return;
    1620             :         }
    1621          26 :         MYSQLI_FETCH_RESOURCE(result, MYSQL_RES *, &mysql_result, "mysqli_result", MYSQLI_STATUS_VALID);
    1622             : 
    1623          25 :         if (mysqli_result_is_unbuffered_and_not_everything_is_fetched(result)) {
    1624           3 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Function cannot be used with MYSQL_USE_RESULT");
    1625           3 :                 RETURN_LONG(0);
    1626             :         }
    1627             : 
    1628          22 :         MYSQLI_RETURN_LONG_LONG(mysql_num_rows(result));
    1629             : }
    1630             : /* }}} */
    1631             : 
    1632             : /* {{{ mysqli_options_get_option_zval_type */
    1633          88 : static int mysqli_options_get_option_zval_type(int option)
    1634             : {
    1635          88 :         switch (option) {
    1636             : #ifdef MYSQLI_USE_MYSQLND
    1637             : #if PHP_MAJOR_VERSION >= 6
    1638             :                 case MYSQLND_OPT_NUMERIC_AND_DATETIME_AS_UNICODE:
    1639             : #endif
    1640             :                 case MYSQLND_OPT_NET_CMD_BUFFER_SIZE:
    1641             :                 case MYSQLND_OPT_NET_READ_BUFFER_SIZE:
    1642             : #ifdef MYSQLND_STRING_TO_INT_CONVERSION
    1643             :                 case MYSQLND_OPT_INT_AND_FLOAT_NATIVE:
    1644             : #endif
    1645             : #endif /* MYSQLI_USE_MYSQLND */
    1646             :                 case MYSQL_OPT_CONNECT_TIMEOUT:
    1647             : #ifdef MYSQL_REPORT_DATA_TRUNCATION
    1648             :                 case MYSQL_REPORT_DATA_TRUNCATION:
    1649             : #endif
    1650             :                 case MYSQL_OPT_LOCAL_INFILE:
    1651             :                 case MYSQL_OPT_NAMED_PIPE:
    1652             : #ifdef MYSQL_OPT_PROTOCOL
    1653             :                 case MYSQL_OPT_PROTOCOL:
    1654             : #endif /* MySQL 4.1.0 */
    1655             : #ifdef MYSQL_OPT_READ_TIMEOUT
    1656             :                 case MYSQL_OPT_READ_TIMEOUT:
    1657             :                 case MYSQL_OPT_WRITE_TIMEOUT:
    1658             :                 case MYSQL_OPT_GUESS_CONNECTION:
    1659             :                 case MYSQL_OPT_USE_EMBEDDED_CONNECTION:
    1660             :                 case MYSQL_OPT_USE_REMOTE_CONNECTION:
    1661             :                 case MYSQL_SECURE_AUTH:
    1662             : #endif /* MySQL 4.1.1 */
    1663             : #ifdef MYSQL_OPT_RECONNECT
    1664             :                 case MYSQL_OPT_RECONNECT:
    1665             : #endif /* MySQL 5.0.13 */
    1666             : #ifdef MYSQL_OPT_SSL_VERIFY_SERVER_CERT
    1667             :                 case MYSQL_OPT_SSL_VERIFY_SERVER_CERT:
    1668             : #endif /* MySQL 5.0.23 */
    1669             : #ifdef MYSQL_OPT_COMPRESS
    1670             :                 case MYSQL_OPT_COMPRESS:
    1671             : #endif /* mysqlnd @ PHP 5.3.2 */
    1672             : #ifdef MYSQL_OPT_SSL_VERIFY_SERVER_CERT
    1673             :         REGISTER_LONG_CONSTANT("MYSQLI_OPT_SSL_VERIFY_SERVER_CERT", MYSQL_OPT_SSL_VERIFY_SERVER_CERT, CONST_CS | CONST_PERSISTENT);
    1674             : #endif /* MySQL 5.1.1., mysqlnd @ PHP 5.3.3 */
    1675             : #if MYSQL_VERSION_ID >= 50611 || defined(MYSQLI_USE_MYSQLND)
    1676             :                 case MYSQL_OPT_CAN_HANDLE_EXPIRED_PASSWORDS:
    1677             : #endif
    1678          31 :                         return IS_LONG;
    1679             : 
    1680             : #ifdef MYSQL_SHARED_MEMORY_BASE_NAME
    1681             :                 case MYSQL_SHARED_MEMORY_BASE_NAME:
    1682             : #endif /* MySQL 4.1.0 */
    1683             : #ifdef MYSQL_SET_CLIENT_IP
    1684             :                 case MYSQL_SET_CLIENT_IP:
    1685             : #endif /* MySQL 4.1.1 */
    1686             :                 case MYSQL_READ_DEFAULT_FILE:
    1687             :                 case MYSQL_READ_DEFAULT_GROUP:
    1688             :                 case MYSQL_INIT_COMMAND:
    1689             :                 case MYSQL_SET_CHARSET_NAME:
    1690             :                 case MYSQL_SET_CHARSET_DIR:
    1691          55 :                         return IS_STRING;
    1692             : 
    1693             :                 default:
    1694           2 :                         return IS_NULL;
    1695             :         }
    1696             : }
    1697             : /* }}} */
    1698             : 
    1699             : 
    1700             : /* {{{ proto bool mysqli_options(object link, int flags, mixed values)
    1701             :    Set options */
    1702         101 : PHP_FUNCTION(mysqli_options)
    1703             : {
    1704             :         MY_MYSQL                *mysql;
    1705         101 :         zval                    *mysql_link = NULL;
    1706             :         zval                    **mysql_value;
    1707             :         long                    mysql_option;
    1708             :         unsigned int    l_value;
    1709             :         long                    ret;
    1710             :         int                             expected_type;
    1711             : 
    1712         101 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OlZ", &mysql_link, mysqli_link_class_entry, &mysql_option, &mysql_value) == FAILURE) {
    1713          10 :                 return;
    1714             :         }
    1715          91 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_INITIALIZED);
    1716             : 
    1717             : #if PHP_API_VERSION < 20100412
    1718             :         if ((PG(open_basedir) && PG(open_basedir)[0] != '\0') || PG(safe_mode)) {
    1719             : #else
    1720          89 :         if (PG(open_basedir) && PG(open_basedir)[0] != '\0') {
    1721             : #endif
    1722           1 :                 if(mysql_option == MYSQL_OPT_LOCAL_INFILE) {
    1723           1 :                         RETURN_FALSE;
    1724             :                 }
    1725             :         }
    1726          88 :         expected_type = mysqli_options_get_option_zval_type(mysql_option);
    1727          88 :         if (expected_type != Z_TYPE_PP(mysql_value)) {
    1728           4 :                 switch (expected_type) {
    1729             :                         case IS_STRING:
    1730           4 :                                 convert_to_string_ex(mysql_value);
    1731           1 :                                 break;
    1732             :                         case IS_LONG:
    1733           4 :                                 convert_to_long_ex(mysql_value);
    1734             :                                 break;
    1735             :                         default:
    1736             :                                 break;
    1737             :                 }
    1738             :         }
    1739          88 :         switch (expected_type) {
    1740             :                 case IS_STRING:
    1741          55 :                         ret = mysql_options(mysql->mysql, mysql_option, Z_STRVAL_PP(mysql_value));
    1742          55 :                         break;
    1743             :                 case IS_LONG:
    1744          31 :                         l_value = Z_LVAL_PP(mysql_value);
    1745          31 :                         ret = mysql_options(mysql->mysql, mysql_option, (char *)&l_value);
    1746          31 :                         break;
    1747             :                 default:
    1748           2 :                         ret = 1;
    1749             :                         break;
    1750             :         }
    1751             : 
    1752          88 :         RETURN_BOOL(!ret);
    1753             : }
    1754             : /* }}} */
    1755             : 
    1756             : 
    1757             : /* {{{ proto bool mysqli_ping(object link)
    1758             :    Ping a server connection or reconnect if there is no connection */
    1759          14 : PHP_FUNCTION(mysqli_ping)
    1760             : {
    1761             :         MY_MYSQL        *mysql;
    1762             :         zval            *mysql_link;
    1763             :         long            rc;
    1764             : 
    1765          14 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    1766           2 :                 return;
    1767             :         }
    1768          12 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1769          11 :         rc = mysql_ping(mysql->mysql);
    1770          11 :         MYSQLI_REPORT_MYSQL_ERROR(mysql->mysql);
    1771             : 
    1772          11 :         RETURN_BOOL(!rc);
    1773             : }
    1774             : /* }}} */
    1775             : 
    1776             : /* {{{ proto mixed mysqli_prepare(object link, string query)
    1777             :    Prepare a SQL statement for execution */
    1778         128 : PHP_FUNCTION(mysqli_prepare)
    1779             : {
    1780             :         MY_MYSQL                *mysql;
    1781             :         MY_STMT                 *stmt;
    1782         128 :         char                    *query = NULL;
    1783             :         int                             query_len;
    1784             :         zval                    *mysql_link;
    1785             :         MYSQLI_RESOURCE *mysqli_resource;
    1786             : 
    1787         128 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os",&mysql_link, mysqli_link_class_entry, &query, &query_len) == FAILURE) {
    1788           2 :                 return;
    1789             :         }
    1790         126 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1791             : 
    1792             : #if !defined(MYSQLI_USE_MYSQLND)
    1793             :         if (mysql->mysql->status == MYSQL_STATUS_GET_RESULT) {
    1794             :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "All data must be fetched before a new statement prepare takes place");
    1795             :                 RETURN_FALSE;
    1796             :         }
    1797             : #endif
    1798             : 
    1799         126 :         stmt = (MY_STMT *)ecalloc(1,sizeof(MY_STMT));
    1800             : 
    1801         126 :         if ((stmt->stmt = mysql_stmt_init(mysql->mysql))) {
    1802         126 :                 if (mysql_stmt_prepare(stmt->stmt, query, query_len)) {
    1803             :                         /* mysql_stmt_close() clears errors, so we have to store them temporarily */
    1804             : #if !defined(MYSQLI_USE_MYSQLND)
    1805             :                         char  last_error[MYSQL_ERRMSG_SIZE];
    1806             :                         char  sqlstate[SQLSTATE_LENGTH+1];
    1807             :                         unsigned int last_errno;
    1808             : 
    1809             :                         last_errno = stmt->stmt->last_errno;
    1810             :                         memcpy(last_error, stmt->stmt->last_error, MYSQL_ERRMSG_SIZE);
    1811             :                         memcpy(sqlstate, mysql->mysql->net.sqlstate, SQLSTATE_LENGTH+1);
    1812             : #else
    1813          10 :                         MYSQLND_ERROR_INFO error_info = *mysql->mysql->data->error_info;
    1814             : #endif
    1815          10 :                         mysqli_stmt_close(stmt->stmt, FALSE);
    1816          10 :                         stmt->stmt = NULL;
    1817             : 
    1818             :                         /* restore error messages */
    1819             : #if !defined(MYSQLI_USE_MYSQLND)
    1820             :                         mysql->mysql->net.last_errno = last_errno;
    1821             :                         memcpy(mysql->mysql->net.last_error, last_error, MYSQL_ERRMSG_SIZE);
    1822             :                         memcpy(mysql->mysql->net.sqlstate, sqlstate, SQLSTATE_LENGTH+1);
    1823             : #else
    1824          10 :                         *mysql->mysql->data->error_info = error_info;
    1825             : #endif
    1826             :                 }
    1827             :         }
    1828             : 
    1829             :         /* don't initialize stmt->query with NULL, we ecalloc()-ed the memory */
    1830             :         /* Get performance boost if reporting is switched off */
    1831         126 :         if (stmt->stmt && query_len && (MyG(report_mode) & MYSQLI_REPORT_INDEX)) {
    1832           0 :                 stmt->query = (char *)emalloc(query_len + 1);
    1833           0 :                 memcpy(stmt->query, query, query_len);
    1834           0 :                 stmt->query[query_len] = '\0';
    1835             :         }
    1836             : 
    1837             :         /* don't join to the previous if because it won't work if mysql_stmt_prepare_fails */
    1838         126 :         if (!stmt->stmt) {
    1839          10 :                 MYSQLI_REPORT_MYSQL_ERROR(mysql->mysql);
    1840          10 :                 efree(stmt);
    1841          10 :                 RETURN_FALSE;
    1842             :         }
    1843             : #ifndef MYSQLI_USE_MYSQLND
    1844             :         stmt->link_handle = Z_OBJ_HANDLE(*mysql_link);
    1845             :         zend_objects_store_add_ref_by_handle(stmt->link_handle TSRMLS_CC);
    1846             : #endif
    1847             : 
    1848         116 :         mysqli_resource = (MYSQLI_RESOURCE *)ecalloc (1, sizeof(MYSQLI_RESOURCE));
    1849         116 :         mysqli_resource->ptr = (void *)stmt;
    1850             : 
    1851             :         /* change status */
    1852         116 :         mysqli_resource->status = MYSQLI_STATUS_VALID;
    1853         116 :         MYSQLI_RETURN_RESOURCE(mysqli_resource, mysqli_stmt_class_entry);
    1854             : }
    1855             : /* }}} */
    1856             : 
    1857             : 
    1858             : /* {{{ proto bool mysqli_real_connect(object link [,string hostname [,string username [,string passwd [,string dbname [,int port [,string socket [,int flags]]]]]]])
    1859             :    Open a connection to a mysql server */
    1860        1148 : PHP_FUNCTION(mysqli_real_connect)
    1861             : {
    1862        1148 :         mysqli_common_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU, TRUE, FALSE);
    1863        1148 : }
    1864             : /* }}} */
    1865             : 
    1866             : 
    1867             : /* {{{ proto bool mysqli_real_query(object link, string query)
    1868             :    Binary-safe version of mysql_query() */
    1869          49 : PHP_FUNCTION(mysqli_real_query)
    1870             : {
    1871             :         MY_MYSQL        *mysql;
    1872             :         zval            *mysql_link;
    1873          49 :         char            *query = NULL;
    1874             :         int                     query_len;
    1875             : 
    1876          49 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &mysql_link, mysqli_link_class_entry, &query, &query_len) == FAILURE) {
    1877           3 :                 return;
    1878             :         }
    1879          46 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1880             : 
    1881          45 :         MYSQLI_DISABLE_MQ; /* disable multi statements/queries */
    1882             : 
    1883          45 :         if (mysql_real_query(mysql->mysql, query, query_len)) {
    1884           7 :                 MYSQLI_REPORT_MYSQL_ERROR(mysql->mysql);
    1885           7 :                 RETURN_FALSE;
    1886             :         }
    1887             : 
    1888          38 :         if (!mysql_field_count(mysql->mysql)) {
    1889          13 :                 if (MyG(report_mode) & MYSQLI_REPORT_INDEX) {
    1890           0 :                         php_mysqli_report_index(query, mysqli_server_status(mysql->mysql) TSRMLS_CC);
    1891             :                 }
    1892             :         }
    1893             : 
    1894          38 :         RETURN_TRUE;
    1895             : }
    1896             : /* }}} */
    1897             : 
    1898             : /* {{{ proto string mysqli_real_escape_string(object link, string escapestr)
    1899             :    Escapes special characters in a string for use in a SQL statement, taking into account the current charset of the connection */
    1900       10179 : PHP_FUNCTION(mysqli_real_escape_string) {
    1901             :         MY_MYSQL        *mysql;
    1902       10179 :         zval            *mysql_link = NULL;
    1903             :         char            *escapestr, *newstr;
    1904             :         int                     escapestr_len, newstr_len;
    1905             : 
    1906       10179 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &mysql_link, mysqli_link_class_entry, &escapestr, &escapestr_len) == FAILURE) {
    1907           7 :                 return;
    1908             :         }
    1909       10172 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1910             : 
    1911       10170 :         newstr = safe_emalloc(2, escapestr_len, 1);
    1912       10170 :         newstr_len = mysql_real_escape_string(mysql->mysql, newstr, escapestr, escapestr_len);
    1913       10170 :         newstr = erealloc(newstr, newstr_len + 1);
    1914             : 
    1915       10170 :         RETURN_STRINGL(newstr, newstr_len, 0);
    1916             : }
    1917             : /* }}} */
    1918             : 
    1919             : /* {{{ proto bool mysqli_rollback(object link)
    1920             :    Undo actions from current transaction */
    1921           7 : PHP_FUNCTION(mysqli_rollback)
    1922             : {
    1923             :         MY_MYSQL        *mysql;
    1924             :         zval            *mysql_link;
    1925             : 
    1926           7 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    1927           3 :                 return;
    1928             :         }
    1929           4 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    1930             : 
    1931           3 :         if (mysql_rollback(mysql->mysql)) {
    1932           0 :                 RETURN_FALSE;
    1933             :         }
    1934           3 :         RETURN_TRUE;
    1935             : }
    1936             : /* }}} */
    1937             : 
    1938             : /* {{{ proto bool mysqli_stmt_send_long_data(object stmt, int param_nr, string data)
    1939             : */
    1940          23 : PHP_FUNCTION(mysqli_stmt_send_long_data)
    1941             : {
    1942             :         MY_STMT *stmt;
    1943             :         zval    *mysql_stmt;
    1944             :         char    *data;
    1945             :         long    param_nr;
    1946             :         int             data_len;
    1947             : 
    1948          23 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ols", &mysql_stmt, mysqli_stmt_class_entry, &param_nr, &data, &data_len) == FAILURE) {
    1949           5 :                 return;
    1950             :         }
    1951          18 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    1952             : 
    1953          18 :         if (param_nr < 0) {
    1954           2 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid parameter number");
    1955           2 :                 RETURN_FALSE;
    1956             :         }
    1957          16 :         if (mysql_stmt_send_long_data(stmt->stmt, param_nr, data, data_len)) {
    1958           1 :                 RETURN_FALSE;
    1959             :         }
    1960          15 :         RETURN_TRUE;
    1961             : }
    1962             : /* }}} */
    1963             : 
    1964             : 
    1965             : /* {{{ proto mixed mysqli_stmt_affected_rows(object stmt)
    1966             :    Return the number of rows affected in the last query for the given link */
    1967          25 : PHP_FUNCTION(mysqli_stmt_affected_rows)
    1968             : {
    1969             :         MY_STMT                 *stmt;
    1970             :         zval                    *mysql_stmt;
    1971             :         my_ulonglong    rc;
    1972             : 
    1973          25 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
    1974           2 :                 return;
    1975             :         }
    1976          23 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    1977             : 
    1978          21 :         rc = mysql_stmt_affected_rows(stmt->stmt);
    1979          21 :         if (rc == (my_ulonglong) -1) {
    1980           5 :                 RETURN_LONG(-1);
    1981             :         }
    1982          16 :         MYSQLI_RETURN_LONG_LONG(rc)
    1983             : }
    1984             : /* }}} */
    1985             : 
    1986             : /* {{{ proto bool mysqli_stmt_close(object stmt)
    1987             :    Close statement */
    1988         917 : PHP_FUNCTION(mysqli_stmt_close)
    1989             : {
    1990             :         MY_STMT         *stmt;
    1991             :         zval            *mysql_stmt;
    1992             : 
    1993         917 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
    1994           2 :                 return;
    1995             :         }
    1996         915 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    1997             : 
    1998         912 :         mysqli_stmt_close(stmt->stmt, FALSE);
    1999         912 :         stmt->stmt = NULL;
    2000         912 :         php_clear_stmt_bind(stmt TSRMLS_CC);
    2001         912 :         MYSQLI_CLEAR_RESOURCE(&mysql_stmt);
    2002         912 :         RETURN_TRUE;
    2003             : }
    2004             : /* }}} */
    2005             : 
    2006             : /* {{{ proto void mysqli_stmt_data_seek(object stmt, int offset)
    2007             :    Move internal result pointer */
    2008           8 : PHP_FUNCTION(mysqli_stmt_data_seek)
    2009             : {
    2010             :         MY_STMT         *stmt;
    2011             :         zval            *mysql_stmt;
    2012             :         long            offset;
    2013             : 
    2014           8 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &mysql_stmt, mysqli_stmt_class_entry, &offset) == FAILURE) {
    2015           2 :                 return;
    2016             :         }
    2017           6 :         if (offset < 0) {
    2018           1 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset must be positive");
    2019           1 :                 RETURN_FALSE;
    2020             :         }
    2021             : 
    2022           5 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    2023             : 
    2024           3 :         mysql_stmt_data_seek(stmt->stmt, offset);
    2025             : }
    2026             : /* }}} */
    2027             : 
    2028             : /* {{{ proto int mysqli_stmt_field_count(object stmt) {
    2029             :    Return the number of result columns for the given statement */
    2030          20 : PHP_FUNCTION(mysqli_stmt_field_count)
    2031             : {
    2032             :         MY_STMT         *stmt;
    2033             :         zval            *mysql_stmt;
    2034             : 
    2035          20 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
    2036           2 :                 return;
    2037             :         }
    2038          18 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    2039             : 
    2040          15 :         RETURN_LONG(mysql_stmt_field_count(stmt->stmt));
    2041             : }
    2042             : /* }}} */
    2043             : 
    2044             : /* {{{ proto void mysqli_stmt_free_result(object stmt)
    2045             :    Free stored result memory for the given statement handle */
    2046          53 : PHP_FUNCTION(mysqli_stmt_free_result)
    2047             : {
    2048             :         MY_STMT         *stmt;
    2049             :         zval            *mysql_stmt;
    2050             : 
    2051          53 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
    2052           2 :                 return;
    2053             :         }
    2054             : 
    2055          51 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    2056             : 
    2057          49 :         mysql_stmt_free_result(stmt->stmt);
    2058             : }
    2059             : /* }}} */
    2060             : 
    2061             : /* {{{ proto mixed mysqli_stmt_insert_id(object stmt)
    2062             :    Get the ID generated from the previous INSERT operation */
    2063           8 : PHP_FUNCTION(mysqli_stmt_insert_id)
    2064             : {
    2065             :         MY_STMT                 *stmt;
    2066             :         my_ulonglong    rc;
    2067             :         zval                    *mysql_stmt;
    2068             : 
    2069           8 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
    2070           1 :                 return;
    2071             :         }
    2072           7 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    2073           5 :         rc = mysql_stmt_insert_id(stmt->stmt);
    2074           5 :         MYSQLI_RETURN_LONG_LONG(rc)
    2075             : }
    2076             : /* }}} */
    2077             : 
    2078             : /* {{{ proto int mysqli_stmt_param_count(object stmt)
    2079             :    Return the number of parameter for the given statement */
    2080          10 : PHP_FUNCTION(mysqli_stmt_param_count)
    2081             : {
    2082             :         MY_STMT         *stmt;
    2083             :         zval            *mysql_stmt;
    2084             : 
    2085          10 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
    2086           3 :                 return;
    2087             :         }
    2088           7 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    2089             : 
    2090           5 :         RETURN_LONG(mysql_stmt_param_count(stmt->stmt));
    2091             : }
    2092             : /* }}} */
    2093             : 
    2094             : /* {{{ proto bool mysqli_stmt_reset(object stmt)
    2095             :    reset a prepared statement */
    2096          11 : PHP_FUNCTION(mysqli_stmt_reset)
    2097             : {
    2098             :         MY_STMT         *stmt;
    2099             :         zval            *mysql_stmt;
    2100             : 
    2101          11 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
    2102           3 :                 return;
    2103             :         }
    2104             : 
    2105           8 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    2106             : 
    2107           6 :         if (mysql_stmt_reset(stmt->stmt)) {
    2108           0 :                 RETURN_FALSE;
    2109             :         }
    2110           6 :         RETURN_TRUE;
    2111             : }
    2112             : /* }}} */
    2113             : 
    2114             : /* {{{ proto mixed mysqli_stmt_num_rows(object stmt)
    2115             :    Return the number of rows in statements result set */
    2116          24 : PHP_FUNCTION(mysqli_stmt_num_rows)
    2117             : {
    2118             :         MY_STMT                 *stmt;
    2119             :         zval                    *mysql_stmt;
    2120             :         my_ulonglong    rc;
    2121             : 
    2122          24 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
    2123           2 :                 return;
    2124             :         }
    2125             : 
    2126          22 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    2127             : 
    2128          21 :         rc = mysql_stmt_num_rows(stmt->stmt);
    2129          21 :         MYSQLI_RETURN_LONG_LONG(rc)
    2130             : }
    2131             : /* }}} */
    2132             : 
    2133             : /* {{{ proto bool mysqli_select_db(object link, string dbname)
    2134             :    Select a MySQL database */
    2135          49 : PHP_FUNCTION(mysqli_select_db)
    2136             : {
    2137             :         MY_MYSQL        *mysql;
    2138             :         zval            *mysql_link;
    2139             :         char            *dbname;
    2140             :         int                     dbname_len;
    2141             : 
    2142          49 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &mysql_link, mysqli_link_class_entry, &dbname, &dbname_len) == FAILURE) {
    2143           3 :                 return;
    2144             :         }
    2145          46 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    2146             : 
    2147          45 :         if (mysql_select_db(mysql->mysql, dbname)) {
    2148           8 :                 MYSQLI_REPORT_MYSQL_ERROR(mysql->mysql);
    2149           8 :                 RETURN_FALSE;
    2150             :         }
    2151          37 :         RETURN_TRUE;
    2152             : }
    2153             : /* }}} */
    2154             : 
    2155             : /* {{{ proto string mysqli_sqlstate(object link)
    2156             :    Returns the SQLSTATE error from previous MySQL operation */
    2157          16 : PHP_FUNCTION(mysqli_sqlstate)
    2158             : {
    2159             :         MY_MYSQL        *mysql;
    2160             :         zval            *mysql_link;
    2161             : 
    2162          16 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    2163           3 :                 return;
    2164             :         }
    2165          13 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    2166           6 :         RETURN_STRING((char *)mysql_sqlstate(mysql->mysql),1);
    2167             : }
    2168             : /* }}} */
    2169             : 
    2170             : /* {{{ proto bool mysqli_ssl_set(object link ,string key ,string cert ,string ca ,string capath ,string cipher]) U
    2171             : */
    2172           9 : PHP_FUNCTION(mysqli_ssl_set)
    2173             : {
    2174             :         MY_MYSQL        *mysql;
    2175             :         zval            *mysql_link;
    2176             :         char            *ssl_parm[5];
    2177             :         int                     ssl_parm_len[5], i;
    2178             : 
    2179           9 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Osssss", &mysql_link, mysqli_link_class_entry, &ssl_parm[0], &ssl_parm_len[0], &ssl_parm[1], &ssl_parm_len[1], &ssl_parm[2], &ssl_parm_len[2], &ssl_parm[3], &ssl_parm_len[3], &ssl_parm[4], &ssl_parm_len[4])   == FAILURE) {
    2180           6 :                 return;
    2181             :         }
    2182           3 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_INITIALIZED);
    2183             : 
    2184          18 :         for (i = 0; i < 5; i++) {
    2185          15 :                 if (!ssl_parm_len[i]) {
    2186          10 :                         ssl_parm[i] = NULL;
    2187             :                 }
    2188             :         }
    2189             : 
    2190           3 :         mysql_ssl_set(mysql->mysql, ssl_parm[0], ssl_parm[1], ssl_parm[2], ssl_parm[3], ssl_parm[4]);
    2191             : 
    2192           3 :         RETURN_TRUE;
    2193             : }
    2194             : /* }}} */
    2195             : 
    2196             : /* {{{ proto mixed mysqli_stat(object link)
    2197             :    Get current system status */
    2198          11 : PHP_FUNCTION(mysqli_stat)
    2199             : {
    2200             :         MY_MYSQL        *mysql;
    2201             :         zval            *mysql_link;
    2202             :         char            *stat;
    2203             : #if defined(MYSQLI_USE_MYSQLND)
    2204             :         uint            stat_len;
    2205             : #endif
    2206             : 
    2207          11 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    2208           3 :                 return;
    2209             :         }
    2210           8 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    2211             : 
    2212             : #if !defined(MYSQLI_USE_MYSQLND)
    2213             :         if ((stat = (char *)mysql_stat(mysql->mysql)))
    2214             :         {
    2215             :                 RETURN_STRING(stat, 1);
    2216             : #else
    2217           7 :         if (mysqlnd_stat(mysql->mysql, &stat, &stat_len) == PASS)
    2218             :         {
    2219           7 :                 RETURN_STRINGL(stat, stat_len, 0);
    2220             : #endif
    2221             :         } else {
    2222           0 :                 RETURN_FALSE;
    2223             :         }
    2224             : }
    2225             : 
    2226             : /* }}} */
    2227             : 
    2228             : /* {{{ proto bool mysqli_refresh(object link, long options)
    2229             :    Flush tables or caches, or reset replication server information */
    2230           0 : PHP_FUNCTION(mysqli_refresh)
    2231             : {
    2232             :         MY_MYSQL *mysql;
    2233           0 :         zval *mysql_link = NULL;
    2234             :         long options;
    2235             : 
    2236           0 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &mysql_link, mysqli_link_class_entry, &options) == FAILURE) {
    2237           0 :                 return;
    2238             :         }
    2239           0 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_INITIALIZED);
    2240             : #ifdef MYSQLI_USE_MYSQLND
    2241           0 :         RETURN_BOOL(!mysql_refresh(mysql->mysql, (uint8_t) options));
    2242             : #else
    2243             :         RETURN_BOOL(!mysql_refresh(mysql->mysql, options));
    2244             : #endif
    2245             : }
    2246             : /* }}} */
    2247             : 
    2248             : /* {{{ proto int mysqli_stmt_attr_set(object stmt, long attr, long mode)
    2249             : */
    2250        1116 : PHP_FUNCTION(mysqli_stmt_attr_set)
    2251             : {
    2252             :         MY_STMT *stmt;
    2253             :         zval    *mysql_stmt;
    2254             :         long    mode_in;
    2255             : #if MYSQL_VERSION_ID >= 50107
    2256             :         my_bool mode_b;
    2257             : #endif
    2258             :         ulong   mode;
    2259             :         ulong   attr;
    2260             :         void    *mode_p;
    2261             : 
    2262        1116 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oll", &mysql_stmt, mysqli_stmt_class_entry, &attr, &mode_in) == FAILURE) {
    2263           4 :                 return;
    2264             :         }
    2265        1112 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    2266             : 
    2267        1111 :         if (mode_in < 0) {
    2268           1 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "mode should be non-negative, %ld passed", mode_in);
    2269           1 :                 RETURN_FALSE;
    2270             :         }
    2271             : 
    2272        1110 :         switch (attr) {
    2273             : #if MYSQL_VERSION_ID >= 50107
    2274             :         case STMT_ATTR_UPDATE_MAX_LENGTH:
    2275             :                 mode_b = (my_bool) mode_in;
    2276             :                 mode_p = &mode_b;
    2277             :                 break;
    2278             : #endif
    2279             :         default:
    2280        1110 :                 mode = mode_in;
    2281        1110 :                 mode_p = &mode;
    2282             :                 break;
    2283             :         }
    2284             : #if !defined(MYSQLI_USE_MYSQLND)
    2285             :         if (mysql_stmt_attr_set(stmt->stmt, attr, mode_p)) {
    2286             : #else
    2287        1110 :         if (FAIL == mysql_stmt_attr_set(stmt->stmt, attr, mode_p)) {
    2288             : #endif
    2289        1100 :                 RETURN_FALSE;
    2290             :         }
    2291          10 :         RETURN_TRUE;
    2292             : }
    2293             : /* }}} */
    2294             : 
    2295             : /* {{{ proto int mysqli_stmt_attr_get(object stmt, long attr)
    2296             : */
    2297          13 : PHP_FUNCTION(mysqli_stmt_attr_get)
    2298             : {
    2299             :         MY_STMT *stmt;
    2300             :         zval    *mysql_stmt;
    2301          13 :         ulong   value = 0;
    2302             :         ulong   attr;
    2303             :         int             rc;
    2304             : 
    2305          13 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &mysql_stmt, mysqli_stmt_class_entry, &attr) == FAILURE) {
    2306           4 :                 return;
    2307             :         }
    2308           9 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    2309             : 
    2310           6 :         if ((rc = mysql_stmt_attr_get(stmt->stmt, attr, &value))) {
    2311           1 :                 RETURN_FALSE;
    2312             :         }
    2313             : 
    2314             : #if MYSQL_VERSION_ID >= 50107
    2315             :         if (attr == STMT_ATTR_UPDATE_MAX_LENGTH)
    2316             :                 value = *((my_bool *)&value);
    2317             : #endif
    2318           5 :         RETURN_LONG((long)value);
    2319             : }
    2320             : /* }}} */
    2321             : 
    2322             : /* {{{ proto int mysqli_stmt_errno(object stmt)
    2323             : */
    2324          11 : PHP_FUNCTION(mysqli_stmt_errno)
    2325             : {
    2326             :         MY_STMT *stmt;
    2327             :         zval    *mysql_stmt;
    2328             : 
    2329          11 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
    2330           2 :                 return;
    2331             :         }
    2332           9 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_INITIALIZED);
    2333             : 
    2334           8 :         RETURN_LONG(mysql_stmt_errno(stmt->stmt));
    2335             : }
    2336             : /* }}} */
    2337             : 
    2338             : /* {{{ proto string mysqli_stmt_error(object stmt)
    2339             : */
    2340          10 : PHP_FUNCTION(mysqli_stmt_error)
    2341             : {
    2342             :         MY_STMT *stmt;
    2343             :         zval    *mysql_stmt;
    2344             : 
    2345          10 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
    2346           2 :                 return;
    2347             :         }
    2348           8 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_INITIALIZED);
    2349             : 
    2350           7 :         RETURN_STRING((char *)mysql_stmt_error(stmt->stmt),1);
    2351             : }
    2352             : /* }}} */
    2353             : 
    2354             : /* {{{ proto mixed mysqli_stmt_init(object link)
    2355             :    Initialize statement object
    2356             : */
    2357         829 : PHP_FUNCTION(mysqli_stmt_init)
    2358             : {
    2359             :         MY_MYSQL                *mysql;
    2360             :         MY_STMT                 *stmt;
    2361             :         zval                    *mysql_link;
    2362             :         MYSQLI_RESOURCE *mysqli_resource;
    2363             : 
    2364         829 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O",&mysql_link, mysqli_link_class_entry) == FAILURE) {
    2365           3 :                 return;
    2366             :         }
    2367         826 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    2368             : 
    2369         825 :         stmt = (MY_STMT *)ecalloc(1,sizeof(MY_STMT));
    2370             : 
    2371         825 :         if (!(stmt->stmt = mysql_stmt_init(mysql->mysql))) {
    2372           0 :                 efree(stmt);
    2373           0 :                 RETURN_FALSE;
    2374             :         }
    2375             : #ifndef MYSQLI_USE_MYSQLND
    2376             :         stmt->link_handle = Z_OBJ_HANDLE(*mysql_link);
    2377             :         zend_objects_store_add_ref_by_handle(stmt->link_handle TSRMLS_CC);
    2378             : #endif
    2379             : 
    2380         825 :         mysqli_resource = (MYSQLI_RESOURCE *)ecalloc (1, sizeof(MYSQLI_RESOURCE));
    2381         825 :         mysqli_resource->status = MYSQLI_STATUS_INITIALIZED;
    2382         825 :         mysqli_resource->ptr = (void *)stmt;
    2383         825 :         MYSQLI_RETURN_RESOURCE(mysqli_resource, mysqli_stmt_class_entry);
    2384             : }
    2385             : /* }}} */
    2386             : 
    2387             : /* {{{ proto bool mysqli_stmt_prepare(object stmt, string query)
    2388             :    prepare server side statement with query
    2389             : */
    2390        3255 : PHP_FUNCTION(mysqli_stmt_prepare)
    2391             : {
    2392             :         MY_STMT *stmt;
    2393             :         zval    *mysql_stmt;
    2394             :         char    *query;
    2395             :         int             query_len;
    2396             : 
    2397        3255 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &mysql_stmt, mysqli_stmt_class_entry, &query, &query_len) == FAILURE) {
    2398           5 :                 return;
    2399             :         }
    2400        3250 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_INITIALIZED);
    2401             : 
    2402        3248 :         if (mysql_stmt_prepare(stmt->stmt, query, query_len)) {
    2403          10 :                 MYSQLI_REPORT_STMT_ERROR(stmt->stmt);
    2404          10 :                 RETURN_FALSE;
    2405             :         }
    2406             :         /* change status */
    2407        3238 :         MYSQLI_SET_STATUS(&mysql_stmt, MYSQLI_STATUS_VALID);
    2408        3238 :         RETURN_TRUE;
    2409             : }
    2410             : /* }}} */
    2411             : 
    2412             : /* {{{ proto mixed mysqli_stmt_result_metadata(object stmt)
    2413             :    return result set from statement */
    2414         221 : PHP_FUNCTION(mysqli_stmt_result_metadata)
    2415             : {
    2416             :         MY_STMT                 *stmt;
    2417             :         MYSQL_RES               *result;
    2418             :         zval                    *mysql_stmt;
    2419             :         MYSQLI_RESOURCE *mysqli_resource;
    2420             : 
    2421         221 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
    2422           3 :                 return;
    2423             :         }
    2424         218 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    2425             : 
    2426         216 :         if (!(result = mysql_stmt_result_metadata(stmt->stmt))){
    2427           0 :                 MYSQLI_REPORT_STMT_ERROR(stmt->stmt);
    2428           0 :                 RETURN_FALSE;
    2429             :         }
    2430             : 
    2431         216 :         mysqli_resource = (MYSQLI_RESOURCE *)ecalloc (1, sizeof(MYSQLI_RESOURCE));
    2432         216 :         mysqli_resource->ptr = (void *)result;
    2433         216 :         mysqli_resource->status = MYSQLI_STATUS_VALID;
    2434         216 :         MYSQLI_RETURN_RESOURCE(mysqli_resource, mysqli_result_class_entry);
    2435             : }
    2436             : /* }}} */
    2437             : 
    2438             : /* {{{ proto bool mysqli_stmt_store_result(stmt)
    2439             : */
    2440          60 : PHP_FUNCTION(mysqli_stmt_store_result)
    2441             : {
    2442             :         MY_STMT *stmt;
    2443             :         zval    *mysql_stmt;
    2444             : 
    2445          60 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
    2446           2 :                 return;
    2447             :         }
    2448          58 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    2449             : 
    2450             : #if !defined(MYSQLI_USE_MYSQLND)
    2451             :         {
    2452             :                 /*
    2453             :                   If the user wants to store the data and we have BLOBs/TEXTs we try to allocate
    2454             :                   not the maximal length of the type (which is 16MB even for LONGBLOB) but
    2455             :                   the maximal length of the field in the result set. If he/she has quite big
    2456             :                   BLOB/TEXT columns after calling store_result() the memory usage of PHP will
    2457             :                   double - but this is a known problem of the simple MySQL API ;)
    2458             :                 */
    2459             :                 int     i = 0;
    2460             : 
    2461             :                 for (i = mysql_stmt_field_count(stmt->stmt) - 1; i >=0; --i) {
    2462             :                         if (stmt->stmt->fields && (stmt->stmt->fields[i].type == MYSQL_TYPE_BLOB ||
    2463             :                                 stmt->stmt->fields[i].type == MYSQL_TYPE_MEDIUM_BLOB ||
    2464             :                                 stmt->stmt->fields[i].type == MYSQL_TYPE_LONG_BLOB ||
    2465             :                                 stmt->stmt->fields[i].type == MYSQL_TYPE_GEOMETRY))
    2466             :                         {
    2467             : #if MYSQL_VERSION_ID >= 50107
    2468             :                                 my_bool tmp=1;
    2469             : #else
    2470             :                                 uint tmp=1;
    2471             : #endif
    2472             :                                 mysql_stmt_attr_set(stmt->stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &tmp);
    2473             :                                 break;
    2474             :                         }
    2475             :                 }
    2476             :         }
    2477             : #endif
    2478             : 
    2479          55 :         if (mysql_stmt_store_result(stmt->stmt)){
    2480           3 :                 MYSQLI_REPORT_STMT_ERROR(stmt->stmt);
    2481           3 :                 RETURN_FALSE;
    2482             :         }
    2483          52 :         RETURN_TRUE;
    2484             : }
    2485             : /* }}} */
    2486             : 
    2487             : /* {{{ proto string mysqli_stmt_sqlstate(object stmt)
    2488             : */
    2489           8 : PHP_FUNCTION(mysqli_stmt_sqlstate)
    2490             : {
    2491             :         MY_STMT *stmt;
    2492             :         zval    *mysql_stmt;
    2493             : 
    2494           8 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_stmt, mysqli_stmt_class_entry) == FAILURE) {
    2495           3 :                 return;
    2496             :         }
    2497           5 :         MYSQLI_FETCH_RESOURCE_STMT(stmt, &mysql_stmt, MYSQLI_STATUS_VALID);
    2498             : 
    2499           3 :         RETURN_STRING((char *)mysql_stmt_sqlstate(stmt->stmt),1);
    2500             : }
    2501             : /* }}} */
    2502             : 
    2503             : /* {{{ proto object mysqli_store_result(object link)
    2504             :    Buffer result set on client */
    2505          54 : PHP_FUNCTION(mysqli_store_result)
    2506             : {
    2507             :         MY_MYSQL                *mysql;
    2508             :         MYSQL_RES               *result;
    2509             :         zval                    *mysql_link;
    2510             :         MYSQLI_RESOURCE *mysqli_resource;
    2511             : 
    2512          54 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    2513           2 :                 return;
    2514             :         }
    2515          52 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    2516             : 
    2517          51 :         if (!(result = mysql_store_result(mysql->mysql))) {
    2518          13 :                 MYSQLI_REPORT_MYSQL_ERROR(mysql->mysql);
    2519          13 :                 RETURN_FALSE;
    2520             :         }
    2521          38 :         if (MyG(report_mode) & MYSQLI_REPORT_INDEX) {
    2522           0 :                 php_mysqli_report_index("from previous query", mysqli_server_status(mysql->mysql) TSRMLS_CC);
    2523             :         }
    2524             : 
    2525          38 :         mysqli_resource = (MYSQLI_RESOURCE *)ecalloc (1, sizeof(MYSQLI_RESOURCE));
    2526          38 :         mysqli_resource->ptr = (void *)result;
    2527          38 :         mysqli_resource->status = MYSQLI_STATUS_VALID;
    2528          38 :         MYSQLI_RETURN_RESOURCE(mysqli_resource, mysqli_result_class_entry);
    2529             : }
    2530             : /* }}} */
    2531             : 
    2532             : 
    2533             : /* {{{ proto int mysqli_thread_id(object link)
    2534             :    Return the current thread ID */
    2535          79 : PHP_FUNCTION(mysqli_thread_id)
    2536             : {
    2537             :         MY_MYSQL        *mysql;
    2538             :         zval            *mysql_link;
    2539             : 
    2540          79 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    2541           2 :                 return;
    2542             :         }
    2543          77 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    2544             : 
    2545          68 :         RETURN_LONG((long) mysql_thread_id(mysql->mysql));
    2546             : }
    2547             : /* }}} */
    2548             : 
    2549             : /* {{{ proto bool mysqli_thread_safe(void)
    2550             :    Return whether thread safety is given or not */
    2551           2 : PHP_FUNCTION(mysqli_thread_safe)
    2552             : {
    2553           2 :         RETURN_BOOL(mysql_thread_safe());
    2554             : }
    2555             : /* }}} */
    2556             : 
    2557             : /* {{{ proto mixed mysqli_use_result(object link)
    2558             :    Directly retrieve query results - do not buffer results on client side */
    2559          22 : PHP_FUNCTION(mysqli_use_result)
    2560             : {
    2561             :         MY_MYSQL                *mysql;
    2562             :         MYSQL_RES               *result;
    2563             :         zval                    *mysql_link;
    2564             :         MYSQLI_RESOURCE *mysqli_resource;
    2565             : 
    2566          22 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    2567           2 :                 return;
    2568             :         }
    2569          20 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    2570             : 
    2571          19 :         if (!(result = mysql_use_result(mysql->mysql))) {
    2572           3 :                 MYSQLI_REPORT_MYSQL_ERROR(mysql->mysql);
    2573           3 :                 RETURN_FALSE;
    2574             :         }
    2575             : 
    2576          16 :         if (MyG(report_mode) & MYSQLI_REPORT_INDEX) {
    2577           0 :                 php_mysqli_report_index("from previous query", mysqli_server_status(mysql->mysql) TSRMLS_CC);
    2578             :         }
    2579          16 :         mysqli_resource = (MYSQLI_RESOURCE *)ecalloc (1, sizeof(MYSQLI_RESOURCE));
    2580          16 :         mysqli_resource->ptr = (void *)result;
    2581          16 :         mysqli_resource->status = MYSQLI_STATUS_VALID;
    2582          16 :         MYSQLI_RETURN_RESOURCE(mysqli_resource, mysqli_result_class_entry);
    2583             : }
    2584             : /* }}} */
    2585             : 
    2586             : /* {{{ proto int mysqli_warning_count (object link)
    2587             :    Return number of warnings from the last query for the given link */
    2588          16 : PHP_FUNCTION(mysqli_warning_count)
    2589             : {
    2590             :         MY_MYSQL        *mysql;
    2591             :         zval            *mysql_link;
    2592             : 
    2593          16 :         if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_link, mysqli_link_class_entry) == FAILURE) {
    2594           3 :                 return;
    2595             :         }
    2596          13 :         MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
    2597             : 
    2598           6 :         RETURN_LONG(mysql_warning_count(mysql->mysql));
    2599             : }
    2600             : /* }}} */
    2601             : 
    2602             : /*
    2603             :  * Local variables:
    2604             :  * tab-width: 4
    2605             :  * c-basic-offset: 4
    2606             :  * End:
    2607             :  * vim600: noet sw=4 ts=4 fdm=marker
    2608             :  * vim<600: noet sw=4 ts=4
    2609             :  */

Generated by: LCOV version 1.10

Generated at Mon, 15 Dec 2014 17:02:44 +0000 (4 days ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.