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