Annotation of embedaddon/php/ext/mysqli/mysqli.c, revision 1.1.1.4
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
1.1.1.3 misho 5: | Copyright (c) 1997-2013 The PHP Group |
1.1 misho 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:
1.1.1.2 misho 20: $Id$
1.1 misho 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 "ext/standard/info.h"
32: #include "ext/standard/php_string.h"
1.1.1.2 misho 33: #include "php_mysqli.h"
1.1 misho 34: #include "php_mysqli_structs.h"
35: #include "mysqli_priv.h"
36: #include "zend_exceptions.h"
1.1.1.2 misho 37: #include "zend_interfaces.h"
1.1 misho 38:
39: ZEND_DECLARE_MODULE_GLOBALS(mysqli)
40: static PHP_GINIT_FUNCTION(mysqli);
41:
42: #define MYSQLI_ADD_PROPERTIES(a,b) \
43: { \
44: int i = 0; \
45: while (b[i].pname != NULL) { \
46: mysqli_add_property((a), (b)[i].pname, (b)[i].pname_length, \
47: (mysqli_read_t)(b)[i].r_func, (mysqli_write_t)(b)[i].w_func TSRMLS_CC); \
48: i++; \
49: }\
50: }
51:
52: #define MYSQLI_ADD_PROPERTIES_INFO(a,b) \
53: { \
54: int i = 0; \
55: while (b[i].name != NULL) { \
56: zend_declare_property_null((a), (b)[i].name, (b)[i].name_length, ZEND_ACC_PUBLIC TSRMLS_CC); \
57: i++; \
58: }\
59: }
60:
61:
62:
63: static zend_object_handlers mysqli_object_handlers;
64: static HashTable classes;
65: static HashTable mysqli_driver_properties;
66: static HashTable mysqli_link_properties;
67: static HashTable mysqli_result_properties;
68: static HashTable mysqli_stmt_properties;
69: static HashTable mysqli_warning_properties;
70:
71: zend_class_entry *mysqli_link_class_entry;
72: zend_class_entry *mysqli_stmt_class_entry;
73: zend_class_entry *mysqli_result_class_entry;
74: zend_class_entry *mysqli_driver_class_entry;
75: zend_class_entry *mysqli_warning_class_entry;
76: zend_class_entry *mysqli_exception_class_entry;
77:
78:
79: typedef int (*mysqli_read_t)(mysqli_object *obj, zval **retval TSRMLS_DC);
80: typedef int (*mysqli_write_t)(mysqli_object *obj, zval *newval TSRMLS_DC);
81:
82: typedef struct _mysqli_prop_handler {
83: char *name;
84: size_t name_len;
85: mysqli_read_t read_func;
86: mysqli_write_t write_func;
87: } mysqli_prop_handler;
88:
89: static int le_pmysqli;
90:
91:
92: /* Destructor for mysqli entries in free_links/used_links */
93: void php_mysqli_dtor_p_elements(void *data)
94: {
95: MYSQL *mysql = (MYSQL *) data;
96: TSRMLS_FETCH();
97: mysqli_close(mysql, MYSQLI_CLOSE_IMPLICIT);
98: }
99:
100:
101: ZEND_RSRC_DTOR_FUNC(php_mysqli_dtor)
102: {
103: if (rsrc->ptr) {
104: mysqli_plist_entry *plist = (mysqli_plist_entry *) rsrc->ptr;
105: zend_ptr_stack_clean(&plist->free_links, php_mysqli_dtor_p_elements, 0);
106: zend_ptr_stack_destroy(&plist->free_links);
107: free(plist);
108: }
109: }
110:
111:
112: int php_le_pmysqli(void)
113: {
114: return le_pmysqli;
115: }
116:
117: #ifndef MYSQLI_USE_MYSQLND
118: /* {{{ php_free_stmt_bind_buffer */
119: void php_free_stmt_bind_buffer(BIND_BUFFER bbuf, int type)
120: {
121: unsigned int i;
122:
123: if (!bbuf.var_cnt) {
124: return;
125: }
126:
127: for (i=0; i < bbuf.var_cnt; i++) {
128:
129: /* free temporary bind buffer */
130: if (type == FETCH_RESULT && bbuf.buf[i].val) {
131: efree(bbuf.buf[i].val);
132: }
133:
134: if (bbuf.vars[i]) {
135: zval_ptr_dtor(&bbuf.vars[i]);
136: }
137: }
138:
139: if (bbuf.vars) {
140: efree(bbuf.vars);
141: }
142:
143: /*
144: Don't free bbuf.is_null for FETCH_RESULT since we have allocated
145: is_null and buf in one block so we free only buf, which is the beginning
146: of the block. When FETCH_SIMPLE then buf wasn't allocated together with
147: buf and we have to free it.
148: */
149: if (type == FETCH_RESULT) {
150: efree(bbuf.buf);
151: } else if (type == FETCH_SIMPLE){
152: efree(bbuf.is_null);
153: }
154:
155: bbuf.var_cnt = 0;
156: }
157: /* }}} */
158: #endif
159:
160: /* {{{ php_clear_stmt_bind */
161: void php_clear_stmt_bind(MY_STMT *stmt TSRMLS_DC)
162: {
163: if (stmt->stmt) {
164: if (mysqli_stmt_close(stmt->stmt, TRUE)) {
1.1.1.3 misho 165: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error occurred while closing statement");
1.1 misho 166: return;
167: }
168: }
169:
170: /*
171: mysqlnd keeps track of the binding and has freed its
172: structures in stmt_close() above
173: */
174: #ifndef MYSQLI_USE_MYSQLND
175: /* Clean param bind */
176: php_free_stmt_bind_buffer(stmt->param, FETCH_SIMPLE);
177: /* Clean output bind */
178: php_free_stmt_bind_buffer(stmt->result, FETCH_RESULT);
179: #endif
180:
181: if (stmt->query) {
182: efree(stmt->query);
183: }
184: efree(stmt);
185: }
186: /* }}} */
187:
188: /* {{{ php_clear_mysql */
189: void php_clear_mysql(MY_MYSQL *mysql) {
190: if (mysql->hash_key) {
191: efree(mysql->hash_key);
192: mysql->hash_key = NULL;
193: }
194: if (mysql->li_read) {
195: zval_ptr_dtor(&(mysql->li_read));
196: mysql->li_read = NULL;
197: }
198: }
199: /* }}} */
200:
201: /* {{{ mysqli_objects_free_storage
202: */
203: static void mysqli_objects_free_storage(void *object TSRMLS_DC)
204: {
205: zend_object *zo = (zend_object *)object;
206: mysqli_object *intern = (mysqli_object *)zo;
207: MYSQLI_RESOURCE *my_res = (MYSQLI_RESOURCE *)intern->ptr;
208:
209: my_efree(my_res);
210: zend_object_std_dtor(&intern->zo TSRMLS_CC);
211: efree(intern);
212: }
213: /* }}} */
214:
215: /* mysqli_link_free_storage partly doubles the work of PHP_FUNCTION(mysqli_close) */
216:
217: /* {{{ mysqli_link_free_storage
218: */
219: static void mysqli_link_free_storage(void *object TSRMLS_DC)
220: {
221: zend_object *zo = (zend_object *)object;
222: mysqli_object *intern = (mysqli_object *)zo;
223: MYSQLI_RESOURCE *my_res = (MYSQLI_RESOURCE *)intern->ptr;
224:
225: if (my_res && my_res->ptr) {
226: MY_MYSQL *mysql = (MY_MYSQL *)my_res->ptr;
227: if (mysql->mysql) {
228: php_mysqli_close(mysql, MYSQLI_CLOSE_EXPLICIT, my_res->status TSRMLS_CC);
229: }
230: php_clear_mysql(mysql);
231: efree(mysql);
232: my_res->status = MYSQLI_STATUS_UNKNOWN;
233: }
234: mysqli_objects_free_storage(object TSRMLS_CC);
235: }
236: /* }}} */
237:
238: /* {{{ mysql_driver_free_storage */
239: static void mysqli_driver_free_storage(void *object TSRMLS_DC)
240: {
241: mysqli_objects_free_storage(object TSRMLS_CC);
242: }
243: /* }}} */
244:
245: /* {{{ mysqli_stmt_free_storage
246: */
247: static void mysqli_stmt_free_storage(void *object TSRMLS_DC)
248: {
249: zend_object *zo = (zend_object *)object;
250: mysqli_object *intern = (mysqli_object *)zo;
251: MYSQLI_RESOURCE *my_res = (MYSQLI_RESOURCE *)intern->ptr;
252:
253: if (my_res && my_res->ptr) {
254: MY_STMT *stmt = (MY_STMT *)my_res->ptr;
255: php_clear_stmt_bind(stmt TSRMLS_CC);
256: }
257: mysqli_objects_free_storage(object TSRMLS_CC);
258: }
259: /* }}} */
260:
261: /* {{{ mysqli_result_free_storage
262: */
263: static void mysqli_result_free_storage(void *object TSRMLS_DC)
264: {
265: zend_object *zo = (zend_object *)object;
266: mysqli_object *intern = (mysqli_object *)zo;
267: MYSQLI_RESOURCE *my_res = (MYSQLI_RESOURCE *)intern->ptr;
268:
269: if (my_res && my_res->ptr) {
270: mysql_free_result(my_res->ptr);
271: }
272: mysqli_objects_free_storage(object TSRMLS_CC);
273: }
274: /* }}} */
275:
276: /* {{{ mysqli_warning_free_storage
277: */
278: static void mysqli_warning_free_storage(void *object TSRMLS_DC)
279: {
280: zend_object *zo = (zend_object *)object;
281: mysqli_object *intern = (mysqli_object *)zo;
282: MYSQLI_RESOURCE *my_res = (MYSQLI_RESOURCE *)intern->ptr;
283:
284: if (my_res && my_res->ptr) {
285: php_clear_warnings((MYSQLI_WARNING *)my_res->info);
286: my_res->ptr = NULL;
287: }
288: mysqli_objects_free_storage(object TSRMLS_CC);
289: }
290: /* }}} */
291:
292: /* {{{ mysqli_read_na */
293: static int mysqli_read_na(mysqli_object *obj, zval **retval TSRMLS_DC)
294: {
295: *retval = NULL;
296: php_error_docref(NULL TSRMLS_CC, E_ERROR, "Cannot read property");
297: return FAILURE;
298: }
299: /* }}} */
300:
301: /* {{{ mysqli_write_na */
302: static int mysqli_write_na(mysqli_object *obj, zval *newval TSRMLS_DC)
303: {
304: php_error_docref(NULL TSRMLS_CC, E_ERROR, "Cannot write property");
305: return FAILURE;
306: }
307: /* }}} */
308:
309: #ifndef Z_ADDREF_P
310: /* PHP 5.2, old GC */
311: #define Z_ADDREF_P(pz) (++(pz)->refcount)
312: #define Z_REFCOUNT_P(pz) ((pz)->refcount)
313: #define Z_SET_REFCOUNT_P(pz, rc) ((pz)->refcount = rc)
314: #endif
315:
316:
317: /* {{{ mysqli_read_property */
1.1.1.2 misho 318: zval *mysqli_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
1.1 misho 319: {
320: zval tmp_member;
321: zval *retval;
322: mysqli_object *obj;
323: mysqli_prop_handler *hnd;
324: int ret;
325:
326: ret = FAILURE;
327: obj = (mysqli_object *)zend_objects_get_address(object TSRMLS_CC);
328:
329: if (member->type != IS_STRING) {
330: tmp_member = *member;
331: zval_copy_ctor(&tmp_member);
332: convert_to_string(&tmp_member);
333: member = &tmp_member;
334: }
335:
336: if (obj->prop_handler != NULL) {
337: ret = zend_hash_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
338: }
339:
340: if (ret == SUCCESS) {
341: ret = hnd->read_func(obj, &retval TSRMLS_CC);
342: if (ret == SUCCESS) {
343: /* ensure we're creating a temporary variable */
344: Z_SET_REFCOUNT_P(retval, 0);
345: } else {
346: retval = EG(uninitialized_zval_ptr);
347: }
348: } else {
349: zend_object_handlers * std_hnd = zend_get_std_object_handlers();
1.1.1.2 misho 350: retval = std_hnd->read_property(object, member, type, key TSRMLS_CC);
1.1 misho 351: }
352:
353: if (member == &tmp_member) {
354: zval_dtor(member);
355: }
356: return(retval);
357: }
358: /* }}} */
359:
360: /* {{{ mysqli_write_property */
1.1.1.2 misho 361: void mysqli_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
1.1 misho 362: {
363: zval tmp_member;
364: mysqli_object *obj;
365: mysqli_prop_handler *hnd;
366: int ret;
367:
368: if (member->type != IS_STRING) {
369: tmp_member = *member;
370: zval_copy_ctor(&tmp_member);
371: convert_to_string(&tmp_member);
372: member = &tmp_member;
373: }
374:
375: ret = FAILURE;
376: obj = (mysqli_object *)zend_objects_get_address(object TSRMLS_CC);
377:
378: if (obj->prop_handler != NULL) {
379: ret = zend_hash_find((HashTable *)obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
380: }
381: if (ret == SUCCESS) {
382: hnd->write_func(obj, value TSRMLS_CC);
383: if (! PZVAL_IS_REF(value) && Z_REFCOUNT_P(value) == 0) {
384: Z_ADDREF_P(value);
385: zval_ptr_dtor(&value);
386: }
387: } else {
388: zend_object_handlers * std_hnd = zend_get_std_object_handlers();
1.1.1.2 misho 389: std_hnd->write_property(object, member, value, key TSRMLS_CC);
1.1 misho 390: }
391:
392: if (member == &tmp_member) {
393: zval_dtor(member);
394: }
395: }
396: /* }}} */
397:
398: /* {{{ void mysqli_add_property(HashTable *h, char *pname, mysqli_read_t r_func, mysqli_write_t w_func TSRMLS_DC) */
399: void mysqli_add_property(HashTable *h, const char *pname, size_t pname_len, mysqli_read_t r_func, mysqli_write_t w_func TSRMLS_DC) {
400: mysqli_prop_handler p;
401:
402: p.name = (char*) pname;
403: p.name_len = pname_len;
404: p.read_func = (r_func) ? r_func : mysqli_read_na;
405: p.write_func = (w_func) ? w_func : mysqli_write_na;
406: zend_hash_add(h, pname, pname_len + 1, &p, sizeof(mysqli_prop_handler), NULL);
407: }
408: /* }}} */
409:
1.1.1.2 misho 410: static int mysqli_object_has_property(zval *object, zval *member, int has_set_exists, const zend_literal *key TSRMLS_DC) /* {{{ */
1.1 misho 411: {
412: mysqli_object *obj = (mysqli_object *)zend_objects_get_address(object TSRMLS_CC);
413: mysqli_prop_handler p;
414: int ret = 0;
415:
416: if (zend_hash_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member) + 1, (void **)&p) == SUCCESS) {
417: switch (has_set_exists) {
418: case 2:
419: ret = 1;
420: break;
421: case 1: {
1.1.1.2 misho 422: zval *value = mysqli_read_property(object, member, BP_VAR_IS, key TSRMLS_CC);
1.1 misho 423: if (value != EG(uninitialized_zval_ptr)) {
424: convert_to_boolean(value);
425: ret = Z_BVAL_P(value)? 1:0;
426: /* refcount is 0 */
427: Z_ADDREF_P(value);
428: zval_ptr_dtor(&value);
429: }
430: break;
431: }
432: case 0:{
1.1.1.2 misho 433: zval *value = mysqli_read_property(object, member, BP_VAR_IS, key TSRMLS_CC);
1.1 misho 434: if (value != EG(uninitialized_zval_ptr)) {
435: ret = Z_TYPE_P(value) != IS_NULL? 1:0;
436: /* refcount is 0 */
437: Z_ADDREF_P(value);
438: zval_ptr_dtor(&value);
439: }
440: break;
441: }
442: default:
443: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid value for has_set_exists");
444: }
445: } else {
446: zend_object_handlers * std_hnd = zend_get_std_object_handlers();
1.1.1.2 misho 447: ret = std_hnd->has_property(object, member, has_set_exists, key TSRMLS_CC);
1.1 misho 448: }
449: return ret;
450: } /* }}} */
451:
452:
453: #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 3
454: HashTable * mysqli_object_get_debug_info(zval *object, int *is_temp TSRMLS_DC)
455: {
456: mysqli_object *obj = (mysqli_object *)zend_objects_get_address(object TSRMLS_CC);
457: HashTable *retval, *props = obj->prop_handler;
458: HashPosition pos;
459: mysqli_prop_handler *entry;
460:
461: ALLOC_HASHTABLE(retval);
462: ZEND_INIT_SYMTABLE_EX(retval, zend_hash_num_elements(props) + 1, 0);
463:
464: zend_hash_internal_pointer_reset_ex(props, &pos);
465: while (zend_hash_get_current_data_ex(props, (void **)&entry, &pos) == SUCCESS) {
466: zval member;
467: zval *value;
468: INIT_ZVAL(member);
469: ZVAL_STRINGL(&member, entry->name, entry->name_len, 0);
1.1.1.2 misho 470: value = mysqli_read_property(object, &member, BP_VAR_IS, 0 TSRMLS_CC);
1.1 misho 471: if (value != EG(uninitialized_zval_ptr)) {
472: Z_ADDREF_P(value);
473: zend_hash_add(retval, entry->name, entry->name_len + 1, &value, sizeof(zval *), NULL);
474: }
475: zend_hash_move_forward_ex(props, &pos);
476: }
477:
478: *is_temp = 1;
479: return retval;
480: }
481: #endif
482:
483: /* {{{ mysqli_objects_new
484: */
485: PHP_MYSQLI_EXPORT(zend_object_value) mysqli_objects_new(zend_class_entry *class_type TSRMLS_DC)
486: {
487: zend_object_value retval;
488: mysqli_object *intern;
489: zend_class_entry *mysqli_base_class;
490: zend_objects_free_object_storage_t free_storage;
491:
492: intern = emalloc(sizeof(mysqli_object));
493: memset(intern, 0, sizeof(mysqli_object));
494: intern->ptr = NULL;
495: intern->prop_handler = NULL;
496:
497: mysqli_base_class = class_type;
498: while (mysqli_base_class->type != ZEND_INTERNAL_CLASS &&
499: mysqli_base_class->parent != NULL) {
500: mysqli_base_class = mysqli_base_class->parent;
501: }
502: zend_hash_find(&classes, mysqli_base_class->name, mysqli_base_class->name_length + 1,
503: (void **) &intern->prop_handler);
504:
505: zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
1.1.1.2 misho 506: object_properties_init(&intern->zo, class_type);
1.1 misho 507:
508: /* link object */
509: if (instanceof_function(class_type, mysqli_link_class_entry TSRMLS_CC)) {
510: free_storage = mysqli_link_free_storage;
511: } else if (instanceof_function(class_type, mysqli_driver_class_entry TSRMLS_CC)) { /* driver object */
512: free_storage = mysqli_driver_free_storage;
513: } else if (instanceof_function(class_type, mysqli_stmt_class_entry TSRMLS_CC)) { /* stmt object */
514: free_storage = mysqli_stmt_free_storage;
515: } else if (instanceof_function(class_type, mysqli_result_class_entry TSRMLS_CC)) { /* result object */
516: free_storage = mysqli_result_free_storage;
517: } else if (instanceof_function(class_type, mysqli_warning_class_entry TSRMLS_CC)) { /* warning object */
518: free_storage = mysqli_warning_free_storage;
519: } else {
520: free_storage = mysqli_objects_free_storage;
521: }
522:
523: retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, free_storage, NULL TSRMLS_CC);
524: retval.handlers = &mysqli_object_handlers;
525:
526: return retval;
527: }
528: /* }}} */
529:
1.1.1.2 misho 530: #ifdef MYSQLI_USE_MYSQLND
531: #include "ext/mysqlnd/mysqlnd_reverse_api.h"
532: static MYSQLND *mysqli_convert_zv_to_mysqlnd(zval * zv TSRMLS_DC)
533: {
1.1.1.4 ! misho 534: if (Z_TYPE_P(zv) == IS_OBJECT && instanceof_function(Z_OBJCE_P(zv), mysqli_link_class_entry TSRMLS_CC)) {
1.1.1.2 misho 535: MY_MYSQL * mysql;
536: MYSQLI_RESOURCE * my_res;
537: mysqli_object * intern = (mysqli_object *)zend_object_store_get_object(zv TSRMLS_CC);
538: if (!(my_res = (MYSQLI_RESOURCE *)intern->ptr)) {
539: /* We know that we have a mysqli object, so this failure should be emitted */
540: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't fetch %s", intern->zo.ce->name);
541: return NULL;
542: }
543: mysql = (MY_MYSQL *)(my_res->ptr);
544: return mysql ? mysql->mysql : NULL;
545: }
546: return NULL;
547: }
548:
549: static MYSQLND_REVERSE_API mysqli_reverse_api = {
550: &mysqli_module_entry,
551: mysqli_convert_zv_to_mysqlnd
552: };
553: #endif
1.1 misho 554:
555: /* {{{ PHP_INI_BEGIN
556: */
557: PHP_INI_BEGIN()
558: STD_PHP_INI_ENTRY_EX("mysqli.max_links", "-1", PHP_INI_SYSTEM, OnUpdateLong, max_links, zend_mysqli_globals, mysqli_globals, display_link_numbers)
559: STD_PHP_INI_ENTRY_EX("mysqli.max_persistent", "-1", PHP_INI_SYSTEM, OnUpdateLong, max_persistent, zend_mysqli_globals, mysqli_globals, display_link_numbers)
560: STD_PHP_INI_BOOLEAN("mysqli.allow_persistent", "1", PHP_INI_SYSTEM, OnUpdateLong, allow_persistent, zend_mysqli_globals, mysqli_globals)
561: STD_PHP_INI_ENTRY("mysqli.default_host", NULL, PHP_INI_ALL, OnUpdateString, default_host, zend_mysqli_globals, mysqli_globals)
562: STD_PHP_INI_ENTRY("mysqli.default_user", NULL, PHP_INI_ALL, OnUpdateString, default_user, zend_mysqli_globals, mysqli_globals)
563: STD_PHP_INI_ENTRY("mysqli.default_pw", NULL, PHP_INI_ALL, OnUpdateString, default_pw, zend_mysqli_globals, mysqli_globals)
564: STD_PHP_INI_ENTRY("mysqli.default_port", "3306", PHP_INI_ALL, OnUpdateLong, default_port, zend_mysqli_globals, mysqli_globals)
565: #ifdef PHP_MYSQL_UNIX_SOCK_ADDR
566: STD_PHP_INI_ENTRY("mysqli.default_socket", MYSQL_UNIX_ADDR,PHP_INI_ALL,OnUpdateStringUnempty, default_socket, zend_mysqli_globals, mysqli_globals)
567: #else
568: STD_PHP_INI_ENTRY("mysqli.default_socket", NULL, PHP_INI_ALL, OnUpdateStringUnempty, default_socket, zend_mysqli_globals, mysqli_globals)
569: #endif
570: STD_PHP_INI_BOOLEAN("mysqli.reconnect", "0", PHP_INI_SYSTEM, OnUpdateLong, reconnect, zend_mysqli_globals, mysqli_globals)
571: STD_PHP_INI_BOOLEAN("mysqli.allow_local_infile", "1", PHP_INI_SYSTEM, OnUpdateLong, allow_local_infile, zend_mysqli_globals, mysqli_globals)
572: PHP_INI_END()
573: /* }}} */
574:
575:
576: /* {{{ PHP_GINIT_FUNCTION
577: */
578: static PHP_GINIT_FUNCTION(mysqli)
579: {
580: mysqli_globals->num_links = 0;
581: mysqli_globals->num_active_persistent = 0;
582: mysqli_globals->num_inactive_persistent = 0;
583: mysqli_globals->max_links = -1;
584: mysqli_globals->max_persistent = -1;
585: mysqli_globals->allow_persistent = 1;
586: mysqli_globals->default_port = 0;
587: mysqli_globals->default_host = NULL;
588: mysqli_globals->default_user = NULL;
589: mysqli_globals->default_pw = NULL;
590: mysqli_globals->default_socket = NULL;
591: mysqli_globals->reconnect = 0;
592: mysqli_globals->report_mode = 0;
593: mysqli_globals->report_ht = 0;
594: mysqli_globals->allow_local_infile = 1;
595: #ifdef HAVE_EMBEDDED_MYSQLI
596: mysqli_globals->embedded = 1;
597: #else
598: mysqli_globals->embedded = 0;
599: #endif
600: }
601: /* }}} */
602:
603: /* {{{ PHP_MINIT_FUNCTION
604: */
605: PHP_MINIT_FUNCTION(mysqli)
606: {
607: zend_class_entry *ce,cex;
608: zend_object_handlers *std_hnd = zend_get_std_object_handlers();
609:
610: REGISTER_INI_ENTRIES();
611: #ifndef MYSQLI_USE_MYSQLND
612: #if MYSQL_VERSION_ID >= 40000
613: if (mysql_server_init(0, NULL, NULL)) {
614: return FAILURE;
615: }
616: #endif
617: #endif
618:
619: memcpy(&mysqli_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
620: mysqli_object_handlers.clone_obj = NULL;
621: mysqli_object_handlers.read_property = mysqli_read_property;
622: mysqli_object_handlers.write_property = mysqli_write_property;
623: mysqli_object_handlers.get_property_ptr_ptr = std_hnd->get_property_ptr_ptr;
624: mysqli_object_handlers.has_property = mysqli_object_has_property;
625: #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 3
626: mysqli_object_handlers.get_debug_info = mysqli_object_get_debug_info;
627: #endif
628:
629: zend_hash_init(&classes, 0, NULL, NULL, 1);
630:
631: /* persistent connections */
632: le_pmysqli = zend_register_list_destructors_ex(NULL, php_mysqli_dtor,
633: "MySqli persistent connection", module_number);
634:
635: INIT_CLASS_ENTRY(cex, "mysqli_sql_exception", mysqli_exception_methods);
636: #ifdef HAVE_SPL
637: mysqli_exception_class_entry = zend_register_internal_class_ex(&cex, spl_ce_RuntimeException, NULL TSRMLS_CC);
638: #else
639: mysqli_exception_class_entry = zend_register_internal_class_ex(&cex, zend_exception_get_default(TSRMLS_C), NULL TSRMLS_CC);
640: #endif
641: mysqli_exception_class_entry->ce_flags |= ZEND_ACC_FINAL;
642: zend_declare_property_long(mysqli_exception_class_entry, "code", sizeof("code")-1, 0, ZEND_ACC_PROTECTED TSRMLS_CC);
643: zend_declare_property_string(mysqli_exception_class_entry, "sqlstate", sizeof("sqlstate")-1, "00000", ZEND_ACC_PROTECTED TSRMLS_CC);
644:
645: REGISTER_MYSQLI_CLASS_ENTRY("mysqli_driver", mysqli_driver_class_entry, mysqli_driver_methods);
646: ce = mysqli_driver_class_entry;
647: zend_hash_init(&mysqli_driver_properties, 0, NULL, NULL, 1);
648: MYSQLI_ADD_PROPERTIES(&mysqli_driver_properties, mysqli_driver_property_entries);
649: MYSQLI_ADD_PROPERTIES_INFO(ce, mysqli_driver_property_info_entries);
650: zend_hash_add(&classes, ce->name, ce->name_length+1, &mysqli_driver_properties, sizeof(mysqli_driver_properties), NULL);
651: ce->ce_flags |= ZEND_ACC_FINAL_CLASS;
652:
653: REGISTER_MYSQLI_CLASS_ENTRY("mysqli", mysqli_link_class_entry, mysqli_link_methods);
654: ce = mysqli_link_class_entry;
655: zend_hash_init(&mysqli_link_properties, 0, NULL, NULL, 1);
656: MYSQLI_ADD_PROPERTIES(&mysqli_link_properties, mysqli_link_property_entries);
657: MYSQLI_ADD_PROPERTIES_INFO(ce, mysqli_link_property_info_entries);
658: zend_hash_add(&classes, ce->name, ce->name_length+1, &mysqli_link_properties, sizeof(mysqli_link_properties), NULL);
659:
660: REGISTER_MYSQLI_CLASS_ENTRY("mysqli_warning", mysqli_warning_class_entry, mysqli_warning_methods);
661: ce = mysqli_warning_class_entry;
662: ce->ce_flags |= ZEND_ACC_FINAL_CLASS | ZEND_ACC_PROTECTED;
663: zend_hash_init(&mysqli_warning_properties, 0, NULL, NULL, 1);
664: MYSQLI_ADD_PROPERTIES(&mysqli_warning_properties, mysqli_warning_property_entries);
665: MYSQLI_ADD_PROPERTIES_INFO(ce, mysqli_warning_property_info_entries);
666: zend_hash_add(&classes, ce->name, ce->name_length+1, &mysqli_warning_properties, sizeof(mysqli_warning_properties), NULL);
667:
668: REGISTER_MYSQLI_CLASS_ENTRY("mysqli_result", mysqli_result_class_entry, mysqli_result_methods);
669: ce = mysqli_result_class_entry;
670: zend_hash_init(&mysqli_result_properties, 0, NULL, NULL, 1);
671: MYSQLI_ADD_PROPERTIES(&mysqli_result_properties, mysqli_result_property_entries);
672: MYSQLI_ADD_PROPERTIES_INFO(ce, mysqli_result_property_info_entries);
1.1.1.2 misho 673: mysqli_result_class_entry->get_iterator = php_mysqli_result_get_iterator;
674: mysqli_result_class_entry->iterator_funcs.funcs = &php_mysqli_result_iterator_funcs;
675: zend_class_implements(mysqli_result_class_entry TSRMLS_CC, 1, zend_ce_traversable);
1.1 misho 676: zend_hash_add(&classes, ce->name, ce->name_length+1, &mysqli_result_properties, sizeof(mysqli_result_properties), NULL);
677:
678: REGISTER_MYSQLI_CLASS_ENTRY("mysqli_stmt", mysqli_stmt_class_entry, mysqli_stmt_methods);
679: ce = mysqli_stmt_class_entry;
680: zend_hash_init(&mysqli_stmt_properties, 0, NULL, NULL, 1);
681: MYSQLI_ADD_PROPERTIES(&mysqli_stmt_properties, mysqli_stmt_property_entries);
682: MYSQLI_ADD_PROPERTIES_INFO(ce, mysqli_stmt_property_info_entries);
683: zend_hash_add(&classes, ce->name, ce->name_length+1, &mysqli_stmt_properties, sizeof(mysqli_stmt_properties), NULL);
684:
685: /* mysqli_options */
686: REGISTER_LONG_CONSTANT("MYSQLI_READ_DEFAULT_GROUP", MYSQL_READ_DEFAULT_GROUP, CONST_CS | CONST_PERSISTENT);
687: REGISTER_LONG_CONSTANT("MYSQLI_READ_DEFAULT_FILE", MYSQL_READ_DEFAULT_FILE, CONST_CS | CONST_PERSISTENT);
688: REGISTER_LONG_CONSTANT("MYSQLI_OPT_CONNECT_TIMEOUT", MYSQL_OPT_CONNECT_TIMEOUT, CONST_CS | CONST_PERSISTENT);
689: REGISTER_LONG_CONSTANT("MYSQLI_OPT_LOCAL_INFILE", MYSQL_OPT_LOCAL_INFILE, CONST_CS | CONST_PERSISTENT);
690: REGISTER_LONG_CONSTANT("MYSQLI_INIT_COMMAND", MYSQL_INIT_COMMAND, CONST_CS | CONST_PERSISTENT);
691: #if defined(MYSQLI_USE_MYSQLND)
692: REGISTER_LONG_CONSTANT("MYSQLI_OPT_NET_CMD_BUFFER_SIZE", MYSQLND_OPT_NET_CMD_BUFFER_SIZE, CONST_CS | CONST_PERSISTENT);
693: REGISTER_LONG_CONSTANT("MYSQLI_OPT_NET_READ_BUFFER_SIZE", MYSQLND_OPT_NET_READ_BUFFER_SIZE, CONST_CS | CONST_PERSISTENT);
694: #endif
695: #ifdef MYSQLND_STRING_TO_INT_CONVERSION
696: REGISTER_LONG_CONSTANT("MYSQLI_OPT_INT_AND_FLOAT_NATIVE", MYSQLND_OPT_INT_AND_FLOAT_NATIVE, CONST_CS | CONST_PERSISTENT);
697: #endif
698: #if MYSQL_VERSION_ID > 50110 || defined(MYSQLI_USE_MYSQLND)
699: REGISTER_LONG_CONSTANT("MYSQLI_OPT_SSL_VERIFY_SERVER_CERT", MYSQL_OPT_SSL_VERIFY_SERVER_CERT, CONST_CS | CONST_PERSISTENT);
700: #endif
701:
702: /* mysqli_real_connect flags */
703: REGISTER_LONG_CONSTANT("MYSQLI_CLIENT_SSL", CLIENT_SSL, CONST_CS | CONST_PERSISTENT);
704: REGISTER_LONG_CONSTANT("MYSQLI_CLIENT_COMPRESS",CLIENT_COMPRESS, CONST_CS | CONST_PERSISTENT);
705: REGISTER_LONG_CONSTANT("MYSQLI_CLIENT_INTERACTIVE", CLIENT_INTERACTIVE, CONST_CS | CONST_PERSISTENT);
706: REGISTER_LONG_CONSTANT("MYSQLI_CLIENT_IGNORE_SPACE", CLIENT_IGNORE_SPACE, CONST_CS | CONST_PERSISTENT);
707: REGISTER_LONG_CONSTANT("MYSQLI_CLIENT_NO_SCHEMA", CLIENT_NO_SCHEMA, CONST_CS | CONST_PERSISTENT);
708: REGISTER_LONG_CONSTANT("MYSQLI_CLIENT_FOUND_ROWS", CLIENT_FOUND_ROWS, CONST_CS | CONST_PERSISTENT);
709:
710: /* for mysqli_query */
711: REGISTER_LONG_CONSTANT("MYSQLI_STORE_RESULT", MYSQLI_STORE_RESULT, CONST_CS | CONST_PERSISTENT);
712: REGISTER_LONG_CONSTANT("MYSQLI_USE_RESULT", MYSQLI_USE_RESULT, CONST_CS | CONST_PERSISTENT);
713: #if defined (MYSQLI_USE_MYSQLND)
714: REGISTER_LONG_CONSTANT("MYSQLI_ASYNC", MYSQLI_ASYNC, CONST_CS | CONST_PERSISTENT);
715: #endif
716:
717: /* for mysqli_fetch_assoc */
718: REGISTER_LONG_CONSTANT("MYSQLI_ASSOC", MYSQLI_ASSOC, CONST_CS | CONST_PERSISTENT);
719: REGISTER_LONG_CONSTANT("MYSQLI_NUM", MYSQLI_NUM, CONST_CS | CONST_PERSISTENT);
720: REGISTER_LONG_CONSTANT("MYSQLI_BOTH", MYSQLI_BOTH, CONST_CS | CONST_PERSISTENT);
721:
722: /* for mysqli_stmt_set_attr */
723: REGISTER_LONG_CONSTANT("MYSQLI_STMT_ATTR_UPDATE_MAX_LENGTH", STMT_ATTR_UPDATE_MAX_LENGTH, CONST_CS | CONST_PERSISTENT);
724:
725: #if MYSQL_VERSION_ID > 50003 || defined(MYSQLI_USE_MYSQLND)
726: REGISTER_LONG_CONSTANT("MYSQLI_STMT_ATTR_CURSOR_TYPE", STMT_ATTR_CURSOR_TYPE, CONST_CS | CONST_PERSISTENT);
727: REGISTER_LONG_CONSTANT("MYSQLI_CURSOR_TYPE_NO_CURSOR", CURSOR_TYPE_NO_CURSOR, CONST_CS | CONST_PERSISTENT);
728: REGISTER_LONG_CONSTANT("MYSQLI_CURSOR_TYPE_READ_ONLY", CURSOR_TYPE_READ_ONLY, CONST_CS | CONST_PERSISTENT);
729: REGISTER_LONG_CONSTANT("MYSQLI_CURSOR_TYPE_FOR_UPDATE", CURSOR_TYPE_FOR_UPDATE, CONST_CS | CONST_PERSISTENT);
730: REGISTER_LONG_CONSTANT("MYSQLI_CURSOR_TYPE_SCROLLABLE", CURSOR_TYPE_SCROLLABLE, CONST_CS | CONST_PERSISTENT);
731: #endif
732:
733: #if MYSQL_VERSION_ID > 50007 || defined(MYSQLI_USE_MYSQLND)
734: REGISTER_LONG_CONSTANT("MYSQLI_STMT_ATTR_PREFETCH_ROWS", STMT_ATTR_PREFETCH_ROWS, CONST_CS | CONST_PERSISTENT);
735: #endif
736:
737: /* column information */
738: REGISTER_LONG_CONSTANT("MYSQLI_NOT_NULL_FLAG", NOT_NULL_FLAG, CONST_CS | CONST_PERSISTENT);
739: REGISTER_LONG_CONSTANT("MYSQLI_PRI_KEY_FLAG", PRI_KEY_FLAG, CONST_CS | CONST_PERSISTENT);
740: REGISTER_LONG_CONSTANT("MYSQLI_UNIQUE_KEY_FLAG", UNIQUE_KEY_FLAG, CONST_CS | CONST_PERSISTENT);
741: REGISTER_LONG_CONSTANT("MYSQLI_MULTIPLE_KEY_FLAG", MULTIPLE_KEY_FLAG, CONST_CS | CONST_PERSISTENT);
742: REGISTER_LONG_CONSTANT("MYSQLI_BLOB_FLAG", BLOB_FLAG, CONST_CS | CONST_PERSISTENT);
743: REGISTER_LONG_CONSTANT("MYSQLI_UNSIGNED_FLAG", UNSIGNED_FLAG, CONST_CS | CONST_PERSISTENT);
744: REGISTER_LONG_CONSTANT("MYSQLI_ZEROFILL_FLAG", ZEROFILL_FLAG, CONST_CS | CONST_PERSISTENT);
745: REGISTER_LONG_CONSTANT("MYSQLI_AUTO_INCREMENT_FLAG", AUTO_INCREMENT_FLAG, CONST_CS | CONST_PERSISTENT);
746: REGISTER_LONG_CONSTANT("MYSQLI_TIMESTAMP_FLAG", TIMESTAMP_FLAG, CONST_CS | CONST_PERSISTENT);
747: REGISTER_LONG_CONSTANT("MYSQLI_SET_FLAG", SET_FLAG, CONST_CS | CONST_PERSISTENT);
748: REGISTER_LONG_CONSTANT("MYSQLI_NUM_FLAG", NUM_FLAG, CONST_CS | CONST_PERSISTENT);
749: REGISTER_LONG_CONSTANT("MYSQLI_PART_KEY_FLAG", PART_KEY_FLAG, CONST_CS | CONST_PERSISTENT);
750: REGISTER_LONG_CONSTANT("MYSQLI_GROUP_FLAG", GROUP_FLAG, CONST_CS | CONST_PERSISTENT);
751: REGISTER_LONG_CONSTANT("MYSQLI_ENUM_FLAG", ENUM_FLAG, CONST_CS | CONST_PERSISTENT);
752: REGISTER_LONG_CONSTANT("MYSQLI_BINARY_FLAG", BINARY_FLAG, CONST_CS | CONST_PERSISTENT);
753: #if MYSQL_VERSION_ID > 50001 || defined(MYSQLI_USE_MYSQLND)
754: REGISTER_LONG_CONSTANT("MYSQLI_NO_DEFAULT_VALUE_FLAG", NO_DEFAULT_VALUE_FLAG, CONST_CS | CONST_PERSISTENT);
755: #endif
756:
757: #if (MYSQL_VERSION_ID > 51122 && MYSQL_VERSION_ID < 60000) || (MYSQL_VERSION_ID > 60003) || defined(MYSQLI_USE_MYSQLND)
758: REGISTER_LONG_CONSTANT("MYSQLI_ON_UPDATE_NOW_FLAG", ON_UPDATE_NOW_FLAG, CONST_CS | CONST_PERSISTENT);
759: #endif
760:
761: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_DECIMAL", FIELD_TYPE_DECIMAL, CONST_CS | CONST_PERSISTENT);
762: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_TINY", FIELD_TYPE_TINY, CONST_CS | CONST_PERSISTENT);
763: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_SHORT", FIELD_TYPE_SHORT, CONST_CS | CONST_PERSISTENT);
764: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_LONG", FIELD_TYPE_LONG, CONST_CS | CONST_PERSISTENT);
765: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_FLOAT", FIELD_TYPE_FLOAT, CONST_CS | CONST_PERSISTENT);
766: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_DOUBLE", FIELD_TYPE_DOUBLE, CONST_CS | CONST_PERSISTENT);
767: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_NULL", FIELD_TYPE_NULL, CONST_CS | CONST_PERSISTENT);
768: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_TIMESTAMP", FIELD_TYPE_TIMESTAMP, CONST_CS | CONST_PERSISTENT);
769: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_LONGLONG", FIELD_TYPE_LONGLONG, CONST_CS | CONST_PERSISTENT);
770: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_INT24", FIELD_TYPE_INT24, CONST_CS | CONST_PERSISTENT);
771: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_DATE", FIELD_TYPE_DATE, CONST_CS | CONST_PERSISTENT);
772: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_TIME", FIELD_TYPE_TIME, CONST_CS | CONST_PERSISTENT);
773: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_DATETIME", FIELD_TYPE_DATETIME , CONST_CS | CONST_PERSISTENT);
774: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_YEAR", FIELD_TYPE_YEAR, CONST_CS | CONST_PERSISTENT);
775: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_NEWDATE", FIELD_TYPE_NEWDATE, CONST_CS | CONST_PERSISTENT);
776: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_ENUM", FIELD_TYPE_ENUM, CONST_CS | CONST_PERSISTENT);
777: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_SET", FIELD_TYPE_SET, CONST_CS | CONST_PERSISTENT);
778: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_TINY_BLOB", FIELD_TYPE_TINY_BLOB, CONST_CS | CONST_PERSISTENT);
779: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_MEDIUM_BLOB", FIELD_TYPE_MEDIUM_BLOB, CONST_CS | CONST_PERSISTENT);
780: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_LONG_BLOB", FIELD_TYPE_LONG_BLOB, CONST_CS | CONST_PERSISTENT);
781: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_BLOB", FIELD_TYPE_BLOB, CONST_CS | CONST_PERSISTENT);
782: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_VAR_STRING", FIELD_TYPE_VAR_STRING, CONST_CS | CONST_PERSISTENT);
783: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_STRING", FIELD_TYPE_STRING, CONST_CS | CONST_PERSISTENT);
784: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_CHAR", FIELD_TYPE_CHAR, CONST_CS | CONST_PERSISTENT);
785: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_INTERVAL", FIELD_TYPE_INTERVAL, CONST_CS | CONST_PERSISTENT);
786: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_GEOMETRY", FIELD_TYPE_GEOMETRY, CONST_CS | CONST_PERSISTENT);
787:
788: #if MYSQL_VERSION_ID > 50002 || defined(MYSQLI_USE_MYSQLND)
789: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_NEWDECIMAL", FIELD_TYPE_NEWDECIMAL, CONST_CS | CONST_PERSISTENT);
790: REGISTER_LONG_CONSTANT("MYSQLI_TYPE_BIT", FIELD_TYPE_BIT, CONST_CS | CONST_PERSISTENT);
791: #endif
792:
793: REGISTER_LONG_CONSTANT("MYSQLI_SET_CHARSET_NAME", MYSQL_SET_CHARSET_NAME, CONST_CS | CONST_PERSISTENT);
794: REGISTER_LONG_CONSTANT("MYSQLI_SET_CHARSET_DIR", MYSQL_SET_CHARSET_DIR, CONST_CS | CONST_PERSISTENT);
795:
796: /* bind support */
797: REGISTER_LONG_CONSTANT("MYSQLI_NO_DATA", MYSQL_NO_DATA, CONST_CS | CONST_PERSISTENT);
798: #ifdef MYSQL_DATA_TRUNCATED
799: REGISTER_LONG_CONSTANT("MYSQLI_DATA_TRUNCATED", MYSQL_DATA_TRUNCATED, CONST_CS | CONST_PERSISTENT);
800: #endif
801:
802: /* reporting */
803: REGISTER_LONG_CONSTANT("MYSQLI_REPORT_INDEX", MYSQLI_REPORT_INDEX, CONST_CS | CONST_PERSISTENT);
804: REGISTER_LONG_CONSTANT("MYSQLI_REPORT_ERROR", MYSQLI_REPORT_ERROR, CONST_CS | CONST_PERSISTENT);
805: REGISTER_LONG_CONSTANT("MYSQLI_REPORT_STRICT", MYSQLI_REPORT_STRICT, CONST_CS | CONST_PERSISTENT);
806: REGISTER_LONG_CONSTANT("MYSQLI_REPORT_ALL", MYSQLI_REPORT_ALL, CONST_CS | CONST_PERSISTENT);
807: REGISTER_LONG_CONSTANT("MYSQLI_REPORT_OFF", 0, CONST_CS | CONST_PERSISTENT);
808:
809: /* We use non-nested macros with expansion, as VC has problems */
810: #ifdef MYSQLI_USE_MYSQLND
811: REGISTER_LONG_CONSTANT("MYSQLI_DEBUG_TRACE_ENABLED", MYSQLND_DBG_ENABLED, CONST_CS | CONST_PERSISTENT);
812: #else
1.1.1.2 misho 813: #ifdef DBUG_ON
1.1 misho 814: REGISTER_LONG_CONSTANT("MYSQLI_DEBUG_TRACE_ENABLED", 1, CONST_CS | CONST_PERSISTENT);
1.1.1.2 misho 815: #else
816: REGISTER_LONG_CONSTANT("MYSQLI_DEBUG_TRACE_ENABLED", 0, CONST_CS | CONST_PERSISTENT);
1.1 misho 817: #endif
818: #endif
819:
820: REGISTER_LONG_CONSTANT("MYSQLI_SERVER_QUERY_NO_GOOD_INDEX_USED", SERVER_QUERY_NO_GOOD_INDEX_USED, CONST_CS | CONST_PERSISTENT);
821: REGISTER_LONG_CONSTANT("MYSQLI_SERVER_QUERY_NO_INDEX_USED", SERVER_QUERY_NO_INDEX_USED, CONST_CS | CONST_PERSISTENT);
822: #ifdef SERVER_QUERY_WAS_SLOW
823: REGISTER_LONG_CONSTANT("MYSQLI_SERVER_QUERY_WAS_SLOW", SERVER_QUERY_WAS_SLOW, CONST_CS | CONST_PERSISTENT);
824: #endif
825: #ifdef SERVER_PS_OUT_PARAMS
826: REGISTER_LONG_CONSTANT("MYSQLI_SERVER_PS_OUT_PARAMS", SERVER_PS_OUT_PARAMS, CONST_CS | CONST_PERSISTENT);
827: #endif
828:
829: REGISTER_LONG_CONSTANT("MYSQLI_REFRESH_GRANT", REFRESH_GRANT, CONST_CS | CONST_PERSISTENT);
830: REGISTER_LONG_CONSTANT("MYSQLI_REFRESH_LOG", REFRESH_LOG, CONST_CS | CONST_PERSISTENT);
831: REGISTER_LONG_CONSTANT("MYSQLI_REFRESH_TABLES", REFRESH_TABLES, CONST_CS | CONST_PERSISTENT);
832: REGISTER_LONG_CONSTANT("MYSQLI_REFRESH_HOSTS", REFRESH_HOSTS, CONST_CS | CONST_PERSISTENT);
833: REGISTER_LONG_CONSTANT("MYSQLI_REFRESH_STATUS", REFRESH_STATUS, CONST_CS | CONST_PERSISTENT);
834: REGISTER_LONG_CONSTANT("MYSQLI_REFRESH_THREADS", REFRESH_THREADS, CONST_CS | CONST_PERSISTENT);
835: REGISTER_LONG_CONSTANT("MYSQLI_REFRESH_SLAVE", REFRESH_SLAVE, CONST_CS | CONST_PERSISTENT);
836: REGISTER_LONG_CONSTANT("MYSQLI_REFRESH_MASTER", REFRESH_MASTER, CONST_CS | CONST_PERSISTENT);
837: #ifdef REFRESH_BACKUP_LOG
838: REGISTER_LONG_CONSTANT("MYSQLI_REFRESH_BACKUP_LOG", REFRESH_BACKUP_LOG, CONST_CS | CONST_PERSISTENT);
839: #endif
840:
1.1.1.3 misho 841: #if MYSQL_VERSION_ID >= 50611 || defined(MYSQLI_USE_MYSQLND)
842: REGISTER_LONG_CONSTANT("MYSQLI_OPT_CAN_HANDLE_EXPIRED_PASSWORDS", MYSQL_OPT_CAN_HANDLE_EXPIRED_PASSWORDS, CONST_CS | CONST_PERSISTENT);
843: #endif
1.1.1.2 misho 844:
845: #ifdef MYSQLI_USE_MYSQLND
846: mysqlnd_reverse_api_register_api(&mysqli_reverse_api TSRMLS_CC);
847: #endif
848:
1.1 misho 849: return SUCCESS;
850: }
851: /* }}} */
852:
853: /* {{{ PHP_MSHUTDOWN_FUNCTION
854: */
855: PHP_MSHUTDOWN_FUNCTION(mysqli)
856: {
857: #ifndef MYSQLI_USE_MYSQLND
858: #if MYSQL_VERSION_ID >= 40000
859: #ifdef PHP_WIN32
860: unsigned long client_ver = mysql_get_client_version();
861: /*
862: Can't call mysql_server_end() multiple times prior to 5.0.46 on Windows.
863: PHP bug#41350 MySQL bug#25621
864: */
865: if ((client_ver >= 50046 && client_ver < 50100) || client_ver > 50122) {
866: mysql_server_end();
867: }
868: #else
869: mysql_server_end();
870: #endif
871: #endif
872: #endif
873:
874: zend_hash_destroy(&mysqli_driver_properties);
875: zend_hash_destroy(&mysqli_result_properties);
876: zend_hash_destroy(&mysqli_stmt_properties);
877: zend_hash_destroy(&mysqli_warning_properties);
878: zend_hash_destroy(&mysqli_link_properties);
879: zend_hash_destroy(&classes);
880:
881: UNREGISTER_INI_ENTRIES();
882: return SUCCESS;
883: }
884: /* }}} */
885:
886: /* {{{ PHP_RINIT_FUNCTION
887: */
888: PHP_RINIT_FUNCTION(mysqli)
889: {
890: #if !defined(MYSQLI_USE_MYSQLND) && defined(ZTS) && MYSQL_VERSION_ID >= 40000
891: if (mysql_thread_init()) {
892: return FAILURE;
893: }
894: #endif
895: MyG(error_msg) = NULL;
896: MyG(error_no) = 0;
897: MyG(report_mode) = 0;
898:
899: return SUCCESS;
900: }
901: /* }}} */
902:
903: #if defined(A0) && defined(MYSQLI_USE_MYSQLND)
904: static void php_mysqli_persistent_helper_for_every(void *p)
905: {
906: TSRMLS_FETCH();
907: mysqlnd_end_psession((MYSQLND *) p);
908: } /* }}} */
909:
910:
911: static int php_mysqli_persistent_helper_once(zend_rsrc_list_entry *le TSRMLS_DC)
912: {
913: if (le->type == php_le_pmysqli()) {
914: mysqli_plist_entry *plist = (mysqli_plist_entry *) le->ptr;
915: zend_ptr_stack_apply(&plist->free_links, php_mysqli_persistent_helper_for_every);
916: }
917: return ZEND_HASH_APPLY_KEEP;
918: } /* }}} */
919: #endif
920:
921:
922: /* {{{ PHP_RSHUTDOWN_FUNCTION
923: */
924: PHP_RSHUTDOWN_FUNCTION(mysqli)
925: {
926: /* check persistent connections, move used to free */
927:
928: #if !defined(MYSQLI_USE_MYSQLND) && defined(ZTS) && MYSQL_VERSION_ID >= 40000
929: mysql_thread_end();
930: #endif
931: if (MyG(error_msg)) {
932: efree(MyG(error_msg));
933: }
934: #if defined(A0) && defined(MYSQLI_USE_MYSQLND)
935: /* psession is being called when the connection is freed - explicitly or implicitly */
936: zend_hash_apply(&EG(persistent_list), (apply_func_t) php_mysqli_persistent_helper_once TSRMLS_CC);
937: #endif
938: return SUCCESS;
939: }
940: /* }}} */
941:
942:
943: /* {{{ PHP_MINFO_FUNCTION
944: */
945: PHP_MINFO_FUNCTION(mysqli)
946: {
947: char buf[32];
948:
949: php_info_print_table_start();
950: php_info_print_table_header(2, "MysqlI Support", "enabled");
951: php_info_print_table_row(2, "Client API library version", mysql_get_client_info());
952: snprintf(buf, sizeof(buf), "%ld", MyG(num_active_persistent));
953: php_info_print_table_row(2, "Active Persistent Links", buf);
954: snprintf(buf, sizeof(buf), "%ld", MyG(num_inactive_persistent));
955: php_info_print_table_row(2, "Inactive Persistent Links", buf);
956: snprintf(buf, sizeof(buf), "%ld", MyG(num_links));
957: php_info_print_table_row(2, "Active Links", buf);
958: #if !defined(MYSQLI_USE_MYSQLND)
959: php_info_print_table_row(2, "Client API header version", MYSQL_SERVER_VERSION);
960: php_info_print_table_row(2, "MYSQLI_SOCKET", MYSQL_UNIX_ADDR);
961: #endif
962: php_info_print_table_end();
963:
964: DISPLAY_INI_ENTRIES();
965: }
966: /* }}} */
967:
968:
969: /* Dependancies */
970: static const zend_module_dep mysqli_deps[] = {
971: #if defined(HAVE_SPL) && ((PHP_MAJOR_VERSION > 5) || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 1))
972: ZEND_MOD_REQUIRED("spl")
973: #endif
974: #if defined(MYSQLI_USE_MYSQLND)
975: ZEND_MOD_REQUIRED("mysqlnd")
976: #endif
977: ZEND_MOD_END
978: };
979:
980: /* {{{ mysqli_module_entry
981: */
982: zend_module_entry mysqli_module_entry = {
983: #if ZEND_MODULE_API_NO >= 20050922
984: STANDARD_MODULE_HEADER_EX, NULL,
985: mysqli_deps,
986: #elif ZEND_MODULE_API_NO >= 20010901
987: STANDARD_MODULE_HEADER,
988: #endif
989: "mysqli",
990: mysqli_functions,
991: PHP_MINIT(mysqli),
992: PHP_MSHUTDOWN(mysqli),
993: PHP_RINIT(mysqli),
994: PHP_RSHUTDOWN(mysqli),
995: PHP_MINFO(mysqli),
996: "0.1", /* Replace with version number for your extension */
997: PHP_MODULE_GLOBALS(mysqli),
998: PHP_GINIT(mysqli),
999: NULL,
1000: NULL,
1001: STANDARD_MODULE_PROPERTIES_EX
1002: };
1003: /* }}} */
1004:
1005: #ifdef COMPILE_DL_MYSQLI
1006: ZEND_GET_MODULE(mysqli)
1007: #endif
1008:
1009:
1010: /* {{{ mixed mysqli_stmt_construct()
1011: constructor for statement object.
1012: Parameters:
1013: object -> mysqli_stmt_init
1014: object, query -> mysqli_prepare
1015: */
1016: PHP_FUNCTION(mysqli_stmt_construct)
1017: {
1018: MY_MYSQL *mysql;
1019: zval *mysql_link;
1020: MY_STMT *stmt;
1021: MYSQLI_RESOURCE *mysqli_resource;
1022: char *statement;
1023: int statement_len;
1024:
1025: switch (ZEND_NUM_ARGS())
1026: {
1027: case 1: /* mysql_stmt_init */
1028: if (zend_parse_parameters(1 TSRMLS_CC, "O", &mysql_link, mysqli_link_class_entry)==FAILURE) {
1029: return;
1030: }
1031: MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
1032:
1033: stmt = (MY_STMT *)ecalloc(1,sizeof(MY_STMT));
1034:
1035: stmt->stmt = mysql_stmt_init(mysql->mysql);
1036: break;
1037: case 2:
1038: if (zend_parse_parameters(2 TSRMLS_CC, "Os", &mysql_link, mysqli_link_class_entry, &statement, &statement_len)==FAILURE) {
1039: return;
1040: }
1041: MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
1042:
1043: stmt = (MY_STMT *)ecalloc(1,sizeof(MY_STMT));
1044:
1045: if ((stmt->stmt = mysql_stmt_init(mysql->mysql))) {
1046: mysql_stmt_prepare(stmt->stmt, (char *)statement, statement_len);
1047: }
1048: break;
1049: default:
1050: WRONG_PARAM_COUNT;
1051: break;
1052: }
1053:
1054: if (!stmt->stmt) {
1055: efree(stmt);
1056: RETURN_FALSE;
1057: }
1058:
1059: mysqli_resource = (MYSQLI_RESOURCE *)ecalloc (1, sizeof(MYSQLI_RESOURCE));
1060: mysqli_resource->ptr = (void *)stmt;
1061: mysqli_resource->status = (ZEND_NUM_ARGS() == 1) ? MYSQLI_STATUS_INITIALIZED : MYSQLI_STATUS_VALID;
1062:
1063: ((mysqli_object *) zend_object_store_get_object(getThis() TSRMLS_CC))->ptr = mysqli_resource;
1064: }
1065: /* }}} */
1066:
1067: /* {{{ mixed mysqli_result_construct()
1068: constructor for result object.
1069: Parameters:
1070: object [, mode] -> mysqli_store/use_result
1071: */
1072: PHP_FUNCTION(mysqli_result_construct)
1073: {
1074: MY_MYSQL *mysql;
1075: MYSQL_RES *result = NULL;
1076: zval *mysql_link;
1077: MYSQLI_RESOURCE *mysqli_resource;
1078: long resmode = MYSQLI_STORE_RESULT;
1079:
1080: switch (ZEND_NUM_ARGS()) {
1081: case 1:
1082: if (zend_parse_parameters(1 TSRMLS_CC, "O", &mysql_link, mysqli_link_class_entry)==FAILURE) {
1083: return;
1084: }
1085: break;
1086: case 2:
1087: if (zend_parse_parameters(2 TSRMLS_CC, "Ol", &mysql_link, mysqli_link_class_entry, &resmode)==FAILURE) {
1088: return;
1089: }
1090: break;
1091: default:
1092: WRONG_PARAM_COUNT;
1093: }
1094:
1095: MYSQLI_FETCH_RESOURCE_CONN(mysql, &mysql_link, MYSQLI_STATUS_VALID);
1096:
1097: switch (resmode) {
1098: case MYSQLI_STORE_RESULT:
1099: result = mysql_store_result(mysql->mysql);
1100: break;
1101: case MYSQLI_USE_RESULT:
1102: result = mysql_use_result(mysql->mysql);
1103: break;
1104: default:
1105: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid value for resultmode");
1106: }
1107:
1108: if (!result) {
1109: RETURN_FALSE;
1110: }
1111:
1112: mysqli_resource = (MYSQLI_RESOURCE *)ecalloc (1, sizeof(MYSQLI_RESOURCE));
1113: mysqli_resource->ptr = (void *)result;
1114: mysqli_resource->status = MYSQLI_STATUS_VALID;
1115:
1116: ((mysqli_object *) zend_object_store_get_object(getThis() TSRMLS_CC))->ptr = mysqli_resource;
1117:
1118: }
1119: /* }}} */
1120:
1.1.1.2 misho 1121:
1122: /* {{{ php_mysqli_fetch_into_hash_aux
1.1 misho 1123: */
1.1.1.2 misho 1124: void php_mysqli_fetch_into_hash_aux(zval *return_value, MYSQL_RES * result, long fetchtype TSRMLS_DC)
1.1 misho 1125: {
1126: #if !defined(MYSQLI_USE_MYSQLND)
1.1.1.2 misho 1127: MYSQL_ROW row;
1.1 misho 1128: unsigned int i;
1129: MYSQL_FIELD *fields;
1130: unsigned long *field_len;
1.1.1.2 misho 1131:
1.1 misho 1132: if (!(row = mysql_fetch_row(result))) {
1133: RETURN_NULL();
1134: }
1135:
1136: if (fetchtype & MYSQLI_ASSOC) {
1137: fields = mysql_fetch_fields(result);
1138: }
1139:
1140: array_init(return_value);
1141: field_len = mysql_fetch_lengths(result);
1142:
1143: for (i = 0; i < mysql_num_fields(result); i++) {
1144: if (row[i]) {
1145: zval *res;
1146:
1147: MAKE_STD_ZVAL(res);
1148:
1149: #if MYSQL_VERSION_ID > 50002
1150: if (mysql_fetch_field_direct(result, i)->type == MYSQL_TYPE_BIT) {
1151: my_ulonglong llval;
1152: char tmp[22];
1153: switch (field_len[i]) {
1154: case 8:llval = (my_ulonglong) bit_uint8korr(row[i]);break;
1155: case 7:llval = (my_ulonglong) bit_uint7korr(row[i]);break;
1156: case 6:llval = (my_ulonglong) bit_uint6korr(row[i]);break;
1157: case 5:llval = (my_ulonglong) bit_uint5korr(row[i]);break;
1158: case 4:llval = (my_ulonglong) bit_uint4korr(row[i]);break;
1159: case 3:llval = (my_ulonglong) bit_uint3korr(row[i]);break;
1160: case 2:llval = (my_ulonglong) bit_uint2korr(row[i]);break;
1161: case 1:llval = (my_ulonglong) uint1korr(row[i]);break;
1162: }
1163: /* even though lval is declared as unsigned, the value
1164: * may be negative. Therefor we cannot use MYSQLI_LLU_SPEC and must
1165: * use MYSQLI_LL_SPEC.
1166: */
1167: snprintf(tmp, sizeof(tmp), (mysql_fetch_field_direct(result, i)->flags & UNSIGNED_FLAG)? MYSQLI_LLU_SPEC : MYSQLI_LL_SPEC, llval);
1168: ZVAL_STRING(res, tmp, 1);
1169: } else
1170: #endif
1171: {
1172:
1.1.1.2 misho 1173: #if PHP_API_VERSION < 20100412
1.1 misho 1174: /* check if we need magic quotes */
1175: if (PG(magic_quotes_runtime)) {
1176: Z_TYPE_P(res) = IS_STRING;
1177: Z_STRVAL_P(res) = php_addslashes(row[i], field_len[i], &Z_STRLEN_P(res), 0 TSRMLS_CC);
1178: } else {
1.1.1.2 misho 1179: #endif
1.1 misho 1180: ZVAL_STRINGL(res, row[i], field_len[i], 1);
1.1.1.2 misho 1181: #if PHP_API_VERSION < 20100412
1.1 misho 1182: }
1.1.1.2 misho 1183: #endif
1.1 misho 1184: }
1185:
1186: if (fetchtype & MYSQLI_NUM) {
1187: add_index_zval(return_value, i, res);
1188: }
1189: if (fetchtype & MYSQLI_ASSOC) {
1190: if (fetchtype & MYSQLI_NUM) {
1191: Z_ADDREF_P(res);
1192: }
1193: add_assoc_zval(return_value, fields[i].name, res);
1194: }
1195: } else {
1196: if (fetchtype & MYSQLI_NUM) {
1197: add_index_null(return_value, i);
1198: }
1199: if (fetchtype & MYSQLI_ASSOC) {
1200: add_assoc_null(return_value, fields[i].name);
1201: }
1202: }
1203: }
1204: #else
1.1.1.2 misho 1205: mysqlnd_fetch_into(result, ((fetchtype & MYSQLI_NUM)? MYSQLND_FETCH_NUM:0) | ((fetchtype & MYSQLI_ASSOC)? MYSQLND_FETCH_ASSOC:0), return_value, MYSQLND_MYSQLI);
1206: #endif
1207: }
1208: /* }}} */
1209:
1210:
1211: /* {{{ php_mysqli_fetch_into_hash
1212: */
1213: void php_mysqli_fetch_into_hash(INTERNAL_FUNCTION_PARAMETERS, int override_flags, int into_object)
1214: {
1215: MYSQL_RES *result;
1216: zval *mysql_result;
1217: long fetchtype;
1218: zval *ctor_params = NULL;
1219: zend_class_entry *ce = NULL;
1220:
1221: if (into_object) {
1222: char *class_name;
1223: int class_name_len;
1224:
1225: if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|sz", &mysql_result, mysqli_result_class_entry, &class_name, &class_name_len, &ctor_params) == FAILURE) {
1226: return;
1227: }
1228: if (ZEND_NUM_ARGS() < (getThis() ? 1 : 2)) {
1229: ce = zend_standard_class_def;
1.1 misho 1230: } else {
1.1.1.2 misho 1231: ce = zend_fetch_class(class_name, class_name_len, ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
1.1 misho 1232: }
1.1.1.2 misho 1233: if (!ce) {
1234: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not find class '%s'", class_name);
1235: return;
1236: }
1237: fetchtype = MYSQLI_ASSOC;
1.1 misho 1238: } else {
1.1.1.2 misho 1239: if (override_flags) {
1240: if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &mysql_result, mysqli_result_class_entry) == FAILURE) {
1241: return;
1242: }
1243: fetchtype = override_flags;
1244: } else {
1245: fetchtype = MYSQLI_BOTH;
1246: if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|l", &mysql_result, mysqli_result_class_entry, &fetchtype) == FAILURE) {
1247: return;
1248: }
1249: }
1.1 misho 1250: }
1.1.1.2 misho 1251: MYSQLI_FETCH_RESOURCE(result, MYSQL_RES *, &mysql_result, "mysqli_result", MYSQLI_STATUS_VALID);
1.1 misho 1252:
1.1.1.2 misho 1253: if (fetchtype < MYSQLI_ASSOC || fetchtype > MYSQLI_BOTH) {
1254: php_error_docref(NULL TSRMLS_CC, E_WARNING, "The result type should be either MYSQLI_NUM, MYSQLI_ASSOC or MYSQLI_BOTH");
1255: RETURN_FALSE;
1256: }
1257:
1258: php_mysqli_fetch_into_hash_aux(return_value, result, fetchtype TSRMLS_CC);
1.1 misho 1259:
1.1.1.3 misho 1260: if (into_object && Z_TYPE_P(return_value) == IS_ARRAY) {
1.1 misho 1261: zval dataset = *return_value;
1262: zend_fcall_info fci;
1263: zend_fcall_info_cache fcc;
1264: zval *retval_ptr;
1265:
1266: object_and_properties_init(return_value, ce, NULL);
1267: zend_merge_properties(return_value, Z_ARRVAL(dataset), 1 TSRMLS_CC);
1268:
1269: if (ce->constructor) {
1270: fci.size = sizeof(fci);
1271: fci.function_table = &ce->function_table;
1272: fci.function_name = NULL;
1273: fci.symbol_table = NULL;
1274: fci.object_ptr = return_value;
1275: fci.retval_ptr_ptr = &retval_ptr;
1276: if (ctor_params && Z_TYPE_P(ctor_params) != IS_NULL) {
1277: if (Z_TYPE_P(ctor_params) == IS_ARRAY) {
1278: HashTable *params_ht = Z_ARRVAL_P(ctor_params);
1279: Bucket *p;
1280:
1281: fci.param_count = 0;
1282: fci.params = safe_emalloc(sizeof(zval*), params_ht->nNumOfElements, 0);
1283: p = params_ht->pListHead;
1284: while (p != NULL) {
1285: fci.params[fci.param_count++] = (zval**)p->pData;
1286: p = p->pListNext;
1287: }
1288: } else {
1289: /* Two problems why we throw exceptions here: PHP is typeless
1290: * and hence passing one argument that's not an array could be
1291: * by mistake and the other way round is possible, too. The
1292: * single value is an array. Also we'd have to make that one
1293: * argument passed by reference.
1294: */
1295: zend_throw_exception(zend_exception_get_default(TSRMLS_C), "Parameter ctor_params must be an array", 0 TSRMLS_CC);
1296: return;
1297: }
1298: } else {
1299: fci.param_count = 0;
1300: fci.params = NULL;
1301: }
1302: fci.no_separation = 1;
1303:
1304: fcc.initialized = 1;
1305: fcc.function_handler = ce->constructor;
1306: fcc.calling_scope = EG(scope);
1307: fcc.called_scope = Z_OBJCE_P(return_value);
1308: fcc.object_ptr = return_value;
1309:
1310: if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
1311: zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "Could not execute %s::%s()", ce->name, ce->constructor->common.function_name);
1312: } else {
1313: if (retval_ptr) {
1314: zval_ptr_dtor(&retval_ptr);
1315: }
1316: }
1317: if (fci.params) {
1318: efree(fci.params);
1319: }
1320: } else if (ctor_params) {
1321: zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "Class %s does not have a constructor hence you cannot use ctor_params", ce->name);
1322: }
1323: }
1324: }
1325: /* }}} */
1326:
1327:
1328: #if !defined(MYSQLI_USE_MYSQLND)
1329:
1330: #define ALLOC_CALLBACK_ARGS(a, b, c)\
1331: if (c) {\
1332: a = (zval ***)safe_emalloc(c, sizeof(zval **), 0);\
1333: for (i = b; i < c; i++) {\
1334: a[i] = emalloc(sizeof(zval *));\
1335: MAKE_STD_ZVAL(*a[i]);\
1336: }\
1337: }
1338:
1339: #define FREE_CALLBACK_ARGS(a, b, c)\
1340: if (a) {\
1341: for (i=b; i < c; i++) {\
1342: zval_ptr_dtor(a[i]);\
1343: efree(a[i]);\
1344: }\
1345: efree(a);\
1346: }
1347:
1348: #define LOCAL_INFILE_ERROR_MSG(source,dest)\
1349: memset(source, 0, LOCAL_INFILE_ERROR_LEN);\
1350: memcpy(source, dest, MIN(strlen(dest), LOCAL_INFILE_ERROR_LEN-1));\
1351: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", dest);
1352:
1353:
1354: /* {{{ php_local_infile_init
1355: */
1356: static int php_local_infile_init(void **ptr, const char *filename, void *userdata)
1357: {
1358: mysqli_local_infile *data;
1359: MY_MYSQL *mysql;
1360: php_stream_context *context = NULL;
1361:
1362: TSRMLS_FETCH();
1363:
1364: /* save pointer to MY_MYSQL structure (userdata) */
1365: if (!(*ptr= data= ((mysqli_local_infile *)calloc(1, sizeof(mysqli_local_infile))))) {
1366: return 1;
1367: }
1368:
1369: if (!(mysql = (MY_MYSQL *)userdata)) {
1370: LOCAL_INFILE_ERROR_MSG(data->error_msg, ER(CR_UNKNOWN_ERROR));
1371: return 1;
1372: }
1373:
1374: /* check open_basedir */
1375: if (PG(open_basedir)) {
1376: if (php_check_open_basedir_ex(filename, 0 TSRMLS_CC) == -1) {
1377: LOCAL_INFILE_ERROR_MSG(data->error_msg, "open_basedir restriction in effect. Unable to open file");
1378: return 1;
1379: }
1380: }
1381:
1382: mysql->li_stream = php_stream_open_wrapper_ex((char *)filename, "r", 0, NULL, context);
1383:
1384: if (mysql->li_stream == NULL) {
1385: snprintf((char *)data->error_msg, sizeof(data->error_msg), "Can't find file '%-.64s'.", filename);
1386: return 1;
1387: }
1388:
1389: data->userdata = mysql;
1390:
1391: return 0;
1392: }
1393: /* }}} */
1394:
1395: /* {{{ int php_local_infile_read */
1396: static int php_local_infile_read(void *ptr, char *buf, uint buf_len)
1397: {
1398: mysqli_local_infile *data;
1399: MY_MYSQL *mysql;
1400: zval ***callback_args;
1401: zval *retval;
1402: zval *fp;
1403: int argc = 4;
1404: int i;
1405: long rc;
1406:
1407: TSRMLS_FETCH();
1408:
1409: data= (mysqli_local_infile *)ptr;
1410: mysql = data->userdata;
1411:
1412: /* default processing */
1413: if (!mysql->li_read) {
1414: int count = (int)php_stream_read(mysql->li_stream, buf, buf_len);
1415:
1416: if (count < 0) {
1417: LOCAL_INFILE_ERROR_MSG(data->error_msg, ER(2));
1418: }
1419:
1420: return count;
1421: }
1422:
1423: ALLOC_CALLBACK_ARGS(callback_args, 1, argc);
1424:
1425: /* set parameters: filepointer, buffer, buffer_len, errormsg */
1426:
1427: MAKE_STD_ZVAL(fp);
1428: php_stream_to_zval(mysql->li_stream, fp);
1429: callback_args[0] = &fp;
1430: ZVAL_STRING(*callback_args[1], "", 1);
1431: ZVAL_LONG(*callback_args[2], buf_len);
1432: ZVAL_STRING(*callback_args[3], "", 1);
1433:
1434: if (call_user_function_ex(EG(function_table),
1435: NULL,
1436: mysql->li_read,
1437: &retval,
1438: argc,
1439: callback_args,
1440: 0,
1441: NULL TSRMLS_CC) == SUCCESS) {
1442:
1443: rc = Z_LVAL_P(retval);
1444: zval_ptr_dtor(&retval);
1445:
1446: if (rc > 0) {
1447: if (rc >= 0 && rc != Z_STRLEN_P(*callback_args[1])) {
1448: LOCAL_INFILE_ERROR_MSG(data->error_msg,
1449: "Mismatch between the return value of the callback and the content "
1450: "length of the buffer.");
1451: rc = -1;
1452: } else if (rc > buf_len) {
1453: /* check buffer overflow */
1454: LOCAL_INFILE_ERROR_MSG(data->error_msg, "Too much data returned");
1455: rc = -1;
1456: } else {
1457: memcpy(buf, Z_STRVAL_P(*callback_args[1]), MIN(rc, Z_STRLEN_P(*callback_args[1])));
1458: }
1459: } else if (rc < 0) {
1460: LOCAL_INFILE_ERROR_MSG(data->error_msg, Z_STRVAL_P(*callback_args[3]));
1461: }
1462: } else {
1463: LOCAL_INFILE_ERROR_MSG(data->error_msg, "Can't execute load data local init callback function");
1464: rc = -1;
1465: }
1466: /*
1467: If the (ab)user has closed the file handle we should
1468: not try to use it anymore or even close it
1469: */
1470: if (!zend_rsrc_list_get_rsrc_type(Z_LVAL_P(fp) TSRMLS_CC)) {
1471: LOCAL_INFILE_ERROR_MSG(data->error_msg, "File handle closed");
1472: rc = -1;
1473: /* Thus the end handler won't try to free already freed memory */
1474: mysql->li_stream = NULL;
1475: }
1476:
1477: FREE_CALLBACK_ARGS(callback_args, 1, argc);
1478: efree(fp);
1479: return rc;
1480: }
1481: /* }}} */
1482:
1483: /* {{{ php_local_infile_error
1484: */
1485: static int php_local_infile_error(void *ptr, char *error_msg, uint error_msg_len)
1486: {
1487: mysqli_local_infile *data = (mysqli_local_infile *) ptr;
1488:
1489: if (data) {
1490: strlcpy(error_msg, data->error_msg, error_msg_len);
1491: return 2000;
1492: }
1493: strlcpy(error_msg, ER(CR_OUT_OF_MEMORY), error_msg_len);
1494: return CR_OUT_OF_MEMORY;
1495: }
1496: /* }}} */
1497:
1498: /* {{{ php_local_infile_end
1499: */
1500: static void php_local_infile_end(void *ptr)
1501: {
1502: mysqli_local_infile *data;
1503: MY_MYSQL *mysql;
1504:
1505: TSRMLS_FETCH();
1506:
1507: data= (mysqli_local_infile *)ptr;
1508:
1509: if (!data || !(mysql = data->userdata)) {
1510: if (data) {
1511: free(data);
1512: }
1513: return;
1514: }
1515:
1516: if (mysql->li_stream) {
1517: php_stream_close(mysql->li_stream);
1518: }
1519: free(data);
1520: return;
1521: }
1522: /* }}} */
1523:
1524:
1525: /* {{{ void php_set_local_infile_handler_default
1526: */
1527: void php_set_local_infile_handler_default(MY_MYSQL *mysql) {
1528: /* register internal callback functions */
1529: mysql_set_local_infile_handler(mysql->mysql, &php_local_infile_init, &php_local_infile_read,
1530: &php_local_infile_end, &php_local_infile_error, (void *)mysql);
1531: if (mysql->li_read) {
1532: zval_ptr_dtor(&mysql->li_read);
1533: mysql->li_read = NULL;
1534: }
1535: }
1536: /* }}} */
1537: #endif
1538:
1539: /*
1540: * Local variables:
1541: * tab-width: 4
1542: * c-basic-offset: 4
1543: * End:
1544: * vim600: noet sw=4 ts=4 fdm=marker
1545: * vim<600: noet sw=4 ts=4
1546: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mysqli.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / mysqli