1/*
2  +----------------------------------------------------------------------+
3  | PHP Version 5                                                        |
4  +----------------------------------------------------------------------+
5  | Copyright (c) 1997-2013 The PHP Group                                |
6  +----------------------------------------------------------------------+
7  | This source file is subject to version 3.01 of the PHP license,      |
8  | that is bundled with this package in the file LICENSE, and is        |
9  | available through the world-wide-web at the following url:           |
10  | http://www.php.net/license/3_01.txt                                  |
11  | If you did not receive a copy of the PHP license and are unable to   |
12  | obtain it through the world-wide-web, please send a note to          |
13  | license@php.net so we can mail you a copy immediately.               |
14  +----------------------------------------------------------------------+
15  | Author: Wez Furlong <wez@php.net>                                    |
16  |         Marcus Boerger <helly@php.net>                               |
17  |         Sterling Hughes <sterling@php.net>                           |
18  +----------------------------------------------------------------------+
19*/
20
21/* $Id$ */
22
23/* The PDO Database Handle Class */
24
25#ifdef HAVE_CONFIG_H
26#include "config.h"
27#endif
28
29#include "php.h"
30#include "php_ini.h"
31#include "ext/standard/info.h"
32#include "php_pdo.h"
33#include "php_pdo_driver.h"
34#include "php_pdo_int.h"
35#include "zend_exceptions.h"
36#include "zend_object_handlers.h"
37#include "zend_hash.h"
38
39static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, long attr, zval *value TSRMLS_DC);
40
41void pdo_raise_impl_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, const char *sqlstate, const char *supp TSRMLS_DC) /* {{{ */
42{
43    pdo_error_type *pdo_err = &dbh->error_code;
44    char *message = NULL;
45    const char *msg;
46
47    if (dbh && dbh->error_mode == PDO_ERRMODE_SILENT) {
48#if 0
49        /* BUG: if user is running in silent mode and hits an error at the driver level
50         * when they use the PDO methods to call up the error information, they may
51         * get bogus information */
52        return;
53#endif
54    }
55
56    if (stmt) {
57        pdo_err = &stmt->error_code;
58    }
59
60    strncpy(*pdo_err, sqlstate, 6);
61
62    /* hash sqlstate to error messages */
63    msg = pdo_sqlstate_state_to_description(*pdo_err);
64    if (!msg) {
65        msg = "<<Unknown error>>";
66    }
67
68    if (supp) {
69        spprintf(&message, 0, "SQLSTATE[%s]: %s: %s", *pdo_err, msg, supp);
70    } else {
71        spprintf(&message, 0, "SQLSTATE[%s]: %s", *pdo_err, msg);
72    }
73
74    if (dbh && dbh->error_mode != PDO_ERRMODE_EXCEPTION) {
75        php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", message);
76    } else {
77        zval *ex, *info;
78        zend_class_entry *def_ex = php_pdo_get_exception_base(1 TSRMLS_CC), *pdo_ex = php_pdo_get_exception();
79
80        MAKE_STD_ZVAL(ex);
81        object_init_ex(ex, pdo_ex);
82
83        zend_update_property_string(def_ex, ex, "message", sizeof("message")-1, message TSRMLS_CC);
84        zend_update_property_string(def_ex, ex, "code", sizeof("code")-1, *pdo_err TSRMLS_CC);
85
86        MAKE_STD_ZVAL(info);
87        array_init(info);
88
89        add_next_index_string(info, *pdo_err, 1);
90        add_next_index_long(info, 0);
91
92        zend_update_property(pdo_ex, ex, "errorInfo", sizeof("errorInfo")-1, info TSRMLS_CC);
93        zval_ptr_dtor(&info);
94
95        zend_throw_exception_object(ex TSRMLS_CC);
96    }
97
98    if (message) {
99        efree(message);
100    }
101}
102/* }}} */
103
104void pdo_handle_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
105{
106    pdo_error_type *pdo_err = &dbh->error_code;
107    const char *msg = "<<Unknown>>";
108    char *supp = NULL;
109    long native_code = 0;
110    char *message = NULL;
111    zval *info = NULL;
112
113    if (dbh == NULL || dbh->error_mode == PDO_ERRMODE_SILENT) {
114        return;
115    }
116
117    if (stmt) {
118        pdo_err = &stmt->error_code;
119    }
120
121    /* hash sqlstate to error messages */
122    msg = pdo_sqlstate_state_to_description(*pdo_err);
123    if (!msg) {
124        msg = "<<Unknown error>>";
125    }
126
127    if (dbh->methods->fetch_err) {
128        MAKE_STD_ZVAL(info);
129        array_init(info);
130
131        add_next_index_string(info, *pdo_err, 1);
132
133        if (dbh->methods->fetch_err(dbh, stmt, info TSRMLS_CC)) {
134            zval **item;
135
136            if (SUCCESS == zend_hash_index_find(Z_ARRVAL_P(info), 1, (void**)&item)) {
137                native_code = Z_LVAL_PP(item);
138            }
139
140            if (SUCCESS == zend_hash_index_find(Z_ARRVAL_P(info), 2, (void**)&item)) {
141                supp = estrndup(Z_STRVAL_PP(item), Z_STRLEN_PP(item));
142            }
143        }
144    }
145
146    if (supp) {
147        spprintf(&message, 0, "SQLSTATE[%s]: %s: %ld %s", *pdo_err, msg, native_code, supp);
148    } else {
149        spprintf(&message, 0, "SQLSTATE[%s]: %s", *pdo_err, msg);
150    }
151
152    if (dbh->error_mode == PDO_ERRMODE_WARNING) {
153        php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", message);
154    } else if (EG(exception) == NULL) {
155        zval *ex;
156        zend_class_entry *def_ex = php_pdo_get_exception_base(1 TSRMLS_CC), *pdo_ex = php_pdo_get_exception();
157
158        MAKE_STD_ZVAL(ex);
159        object_init_ex(ex, pdo_ex);
160
161        zend_update_property_string(def_ex, ex, "message", sizeof("message")-1, message TSRMLS_CC);
162        zend_update_property_string(def_ex, ex, "code", sizeof("code")-1, *pdo_err TSRMLS_CC);
163
164        if (info) {
165            zend_update_property(pdo_ex, ex, "errorInfo", sizeof("errorInfo")-1, info TSRMLS_CC);
166        }
167
168        zend_throw_exception_object(ex TSRMLS_CC);
169    }
170
171    if (info) {
172        zval_ptr_dtor(&info);
173    }
174
175    if (message) {
176        efree(message);
177    }
178
179    if (supp) {
180        efree(supp);
181    }
182}
183/* }}} */
184
185static char *dsn_from_uri(char *uri, char *buf, size_t buflen TSRMLS_DC) /* {{{ */
186{
187    php_stream *stream;
188    char *dsn = NULL;
189
190    stream = php_stream_open_wrapper(uri, "rb", ENFORCE_SAFE_MODE|REPORT_ERRORS, NULL);
191    if (stream) {
192        dsn = php_stream_get_line(stream, buf, buflen, NULL);
193        php_stream_close(stream);
194    }
195    return dsn;
196}
197/* }}} */
198
199/* {{{ proto void PDO::__construct(string dsn, string username, string passwd [, array options])
200   */
201static PHP_METHOD(PDO, dbh_constructor)
202{
203    zval *object = getThis();
204    pdo_dbh_t *dbh = NULL;
205    zend_bool is_persistent = FALSE;
206    char *data_source;
207    int data_source_len;
208    char *colon;
209    char *username=NULL, *password=NULL;
210    int usernamelen, passwordlen;
211    pdo_driver_t *driver = NULL;
212    zval *options = NULL;
213    char alt_dsn[512];
214    int call_factory = 1;
215
216    if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s!s!a!", &data_source, &data_source_len,
217                &username, &usernamelen, &password, &passwordlen, &options)) {
218        ZVAL_NULL(object);
219        return;
220    }
221
222    /* parse the data source name */
223    colon = strchr(data_source, ':');
224
225    if (!colon) {
226        /* let's see if this string has a matching dsn in the php.ini */
227        char *ini_dsn = NULL;
228
229        snprintf(alt_dsn, sizeof(alt_dsn), "pdo.dsn.%s", data_source);
230        if (FAILURE == cfg_get_string(alt_dsn, &ini_dsn)) {
231            zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "invalid data source name");
232            ZVAL_NULL(object);
233            return;
234        }
235
236        data_source = ini_dsn;
237        colon = strchr(data_source, ':');
238
239        if (!colon) {
240            zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "invalid data source name (via INI: %s)", alt_dsn);
241            ZVAL_NULL(object);
242            return;
243        }
244    }
245
246    if (!strncmp(data_source, "uri:", sizeof("uri:")-1)) {
247        /* the specified URI holds connection details */
248        data_source = dsn_from_uri(data_source + sizeof("uri:")-1, alt_dsn, sizeof(alt_dsn) TSRMLS_CC);
249        if (!data_source) {
250            zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "invalid data source URI");
251            ZVAL_NULL(object);
252            return;
253        }
254        colon = strchr(data_source, ':');
255        if (!colon) {
256            zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "invalid data source name (via URI)");
257            ZVAL_NULL(object);
258            return;
259        }
260    }
261
262    driver = pdo_find_driver(data_source, colon - data_source);
263
264    if (!driver) {
265        /* NB: don't want to include the data_source in the error message as
266         * it might contain a password */
267        zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "could not find driver");
268        ZVAL_NULL(object);
269        return;
270    }
271
272    dbh = (pdo_dbh_t *) zend_object_store_get_object(object TSRMLS_CC);
273
274    /* is this supposed to be a persistent connection ? */
275    if (options) {
276        zval **v;
277        int plen = 0;
278        char *hashkey = NULL;
279        zend_rsrc_list_entry *le;
280        pdo_dbh_t *pdbh = NULL;
281
282        if (SUCCESS == zend_hash_index_find(Z_ARRVAL_P(options), PDO_ATTR_PERSISTENT, (void**)&v)) {
283            if (Z_TYPE_PP(v) == IS_STRING && !is_numeric_string(Z_STRVAL_PP(v), Z_STRLEN_PP(v), NULL, NULL, 0) && Z_STRLEN_PP(v) > 0) {
284                /* user specified key */
285                plen = spprintf(&hashkey, 0, "PDO:DBH:DSN=%s:%s:%s:%s", data_source,
286                        username ? username : "",
287                        password ? password : "",
288                        Z_STRVAL_PP(v));
289                is_persistent = 1;
290            } else {
291                convert_to_long_ex(v);
292                is_persistent = Z_LVAL_PP(v) ? 1 : 0;
293                plen = spprintf(&hashkey, 0, "PDO:DBH:DSN=%s:%s:%s", data_source,
294                        username ? username : "",
295                        password ? password : "");
296            }
297        }
298
299        if (is_persistent) {
300            /* let's see if we have one cached.... */
301            if (SUCCESS == zend_hash_find(&EG(persistent_list), hashkey, plen+1, (void*)&le)) {
302                if (Z_TYPE_P(le) == php_pdo_list_entry()) {
303                    pdbh = (pdo_dbh_t*)le->ptr;
304
305                    /* is the connection still alive ? */
306                    if (pdbh->methods->check_liveness && FAILURE == (pdbh->methods->check_liveness)(pdbh TSRMLS_CC)) {
307                        /* nope... need to kill it */
308                        pdbh = NULL;
309                    }
310                }
311            }
312
313            if (pdbh) {
314                call_factory = 0;
315            } else {
316                /* need a brand new pdbh */
317                pdbh = pecalloc(1, sizeof(*pdbh), 1);
318
319                if (!pdbh) {
320                    php_error_docref(NULL TSRMLS_CC, E_ERROR, "out of memory while allocating PDO handle");
321                    /* NOTREACHED */
322                }
323
324                pdbh->is_persistent = 1;
325                if (!(pdbh->persistent_id = pemalloc(plen + 1, 1))) {
326                    php_error_docref(NULL TSRMLS_CC, E_ERROR, "out of memory while allocating PDO handle");
327                }
328                memcpy((char *)pdbh->persistent_id, hashkey, plen+1);
329                pdbh->persistent_id_len = plen+1;
330                pdbh->refcount = 1;
331                pdbh->properties = NULL;
332            }
333        }
334
335        if (pdbh) {
336            /* let's copy the emalloc bits over from the other handle */
337            if (pdbh->properties) {
338                zend_hash_destroy(dbh->properties);
339                efree(dbh->properties);
340            } else {
341                pdbh->ce = dbh->ce;
342                pdbh->def_stmt_ce = dbh->def_stmt_ce;
343                pdbh->def_stmt_ctor_args = dbh->def_stmt_ctor_args;
344                pdbh->properties = dbh->properties;
345            }
346            /* kill the non-persistent thingamy */
347            efree(dbh);
348            /* switch over to the persistent one */
349            dbh = pdbh;
350            zend_object_store_set_object(object, dbh TSRMLS_CC);
351            dbh->refcount++;
352        }
353
354        if (hashkey) {
355            efree(hashkey);
356        }
357    }
358
359    if (call_factory) {
360        dbh->data_source_len = strlen(colon + 1);
361        dbh->data_source = (const char*)pestrdup(colon + 1, is_persistent);
362        dbh->username = username ? pestrdup(username, is_persistent) : NULL;
363        dbh->password = password ? pestrdup(password, is_persistent) : NULL;
364        dbh->default_fetch_type = PDO_FETCH_BOTH;
365    }
366
367    dbh->auto_commit = pdo_attr_lval(options, PDO_ATTR_AUTOCOMMIT, 1 TSRMLS_CC);
368
369    if (!dbh->data_source || (username && !dbh->username) || (password && !dbh->password)) {
370        php_error_docref(NULL TSRMLS_CC, E_ERROR, "out of memory");
371    }
372
373    if (!call_factory) {
374        /* we got a persistent guy from our cache */
375        goto options;
376    }
377
378    if (driver->db_handle_factory(dbh, options TSRMLS_CC)) {
379        /* all set */
380
381        if (is_persistent) {
382            zend_rsrc_list_entry le;
383
384            /* register in the persistent list etc. */
385            /* we should also need to replace the object store entry,
386               since it was created with emalloc */
387
388            le.type = php_pdo_list_entry();
389            le.ptr = dbh;
390
391            if (FAILURE == zend_hash_update(&EG(persistent_list),
392                    (char*)dbh->persistent_id, dbh->persistent_id_len, (void*)&le,
393                    sizeof(le), NULL)) {
394                php_error_docref(NULL TSRMLS_CC, E_ERROR, "Failed to register persistent entry");
395            }
396        }
397
398        dbh->driver = driver;
399options:
400        if (options) {
401            zval **attr_value;
402            char *str_key;
403            long long_key;
404
405            zend_hash_internal_pointer_reset(Z_ARRVAL_P(options));
406            while (SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(options), (void**)&attr_value)
407                && HASH_KEY_IS_LONG == zend_hash_get_current_key(Z_ARRVAL_P(options), &str_key, &long_key, 0)) {
408
409                pdo_dbh_attribute_set(dbh, long_key, *attr_value TSRMLS_CC);
410                zend_hash_move_forward(Z_ARRVAL_P(options));
411            }
412        }
413
414        return;
415    }
416
417    /* the connection failed; things will tidy up in free_storage */
418    /* XXX raise exception */
419    ZVAL_NULL(object);
420}
421/* }}} */
422
423static zval *pdo_stmt_instantiate(pdo_dbh_t *dbh, zval *object, zend_class_entry *dbstmt_ce, zval *ctor_args TSRMLS_DC) /* {{{ */
424{
425    if (ctor_args) {
426        if (Z_TYPE_P(ctor_args) != IS_ARRAY) {
427            pdo_raise_impl_error(dbh, NULL, "HY000", "constructor arguments must be passed as an array" TSRMLS_CC);
428            return NULL;
429        }
430        if (!dbstmt_ce->constructor) {
431            pdo_raise_impl_error(dbh, NULL, "HY000", "user-supplied statement does not accept constructor arguments" TSRMLS_CC);
432            return NULL;
433        }
434    }
435
436    Z_TYPE_P(object) = IS_OBJECT;
437    object_init_ex(object, dbstmt_ce);
438    Z_SET_REFCOUNT_P(object, 1);
439    Z_SET_ISREF_P(object);
440
441    return object;
442} /* }}} */
443
444static void pdo_stmt_construct(pdo_stmt_t *stmt, zval *object, zend_class_entry *dbstmt_ce, zval *ctor_args TSRMLS_DC) /* {{{ */
445{
446    zval *query_string;
447    zval z_key;
448
449    MAKE_STD_ZVAL(query_string);
450    ZVAL_STRINGL(query_string, stmt->query_string, stmt->query_stringlen, 1);
451    ZVAL_STRINGL(&z_key, "queryString", sizeof("queryString")-1, 0);
452    std_object_handlers.write_property(object, &z_key, query_string TSRMLS_CC);
453    zval_ptr_dtor(&query_string);
454
455    if (dbstmt_ce->constructor) {
456        zend_fcall_info fci;
457        zend_fcall_info_cache fcc;
458        zval *retval;
459
460        fci.size = sizeof(zend_fcall_info);
461        fci.function_table = &dbstmt_ce->function_table;
462        fci.function_name = NULL;
463        fci.object_ptr = object;
464        fci.symbol_table = NULL;
465        fci.retval_ptr_ptr = &retval;
466        if (ctor_args) {
467            HashTable *ht = Z_ARRVAL_P(ctor_args);
468            Bucket *p;
469
470            fci.param_count = 0;
471            fci.params = safe_emalloc(sizeof(zval*), ht->nNumOfElements, 0);
472            p = ht->pListHead;
473            while (p != NULL) {
474                fci.params[fci.param_count++] = (zval**)p->pData;
475                p = p->pListNext;
476            }
477        } else {
478            fci.param_count = 0;
479            fci.params = NULL;
480        }
481        fci.no_separation = 1;
482
483        fcc.initialized = 1;
484        fcc.function_handler = dbstmt_ce->constructor;
485        fcc.calling_scope = EG(scope);
486        fcc.called_scope = Z_OBJCE_P(object);
487        fcc.object_ptr = object;
488
489        if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
490            zval_dtor(object);
491            ZVAL_NULL(object);
492            object = NULL; /* marks failure */
493        } else {
494            zval_ptr_dtor(&retval);
495        }
496
497        if (fci.params) {
498            efree(fci.params);
499        }
500    }
501}
502/* }}} */
503
504/* {{{ proto object PDO::prepare(string statment [, array options])
505   Prepares a statement for execution and returns a statement object */
506static PHP_METHOD(PDO, prepare)
507{
508    pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
509    pdo_stmt_t *stmt;
510    char *statement;
511    int statement_len;
512    zval *options = NULL, **opt, **item, *ctor_args;
513    zend_class_entry *dbstmt_ce, **pce;
514
515    if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a", &statement,
516            &statement_len, &options)) {
517        RETURN_FALSE;
518    }
519
520    PDO_DBH_CLEAR_ERR();
521    PDO_CONSTRUCT_CHECK;
522
523    if (ZEND_NUM_ARGS() > 1 && SUCCESS == zend_hash_index_find(Z_ARRVAL_P(options), PDO_ATTR_STATEMENT_CLASS, (void**)&opt)) {
524        if (Z_TYPE_PP(opt) != IS_ARRAY || zend_hash_index_find(Z_ARRVAL_PP(opt), 0, (void**)&item) == FAILURE
525            || Z_TYPE_PP(item) != IS_STRING
526            || zend_lookup_class(Z_STRVAL_PP(item), Z_STRLEN_PP(item), &pce TSRMLS_CC) == FAILURE
527        ) {
528            pdo_raise_impl_error(dbh, NULL, "HY000",
529                "PDO::ATTR_STATEMENT_CLASS requires format array(classname, array(ctor_args)); "
530                "the classname must be a string specifying an existing class"
531                TSRMLS_CC);
532            PDO_HANDLE_DBH_ERR();
533            RETURN_FALSE;
534        }
535        dbstmt_ce = *pce;
536        if (!instanceof_function(dbstmt_ce, pdo_dbstmt_ce TSRMLS_CC)) {
537            pdo_raise_impl_error(dbh, NULL, "HY000",
538                "user-supplied statement class must be derived from PDOStatement" TSRMLS_CC);
539            PDO_HANDLE_DBH_ERR();
540            RETURN_FALSE;
541        }
542        if (dbstmt_ce->constructor && !(dbstmt_ce->constructor->common.fn_flags & (ZEND_ACC_PRIVATE|ZEND_ACC_PROTECTED))) {
543            pdo_raise_impl_error(dbh, NULL, "HY000",
544                "user-supplied statement class cannot have a public constructor" TSRMLS_CC);
545            PDO_HANDLE_DBH_ERR();
546            RETURN_FALSE;
547        }
548        if (zend_hash_index_find(Z_ARRVAL_PP(opt), 1, (void**)&item) == SUCCESS) {
549            if (Z_TYPE_PP(item) != IS_ARRAY) {
550                pdo_raise_impl_error(dbh, NULL, "HY000",
551                    "PDO::ATTR_STATEMENT_CLASS requires format array(classname, ctor_args); "
552                    "ctor_args must be an array"
553                TSRMLS_CC);
554                PDO_HANDLE_DBH_ERR();
555                RETURN_FALSE;
556            }
557            ctor_args = *item;
558        } else {
559            ctor_args = NULL;
560        }
561    } else {
562        dbstmt_ce = dbh->def_stmt_ce;
563        ctor_args = dbh->def_stmt_ctor_args;
564    }
565
566    if (!pdo_stmt_instantiate(dbh, return_value, dbstmt_ce, ctor_args TSRMLS_CC)) {
567        pdo_raise_impl_error(dbh, NULL, "HY000",
568            "failed to instantiate user-supplied statement class"
569            TSRMLS_CC);
570        PDO_HANDLE_DBH_ERR();
571        RETURN_FALSE;
572    }
573    stmt = (pdo_stmt_t*)zend_object_store_get_object(return_value TSRMLS_CC);
574
575    /* unconditionally keep this for later reference */
576    stmt->query_string = estrndup(statement, statement_len);
577    stmt->query_stringlen = statement_len;
578    stmt->default_fetch_type = dbh->default_fetch_type;
579    stmt->dbh = dbh;
580    /* give it a reference to me */
581    zend_objects_store_add_ref(getThis() TSRMLS_CC);
582    php_pdo_dbh_addref(dbh TSRMLS_CC);
583    stmt->database_object_handle = *getThis();
584    /* we haven't created a lazy object yet */
585    ZVAL_NULL(&stmt->lazy_object_ref);
586
587    if (dbh->methods->preparer(dbh, statement, statement_len, stmt, options TSRMLS_CC)) {
588        pdo_stmt_construct(stmt, return_value, dbstmt_ce, ctor_args TSRMLS_CC);
589        return;
590    }
591
592    PDO_HANDLE_DBH_ERR();
593
594    /* kill the object handle for the stmt here */
595    zval_dtor(return_value);
596
597    RETURN_FALSE;
598}
599/* }}} */
600
601/* {{{ proto bool PDO::beginTransaction()
602   Initiates a transaction */
603static PHP_METHOD(PDO, beginTransaction)
604{
605    pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
606
607    if (zend_parse_parameters_none() == FAILURE) {
608        return;
609    }
610    PDO_CONSTRUCT_CHECK;
611
612    if (dbh->in_txn) {
613        zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "There is already an active transaction");
614        RETURN_FALSE;
615    }
616
617    if (!dbh->methods->begin) {
618        /* TODO: this should be an exception; see the auto-commit mode
619         * comments below */
620        zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "This driver doesn't support transactions");
621        RETURN_FALSE;
622    }
623
624    if (dbh->methods->begin(dbh TSRMLS_CC)) {
625        dbh->in_txn = 1;
626        RETURN_TRUE;
627    }
628
629    PDO_HANDLE_DBH_ERR();
630    RETURN_FALSE;
631}
632/* }}} */
633
634/* {{{ proto bool PDO::commit()
635   Commit a transaction */
636static PHP_METHOD(PDO, commit)
637{
638    pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
639
640    if (zend_parse_parameters_none() == FAILURE) {
641        return;
642    }
643    PDO_CONSTRUCT_CHECK;
644
645    if (!dbh->in_txn) {
646        zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "There is no active transaction");
647        RETURN_FALSE;
648    }
649
650    if (dbh->methods->commit(dbh TSRMLS_CC)) {
651        dbh->in_txn = 0;
652        RETURN_TRUE;
653    }
654
655    PDO_HANDLE_DBH_ERR();
656    RETURN_FALSE;
657}
658/* }}} */
659
660/* {{{ proto bool PDO::rollBack()
661   roll back a transaction */
662static PHP_METHOD(PDO, rollBack)
663{
664    pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
665
666    if (zend_parse_parameters_none() == FAILURE) {
667        return;
668    }
669    PDO_CONSTRUCT_CHECK;
670
671    if (!dbh->in_txn) {
672        zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "There is no active transaction");
673        RETURN_FALSE;
674    }
675
676    if (dbh->methods->rollback(dbh TSRMLS_CC)) {
677        dbh->in_txn = 0;
678        RETURN_TRUE;
679    }
680
681    PDO_HANDLE_DBH_ERR();
682    RETURN_FALSE;
683}
684/* }}} */
685
686/* {{{ proto bool PDO::inTransaction()
687   determine if inside a transaction */
688static PHP_METHOD(PDO, inTransaction)
689{
690    pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
691
692    if (zend_parse_parameters_none() == FAILURE) {
693        return;
694    }
695    PDO_CONSTRUCT_CHECK;
696
697    RETURN_BOOL(dbh->in_txn);
698}
699/* }}} */
700
701static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, long attr, zval *value TSRMLS_DC) /* {{{ */
702{
703
704#define PDO_LONG_PARAM_CHECK \
705    if (Z_TYPE_P(value) != IS_LONG && Z_TYPE_P(value) != IS_STRING && Z_TYPE_P(value) != IS_BOOL) { \
706        pdo_raise_impl_error(dbh, NULL, "HY000", "attribute value must be an integer" TSRMLS_CC); \
707        PDO_HANDLE_DBH_ERR(); \
708        return FAILURE; \
709    } \
710
711    switch (attr) {
712        case PDO_ATTR_ERRMODE:
713            PDO_LONG_PARAM_CHECK;
714            convert_to_long(value);
715            switch (Z_LVAL_P(value)) {
716                case PDO_ERRMODE_SILENT:
717                case PDO_ERRMODE_WARNING:
718                case PDO_ERRMODE_EXCEPTION:
719                    dbh->error_mode = Z_LVAL_P(value);
720                    return SUCCESS;
721                default:
722                    pdo_raise_impl_error(dbh, NULL, "HY000", "invalid error mode" TSRMLS_CC);
723                    PDO_HANDLE_DBH_ERR();
724                    return FAILURE;
725            }
726            return FAILURE;
727
728        case PDO_ATTR_CASE:
729            PDO_LONG_PARAM_CHECK;
730            convert_to_long(value);
731            switch (Z_LVAL_P(value)) {
732                case PDO_CASE_NATURAL:
733                case PDO_CASE_UPPER:
734                case PDO_CASE_LOWER:
735                    dbh->desired_case = Z_LVAL_P(value);
736                    return SUCCESS;
737                default:
738                    pdo_raise_impl_error(dbh, NULL, "HY000", "invalid case folding mode" TSRMLS_CC);
739                    PDO_HANDLE_DBH_ERR();
740                    return FAILURE;
741            }
742            return FAILURE;
743
744        case PDO_ATTR_ORACLE_NULLS:
745            PDO_LONG_PARAM_CHECK;
746            convert_to_long(value);
747            dbh->oracle_nulls = Z_LVAL_P(value);
748            return SUCCESS;
749
750        case PDO_ATTR_DEFAULT_FETCH_MODE:
751            if (Z_TYPE_P(value) == IS_ARRAY) {
752                zval **tmp;
753                if (zend_hash_index_find(Z_ARRVAL_P(value), 0, (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG) {
754                    if (Z_LVAL_PP(tmp) == PDO_FETCH_INTO || Z_LVAL_PP(tmp) == PDO_FETCH_CLASS) {
755                        pdo_raise_impl_error(dbh, NULL, "HY000", "FETCH_INTO and FETCH_CLASS are not yet supported as default fetch modes" TSRMLS_CC);
756                        return FAILURE;
757                    }
758                }
759            } else {
760                PDO_LONG_PARAM_CHECK;
761            }
762            convert_to_long(value);
763            if (Z_LVAL_P(value) == PDO_FETCH_USE_DEFAULT) {
764                pdo_raise_impl_error(dbh, NULL, "HY000", "invalid fetch mode type" TSRMLS_CC);
765                return FAILURE;
766            }
767            dbh->default_fetch_type = Z_LVAL_P(value);
768            return SUCCESS;
769
770        case PDO_ATTR_STRINGIFY_FETCHES:
771            PDO_LONG_PARAM_CHECK;
772            convert_to_long(value);
773            dbh->stringify = Z_LVAL_P(value) ? 1 : 0;
774            return SUCCESS;
775
776        case PDO_ATTR_STATEMENT_CLASS: {
777            /* array(string classname, array(mixed ctor_args)) */
778            zend_class_entry **pce;
779            zval **item;
780
781            if (dbh->is_persistent) {
782                pdo_raise_impl_error(dbh, NULL, "HY000",
783                    "PDO::ATTR_STATEMENT_CLASS cannot be used with persistent PDO instances"
784                    TSRMLS_CC);
785                PDO_HANDLE_DBH_ERR();
786                return FAILURE;
787            }
788            if (Z_TYPE_P(value) != IS_ARRAY
789                || zend_hash_index_find(Z_ARRVAL_P(value), 0, (void**)&item) == FAILURE
790                || Z_TYPE_PP(item) != IS_STRING
791                || zend_lookup_class(Z_STRVAL_PP(item), Z_STRLEN_PP(item), &pce TSRMLS_CC) == FAILURE
792            ) {
793                pdo_raise_impl_error(dbh, NULL, "HY000",
794                    "PDO::ATTR_STATEMENT_CLASS requires format array(classname, array(ctor_args)); "
795                    "the classname must be a string specifying an existing class"
796                    TSRMLS_CC);
797                PDO_HANDLE_DBH_ERR();
798                return FAILURE;
799            }
800            if (!instanceof_function(*pce, pdo_dbstmt_ce TSRMLS_CC)) {
801                pdo_raise_impl_error(dbh, NULL, "HY000",
802                    "user-supplied statement class must be derived from PDOStatement" TSRMLS_CC);
803                PDO_HANDLE_DBH_ERR();
804                return FAILURE;
805            }
806            if ((*pce)->constructor && !((*pce)->constructor->common.fn_flags & (ZEND_ACC_PRIVATE|ZEND_ACC_PROTECTED))) {
807                pdo_raise_impl_error(dbh, NULL, "HY000",
808                    "user-supplied statement class cannot have a public constructor" TSRMLS_CC);
809                PDO_HANDLE_DBH_ERR();
810                return FAILURE;
811            }
812            dbh->def_stmt_ce = *pce;
813            if (dbh->def_stmt_ctor_args) {
814                zval_ptr_dtor(&dbh->def_stmt_ctor_args);
815                dbh->def_stmt_ctor_args = NULL;
816            }
817            if (zend_hash_index_find(Z_ARRVAL_P(value), 1, (void**)&item) == SUCCESS) {
818                if (Z_TYPE_PP(item) != IS_ARRAY) {
819                    pdo_raise_impl_error(dbh, NULL, "HY000",
820                        "PDO::ATTR_STATEMENT_CLASS requires format array(classname, array(ctor_args)); "
821                        "ctor_args must be an array"
822                    TSRMLS_CC);
823                    PDO_HANDLE_DBH_ERR();
824                    return FAILURE;
825                }
826                Z_ADDREF_PP(item);
827                dbh->def_stmt_ctor_args = *item;
828            }
829            return SUCCESS;
830        }
831
832        default:
833            ;
834    }
835
836    if (!dbh->methods->set_attribute) {
837        goto fail;
838    }
839
840    PDO_DBH_CLEAR_ERR();
841    if (dbh->methods->set_attribute(dbh, attr, value TSRMLS_CC)) {
842        return SUCCESS;
843    }
844
845fail:
846    if (attr == PDO_ATTR_AUTOCOMMIT) {
847        zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "The auto-commit mode cannot be changed for this driver");
848    } else if (!dbh->methods->set_attribute) {
849        pdo_raise_impl_error(dbh, NULL, "IM001", "driver does not support setting attributes" TSRMLS_CC);
850    } else {
851        PDO_HANDLE_DBH_ERR();
852    }
853    return FAILURE;
854}
855/* }}} */
856
857/* {{{ proto bool PDO::setAttribute(long attribute, mixed value)
858   Set an attribute */
859static PHP_METHOD(PDO, setAttribute)
860{
861    pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
862    long attr;
863    zval *value;
864
865    if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz", &attr, &value)) {
866        RETURN_FALSE;
867    }
868
869    PDO_DBH_CLEAR_ERR();
870    PDO_CONSTRUCT_CHECK;
871
872    if (pdo_dbh_attribute_set(dbh, attr, value TSRMLS_CC) != FAILURE) {
873        RETURN_TRUE;
874    }
875    RETURN_FALSE;
876}
877/* }}} */
878
879/* {{{ proto mixed PDO::getAttribute(long attribute)
880   Get an attribute */
881static PHP_METHOD(PDO, getAttribute)
882{
883    pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
884    long attr;
885
886    if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &attr)) {
887        RETURN_FALSE;
888    }
889
890    PDO_DBH_CLEAR_ERR();
891    PDO_CONSTRUCT_CHECK;
892
893    /* handle generic PDO-level atributes */
894    switch (attr) {
895        case PDO_ATTR_PERSISTENT:
896            RETURN_BOOL(dbh->is_persistent);
897
898        case PDO_ATTR_CASE:
899            RETURN_LONG(dbh->desired_case);
900
901        case PDO_ATTR_ORACLE_NULLS:
902            RETURN_LONG(dbh->oracle_nulls);
903
904        case PDO_ATTR_ERRMODE:
905            RETURN_LONG(dbh->error_mode);
906
907        case PDO_ATTR_DRIVER_NAME:
908            RETURN_STRINGL((char*)dbh->driver->driver_name, dbh->driver->driver_name_len, 1);
909
910        case PDO_ATTR_STATEMENT_CLASS:
911            array_init(return_value);
912            add_next_index_string(return_value, dbh->def_stmt_ce->name, 1);
913            if (dbh->def_stmt_ctor_args) {
914                Z_ADDREF_P(dbh->def_stmt_ctor_args);
915                add_next_index_zval(return_value, dbh->def_stmt_ctor_args);
916            }
917            return;
918        case PDO_ATTR_DEFAULT_FETCH_MODE:
919            RETURN_LONG(dbh->default_fetch_type);
920
921    }
922
923    if (!dbh->methods->get_attribute) {
924        pdo_raise_impl_error(dbh, NULL, "IM001", "driver does not support getting attributes" TSRMLS_CC);
925        RETURN_FALSE;
926    }
927
928    switch (dbh->methods->get_attribute(dbh, attr, return_value TSRMLS_CC)) {
929        case -1:
930            PDO_HANDLE_DBH_ERR();
931            RETURN_FALSE;
932
933        case 0:
934            pdo_raise_impl_error(dbh, NULL, "IM001", "driver does not support that attribute" TSRMLS_CC);
935            RETURN_FALSE;
936
937        default:
938            return;
939    }
940}
941/* }}} */
942
943/* {{{ proto long PDO::exec(string query)
944   Execute a query that does not return a row set, returning the number of affected rows */
945static PHP_METHOD(PDO, exec)
946{
947    pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
948    char *statement;
949    int statement_len;
950    long ret;
951
952    if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &statement, &statement_len)) {
953        RETURN_FALSE;
954    }
955
956    if (!statement_len) {
957        pdo_raise_impl_error(dbh, NULL, "HY000",  "trying to execute an empty query" TSRMLS_CC);
958        RETURN_FALSE;
959    }
960    PDO_DBH_CLEAR_ERR();
961    PDO_CONSTRUCT_CHECK;
962    ret = dbh->methods->doer(dbh, statement, statement_len TSRMLS_CC);
963    if(ret == -1) {
964        PDO_HANDLE_DBH_ERR();
965        RETURN_FALSE;
966    } else {
967        RETURN_LONG(ret);
968    }
969}
970/* }}} */
971
972
973/* {{{ proto string PDO::lastInsertId([string seqname])
974   Returns the id of the last row that we affected on this connection.  Some databases require a sequence or table name to be passed in.  Not always meaningful. */
975static PHP_METHOD(PDO, lastInsertId)
976{
977    pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
978    char *name = NULL;
979    int namelen;
980
981    if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!", &name, &namelen)) {
982        RETURN_FALSE;
983    }
984
985    PDO_DBH_CLEAR_ERR();
986    PDO_CONSTRUCT_CHECK;
987    if (!dbh->methods->last_id) {
988        pdo_raise_impl_error(dbh, NULL, "IM001", "driver does not support lastInsertId()" TSRMLS_CC);
989        RETURN_FALSE;
990    } else {
991        Z_STRVAL_P(return_value) = dbh->methods->last_id(dbh, name, &Z_STRLEN_P(return_value) TSRMLS_CC);
992        if (!Z_STRVAL_P(return_value)) {
993            PDO_HANDLE_DBH_ERR();
994            RETURN_FALSE;
995        } else {
996            Z_TYPE_P(return_value) = IS_STRING;
997        }
998    }
999}
1000/* }}} */
1001
1002/* {{{ proto string PDO::errorCode()
1003   Fetch the error code associated with the last operation on the database handle */
1004static PHP_METHOD(PDO, errorCode)
1005{
1006    pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
1007
1008    if (zend_parse_parameters_none() == FAILURE) {
1009        return;
1010    }
1011    PDO_CONSTRUCT_CHECK;
1012
1013    if (dbh->query_stmt) {
1014        RETURN_STRING(dbh->query_stmt->error_code, 1);
1015    }
1016
1017    if (dbh->error_code[0] == '\0') {
1018        RETURN_NULL();
1019    }
1020
1021    /**
1022     * Making sure that we fallback to the default implementation
1023     * if the dbh->error_code is not null.
1024     */
1025    RETURN_STRING(dbh->error_code, 1);
1026}
1027/* }}} */
1028
1029/* {{{ proto int PDO::errorInfo()
1030   Fetch extended error information associated with the last operation on the database handle */
1031static PHP_METHOD(PDO, errorInfo)
1032{
1033    int error_count;
1034    int error_count_diff     = 0;
1035    int error_expected_count = 3;
1036
1037    pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
1038
1039    if (zend_parse_parameters_none() == FAILURE) {
1040        return;
1041    }
1042
1043    PDO_CONSTRUCT_CHECK;
1044
1045    array_init(return_value);
1046
1047    if (dbh->query_stmt) {
1048        add_next_index_string(return_value, dbh->query_stmt->error_code, 1);
1049    } else {
1050        add_next_index_string(return_value, dbh->error_code, 1);
1051    }
1052
1053    if (dbh->methods->fetch_err) {
1054        dbh->methods->fetch_err(dbh, dbh->query_stmt, return_value TSRMLS_CC);
1055    }
1056
1057    /**
1058     * In order to be consistent, we have to make sure we add the good amount
1059     * of nulls depending on the current number of elements. We make a simple
1060     * difference and add the needed elements
1061     */
1062    error_count = zend_hash_num_elements(Z_ARRVAL_P(return_value));
1063
1064    if (error_expected_count > error_count) {
1065        int current_index;
1066
1067        error_count_diff = error_expected_count - error_count;
1068        for (current_index = 0; current_index < error_count_diff; current_index++) {
1069            add_next_index_null(return_value);
1070        }
1071    }
1072}
1073/* }}} */
1074
1075/* {{{ proto object PDO::query(string sql [, PDOStatement::setFetchMode() args])
1076   Prepare and execute $sql; returns the statement object for iteration */
1077static PHP_METHOD(PDO, query)
1078{
1079    pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
1080    pdo_stmt_t *stmt;
1081    char *statement;
1082    int statement_len;
1083
1084    /* Return a meaningful error when no parameters were passed */
1085    if (!ZEND_NUM_ARGS()) {
1086        zend_parse_parameters(0 TSRMLS_CC, "z|z", NULL, NULL);
1087        RETURN_FALSE;
1088    }
1089
1090    if (FAILURE == zend_parse_parameters(1 TSRMLS_CC, "s", &statement,
1091            &statement_len)) {
1092        RETURN_FALSE;
1093    }
1094
1095    PDO_DBH_CLEAR_ERR();
1096    PDO_CONSTRUCT_CHECK;
1097
1098    if (!pdo_stmt_instantiate(dbh, return_value, dbh->def_stmt_ce, dbh->def_stmt_ctor_args TSRMLS_CC)) {
1099        pdo_raise_impl_error(dbh, NULL, "HY000", "failed to instantiate user supplied statement class" TSRMLS_CC);
1100        return;
1101    }
1102    stmt = (pdo_stmt_t*)zend_object_store_get_object(return_value TSRMLS_CC);
1103
1104    /* unconditionally keep this for later reference */
1105    stmt->query_string = estrndup(statement, statement_len);
1106    stmt->query_stringlen = statement_len;
1107
1108    stmt->default_fetch_type = dbh->default_fetch_type;
1109    stmt->active_query_string = stmt->query_string;
1110    stmt->active_query_stringlen = statement_len;
1111    stmt->dbh = dbh;
1112    /* give it a reference to me */
1113    zend_objects_store_add_ref(getThis() TSRMLS_CC);
1114    php_pdo_dbh_addref(dbh TSRMLS_CC);
1115    stmt->database_object_handle = *getThis();
1116    /* we haven't created a lazy object yet */
1117    ZVAL_NULL(&stmt->lazy_object_ref);
1118
1119    if (dbh->methods->preparer(dbh, statement, statement_len, stmt, NULL TSRMLS_CC)) {
1120        PDO_STMT_CLEAR_ERR();
1121        if (ZEND_NUM_ARGS() == 1 || SUCCESS == pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAM_PASSTHRU, stmt, 1)) {
1122
1123            /* now execute the statement */
1124            PDO_STMT_CLEAR_ERR();
1125            if (stmt->methods->executer(stmt TSRMLS_CC)) {
1126                int ret = 1;
1127                if (!stmt->executed) {
1128                    if (stmt->dbh->alloc_own_columns) {
1129                        ret = pdo_stmt_describe_columns(stmt TSRMLS_CC);
1130                    }
1131                    stmt->executed = 1;
1132                }
1133                if (ret) {
1134                    pdo_stmt_construct(stmt, return_value, dbh->def_stmt_ce, dbh->def_stmt_ctor_args TSRMLS_CC);
1135                    return;
1136                }
1137            }
1138        }
1139        /* something broke */
1140        dbh->query_stmt = stmt;
1141        dbh->query_stmt_zval = *return_value;
1142        PDO_HANDLE_STMT_ERR();
1143    } else {
1144        PDO_HANDLE_DBH_ERR();
1145        zval_dtor(return_value);
1146    }
1147
1148    RETURN_FALSE;
1149}
1150/* }}} */
1151
1152/* {{{ proto string PDO::quote(string string [, int paramtype])
1153   quotes string for use in a query.  The optional paramtype acts as a hint for drivers that have alternate quoting styles.  The default value is PDO_PARAM_STR */
1154static PHP_METHOD(PDO, quote)
1155{
1156    pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
1157    char *str;
1158    int str_len;
1159    long paramtype = PDO_PARAM_STR;
1160    char *qstr;
1161    int qlen;
1162
1163    if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &str, &str_len, &paramtype)) {
1164        RETURN_FALSE;
1165    }
1166
1167    PDO_DBH_CLEAR_ERR();
1168    PDO_CONSTRUCT_CHECK;
1169    if (!dbh->methods->quoter) {
1170        pdo_raise_impl_error(dbh, NULL, "IM001", "driver does not support quoting" TSRMLS_CC);
1171        RETURN_FALSE;
1172    }
1173
1174    if (dbh->methods->quoter(dbh, str, str_len, &qstr, &qlen, paramtype TSRMLS_CC)) {
1175        RETURN_STRINGL(qstr, qlen, 0);
1176    }
1177    PDO_HANDLE_DBH_ERR();
1178    RETURN_FALSE;
1179}
1180/* }}} */
1181
1182/* {{{ proto int PDO::__wakeup()
1183   Prevents use of a PDO instance that has been unserialized */
1184static PHP_METHOD(PDO, __wakeup)
1185{
1186    zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "You cannot serialize or unserialize PDO instances");
1187}
1188/* }}} */
1189
1190/* {{{ proto int PDO::__sleep()
1191   Prevents serialization of a PDO instance */
1192static PHP_METHOD(PDO, __sleep)
1193{
1194    zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "You cannot serialize or unserialize PDO instances");
1195}
1196/* }}} */
1197
1198/* {{{ proto array PDO::getAvailableDrivers()
1199   Return array of available PDO drivers */
1200static PHP_METHOD(PDO, getAvailableDrivers)
1201{
1202    HashPosition pos;
1203    pdo_driver_t **pdriver;
1204
1205    if (zend_parse_parameters_none() == FAILURE) {
1206        return;
1207    }
1208
1209    array_init(return_value);
1210
1211    zend_hash_internal_pointer_reset_ex(&pdo_driver_hash, &pos);
1212    while (SUCCESS == zend_hash_get_current_data_ex(&pdo_driver_hash, (void**)&pdriver, &pos)) {
1213        add_next_index_stringl(return_value, (char*)(*pdriver)->driver_name, (*pdriver)->driver_name_len, 1);
1214        zend_hash_move_forward_ex(&pdo_driver_hash, &pos);
1215    }
1216}
1217/* }}} */
1218
1219/* {{{ arginfo */
1220ZEND_BEGIN_ARG_INFO_EX(arginfo_pdo___construct, 0, 0, 3)
1221    ZEND_ARG_INFO(0, dsn)
1222    ZEND_ARG_INFO(0, username)
1223    ZEND_ARG_INFO(0, passwd)
1224    ZEND_ARG_INFO(0, options) /* array */
1225ZEND_END_ARG_INFO()
1226
1227ZEND_BEGIN_ARG_INFO_EX(arginfo_pdo_prepare, 0, 0, 1)
1228    ZEND_ARG_INFO(0, statment)
1229    ZEND_ARG_INFO(0, options) /* array */
1230ZEND_END_ARG_INFO()
1231
1232ZEND_BEGIN_ARG_INFO(arginfo_pdo_setattribute, 0)
1233    ZEND_ARG_INFO(0, attribute)
1234    ZEND_ARG_INFO(0, value)
1235ZEND_END_ARG_INFO()
1236
1237ZEND_BEGIN_ARG_INFO(arginfo_pdo_getattribute, 0)
1238    ZEND_ARG_INFO(0, attribute)
1239ZEND_END_ARG_INFO()
1240
1241ZEND_BEGIN_ARG_INFO(arginfo_pdo_exec, 0)
1242    ZEND_ARG_INFO(0, query)
1243ZEND_END_ARG_INFO()
1244
1245ZEND_BEGIN_ARG_INFO_EX(arginfo_pdo_lastinsertid, 0, 0, 0)
1246    ZEND_ARG_INFO(0, seqname)
1247ZEND_END_ARG_INFO()
1248
1249ZEND_BEGIN_ARG_INFO_EX(arginfo_pdo_quote, 0, 0, 1)
1250    ZEND_ARG_INFO(0, string)
1251    ZEND_ARG_INFO(0, paramtype)
1252ZEND_END_ARG_INFO()
1253
1254ZEND_BEGIN_ARG_INFO(arginfo_pdo__void, 0)
1255ZEND_END_ARG_INFO()
1256/* }}} */
1257
1258const zend_function_entry pdo_dbh_functions[] = {
1259    ZEND_MALIAS(PDO, __construct, dbh_constructor,  arginfo_pdo___construct,    ZEND_ACC_PUBLIC)
1260    PHP_ME(PDO, prepare,                arginfo_pdo_prepare,        ZEND_ACC_PUBLIC)
1261    PHP_ME(PDO, beginTransaction,       arginfo_pdo__void,         ZEND_ACC_PUBLIC)
1262    PHP_ME(PDO, commit,                 arginfo_pdo__void,         ZEND_ACC_PUBLIC)
1263    PHP_ME(PDO, rollBack,               arginfo_pdo__void,         ZEND_ACC_PUBLIC)
1264    PHP_ME(PDO, inTransaction,          arginfo_pdo__void,         ZEND_ACC_PUBLIC)
1265    PHP_ME(PDO, setAttribute,   arginfo_pdo_setattribute,   ZEND_ACC_PUBLIC)
1266    PHP_ME(PDO, exec,           arginfo_pdo_exec,       ZEND_ACC_PUBLIC)
1267    PHP_ME(PDO, query,          NULL,                   ZEND_ACC_PUBLIC)
1268    PHP_ME(PDO, lastInsertId,   arginfo_pdo_lastinsertid,   ZEND_ACC_PUBLIC)
1269    PHP_ME(PDO, errorCode,              arginfo_pdo__void,         ZEND_ACC_PUBLIC)
1270    PHP_ME(PDO, errorInfo,              arginfo_pdo__void,         ZEND_ACC_PUBLIC)
1271    PHP_ME(PDO, getAttribute,   arginfo_pdo_getattribute,   ZEND_ACC_PUBLIC)
1272    PHP_ME(PDO, quote,          arginfo_pdo_quote,      ZEND_ACC_PUBLIC)
1273    PHP_ME(PDO, __wakeup,               arginfo_pdo__void,         ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
1274    PHP_ME(PDO, __sleep,                arginfo_pdo__void,         ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
1275    PHP_ME(PDO, getAvailableDrivers,    arginfo_pdo__void,         ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
1276    {NULL, NULL, NULL}
1277};
1278
1279/* {{{ overloaded object handlers for PDO class */
1280int pdo_hash_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
1281{
1282    const zend_function_entry *funcs;
1283    zend_function func;
1284    zend_internal_function *ifunc = (zend_internal_function*)&func;
1285    int namelen;
1286    char *lc_name;
1287
1288    if (!dbh || !dbh->methods || !dbh->methods->get_driver_methods) {
1289        return 0;
1290    }
1291    funcs = dbh->methods->get_driver_methods(dbh, kind TSRMLS_CC);
1292    if (!funcs) {
1293        return 0;
1294    }
1295
1296    if (!(dbh->cls_methods[kind] = pemalloc(sizeof(HashTable), dbh->is_persistent))) {
1297        php_error_docref(NULL TSRMLS_CC, E_ERROR, "out of memory while allocating PDO methods.");
1298    }
1299    zend_hash_init_ex(dbh->cls_methods[kind], 8, NULL, NULL, dbh->is_persistent, 0);
1300
1301    while (funcs->fname) {
1302        ifunc->type = ZEND_INTERNAL_FUNCTION;
1303        ifunc->handler = funcs->handler;
1304        ifunc->function_name = (char*)funcs->fname;
1305        ifunc->scope = dbh->ce;
1306        ifunc->prototype = NULL;
1307        if (funcs->arg_info) {
1308            ifunc->arg_info = (zend_arg_info*)funcs->arg_info + 1;
1309            ifunc->num_args = funcs->num_args;
1310            if (funcs->arg_info[0].required_num_args == -1) {
1311                ifunc->required_num_args = funcs->num_args;
1312            } else {
1313                ifunc->required_num_args = funcs->arg_info[0].required_num_args;
1314            }
1315            ifunc->pass_rest_by_reference = funcs->arg_info[0].pass_by_reference;
1316            ifunc->return_reference = funcs->arg_info[0].return_reference;
1317        } else {
1318            ifunc->arg_info = NULL;
1319            ifunc->num_args = 0;
1320            ifunc->required_num_args = 0;
1321            ifunc->pass_rest_by_reference = 0;
1322            ifunc->return_reference = 0;
1323        }
1324        if (funcs->flags) {
1325            ifunc->fn_flags = funcs->flags;
1326        } else {
1327            ifunc->fn_flags = ZEND_ACC_PUBLIC;
1328        }
1329        namelen = strlen(funcs->fname);
1330        lc_name = emalloc(namelen+1);
1331        zend_str_tolower_copy(lc_name, funcs->fname, namelen);
1332        zend_hash_add(dbh->cls_methods[kind], lc_name, namelen+1, &func, sizeof(func), NULL);
1333        efree(lc_name);
1334        funcs++;
1335    }
1336
1337    return 1;
1338}
1339
1340static union _zend_function *dbh_method_get(
1341#if PHP_API_VERSION >= 20041225
1342    zval **object_pp,
1343#else
1344    zval *object,
1345#endif
1346    char *method_name, int method_len TSRMLS_DC)
1347{
1348    zend_function *fbc = NULL;
1349    char *lc_method_name;
1350#if PHP_API_VERSION >= 20041225
1351    zval *object = *object_pp;
1352#endif
1353    pdo_dbh_t *dbh = zend_object_store_get_object(object TSRMLS_CC);
1354
1355    lc_method_name = emalloc(method_len + 1);
1356    zend_str_tolower_copy(lc_method_name, method_name, method_len);
1357
1358    if ((fbc = std_object_handlers.get_method(object_pp, method_name, method_len TSRMLS_CC)) == NULL) {
1359        /* not a pre-defined method, nor a user-defined method; check
1360         * the driver specific methods */
1361        if (!dbh->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_DBH]) {
1362            if (!pdo_hash_methods(dbh,
1363                PDO_DBH_DRIVER_METHOD_KIND_DBH TSRMLS_CC)
1364                || !dbh->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_DBH]) {
1365                goto out;
1366            }
1367        }
1368
1369        if (zend_hash_find(dbh->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_DBH],
1370                lc_method_name, method_len+1, (void**)&fbc) == FAILURE) {
1371            if (!fbc) {
1372                fbc = NULL;
1373            }
1374        }
1375    }
1376
1377out:
1378    efree(lc_method_name);
1379    return fbc;
1380}
1381
1382static int dbh_compare(zval *object1, zval *object2 TSRMLS_DC)
1383{
1384    return -1;
1385}
1386
1387static zend_object_handlers pdo_dbh_object_handlers;
1388
1389void pdo_dbh_init(TSRMLS_D)
1390{
1391    zend_class_entry ce;
1392
1393    INIT_CLASS_ENTRY(ce, "PDO", pdo_dbh_functions);
1394    pdo_dbh_ce = zend_register_internal_class(&ce TSRMLS_CC);
1395    pdo_dbh_ce->create_object = pdo_dbh_new;
1396
1397    memcpy(&pdo_dbh_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
1398    pdo_dbh_object_handlers.get_method = dbh_method_get;
1399    pdo_dbh_object_handlers.compare_objects = dbh_compare;
1400
1401    REGISTER_PDO_CLASS_CONST_LONG("PARAM_BOOL", (long)PDO_PARAM_BOOL);
1402    REGISTER_PDO_CLASS_CONST_LONG("PARAM_NULL", (long)PDO_PARAM_NULL);
1403    REGISTER_PDO_CLASS_CONST_LONG("PARAM_INT",  (long)PDO_PARAM_INT);
1404    REGISTER_PDO_CLASS_CONST_LONG("PARAM_STR",  (long)PDO_PARAM_STR);
1405    REGISTER_PDO_CLASS_CONST_LONG("PARAM_LOB",  (long)PDO_PARAM_LOB);
1406    REGISTER_PDO_CLASS_CONST_LONG("PARAM_STMT", (long)PDO_PARAM_STMT);
1407    REGISTER_PDO_CLASS_CONST_LONG("PARAM_INPUT_OUTPUT", (long)PDO_PARAM_INPUT_OUTPUT);
1408
1409    REGISTER_PDO_CLASS_CONST_LONG("PARAM_EVT_ALLOC",        (long)PDO_PARAM_EVT_ALLOC);
1410    REGISTER_PDO_CLASS_CONST_LONG("PARAM_EVT_FREE",         (long)PDO_PARAM_EVT_FREE);
1411    REGISTER_PDO_CLASS_CONST_LONG("PARAM_EVT_EXEC_PRE",     (long)PDO_PARAM_EVT_EXEC_PRE);
1412    REGISTER_PDO_CLASS_CONST_LONG("PARAM_EVT_EXEC_POST",    (long)PDO_PARAM_EVT_EXEC_POST);
1413    REGISTER_PDO_CLASS_CONST_LONG("PARAM_EVT_FETCH_PRE",    (long)PDO_PARAM_EVT_FETCH_PRE);
1414    REGISTER_PDO_CLASS_CONST_LONG("PARAM_EVT_FETCH_POST",   (long)PDO_PARAM_EVT_FETCH_POST);
1415    REGISTER_PDO_CLASS_CONST_LONG("PARAM_EVT_NORMALIZE",    (long)PDO_PARAM_EVT_NORMALIZE);
1416
1417    REGISTER_PDO_CLASS_CONST_LONG("FETCH_LAZY", (long)PDO_FETCH_LAZY);
1418    REGISTER_PDO_CLASS_CONST_LONG("FETCH_ASSOC",(long)PDO_FETCH_ASSOC);
1419    REGISTER_PDO_CLASS_CONST_LONG("FETCH_NUM",  (long)PDO_FETCH_NUM);
1420    REGISTER_PDO_CLASS_CONST_LONG("FETCH_BOTH", (long)PDO_FETCH_BOTH);
1421    REGISTER_PDO_CLASS_CONST_LONG("FETCH_OBJ",  (long)PDO_FETCH_OBJ);
1422    REGISTER_PDO_CLASS_CONST_LONG("FETCH_BOUND",(long)PDO_FETCH_BOUND);
1423    REGISTER_PDO_CLASS_CONST_LONG("FETCH_COLUMN",(long)PDO_FETCH_COLUMN);
1424    REGISTER_PDO_CLASS_CONST_LONG("FETCH_CLASS",(long)PDO_FETCH_CLASS);
1425    REGISTER_PDO_CLASS_CONST_LONG("FETCH_INTO", (long)PDO_FETCH_INTO);
1426    REGISTER_PDO_CLASS_CONST_LONG("FETCH_FUNC", (long)PDO_FETCH_FUNC);
1427    REGISTER_PDO_CLASS_CONST_LONG("FETCH_GROUP",(long)PDO_FETCH_GROUP);
1428    REGISTER_PDO_CLASS_CONST_LONG("FETCH_UNIQUE",(long)PDO_FETCH_UNIQUE);
1429    REGISTER_PDO_CLASS_CONST_LONG("FETCH_KEY_PAIR",(long)PDO_FETCH_KEY_PAIR);
1430    REGISTER_PDO_CLASS_CONST_LONG("FETCH_CLASSTYPE",(long)PDO_FETCH_CLASSTYPE);
1431#if PHP_MAJOR_VERSION > 5 || PHP_MINOR_VERSION >= 1
1432    REGISTER_PDO_CLASS_CONST_LONG("FETCH_SERIALIZE",(long)PDO_FETCH_SERIALIZE);
1433#endif
1434    REGISTER_PDO_CLASS_CONST_LONG("FETCH_PROPS_LATE",(long)PDO_FETCH_PROPS_LATE);
1435    REGISTER_PDO_CLASS_CONST_LONG("FETCH_NAMED",(long)PDO_FETCH_NAMED);
1436
1437    REGISTER_PDO_CLASS_CONST_LONG("ATTR_AUTOCOMMIT",    (long)PDO_ATTR_AUTOCOMMIT);
1438    REGISTER_PDO_CLASS_CONST_LONG("ATTR_PREFETCH",      (long)PDO_ATTR_PREFETCH);
1439    REGISTER_PDO_CLASS_CONST_LONG("ATTR_TIMEOUT",       (long)PDO_ATTR_TIMEOUT);
1440    REGISTER_PDO_CLASS_CONST_LONG("ATTR_ERRMODE",       (long)PDO_ATTR_ERRMODE);
1441    REGISTER_PDO_CLASS_CONST_LONG("ATTR_SERVER_VERSION",    (long)PDO_ATTR_SERVER_VERSION);
1442    REGISTER_PDO_CLASS_CONST_LONG("ATTR_CLIENT_VERSION",    (long)PDO_ATTR_CLIENT_VERSION);
1443    REGISTER_PDO_CLASS_CONST_LONG("ATTR_SERVER_INFO",       (long)PDO_ATTR_SERVER_INFO);
1444    REGISTER_PDO_CLASS_CONST_LONG("ATTR_CONNECTION_STATUS",     (long)PDO_ATTR_CONNECTION_STATUS);
1445    REGISTER_PDO_CLASS_CONST_LONG("ATTR_CASE",          (long)PDO_ATTR_CASE);
1446    REGISTER_PDO_CLASS_CONST_LONG("ATTR_CURSOR_NAME",   (long)PDO_ATTR_CURSOR_NAME);
1447    REGISTER_PDO_CLASS_CONST_LONG("ATTR_CURSOR",        (long)PDO_ATTR_CURSOR);
1448    REGISTER_PDO_CLASS_CONST_LONG("ATTR_ORACLE_NULLS",  (long)PDO_ATTR_ORACLE_NULLS);
1449    REGISTER_PDO_CLASS_CONST_LONG("ATTR_PERSISTENT",    (long)PDO_ATTR_PERSISTENT);
1450    REGISTER_PDO_CLASS_CONST_LONG("ATTR_STATEMENT_CLASS",       (long)PDO_ATTR_STATEMENT_CLASS);
1451    REGISTER_PDO_CLASS_CONST_LONG("ATTR_FETCH_TABLE_NAMES",     (long)PDO_ATTR_FETCH_TABLE_NAMES);
1452    REGISTER_PDO_CLASS_CONST_LONG("ATTR_FETCH_CATALOG_NAMES",       (long)PDO_ATTR_FETCH_CATALOG_NAMES);
1453    REGISTER_PDO_CLASS_CONST_LONG("ATTR_DRIVER_NAME",       (long)PDO_ATTR_DRIVER_NAME);
1454    REGISTER_PDO_CLASS_CONST_LONG("ATTR_STRINGIFY_FETCHES",(long)PDO_ATTR_STRINGIFY_FETCHES);
1455    REGISTER_PDO_CLASS_CONST_LONG("ATTR_MAX_COLUMN_LEN",(long)PDO_ATTR_MAX_COLUMN_LEN);
1456    REGISTER_PDO_CLASS_CONST_LONG("ATTR_EMULATE_PREPARES",(long)PDO_ATTR_EMULATE_PREPARES);
1457    REGISTER_PDO_CLASS_CONST_LONG("ATTR_DEFAULT_FETCH_MODE",(long)PDO_ATTR_DEFAULT_FETCH_MODE);
1458
1459    REGISTER_PDO_CLASS_CONST_LONG("ERRMODE_SILENT", (long)PDO_ERRMODE_SILENT);
1460    REGISTER_PDO_CLASS_CONST_LONG("ERRMODE_WARNING",    (long)PDO_ERRMODE_WARNING);
1461    REGISTER_PDO_CLASS_CONST_LONG("ERRMODE_EXCEPTION",  (long)PDO_ERRMODE_EXCEPTION);
1462
1463    REGISTER_PDO_CLASS_CONST_LONG("CASE_NATURAL",   (long)PDO_CASE_NATURAL);
1464    REGISTER_PDO_CLASS_CONST_LONG("CASE_LOWER", (long)PDO_CASE_LOWER);
1465    REGISTER_PDO_CLASS_CONST_LONG("CASE_UPPER", (long)PDO_CASE_UPPER);
1466
1467    REGISTER_PDO_CLASS_CONST_LONG("NULL_NATURAL",   (long)PDO_NULL_NATURAL);
1468    REGISTER_PDO_CLASS_CONST_LONG("NULL_EMPTY_STRING",  (long)PDO_NULL_EMPTY_STRING);
1469    REGISTER_PDO_CLASS_CONST_LONG("NULL_TO_STRING", (long)PDO_NULL_TO_STRING);
1470
1471    REGISTER_PDO_CLASS_CONST_STRING("ERR_NONE", PDO_ERR_NONE);
1472
1473    REGISTER_PDO_CLASS_CONST_LONG("FETCH_ORI_NEXT", (long)PDO_FETCH_ORI_NEXT);
1474    REGISTER_PDO_CLASS_CONST_LONG("FETCH_ORI_PRIOR", (long)PDO_FETCH_ORI_PRIOR);
1475    REGISTER_PDO_CLASS_CONST_LONG("FETCH_ORI_FIRST", (long)PDO_FETCH_ORI_FIRST);
1476    REGISTER_PDO_CLASS_CONST_LONG("FETCH_ORI_LAST", (long)PDO_FETCH_ORI_LAST);
1477    REGISTER_PDO_CLASS_CONST_LONG("FETCH_ORI_ABS", (long)PDO_FETCH_ORI_ABS);
1478    REGISTER_PDO_CLASS_CONST_LONG("FETCH_ORI_REL", (long)PDO_FETCH_ORI_REL);
1479
1480    REGISTER_PDO_CLASS_CONST_LONG("CURSOR_FWDONLY", (long)PDO_CURSOR_FWDONLY);
1481    REGISTER_PDO_CLASS_CONST_LONG("CURSOR_SCROLL", (long)PDO_CURSOR_SCROLL);
1482
1483#if 0
1484    REGISTER_PDO_CLASS_CONST_LONG("ERR_CANT_MAP",       (long)PDO_ERR_CANT_MAP);
1485    REGISTER_PDO_CLASS_CONST_LONG("ERR_SYNTAX",         (long)PDO_ERR_SYNTAX);
1486    REGISTER_PDO_CLASS_CONST_LONG("ERR_CONSTRAINT",     (long)PDO_ERR_CONSTRAINT);
1487    REGISTER_PDO_CLASS_CONST_LONG("ERR_NOT_FOUND",      (long)PDO_ERR_NOT_FOUND);
1488    REGISTER_PDO_CLASS_CONST_LONG("ERR_ALREADY_EXISTS",     (long)PDO_ERR_ALREADY_EXISTS);
1489    REGISTER_PDO_CLASS_CONST_LONG("ERR_NOT_IMPLEMENTED",    (long)PDO_ERR_NOT_IMPLEMENTED);
1490    REGISTER_PDO_CLASS_CONST_LONG("ERR_MISMATCH",       (long)PDO_ERR_MISMATCH);
1491    REGISTER_PDO_CLASS_CONST_LONG("ERR_TRUNCATED",      (long)PDO_ERR_TRUNCATED);
1492    REGISTER_PDO_CLASS_CONST_LONG("ERR_DISCONNECTED",   (long)PDO_ERR_DISCONNECTED);
1493    REGISTER_PDO_CLASS_CONST_LONG("ERR_NO_PERM",        (long)PDO_ERR_NO_PERM);
1494#endif
1495
1496}
1497
1498static void dbh_free(pdo_dbh_t *dbh TSRMLS_DC)
1499{
1500    int i;
1501
1502    if (--dbh->refcount)
1503        return;
1504
1505    if (dbh->query_stmt) {
1506        zval_dtor(&dbh->query_stmt_zval);
1507        dbh->query_stmt = NULL;
1508    }
1509
1510    if (dbh->methods) {
1511        dbh->methods->closer(dbh TSRMLS_CC);
1512    }
1513
1514    if (dbh->data_source) {
1515        pefree((char *)dbh->data_source, dbh->is_persistent);
1516    }
1517    if (dbh->username) {
1518        pefree(dbh->username, dbh->is_persistent);
1519    }
1520    if (dbh->password) {
1521        pefree(dbh->password, dbh->is_persistent);
1522    }
1523
1524    if (dbh->persistent_id) {
1525        pefree((char *)dbh->persistent_id, dbh->is_persistent);
1526    }
1527
1528    if (dbh->def_stmt_ctor_args) {
1529        zval_ptr_dtor(&dbh->def_stmt_ctor_args);
1530    }
1531
1532    for (i = 0; i < PDO_DBH_DRIVER_METHOD_KIND__MAX; i++) {
1533        if (dbh->cls_methods[i]) {
1534            zend_hash_destroy(dbh->cls_methods[i]);
1535            pefree(dbh->cls_methods[i], dbh->is_persistent);
1536        }
1537    }
1538
1539    pefree(dbh, dbh->is_persistent);
1540}
1541
1542PDO_API void php_pdo_dbh_addref(pdo_dbh_t *dbh TSRMLS_DC)
1543{
1544    dbh->refcount++;
1545}
1546
1547PDO_API void php_pdo_dbh_delref(pdo_dbh_t *dbh TSRMLS_DC)
1548{
1549    dbh_free(dbh TSRMLS_CC);
1550}
1551
1552static void pdo_dbh_free_storage(pdo_dbh_t *dbh TSRMLS_DC)
1553{
1554    if (dbh->in_txn && dbh->methods && dbh->methods->rollback) {
1555        dbh->methods->rollback(dbh TSRMLS_CC);
1556        dbh->in_txn = 0;
1557    }
1558
1559    if (dbh->properties) {
1560        zend_hash_destroy(dbh->properties);
1561        efree(dbh->properties);
1562        dbh->properties = NULL;
1563    }
1564
1565    if (dbh->is_persistent && dbh->methods && dbh->methods->persistent_shutdown) {
1566        dbh->methods->persistent_shutdown(dbh TSRMLS_CC);
1567    }
1568    dbh_free(dbh TSRMLS_CC);
1569}
1570
1571zend_object_value pdo_dbh_new(zend_class_entry *ce TSRMLS_DC)
1572{
1573    zend_object_value retval;
1574    pdo_dbh_t *dbh;
1575    zval *tmp;
1576
1577    dbh = emalloc(sizeof(*dbh));
1578    memset(dbh, 0, sizeof(*dbh));
1579    dbh->ce = ce;
1580    dbh->refcount = 1;
1581    ALLOC_HASHTABLE(dbh->properties);
1582    zend_hash_init(dbh->properties, 0, NULL, ZVAL_PTR_DTOR, 0);
1583    zend_hash_copy(dbh->properties, &ce->default_properties, (copy_ctor_func_t) zval_property_ctor, (void *) &tmp, sizeof(zval *));
1584    dbh->def_stmt_ce = pdo_dbstmt_ce;
1585
1586    retval.handle = zend_objects_store_put(dbh, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t)pdo_dbh_free_storage, NULL TSRMLS_CC);
1587    retval.handlers = &pdo_dbh_object_handlers;
1588
1589    return retval;
1590}
1591
1592/* }}} */
1593
1594ZEND_RSRC_DTOR_FUNC(php_pdo_pdbh_dtor)
1595{
1596    if (rsrc->ptr) {
1597        pdo_dbh_t *dbh = (pdo_dbh_t*)rsrc->ptr;
1598        dbh_free(dbh TSRMLS_CC);
1599        rsrc->ptr = NULL;
1600    }
1601}
1602
1603/*
1604 * Local variables:
1605 * tab-width: 4
1606 * c-basic-offset: 4
1607 * End:
1608 * vim600: noet sw=4 ts=4 fdm=marker
1609 * vim<600: noet sw=4 ts=4
1610 */
1611