1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 5 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1997-2016 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: Sascha Schumann <sascha@schumann.cx> |
16 | Marcus Boerger <helly@php.net> |
17 +----------------------------------------------------------------------+
18 */
19
20 /* $Id$ */
21
22 #ifdef HAVE_CONFIG_H
23 #include "config.h"
24 #endif
25
26 #include "php.h"
27
28 #if HAVE_DBA
29
30 #include "php_ini.h"
31 #include <stdio.h>
32 #include <fcntl.h>
33 #ifdef HAVE_SYS_FILE_H
34 #include <sys/file.h>
35 #endif
36
37 #include "php_dba.h"
38 #include "ext/standard/info.h"
39 #include "ext/standard/php_string.h"
40 #include "ext/standard/flock_compat.h"
41
42 #include "php_gdbm.h"
43 #include "php_ndbm.h"
44 #include "php_dbm.h"
45 #include "php_cdb.h"
46 #include "php_db1.h"
47 #include "php_db2.h"
48 #include "php_db3.h"
49 #include "php_db4.h"
50 #include "php_flatfile.h"
51 #include "php_inifile.h"
52 #include "php_qdbm.h"
53 #include "php_tcadb.h"
54
55 /* {{{ arginfo */
56 ZEND_BEGIN_ARG_INFO_EX(arginfo_dba_popen, 0, 0, 2)
57 ZEND_ARG_INFO(0, path)
58 ZEND_ARG_INFO(0, mode)
59 ZEND_ARG_INFO(0, handlername)
60 ZEND_ARG_VARIADIC_INFO(0, handler_parameters)
61 ZEND_END_ARG_INFO()
62
63 ZEND_BEGIN_ARG_INFO_EX(arginfo_dba_open, 0, 0, 2)
64 ZEND_ARG_INFO(0, path)
65 ZEND_ARG_INFO(0, mode)
66 ZEND_ARG_INFO(0, handlername)
67 ZEND_ARG_VARIADIC_INFO(0, handler_parameters)
68 ZEND_END_ARG_INFO()
69
70 ZEND_BEGIN_ARG_INFO(arginfo_dba_close, 0)
71 ZEND_ARG_INFO(0, handle)
72 ZEND_END_ARG_INFO()
73
74 ZEND_BEGIN_ARG_INFO(arginfo_dba_exists, 0)
75 ZEND_ARG_INFO(0, key)
76 ZEND_ARG_INFO(0, handle)
77 ZEND_END_ARG_INFO()
78
79 ZEND_BEGIN_ARG_INFO_EX(arginfo_dba_fetch, 0, 0, 2)
80 ZEND_ARG_INFO(0, key)
81 ZEND_ARG_INFO(0, skip)
82 ZEND_ARG_INFO(0, handle)
83 ZEND_END_ARG_INFO()
84
85 ZEND_BEGIN_ARG_INFO(arginfo_dba_key_split, 0)
86 ZEND_ARG_INFO(0, key)
87 ZEND_END_ARG_INFO()
88
89 ZEND_BEGIN_ARG_INFO(arginfo_dba_firstkey, 0)
90 ZEND_ARG_INFO(0, handle)
91 ZEND_END_ARG_INFO()
92
93 ZEND_BEGIN_ARG_INFO(arginfo_dba_nextkey, 0)
94 ZEND_ARG_INFO(0, handle)
95 ZEND_END_ARG_INFO()
96
97 ZEND_BEGIN_ARG_INFO(arginfo_dba_delete, 0)
98 ZEND_ARG_INFO(0, key)
99 ZEND_ARG_INFO(0, handle)
100 ZEND_END_ARG_INFO()
101
102 ZEND_BEGIN_ARG_INFO(arginfo_dba_insert, 0)
103 ZEND_ARG_INFO(0, key)
104 ZEND_ARG_INFO(0, value)
105 ZEND_ARG_INFO(0, handle)
106 ZEND_END_ARG_INFO()
107
108 ZEND_BEGIN_ARG_INFO(arginfo_dba_replace, 0)
109 ZEND_ARG_INFO(0, key)
110 ZEND_ARG_INFO(0, value)
111 ZEND_ARG_INFO(0, handle)
112 ZEND_END_ARG_INFO()
113
114 ZEND_BEGIN_ARG_INFO(arginfo_dba_optimize, 0)
115 ZEND_ARG_INFO(0, handle)
116 ZEND_END_ARG_INFO()
117
118 ZEND_BEGIN_ARG_INFO(arginfo_dba_sync, 0)
119 ZEND_ARG_INFO(0, handle)
120 ZEND_END_ARG_INFO()
121
122 ZEND_BEGIN_ARG_INFO_EX(arginfo_dba_handlers, 0, 0, 0)
123 ZEND_ARG_INFO(0, full_info)
124 ZEND_END_ARG_INFO()
125
126 ZEND_BEGIN_ARG_INFO(arginfo_dba_list, 0)
127 ZEND_END_ARG_INFO()
128
129 /* }}} */
130
131 /* {{{ dba_functions[]
132 */
133 const zend_function_entry dba_functions[] = {
134 PHP_FE(dba_open, arginfo_dba_open)
135 PHP_FE(dba_popen, arginfo_dba_popen)
136 PHP_FE(dba_close, arginfo_dba_close)
137 PHP_FE(dba_delete, arginfo_dba_delete)
138 PHP_FE(dba_exists, arginfo_dba_exists)
139 PHP_FE(dba_fetch, arginfo_dba_fetch)
140 PHP_FE(dba_insert, arginfo_dba_insert)
141 PHP_FE(dba_replace, arginfo_dba_replace)
142 PHP_FE(dba_firstkey, arginfo_dba_firstkey)
143 PHP_FE(dba_nextkey, arginfo_dba_nextkey)
144 PHP_FE(dba_optimize, arginfo_dba_optimize)
145 PHP_FE(dba_sync, arginfo_dba_sync)
146 PHP_FE(dba_handlers, arginfo_dba_handlers)
147 PHP_FE(dba_list, arginfo_dba_list)
148 PHP_FE(dba_key_split, arginfo_dba_key_split)
149 PHP_FE_END
150 };
151 /* }}} */
152
153 PHP_MINIT_FUNCTION(dba);
154 PHP_MSHUTDOWN_FUNCTION(dba);
155 PHP_MINFO_FUNCTION(dba);
156
157 ZEND_BEGIN_MODULE_GLOBALS(dba)
158 char *default_handler;
159 dba_handler *default_hptr;
160 ZEND_END_MODULE_GLOBALS(dba)
161
162 ZEND_DECLARE_MODULE_GLOBALS(dba)
163
164 #ifdef ZTS
165 #define DBA_G(v) TSRMG(dba_globals_id, zend_dba_globals *, v)
166 #else
167 #define DBA_G(v) (dba_globals.v)
168 #endif
169
170 static PHP_GINIT_FUNCTION(dba);
171
172 zend_module_entry dba_module_entry = {
173 STANDARD_MODULE_HEADER,
174 "dba",
175 dba_functions,
176 PHP_MINIT(dba),
177 PHP_MSHUTDOWN(dba),
178 NULL,
179 NULL,
180 PHP_MINFO(dba),
181 NO_VERSION_YET,
182 PHP_MODULE_GLOBALS(dba),
183 PHP_GINIT(dba),
184 NULL,
185 NULL,
186 STANDARD_MODULE_PROPERTIES_EX
187 };
188
189 #ifdef COMPILE_DL_DBA
ZEND_GET_MODULE(dba)190 ZEND_GET_MODULE(dba)
191 #endif
192
193 /* {{{ macromania */
194
195 #define DBA_ID_PARS \
196 zval *id; \
197 dba_info *info = NULL; \
198 int ac = ZEND_NUM_ARGS()
199
200 /* these are used to get the standard arguments */
201
202 /* {{{ php_dba_myke_key */
203 static size_t php_dba_make_key(zval *key, char **key_str, char **key_free TSRMLS_DC)
204 {
205 if (Z_TYPE_P(key) == IS_ARRAY) {
206 zval **group, **name;
207 HashPosition pos;
208 size_t len;
209
210 if (zend_hash_num_elements(Z_ARRVAL_P(key)) != 2) {
211 php_error_docref(NULL TSRMLS_CC, E_RECOVERABLE_ERROR, "Key does not have exactly two elements: (key, name)");
212 return -1;
213 }
214 zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(key), &pos);
215 zend_hash_get_current_data_ex(Z_ARRVAL_P(key), (void **) &group, &pos);
216 zend_hash_move_forward_ex(Z_ARRVAL_P(key), &pos);
217 zend_hash_get_current_data_ex(Z_ARRVAL_P(key), (void **) &name, &pos);
218 convert_to_string_ex(group);
219 convert_to_string_ex(name);
220 if (Z_STRLEN_PP(group) == 0) {
221 *key_str = Z_STRVAL_PP(name);
222 *key_free = NULL;
223 return Z_STRLEN_PP(name);
224 }
225 len = spprintf(key_str, 0, "[%s]%s", Z_STRVAL_PP(group), Z_STRVAL_PP(name));
226 *key_free = *key_str;
227 return len;
228 } else {
229 zval tmp = *key;
230 int len;
231
232 zval_copy_ctor(&tmp);
233 convert_to_string(&tmp);
234
235 *key_free = *key_str = estrndup(Z_STRVAL(tmp), Z_STRLEN(tmp));
236 len = Z_STRLEN(tmp);
237
238 zval_dtor(&tmp);
239 return len;
240 }
241 }
242 /* }}} */
243
244 #define DBA_GET2 \
245 zval *key; \
246 char *key_str, *key_free; \
247 size_t key_len; \
248 if (zend_parse_parameters(ac TSRMLS_CC, "zr", &key, &id) == FAILURE) { \
249 return; \
250 } \
251 if ((key_len = php_dba_make_key(key, &key_str, &key_free TSRMLS_CC)) == 0) {\
252 RETURN_FALSE; \
253 }
254
255 #define DBA_GET2_3 \
256 zval *key; \
257 char *key_str, *key_free; \
258 size_t key_len; \
259 long skip = 0; \
260 switch(ac) { \
261 case 2: \
262 if (zend_parse_parameters(ac TSRMLS_CC, "zr", &key, &id) == FAILURE) { \
263 return; \
264 } \
265 break; \
266 case 3: \
267 if (zend_parse_parameters(ac TSRMLS_CC, "zlr", &key, &skip, &id) == FAILURE) { \
268 return; \
269 } \
270 break; \
271 default: \
272 WRONG_PARAM_COUNT; \
273 } \
274 if ((key_len = php_dba_make_key(key, &key_str, &key_free TSRMLS_CC)) == 0) {\
275 RETURN_FALSE; \
276 }
277
278
279 #define DBA_FETCH_RESOURCE(info, id) \
280 ZEND_FETCH_RESOURCE2(info, dba_info *, id, -1, "DBA identifier", le_db, le_pdb);
281
282 #define DBA_ID_GET2 DBA_ID_PARS; DBA_GET2; DBA_FETCH_RESOURCE(info, &id)
283 #define DBA_ID_GET2_3 DBA_ID_PARS; DBA_GET2_3; DBA_FETCH_RESOURCE(info, &id)
284
285 #define DBA_ID_DONE \
286 if (key_free) efree(key_free)
287 /* a DBA handler must have specific routines */
288
289 #define DBA_NAMED_HND(alias, name, flags) \
290 {\
291 #alias, flags, dba_open_##name, dba_close_##name, dba_fetch_##name, dba_update_##name, \
292 dba_exists_##name, dba_delete_##name, dba_firstkey_##name, dba_nextkey_##name, \
293 dba_optimize_##name, dba_sync_##name, dba_info_##name \
294 },
295
296 #define DBA_HND(name, flags) DBA_NAMED_HND(name, name, flags)
297
298 /* check whether the user has write access */
299 #define DBA_WRITE_CHECK \
300 if(info->mode != DBA_WRITER && info->mode != DBA_TRUNC && info->mode != DBA_CREAT) { \
301 php_error_docref(NULL TSRMLS_CC, E_WARNING, "You cannot perform a modification to a database without proper access"); \
302 RETURN_FALSE; \
303 }
304
305 /* the same check, but with a call to DBA_ID_DONE before returning */
306 #define DBA_WRITE_CHECK_WITH_ID \
307 if(info->mode != DBA_WRITER && info->mode != DBA_TRUNC && info->mode != DBA_CREAT) { \
308 php_error_docref(NULL TSRMLS_CC, E_WARNING, "You cannot perform a modification to a database without proper access"); \
309 DBA_ID_DONE; \
310 RETURN_FALSE; \
311 }
312
313 /* }}} */
314
315 /* {{{ globals */
316
317 static dba_handler handler[] = {
318 #if DBA_GDBM
319 DBA_HND(gdbm, DBA_LOCK_EXT) /* Locking done in library if set */
320 #endif
321 #if DBA_DBM
322 DBA_HND(dbm, DBA_LOCK_ALL) /* No lock in lib */
323 #endif
324 #if DBA_NDBM
325 DBA_HND(ndbm, DBA_LOCK_ALL) /* Could be done in library: filemode = 0644 + S_ENFMT */
326 #endif
327 #if DBA_CDB
328 DBA_HND(cdb, DBA_STREAM_OPEN|DBA_LOCK_ALL) /* No lock in lib */
329 #endif
330 #if DBA_CDB_BUILTIN
331 DBA_NAMED_HND(cdb_make, cdb, DBA_STREAM_OPEN|DBA_LOCK_ALL) /* No lock in lib */
332 #endif
333 #if DBA_DB1
334 DBA_HND(db1, DBA_LOCK_ALL) /* No lock in lib */
335 #endif
336 #if DBA_DB2
337 DBA_HND(db2, DBA_LOCK_ALL) /* No lock in lib */
338 #endif
339 #if DBA_DB3
340 DBA_HND(db3, DBA_LOCK_ALL) /* No lock in lib */
341 #endif
342 #if DBA_DB4
343 DBA_HND(db4, DBA_LOCK_ALL) /* No lock in lib */
344 #endif
345 #if DBA_INIFILE
346 DBA_HND(inifile, DBA_STREAM_OPEN|DBA_LOCK_ALL|DBA_CAST_AS_FD) /* No lock in lib */
347 #endif
348 #if DBA_FLATFILE
349 DBA_HND(flatfile, DBA_STREAM_OPEN|DBA_LOCK_ALL|DBA_NO_APPEND) /* No lock in lib */
350 #endif
351 #if DBA_QDBM
352 DBA_HND(qdbm, DBA_LOCK_EXT)
353 #endif
354 #if DBA_TCADB
355 DBA_HND(tcadb, DBA_LOCK_ALL)
356 #endif
357 { NULL, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
358 };
359
360 #if DBA_FLATFILE
361 #define DBA_DEFAULT "flatfile"
362 #elif DBA_DB4
363 #define DBA_DEFAULT "db4"
364 #elif DBA_DB3
365 #define DBA_DEFAULT "db3"
366 #elif DBA_DB2
367 #define DBA_DEFAULT "db2"
368 #elif DBA_DB1
369 #define DBA_DEFAULT "db1"
370 #elif DBA_GDBM
371 #define DBA_DEFAULT "gdbm"
372 #elif DBA_NBBM
373 #define DBA_DEFAULT "ndbm"
374 #elif DBA_DBM
375 #define DBA_DEFAULT "dbm"
376 #elif DBA_QDBM
377 #define DBA_DEFAULT "qdbm"
378 #elif DBA_TCADB
379 #define DBA_DEFAULT "tcadb"
380 #else
381 #define DBA_DEFAULT ""
382 #endif
383 /* cdb/cdb_make and ini are no option here */
384
385 static int le_db;
386 static int le_pdb;
387 /* }}} */
388
389 /* {{{ dba_fetch_resource
390 PHPAPI void dba_fetch_resource(dba_info **pinfo, zval **id TSRMLS_DC)
391 {
392 dba_info *info;
393 DBA_ID_FETCH
394 *pinfo = info;
395 }
396 */
397 /* }}} */
398
399 /* {{{ dba_get_handler
400 PHPAPI dba_handler *dba_get_handler(const char* handler_name)
401 {
402 dba_handler *hptr;
403 for (hptr = handler; hptr->name && strcasecmp(hptr->name, handler_name); hptr++);
404 return hptr;
405 }
406 */
407 /* }}} */
408
409 /* {{{ dba_close
410 */
dba_close(dba_info * info TSRMLS_DC)411 static void dba_close(dba_info *info TSRMLS_DC)
412 {
413 if (info->hnd) {
414 info->hnd->close(info TSRMLS_CC);
415 }
416 if (info->path) {
417 pefree(info->path, info->flags&DBA_PERSISTENT);
418 }
419 if (info->fp && info->fp!=info->lock.fp) {
420 if(info->flags&DBA_PERSISTENT) {
421 php_stream_pclose(info->fp);
422 } else {
423 php_stream_close(info->fp);
424 }
425 }
426 if (info->lock.fp) {
427 if(info->flags&DBA_PERSISTENT) {
428 php_stream_pclose(info->lock.fp);
429 } else {
430 php_stream_close(info->lock.fp);
431 }
432 }
433 if (info->lock.name) {
434 pefree(info->lock.name, info->flags&DBA_PERSISTENT);
435 }
436 pefree(info, info->flags&DBA_PERSISTENT);
437 }
438 /* }}} */
439
440 /* {{{ dba_close_rsrc
441 */
dba_close_rsrc(zend_rsrc_list_entry * rsrc TSRMLS_DC)442 static void dba_close_rsrc(zend_rsrc_list_entry *rsrc TSRMLS_DC)
443 {
444 dba_info *info = (dba_info *)rsrc->ptr;
445
446 dba_close(info TSRMLS_CC);
447 }
448 /* }}} */
449
450 /* {{{ dba_close_pe_rsrc_deleter */
dba_close_pe_rsrc_deleter(zend_rsrc_list_entry * le,void * pDba TSRMLS_DC)451 int dba_close_pe_rsrc_deleter(zend_rsrc_list_entry *le, void *pDba TSRMLS_DC)
452 {
453 return le->ptr == pDba;
454 }
455 /* }}} */
456
457 /* {{{ dba_close_pe_rsrc */
dba_close_pe_rsrc(zend_rsrc_list_entry * rsrc TSRMLS_DC)458 static void dba_close_pe_rsrc(zend_rsrc_list_entry *rsrc TSRMLS_DC)
459 {
460 dba_info *info = (dba_info *)rsrc->ptr;
461
462 /* closes the resource by calling dba_close_rsrc() */
463 zend_hash_apply_with_argument(&EG(persistent_list), (apply_func_arg_t) dba_close_pe_rsrc_deleter, info TSRMLS_CC);
464 }
465 /* }}} */
466
467 /* {{{ PHP_INI
468 */
ZEND_INI_MH(OnUpdateDefaultHandler)469 ZEND_INI_MH(OnUpdateDefaultHandler)
470 {
471 dba_handler *hptr;
472
473 if (!strlen(new_value)) {
474 DBA_G(default_hptr) = NULL;
475 return OnUpdateString(entry, new_value, new_value_length, mh_arg1, mh_arg2, mh_arg3, stage TSRMLS_CC);
476 }
477
478 for (hptr = handler; hptr->name && strcasecmp(hptr->name, new_value); hptr++);
479
480 if (!hptr->name) {
481 php_error_docref(NULL TSRMLS_CC, E_WARNING, "No such handler: %s", new_value);
482 return FAILURE;
483 }
484 DBA_G(default_hptr) = hptr;
485 return OnUpdateString(entry, new_value, new_value_length, mh_arg1, mh_arg2, mh_arg3, stage TSRMLS_CC);
486 }
487
488 PHP_INI_BEGIN()
489 STD_PHP_INI_ENTRY("dba.default_handler", DBA_DEFAULT, PHP_INI_ALL, OnUpdateDefaultHandler, default_handler, zend_dba_globals, dba_globals)
PHP_INI_END()490 PHP_INI_END()
491 /* }}} */
492
493 /* {{{ PHP_GINIT_FUNCTION
494 */
495 static PHP_GINIT_FUNCTION(dba)
496 {
497 dba_globals->default_handler = "";
498 dba_globals->default_hptr = NULL;
499 }
500 /* }}} */
501
502 /* {{{ PHP_MINIT_FUNCTION
503 */
PHP_MINIT_FUNCTION(dba)504 PHP_MINIT_FUNCTION(dba)
505 {
506 REGISTER_INI_ENTRIES();
507 le_db = zend_register_list_destructors_ex(dba_close_rsrc, NULL, "dba", module_number);
508 le_pdb = zend_register_list_destructors_ex(dba_close_pe_rsrc, dba_close_rsrc, "dba persistent", module_number);
509 return SUCCESS;
510 }
511 /* }}} */
512
513 /* {{{ PHP_MSHUTDOWN_FUNCTION
514 */
PHP_MSHUTDOWN_FUNCTION(dba)515 PHP_MSHUTDOWN_FUNCTION(dba)
516 {
517 UNREGISTER_INI_ENTRIES();
518 return SUCCESS;
519 }
520 /* }}} */
521
522 #include "ext/standard/php_smart_str.h"
523
524 /* {{{ PHP_MINFO_FUNCTION
525 */
PHP_MINFO_FUNCTION(dba)526 PHP_MINFO_FUNCTION(dba)
527 {
528 dba_handler *hptr;
529 smart_str handlers = {0};
530
531 for(hptr = handler; hptr->name; hptr++) {
532 smart_str_appends(&handlers, hptr->name);
533 smart_str_appendc(&handlers, ' ');
534 }
535
536 php_info_print_table_start();
537 php_info_print_table_row(2, "DBA support", "enabled");
538 if (handlers.c) {
539 smart_str_0(&handlers);
540 php_info_print_table_row(2, "Supported handlers", handlers.c);
541 smart_str_free(&handlers);
542 } else {
543 php_info_print_table_row(2, "Supported handlers", "none");
544 }
545 php_info_print_table_end();
546 DISPLAY_INI_ENTRIES();
547 }
548 /* }}} */
549
550 /* {{{ php_dba_update
551 */
php_dba_update(INTERNAL_FUNCTION_PARAMETERS,int mode)552 static void php_dba_update(INTERNAL_FUNCTION_PARAMETERS, int mode)
553 {
554 int val_len;
555 zval *id;
556 dba_info *info = NULL;
557 int ac = ZEND_NUM_ARGS();
558 zval *key;
559 char *val;
560 char *key_str, *key_free;
561 size_t key_len;
562
563 if (zend_parse_parameters(ac TSRMLS_CC, "zsr", &key, &val, &val_len, &id) == FAILURE) {
564 return;
565 }
566
567 if ((key_len = php_dba_make_key(key, &key_str, &key_free TSRMLS_CC)) == 0) {
568 RETURN_FALSE;
569 }
570
571 DBA_FETCH_RESOURCE(info, &id);
572
573 DBA_WRITE_CHECK_WITH_ID;
574
575 if (info->hnd->update(info, key_str, key_len, val, val_len, mode TSRMLS_CC) == SUCCESS) {
576 DBA_ID_DONE;
577 RETURN_TRUE;
578 }
579
580 DBA_ID_DONE;
581 RETURN_FALSE;
582 }
583 /* }}} */
584
585 #define FREENOW if(args) efree(args); if(key) efree(key)
586
587 /* {{{ php_find_dbm
588 */
php_dba_find(const char * path TSRMLS_DC)589 dba_info *php_dba_find(const char* path TSRMLS_DC)
590 {
591 zend_rsrc_list_entry *le;
592 dba_info *info;
593 int numitems, i;
594
595 numitems = zend_hash_next_free_element(&EG(regular_list));
596 for (i=1; i<numitems; i++) {
597 if (zend_hash_index_find(&EG(regular_list), i, (void **) &le)==FAILURE) {
598 continue;
599 }
600 if (Z_TYPE_P(le) == le_db || Z_TYPE_P(le) == le_pdb) {
601 info = (dba_info *)(le->ptr);
602 if (!strcmp(info->path, path)) {
603 return (dba_info *)(le->ptr);
604 }
605 }
606 }
607
608 return NULL;
609 }
610 /* }}} */
611
612 /* {{{ php_dba_open
613 */
php_dba_open(INTERNAL_FUNCTION_PARAMETERS,int persistent)614 static void php_dba_open(INTERNAL_FUNCTION_PARAMETERS, int persistent)
615 {
616 zval ***args = (zval ***) NULL;
617 int ac = ZEND_NUM_ARGS();
618 dba_mode_t modenr;
619 dba_info *info, *other;
620 dba_handler *hptr;
621 char *key = NULL, *error = NULL;
622 int keylen = 0;
623 int i;
624 int lock_mode, lock_flag, lock_dbf = 0;
625 char *file_mode;
626 char mode[4], *pmode, *lock_file_mode = NULL;
627 int persistent_flag = persistent ? STREAM_OPEN_PERSISTENT : 0;
628 char *opened_path = NULL;
629 char *lock_name;
630
631 if(ac < 2) {
632 WRONG_PARAM_COUNT;
633 }
634
635 /* we pass additional args to the respective handler */
636 args = safe_emalloc(ac, sizeof(zval *), 0);
637 if (zend_get_parameters_array_ex(ac, args) != SUCCESS) {
638 FREENOW;
639 WRONG_PARAM_COUNT;
640 }
641
642 /* we only take string arguments */
643 for (i = 0; i < ac; i++) {
644 convert_to_string_ex(args[i]);
645 keylen += Z_STRLEN_PP(args[i]);
646 }
647
648 if (persistent) {
649 zend_rsrc_list_entry *le;
650
651 /* calculate hash */
652 key = safe_emalloc(keylen, 1, 1);
653 key[keylen] = '\0';
654 keylen = 0;
655
656 for(i = 0; i < ac; i++) {
657 memcpy(key+keylen, Z_STRVAL_PP(args[i]), Z_STRLEN_PP(args[i]));
658 keylen += Z_STRLEN_PP(args[i]);
659 }
660
661 /* try to find if we already have this link in our persistent list */
662 if (zend_hash_find(&EG(persistent_list), key, keylen+1, (void **) &le) == SUCCESS) {
663 FREENOW;
664
665 if (Z_TYPE_P(le) != le_pdb) {
666 RETURN_FALSE;
667 }
668
669 info = (dba_info *)le->ptr;
670
671 ZEND_REGISTER_RESOURCE(return_value, info, le_pdb);
672 return;
673 }
674 }
675
676 if (ac==2) {
677 hptr = DBA_G(default_hptr);
678 if (!hptr) {
679 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "No default handler selected");
680 FREENOW;
681 RETURN_FALSE;
682 }
683 } else {
684 for (hptr = handler; hptr->name && strcasecmp(hptr->name, Z_STRVAL_PP(args[2])); hptr++);
685 }
686
687 if (!hptr->name) {
688 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "No such handler: %s", Z_STRVAL_PP(args[2]));
689 FREENOW;
690 RETURN_FALSE;
691 }
692
693 /* Check mode: [rwnc][fl]?t?
694 * r: Read
695 * w: Write
696 * n: Create/Truncate
697 * c: Create
698 *
699 * d: force lock on database file
700 * l: force lock on lck file
701 * -: ignore locking
702 *
703 * t: test open database, warning if locked
704 */
705 strlcpy(mode, Z_STRVAL_PP(args[1]), sizeof(mode));
706 pmode = &mode[0];
707 if (pmode[0] && (pmode[1]=='d' || pmode[1]=='l' || pmode[1]=='-')) { /* force lock on db file or lck file or disable locking */
708 switch (pmode[1]) {
709 case 'd':
710 lock_dbf = 1;
711 if ((hptr->flags & DBA_LOCK_ALL) == 0) {
712 lock_flag = (hptr->flags & DBA_LOCK_ALL);
713 break;
714 }
715 /* no break */
716 case 'l':
717 lock_flag = DBA_LOCK_ALL;
718 if ((hptr->flags & DBA_LOCK_ALL) == 0) {
719 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_NOTICE, "Handler %s does locking internally", hptr->name);
720 }
721 break;
722 default:
723 case '-':
724 if ((hptr->flags & DBA_LOCK_ALL) == 0) {
725 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "Locking cannot be disabled for handler %s", hptr->name);
726 FREENOW;
727 RETURN_FALSE;
728 }
729 lock_flag = 0;
730 break;
731 }
732 } else {
733 lock_flag = (hptr->flags&DBA_LOCK_ALL);
734 lock_dbf = 1;
735 }
736 switch (*pmode++) {
737 case 'r':
738 modenr = DBA_READER;
739 lock_mode = (lock_flag & DBA_LOCK_READER) ? LOCK_SH : 0;
740 file_mode = "r";
741 break;
742 case 'w':
743 modenr = DBA_WRITER;
744 lock_mode = (lock_flag & DBA_LOCK_WRITER) ? LOCK_EX : 0;
745 file_mode = "r+b";
746 break;
747 case 'c':
748 modenr = DBA_CREAT;
749 lock_mode = (lock_flag & DBA_LOCK_CREAT) ? LOCK_EX : 0;
750 if (lock_mode) {
751 if (lock_dbf) {
752 /* the create/append check will be done on the lock
753 * when the lib opens the file it is already created
754 */
755 file_mode = "r+b"; /* read & write, seek 0 */
756 lock_file_mode = "a+b"; /* append */
757 } else {
758 file_mode = "a+b"; /* append */
759 lock_file_mode = "w+b"; /* create/truncate */
760 }
761 } else {
762 file_mode = "a+b";
763 }
764 /* In case of the 'a+b' append mode, the handler is responsible
765 * to handle any rewind problems (see flatfile handler).
766 */
767 break;
768 case 'n':
769 modenr = DBA_TRUNC;
770 lock_mode = (lock_flag & DBA_LOCK_TRUNC) ? LOCK_EX : 0;
771 file_mode = "w+b";
772 break;
773 default:
774 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "Illegal DBA mode");
775 FREENOW;
776 RETURN_FALSE;
777 }
778 if (!lock_file_mode) {
779 lock_file_mode = file_mode;
780 }
781 if (*pmode=='d' || *pmode=='l' || *pmode=='-') {
782 pmode++; /* done already - skip here */
783 }
784 if (*pmode=='t') {
785 pmode++;
786 if (!lock_flag) {
787 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "You cannot combine modifiers - (no lock) and t (test lock)");
788 FREENOW;
789 RETURN_FALSE;
790 }
791 if (!lock_mode) {
792 if ((hptr->flags & DBA_LOCK_ALL) == 0) {
793 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "Handler %s uses its own locking which doesn't support mode modifier t (test lock)", hptr->name);
794 FREENOW;
795 RETURN_FALSE;
796 } else {
797 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "Handler %s doesn't uses locking for this mode which makes modifier t (test lock) obsolete", hptr->name);
798 FREENOW;
799 RETURN_FALSE;
800 }
801 } else {
802 lock_mode |= LOCK_NB; /* test =: non blocking */
803 }
804 }
805 if (*pmode) {
806 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "Illegal DBA mode");
807 FREENOW;
808 RETURN_FALSE;
809 }
810
811 info = pemalloc(sizeof(dba_info), persistent);
812 memset(info, 0, sizeof(dba_info));
813 info->path = pestrdup(Z_STRVAL_PP(args[0]), persistent);
814 info->mode = modenr;
815 info->argc = ac - 3;
816 info->argv = args + 3;
817 info->flags = (hptr->flags & ~DBA_LOCK_ALL) | (lock_flag & DBA_LOCK_ALL) | (persistent ? DBA_PERSISTENT : 0);
818 info->lock.mode = lock_mode;
819
820 /* if any open call is a locking call:
821 * check if we already habe a locking call open that should block this call
822 * the problem is some systems would allow read during write
823 */
824 if (hptr->flags & DBA_LOCK_ALL) {
825 if ((other = php_dba_find(info->path TSRMLS_CC)) != NULL) {
826 if ( ( (lock_mode&LOCK_EX) && (other->lock.mode&(LOCK_EX|LOCK_SH)) )
827 || ( (other->lock.mode&LOCK_EX) && (lock_mode&(LOCK_EX|LOCK_SH)) )
828 ) {
829 error = "Unable to establish lock (database file already open)"; /* force failure exit */
830 }
831 }
832 }
833
834 if (!error && lock_mode) {
835 if (lock_dbf) {
836 lock_name = Z_STRVAL_PP(args[0]);
837 } else {
838 spprintf(&lock_name, 0, "%s.lck", info->path);
839 if (!strcmp(file_mode, "r")) {
840 /* when in read only mode try to use existing .lck file first */
841 /* do not log errors for .lck file while in read ony mode on .lck file */
842 lock_file_mode = "rb";
843 info->lock.fp = php_stream_open_wrapper(lock_name, lock_file_mode, STREAM_MUST_SEEK|IGNORE_PATH|persistent_flag, &opened_path);
844 }
845 if (!info->lock.fp) {
846 /* when not in read mode or failed to open .lck file read only. now try again in create(write) mode and log errors */
847 lock_file_mode = "a+b";
848 } else {
849 if (!persistent) {
850 info->lock.name = opened_path;
851 } else {
852 if (opened_path) {
853 info->lock.name = pestrdup(opened_path, persistent);
854 efree(opened_path);
855 }
856 }
857 }
858 }
859 if (!info->lock.fp) {
860 info->lock.fp = php_stream_open_wrapper(lock_name, lock_file_mode, STREAM_MUST_SEEK|REPORT_ERRORS|IGNORE_PATH|persistent_flag, &opened_path);
861 if (info->lock.fp) {
862 if (lock_dbf) {
863 /* replace the path info with the real path of the opened file */
864 pefree(info->path, persistent);
865 info->path = pestrdup(opened_path, persistent);
866 }
867 /* now store the name of the lock */
868 if (!persistent) {
869 info->lock.name = opened_path;
870 } else {
871 info->lock.name = pestrdup(opened_path, persistent);
872 efree(opened_path);
873 }
874 }
875 }
876 if (!lock_dbf) {
877 efree(lock_name);
878 }
879 if (!info->lock.fp) {
880 dba_close(info TSRMLS_CC);
881 /* stream operation already wrote an error message */
882 FREENOW;
883 RETURN_FALSE;
884 }
885 if (!php_stream_supports_lock(info->lock.fp)) {
886 error = "Stream does not support locking";
887 }
888 if (php_stream_lock(info->lock.fp, lock_mode)) {
889 error = "Unable to establish lock"; /* force failure exit */
890 }
891 }
892
893 /* centralised open stream for builtin */
894 if (!error && (hptr->flags&DBA_STREAM_OPEN)==DBA_STREAM_OPEN) {
895 if (info->lock.fp && lock_dbf) {
896 info->fp = info->lock.fp; /* use the same stream for locking and database access */
897 } else {
898 info->fp = php_stream_open_wrapper(info->path, file_mode, STREAM_MUST_SEEK|REPORT_ERRORS|IGNORE_PATH|persistent_flag, NULL);
899 }
900 if (!info->fp) {
901 dba_close(info TSRMLS_CC);
902 /* stream operation already wrote an error message */
903 FREENOW;
904 RETURN_FALSE;
905 }
906 if (hptr->flags & (DBA_NO_APPEND|DBA_CAST_AS_FD)) {
907 /* Needed because some systems do not allow to write to the original
908 * file contents with O_APPEND being set.
909 */
910 if (SUCCESS != php_stream_cast(info->fp, PHP_STREAM_AS_FD, (void*)&info->fd, 1)) {
911 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not cast stream");
912 dba_close(info TSRMLS_CC);
913 FREENOW;
914 RETURN_FALSE;
915 #ifdef F_SETFL
916 } else if (modenr == DBA_CREAT) {
917 int flags = fcntl(info->fd, F_GETFL);
918 fcntl(info->fd, F_SETFL, flags & ~O_APPEND);
919 #endif
920 }
921
922 }
923 }
924
925 if (error || hptr->open(info, &error TSRMLS_CC) != SUCCESS) {
926 dba_close(info TSRMLS_CC);
927 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "Driver initialization failed for handler: %s%s%s", hptr->name, error?": ":"", error?error:"");
928 FREENOW;
929 RETURN_FALSE;
930 }
931
932 info->hnd = hptr;
933 info->argc = 0;
934 info->argv = NULL;
935
936 if (persistent) {
937 zend_rsrc_list_entry new_le;
938
939 Z_TYPE(new_le) = le_pdb;
940 new_le.ptr = info;
941 if (zend_hash_update(&EG(persistent_list), key, keylen+1, &new_le, sizeof(zend_rsrc_list_entry), NULL) == FAILURE) {
942 dba_close(info TSRMLS_CC);
943 php_error_docref2(NULL TSRMLS_CC, Z_STRVAL_PP(args[0]), Z_STRVAL_PP(args[1]), E_WARNING, "Could not register persistent resource");
944 FREENOW;
945 RETURN_FALSE;
946 }
947 }
948
949 ZEND_REGISTER_RESOURCE(return_value, info, (persistent ? le_pdb : le_db));
950 FREENOW;
951 }
952 /* }}} */
953 #undef FREENOW
954
955 /* {{{ proto resource dba_popen(string path, string mode [, string handlername, string ...])
956 Opens path using the specified handler in mode persistently */
PHP_FUNCTION(dba_popen)957 PHP_FUNCTION(dba_popen)
958 {
959 php_dba_open(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
960 }
961 /* }}} */
962
963 /* {{{ proto resource dba_open(string path, string mode [, string handlername, string ...])
964 Opens path using the specified handler in mode*/
PHP_FUNCTION(dba_open)965 PHP_FUNCTION(dba_open)
966 {
967 php_dba_open(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
968 }
969 /* }}} */
970
971 /* {{{ proto void dba_close(resource handle)
972 Closes database */
PHP_FUNCTION(dba_close)973 PHP_FUNCTION(dba_close)
974 {
975 zval *id;
976 dba_info *info = NULL;
977
978 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &id) == FAILURE) {
979 return;
980 }
981
982 DBA_FETCH_RESOURCE(info, &id);
983
984 zend_list_delete(Z_RESVAL_P(id));
985 }
986 /* }}} */
987
988 /* {{{ proto bool dba_exists(string key, resource handle)
989 Checks, if the specified key exists */
PHP_FUNCTION(dba_exists)990 PHP_FUNCTION(dba_exists)
991 {
992 DBA_ID_GET2;
993
994 if(info->hnd->exists(info, key_str, key_len TSRMLS_CC) == SUCCESS) {
995 DBA_ID_DONE;
996 RETURN_TRUE;
997 }
998 DBA_ID_DONE;
999 RETURN_FALSE;
1000 }
1001 /* }}} */
1002
1003 /* {{{ proto string dba_fetch(string key, [int skip ,] resource handle)
1004 Fetches the data associated with key */
PHP_FUNCTION(dba_fetch)1005 PHP_FUNCTION(dba_fetch)
1006 {
1007 char *val;
1008 int len = 0;
1009 DBA_ID_GET2_3;
1010
1011 if (ac==3) {
1012 if (!strcmp(info->hnd->name, "cdb")) {
1013 if (skip < 0) {
1014 php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Handler %s accepts only skip values greater than or equal to zero, using skip=0", info->hnd->name);
1015 skip = 0;
1016 }
1017 } else if (!strcmp(info->hnd->name, "inifile")) {
1018 /* "-1" is compareable to 0 but allows a non restrictive
1019 * access which is fater. For example 'inifile' uses this
1020 * to allow faster access when the key was already found
1021 * using firstkey/nextkey. However explicitly setting the
1022 * value to 0 ensures the first value.
1023 */
1024 if (skip < -1) {
1025 php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Handler %s accepts only skip value -1 and greater, using skip=0", info->hnd->name);
1026 skip = 0;
1027 }
1028 } else {
1029 php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Handler %s does not support optional skip parameter, the value will be ignored", info->hnd->name);
1030 skip = 0;
1031 }
1032 } else {
1033 skip = 0;
1034 }
1035 if((val = info->hnd->fetch(info, key_str, key_len, skip, &len TSRMLS_CC)) != NULL) {
1036 DBA_ID_DONE;
1037 RETURN_STRINGL(val, len, 0);
1038 }
1039 DBA_ID_DONE;
1040 RETURN_FALSE;
1041 }
1042 /* }}} */
1043
1044 /* {{{ proto array|false dba_key_split(string key)
1045 Splits an inifile key into an array of the form array(0=>group,1=>value_name) but returns false if input is false or null */
PHP_FUNCTION(dba_key_split)1046 PHP_FUNCTION(dba_key_split)
1047 {
1048 zval *zkey;
1049 char *key, *name;
1050 int key_len;
1051
1052 if (ZEND_NUM_ARGS() != 1) {
1053 WRONG_PARAM_COUNT;
1054 }
1055 if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "z", &zkey) == SUCCESS) {
1056 if (Z_TYPE_P(zkey) == IS_NULL || (Z_TYPE_P(zkey) == IS_BOOL && !Z_LVAL_P(zkey))) {
1057 RETURN_BOOL(0);
1058 }
1059 }
1060 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key, &key_len) == FAILURE) {
1061 RETURN_BOOL(0);
1062 }
1063 array_init(return_value);
1064 if (key[0] == '[' && (name = strchr(key, ']')) != NULL) {
1065 add_next_index_stringl(return_value, key+1, name - (key + 1), 1);
1066 add_next_index_stringl(return_value, name+1, key_len - (name - key + 1), 1);
1067 } else {
1068 add_next_index_stringl(return_value, "", 0, 1);
1069 add_next_index_stringl(return_value, key, key_len, 1);
1070 }
1071 }
1072 /* }}} */
1073
1074 /* {{{ proto string dba_firstkey(resource handle)
1075 Resets the internal key pointer and returns the first key */
PHP_FUNCTION(dba_firstkey)1076 PHP_FUNCTION(dba_firstkey)
1077 {
1078 char *fkey;
1079 int len;
1080 zval *id;
1081 dba_info *info = NULL;
1082
1083 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &id) == FAILURE) {
1084 return;
1085 }
1086
1087 DBA_FETCH_RESOURCE(info, &id);
1088
1089 fkey = info->hnd->firstkey(info, &len TSRMLS_CC);
1090
1091 if (fkey)
1092 RETURN_STRINGL(fkey, len, 0);
1093
1094 RETURN_FALSE;
1095 }
1096 /* }}} */
1097
1098 /* {{{ proto string dba_nextkey(resource handle)
1099 Returns the next key */
PHP_FUNCTION(dba_nextkey)1100 PHP_FUNCTION(dba_nextkey)
1101 {
1102 char *nkey;
1103 int len;
1104 zval *id;
1105 dba_info *info = NULL;
1106
1107 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &id) == FAILURE) {
1108 return;
1109 }
1110
1111 DBA_FETCH_RESOURCE(info, &id);
1112
1113 nkey = info->hnd->nextkey(info, &len TSRMLS_CC);
1114
1115 if (nkey)
1116 RETURN_STRINGL(nkey, len, 0);
1117
1118 RETURN_FALSE;
1119 }
1120 /* }}} */
1121
1122 /* {{{ proto bool dba_delete(string key, resource handle)
1123 Deletes the entry associated with key
1124 If inifile: remove all other key lines */
PHP_FUNCTION(dba_delete)1125 PHP_FUNCTION(dba_delete)
1126 {
1127 DBA_ID_GET2;
1128
1129 DBA_WRITE_CHECK_WITH_ID;
1130
1131 if(info->hnd->delete(info, key_str, key_len TSRMLS_CC) == SUCCESS)
1132 {
1133 DBA_ID_DONE;
1134 RETURN_TRUE;
1135 }
1136 DBA_ID_DONE;
1137 RETURN_FALSE;
1138 }
1139 /* }}} */
1140
1141 /* {{{ proto bool dba_insert(string key, string value, resource handle)
1142 If not inifile: Insert value as key, return false, if key exists already
1143 If inifile: Add vakue as key (next instance of key) */
PHP_FUNCTION(dba_insert)1144 PHP_FUNCTION(dba_insert)
1145 {
1146 php_dba_update(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
1147 }
1148 /* }}} */
1149
1150 /* {{{ proto bool dba_replace(string key, string value, resource handle)
1151 Inserts value as key, replaces key, if key exists already
1152 If inifile: remove all other key lines */
PHP_FUNCTION(dba_replace)1153 PHP_FUNCTION(dba_replace)
1154 {
1155 php_dba_update(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
1156 }
1157 /* }}} */
1158
1159 /* {{{ proto bool dba_optimize(resource handle)
1160 Optimizes (e.g. clean up, vacuum) database */
PHP_FUNCTION(dba_optimize)1161 PHP_FUNCTION(dba_optimize)
1162 {
1163 zval *id;
1164 dba_info *info = NULL;
1165
1166 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &id) == FAILURE) {
1167 return;
1168 }
1169
1170 DBA_FETCH_RESOURCE(info, &id);
1171
1172 DBA_WRITE_CHECK;
1173
1174 if (info->hnd->optimize(info TSRMLS_CC) == SUCCESS) {
1175 RETURN_TRUE;
1176 }
1177
1178 RETURN_FALSE;
1179 }
1180 /* }}} */
1181
1182 /* {{{ proto bool dba_sync(resource handle)
1183 Synchronizes database */
PHP_FUNCTION(dba_sync)1184 PHP_FUNCTION(dba_sync)
1185 {
1186 zval *id;
1187 dba_info *info = NULL;
1188
1189 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &id) == FAILURE) {
1190 return;
1191 }
1192
1193 DBA_FETCH_RESOURCE(info, &id);
1194
1195 if (info->hnd->sync(info TSRMLS_CC) == SUCCESS) {
1196 RETURN_TRUE;
1197 }
1198
1199 RETURN_FALSE;
1200 }
1201 /* }}} */
1202
1203 /* {{{ proto array dba_handlers([bool full_info])
1204 List configured database handlers */
PHP_FUNCTION(dba_handlers)1205 PHP_FUNCTION(dba_handlers)
1206 {
1207 dba_handler *hptr;
1208 zend_bool full_info = 0;
1209
1210 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &full_info) == FAILURE) {
1211 RETURN_FALSE;
1212 }
1213
1214 array_init(return_value);
1215
1216 for(hptr = handler; hptr->name; hptr++) {
1217 if (full_info) {
1218 add_assoc_string(return_value, hptr->name, hptr->info(hptr, NULL TSRMLS_CC), 0);
1219 } else {
1220 add_next_index_string(return_value, hptr->name, 1);
1221 }
1222 }
1223 }
1224 /* }}} */
1225
1226 /* {{{ proto array dba_list()
1227 List opened databases */
PHP_FUNCTION(dba_list)1228 PHP_FUNCTION(dba_list)
1229 {
1230 ulong numitems, i;
1231 zend_rsrc_list_entry *le;
1232 dba_info *info;
1233
1234 if (zend_parse_parameters_none() == FAILURE) {
1235 RETURN_FALSE;
1236 }
1237
1238 array_init(return_value);
1239
1240 numitems = zend_hash_next_free_element(&EG(regular_list));
1241 for (i=1; i<numitems; i++) {
1242 if (zend_hash_index_find(&EG(regular_list), i, (void **) &le)==FAILURE) {
1243 continue;
1244 }
1245 if (Z_TYPE_P(le) == le_db || Z_TYPE_P(le) == le_pdb) {
1246 info = (dba_info *)(le->ptr);
1247 add_index_string(return_value, i, info->path, 1);
1248 }
1249 }
1250 }
1251 /* }}} */
1252
1253 #endif /* HAVE_DBA */
1254
1255 /*
1256 * Local variables:
1257 * tab-width: 4
1258 * c-basic-offset: 4
1259 * End:
1260 * vim600: sw=4 ts=4 fdm=marker
1261 * vim<600: sw=4 ts=4
1262 */
1263
