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