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: 642 691 92.9 %
Date: 2014-04-18 Functions: 79 83 95.2 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Fri, 18 Apr 2014 07:01:30 +0000 (7 days ago)

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