ext/pdo_oci/oci

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
pdo_oci_fetch_error_func
_oci_error
oci_handle_closer
oci_handle_preparer
oci_handle_doer
oci_handle_quoter
oci_handle_begin
oci_handle_commit
oci_handle_rollback
oci_handle_set_attribute
oci_handle_get_attribute
pdo_oci_check_liveness
pdo_oci_handle_factory
pdo_oci_sanitize_prefetch
   1 /*
   2   +----------------------------------------------------------------------+
   3   | PHP Version 7                                                        |
   4   +----------------------------------------------------------------------+
   5   | Copyright (c) 1997-2016 The PHP Group                                |
   6   +----------------------------------------------------------------------+
   7   | This source file is subject to version 3.01 of the PHP license,      |
   8   | that is bundled with this package in the file LICENSE, and is        |
   9   | available through the world-wide-web at the following url:           |
  10   | http://www.php.net/license/3_01.txt                                  |
  11   | If you did not receive a copy of the PHP license and are unable to   |
  12   | obtain it through the world-wide-web, please send a note to          |
  13   | license@php.net so we can mail you a copy immediately.               |
  14   +----------------------------------------------------------------------+
  15   | Author: Wez Furlong <wez@php.net>                                    |
  16   +----------------------------------------------------------------------+
  17 */
  18 
  19 /* $Id$ */
  20 
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24 
  25 #include "php.h"
  26 #include "php_ini.h"
  27 #include "ext/standard/info.h"
  28 #include "pdo/php_pdo.h"
  29 #include "pdo/php_pdo_driver.h"
  30 #include "php_pdo_oci.h"
  31 #include "php_pdo_oci_int.h"
  32 #include "Zend/zend_exceptions.h"
  33 
  34 static inline ub4 pdo_oci_sanitize_prefetch(long prefetch);
  35 
  36 static int pdo_oci_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *info) /* {{{ */
  37 {
  38         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
  39         pdo_oci_error_info *einfo;
  40 
  41         einfo = &H->einfo;
  42 
  43         if (stmt) {
  44                 pdo_oci_stmt *S = (pdo_oci_stmt*)stmt->driver_data;
  45 
  46                 if (S->einfo.errmsg) {
  47                         einfo = &S->einfo;
  48                 }
  49         }
  50 
  51         if (einfo->errcode) {
  52                 add_next_index_long(info, einfo->errcode);
  53                 add_next_index_string(info, einfo->errmsg);
  54         }
  55 
  56         return 1;
  57 }
  58 /* }}} */
  59 
  60 ub4 _oci_error(OCIError *err, pdo_dbh_t *dbh, pdo_stmt_t *stmt, char *what, sword status, int isinit, const char *file, int line) /* {{{ */
  61 {
  62         text errbuf[1024] = "<<Unknown>>";
  63         char tmp_buf[2048];
  64         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
  65         pdo_oci_error_info *einfo;
  66         pdo_oci_stmt *S = NULL;
  67         pdo_error_type *pdo_err = &dbh->error_code;
  68 
  69         if (stmt) {
  70                 S = (pdo_oci_stmt*)stmt->driver_data;
  71                 einfo = &S->einfo;
  72                 pdo_err = &stmt->error_code;
  73         }
  74         else {
  75                 einfo = &H->einfo;
  76         }
  77 
  78         if (einfo->errmsg) {
  79                 pefree(einfo->errmsg, dbh->is_persistent);
  80         }
  81 
  82         einfo->errmsg = NULL;
  83         einfo->errcode = 0;
  84         einfo->file = file;
  85         einfo->line = line;
  86 
  87         if (isinit) { /* Initialization error */
  88                 strcpy(*pdo_err, "HY000");
  89                 slprintf(tmp_buf, sizeof(tmp_buf), "%s (%s:%d)", what, file, line);
  90                 einfo->errmsg = pestrdup(tmp_buf, dbh->is_persistent);
  91         }
  92         else {
  93                 switch (status) {
  94                         case OCI_SUCCESS:
  95                                 strcpy(*pdo_err, "00000");
  96                                 break;
  97                         case OCI_ERROR:
  98                                 OCIErrorGet(err, (ub4)1, NULL, &einfo->errcode, errbuf, (ub4)sizeof(errbuf), OCI_HTYPE_ERROR);
  99                                 slprintf(tmp_buf, sizeof(tmp_buf), "%s: %s (%s:%d)", what, errbuf, file, line);
 100                                 einfo->errmsg = pestrdup(tmp_buf, dbh->is_persistent);
 101                                 break;
 102                         case OCI_SUCCESS_WITH_INFO:
 103                                 OCIErrorGet(err, (ub4)1, NULL, &einfo->errcode, errbuf, (ub4)sizeof(errbuf), OCI_HTYPE_ERROR);
 104                                 slprintf(tmp_buf, sizeof(tmp_buf), "%s: OCI_SUCCESS_WITH_INFO: %s (%s:%d)", what, errbuf, file, line);
 105                                 einfo->errmsg = pestrdup(tmp_buf, dbh->is_persistent);
 106                                 break;
 107                         case OCI_NEED_DATA:
 108                                 slprintf(tmp_buf, sizeof(tmp_buf), "%s: OCI_NEED_DATA (%s:%d)", what, file, line);
 109                                 einfo->errmsg = pestrdup(tmp_buf, dbh->is_persistent);
 110                                 break;
 111                         case OCI_NO_DATA:
 112                                 slprintf(tmp_buf, sizeof(tmp_buf), "%s: OCI_NO_DATA (%s:%d)", what, file, line);
 113                                 einfo->errmsg = pestrdup(tmp_buf, dbh->is_persistent);
 114                                 break;
 115                         case OCI_INVALID_HANDLE:
 116                                 slprintf(tmp_buf, sizeof(tmp_buf), "%s: OCI_INVALID_HANDLE (%s:%d)", what, file, line);
 117                                 einfo->errmsg = pestrdup(tmp_buf, dbh->is_persistent);
 118                                 break;
 119                         case OCI_STILL_EXECUTING:
 120                                 slprintf(tmp_buf, sizeof(tmp_buf), "%s: OCI_STILL_EXECUTING (%s:%d)", what, file, line);
 121                                 einfo->errmsg = pestrdup(tmp_buf, dbh->is_persistent);
 122                                 break;
 123                         case OCI_CONTINUE:
 124                                 slprintf(tmp_buf, sizeof(tmp_buf), "%s: OCI_CONTINUE (%s:%d)", what, file, line);
 125                                 einfo->errmsg = pestrdup(tmp_buf, dbh->is_persistent);
 126                                 break;
 127                 }
 128 
 129                 if (einfo->errcode) {
 130                         switch (einfo->errcode) {
 131                                 case 1013:      /* user requested cancel of current operation */
 132                                         zend_bailout();
 133                                         break;
 134 
 135 #if 0
 136                                 case 955:       /* ORA-00955: name is already used by an existing object */
 137                                         *pdo_err = PDO_ERR_ALREADY_EXISTS;
 138                                         break;
 139 #endif
 140 
 141                                 case 12154:     /* ORA-12154: TNS:could not resolve service name */
 142                                         strcpy(*pdo_err, "42S02");
 143                                         break;
 144 
 145                                 case    22:     /* ORA-00022: invalid session id */
 146                                 case   378:
 147                                 case   602:
 148                                 case   603:
 149                                 case   604:
 150                                 case   609:
 151                                 case  1012:     /* ORA-01012: */
 152                                 case  1033:
 153                                 case  1041:
 154                                 case  1043:
 155                                 case  1089:
 156                                 case  1090:
 157                                 case  1092:
 158                                 case  3113:     /* ORA-03133: end of file on communication channel */
 159                                 case  3114:
 160                                 case  3122:
 161                                 case  3135:
 162                                 case 12153:
 163                                 case 27146:
 164                                 case 28511:
 165                                         /* consider the connection closed */
 166                                         dbh->is_closed = 1;
 167                                         H->attached = 0;
 168                                         strcpy(*pdo_err, "01002"); /* FIXME */
 169                                         break;
 170 
 171                                 default:
 172                                         strcpy(*pdo_err, "HY000");
 173                         }
 174                 }
 175 
 176                 if (stmt) {
 177                         /* always propagate the error code back up to the dbh,
 178                          * so that we can catch the error information when execute
 179                          * is called via query.  See Bug #33707 */
 180                         if (H->einfo.errmsg) {
 181                                 pefree(H->einfo.errmsg, dbh->is_persistent);
 182                         }
 183                         H->einfo = *einfo;
 184                         H->einfo.errmsg = einfo->errmsg ? pestrdup(einfo->errmsg, dbh->is_persistent) : NULL;
 185                         strcpy(dbh->error_code, stmt->error_code);
 186                 }
 187         }
 188 
 189         /* little mini hack so that we can use this code from the dbh ctor */
 190         if (!dbh->methods) {
 191                 zend_throw_exception_ex(php_pdo_get_exception(), einfo->errcode, "SQLSTATE[%s]: %s", *pdo_err, einfo->errmsg);
 192         }
 193 
 194         return einfo->errcode;
 195 }
 196 /* }}} */
 197 
 198 static int oci_handle_closer(pdo_dbh_t *dbh) /* {{{ */
 199 {
 200         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
 201 
 202         if (H->svc) {
 203                 /* rollback any outstanding work */
 204                 OCITransRollback(H->svc, H->err, 0);
 205         }
 206 
 207         if (H->session) {
 208                 OCIHandleFree(H->session, OCI_HTYPE_SESSION);
 209                 H->session = NULL;
 210         }
 211 
 212         if (H->svc) {
 213                 OCIHandleFree(H->svc, OCI_HTYPE_SVCCTX);
 214                 H->svc = NULL;
 215         }
 216 
 217         if (H->server && H->attached) {
 218                 H->last_err = OCIServerDetach(H->server, H->err, OCI_DEFAULT);
 219                 if (H->last_err) {
 220                         oci_drv_error("OCIServerDetach");
 221                 }
 222                 H->attached = 0;
 223         }
 224 
 225         if (H->server) {
 226                 OCIHandleFree(H->server, OCI_HTYPE_SERVER);
 227                 H->server = NULL;
 228         }
 229 
 230         if (H->err) {
 231                 OCIHandleFree(H->err, OCI_HTYPE_ERROR);
 232                 H->err = NULL;
 233         }
 234 
 235         if (H->charset && H->env) {
 236                 OCIHandleFree(H->env, OCI_HTYPE_ENV);
 237                 H->env = NULL;
 238         }
 239 
 240         if (H->einfo.errmsg) {
 241                 pefree(H->einfo.errmsg, dbh->is_persistent);
 242                 H->einfo.errmsg = NULL;
 243         }
 244 
 245         pefree(H, dbh->is_persistent);
 246 
 247         return 0;
 248 }
 249 /* }}} */
 250 
 251 static int oci_handle_preparer(pdo_dbh_t *dbh, const char *sql, size_t sql_len, pdo_stmt_t *stmt, zval *driver_options) /* {{{ */
 252 {
 253         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
 254         pdo_oci_stmt *S = ecalloc(1, sizeof(*S));
 255         ub4 prefetch;
 256         char *nsql = NULL;
 257         size_t nsql_len = 0;
 258         int ret;
 259 
 260 #if HAVE_OCISTMTFETCH2
 261         S->exec_type = pdo_attr_lval(driver_options, PDO_ATTR_CURSOR,
 262                 PDO_CURSOR_FWDONLY) == PDO_CURSOR_SCROLL ?
 263                 OCI_STMT_SCROLLABLE_READONLY : OCI_DEFAULT;
 264 #else
 265         S->exec_type = OCI_DEFAULT;
 266 #endif
 267 
 268         S->H = H;
 269         stmt->supports_placeholders = PDO_PLACEHOLDER_NAMED;
 270         ret = pdo_parse_params(stmt, (char*)sql, sql_len, &nsql, &nsql_len);
 271 
 272         if (ret == 1) {
 273                 /* query was re-written */
 274                 sql = nsql;
 275                 sql_len = nsql_len;
 276         } else if (ret == -1) {
 277                 /* couldn't grok it */
 278                 strcpy(dbh->error_code, stmt->error_code);
 279                 efree(S);
 280                 return 0;
 281         }
 282 
 283         /* create an OCI statement handle */
 284         OCIHandleAlloc(H->env, (dvoid*)&S->stmt, OCI_HTYPE_STMT, 0, NULL);
 285 
 286         /* and our own private error handle */
 287         OCIHandleAlloc(H->env, (dvoid*)&S->err, OCI_HTYPE_ERROR, 0, NULL);
 288 
 289         if (sql_len) {
 290                 H->last_err = OCIStmtPrepare(S->stmt, H->err, (text*)sql, (ub4) sql_len, OCI_NTV_SYNTAX, OCI_DEFAULT);
 291                 if (nsql) {
 292                         efree(nsql);
 293                         nsql = NULL;
 294                 }
 295                 if (H->last_err) {
 296                         H->last_err = oci_drv_error("OCIStmtPrepare");
 297                         OCIHandleFree(S->stmt, OCI_HTYPE_STMT);
 298                         OCIHandleFree(S->err, OCI_HTYPE_ERROR);
 299                         efree(S);
 300                         return 0;
 301                 }
 302 
 303         }
 304 
 305         prefetch = H->prefetch;  /* Note 0 is allowed so in future REF CURSORs can be used & then passed with no row loss*/
 306         H->last_err = OCIAttrSet(S->stmt, OCI_HTYPE_STMT, &prefetch, 0,
 307                                                          OCI_ATTR_PREFETCH_ROWS, H->err);
 308         if (!H->last_err) {
 309                 prefetch *= PDO_OCI_PREFETCH_ROWSIZE;
 310                 H->last_err = OCIAttrSet(S->stmt, OCI_HTYPE_STMT, &prefetch, 0,
 311                                                                  OCI_ATTR_PREFETCH_MEMORY, H->err);
 312         }
 313 
 314         stmt->driver_data = S;
 315         stmt->methods = &oci_stmt_methods;
 316         if (nsql) {
 317                 efree(nsql);
 318                 nsql = NULL;
 319         }
 320 
 321         return 1;
 322 }
 323 /* }}} */
 324 
 325 static zend_long oci_handle_doer(pdo_dbh_t *dbh, const char *sql, size_t sql_len) /* {{{ */
 326 {
 327         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
 328         OCIStmt         *stmt;
 329         ub2 stmt_type;
 330         ub4 rowcount;
 331         int ret = -1;
 332 
 333         OCIHandleAlloc(H->env, (dvoid*)&stmt, OCI_HTYPE_STMT, 0, NULL);
 334 
 335         H->last_err = OCIStmtPrepare(stmt, H->err, (text*)sql, (ub4) sql_len, OCI_NTV_SYNTAX, OCI_DEFAULT);
 336         if (H->last_err) {
 337                 H->last_err = oci_drv_error("OCIStmtPrepare");
 338                 OCIHandleFree(stmt, OCI_HTYPE_STMT);
 339                 return -1;
 340         }
 341 
 342         H->last_err = OCIAttrGet(stmt, OCI_HTYPE_STMT, &stmt_type, 0, OCI_ATTR_STMT_TYPE, H->err);
 343 
 344         if (stmt_type == OCI_STMT_SELECT) {
 345                 /* invalid usage; cancel it */
 346                 OCIHandleFree(stmt, OCI_HTYPE_STMT);
 347                 php_error_docref(NULL, E_WARNING, "issuing a SELECT query here is invalid");
 348                 return -1;
 349         }
 350 
 351         /* now we are good to go */
 352         H->last_err = OCIStmtExecute(H->svc, stmt, H->err, 1, 0, NULL, NULL,
 353                         (dbh->auto_commit && !dbh->in_txn) ? OCI_COMMIT_ON_SUCCESS : OCI_DEFAULT);
 354 
 355         if (H->last_err) {
 356                 H->last_err = oci_drv_error("OCIStmtExecute");
 357         } else {
 358                 /* return the number of affected rows */
 359                 H->last_err = OCIAttrGet(stmt, OCI_HTYPE_STMT, &rowcount, 0, OCI_ATTR_ROW_COUNT, H->err);
 360                 ret = rowcount;
 361         }
 362 
 363         OCIHandleFree(stmt, OCI_HTYPE_STMT);
 364 
 365         return ret;
 366 }
 367 /* }}} */
 368 
 369 static int oci_handle_quoter(pdo_dbh_t *dbh, const char *unquoted, size_t unquotedlen, char **quoted, size_t *quotedlen, enum pdo_param_type paramtype ) /* {{{ */
 370 {
 371         int qcount = 0;
 372         char const *cu, *l, *r;
 373         char *c;
 374 
 375         if (!unquotedlen) {
 376                 *quotedlen = 2;
 377                 *quoted = emalloc(*quotedlen+1);
 378                 strcpy(*quoted, "''");
 379                 return 1;
 380         }
 381 
 382         /* count single quotes */
 383         for (cu = unquoted; (cu = strchr(cu,'\'')); qcount++, cu++)
 384                 ; /* empty loop */
 385 
 386         *quotedlen = unquotedlen + qcount + 2;
 387         *quoted = c = emalloc(*quotedlen+1);
 388         *c++ = '\'';
 389 
 390         /* foreach (chunk that ends in a quote) */
 391         for (l = unquoted; (r = strchr(l,'\'')); l = r+1) {
 392                 strncpy(c, l, r-l+1);
 393                 c += (r-l+1);
 394                 *c++ = '\'';                    /* add second quote */
 395         }
 396 
 397     /* Copy remainder and add enclosing quote */
 398         strncpy(c, l, *quotedlen-(c-*quoted)-1);
 399         (*quoted)[*quotedlen-1] = '\'';
 400         (*quoted)[*quotedlen]   = '\0';
 401 
 402         return 1;
 403 }
 404 /* }}} */
 405 
 406 static int oci_handle_begin(pdo_dbh_t *dbh) /* {{{ */
 407 {
 408         /* with Oracle, there is nothing special to be done */
 409         return 1;
 410 }
 411 /* }}} */
 412 
 413 static int oci_handle_commit(pdo_dbh_t *dbh) /* {{{ */
 414 {
 415         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
 416 
 417         H->last_err = OCITransCommit(H->svc, H->err, 0);
 418 
 419         if (H->last_err) {
 420                 H->last_err = oci_drv_error("OCITransCommit");
 421                 return 0;
 422         }
 423         return 1;
 424 }
 425 /* }}} */
 426 
 427 static int oci_handle_rollback(pdo_dbh_t *dbh) /* {{{ */
 428 {
 429         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
 430 
 431         H->last_err = OCITransRollback(H->svc, H->err, 0);
 432 
 433         if (H->last_err) {
 434                 H->last_err = oci_drv_error("OCITransRollback");
 435                 return 0;
 436         }
 437         return 1;
 438 }
 439 /* }}} */
 440 
 441 static int oci_handle_set_attribute(pdo_dbh_t *dbh, zend_long attr, zval *val) /* {{{ */
 442 {
 443         zend_long lval = zval_get_long(val);
 444         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
 445 
 446         if (attr == PDO_ATTR_AUTOCOMMIT) {
 447                 if (dbh->in_txn) {
 448                         /* Assume they want to commit whatever is outstanding */
 449                         H->last_err = OCITransCommit(H->svc, H->err, 0);
 450 
 451                         if (H->last_err) {
 452                                 H->last_err = oci_drv_error("OCITransCommit");
 453                                 return 0;
 454                         }
 455                         dbh->in_txn = 0;
 456                 }
 457 
 458                 dbh->auto_commit = (unsigned int)lval? 1 : 0;
 459                 return 1;
 460         } else if (attr == PDO_ATTR_PREFETCH) {
 461                 H->prefetch = pdo_oci_sanitize_prefetch(lval);
 462                 return 1;
 463         } else {
 464                 return 0;
 465         }
 466 
 467 }
 468 /* }}} */
 469 
 470 static int oci_handle_get_attribute(pdo_dbh_t *dbh, zend_long attr, zval *return_value)  /* {{{ */
 471 {
 472         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
 473 
 474         switch (attr) {
 475                 case PDO_ATTR_SERVER_VERSION:
 476                 case PDO_ATTR_SERVER_INFO:
 477                 {
 478                         text infostr[512];
 479                         char verstr[15];
 480                         ub4  vernum;
 481 
 482                         if (OCIServerRelease(H->svc, H->err, infostr, (ub4)sizeof(infostr), (ub1)OCI_HTYPE_SVCCTX, &vernum))
 483                         {
 484                                 ZVAL_STRING(return_value, "<<Unknown>>");
 485                         } else {
 486                                 if (attr == PDO_ATTR_SERVER_INFO) {
 487                                         ZVAL_STRING(return_value, (char *)infostr);
 488                                 } else {
 489                                         slprintf(verstr, sizeof(verstr), "%d.%d.%d.%d.%d",
 490                                                          (int)((vernum>>24) & 0xFF),  /* version number */
 491                                                          (int)((vernum>>20) & 0x0F),  /* release number*/
 492                                                          (int)((vernum>>12) & 0xFF),  /* update number */
 493                                                          (int)((vernum>>8)  & 0x0F),  /* port release number */
 494                                                          (int)((vernum>>0)  & 0xFF)); /* port update number */
 495 
 496                                         ZVAL_STRING(return_value, verstr);
 497                                 }
 498                         }
 499                         return TRUE;
 500                 }
 501 
 502                 case PDO_ATTR_CLIENT_VERSION:
 503                 {
 504 #if OCI_MAJOR_VERSION > 10 || (OCI_MAJOR_VERSION == 10 && OCI_MINOR_VERSION >= 2)
 505                         /* Run time client version */
 506                         sword major, minor, update, patch, port_update;
 507                         char verstr[15];
 508 
 509                         OCIClientVersion(&major, &minor, &update, &patch, &port_update);
 510                         slprintf(verstr, sizeof(verstr), "%d.%d.%d.%d.%d", major, minor, update, patch, port_update);
 511                         ZVAL_STRING(return_value, verstr);
 512 #elif defined(PHP_PDO_OCI_CLIENT_VERSION)
 513                         /* Compile time client version */
 514                         ZVAL_STRING(return_value, PHP_PDO_OCI_CLIENT_VERSION);
 515 #else
 516                         return FALSE;
 517 
 518 #endif /* Check for OCIClientVersion() support */
 519 
 520                         return TRUE;
 521                 }
 522 
 523                 case PDO_ATTR_AUTOCOMMIT:
 524                         ZVAL_BOOL(return_value, dbh->auto_commit);
 525                         return TRUE;
 526 
 527                 case PDO_ATTR_PREFETCH:
 528                         ZVAL_LONG(return_value, H->prefetch);
 529                         return TRUE;
 530                 default:
 531                         return FALSE;
 532 
 533         }
 534         return FALSE;
 535 
 536 }
 537 /* }}} */
 538 
 539 static int pdo_oci_check_liveness(pdo_dbh_t *dbh) /* {{{ */
 540 {
 541         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
 542         sb4 error_code = 0;
 543 #if (!((OCI_MAJOR_VERSION > 10) || ((OCI_MAJOR_VERSION == 10) && (OCI_MINOR_VERSION >= 2))))
 544         char version[256];
 545 #endif
 546 
 547         /* TODO move attached check to PDO level */
 548         if (H->attached == 0) {
 549                 return FAILURE;
 550         }
 551         /* TODO add persistent_timeout check at PDO level */
 552 
 553 
 554         /* Use OCIPing instead of OCIServerVersion. If OCIPing returns ORA-1010 (invalid OCI operation)
 555          * such as from Pre-10.1 servers, the error is still from the server and we would have
 556          * successfully performed a roundtrip and validated the connection. Use OCIServerVersion for
 557          * Pre-10.2 clients
 558          */
 559 #if ((OCI_MAJOR_VERSION > 10) || ((OCI_MAJOR_VERSION == 10) && (OCI_MINOR_VERSION >= 2)))       /* OCIPing available 10.2 onwards */
 560         H->last_err = OCIPing (H->svc, H->err, OCI_DEFAULT);
 561 #else
 562         /* use good old OCIServerVersion() */
 563         H->last_err = OCIServerVersion (H->svc, H->err, (text *)version, sizeof(version), OCI_HTYPE_SVCCTX);
 564 #endif
 565         if (H->last_err == OCI_SUCCESS) {
 566                 return SUCCESS;
 567         }
 568 
 569         OCIErrorGet (H->err, (ub4)1, NULL, &error_code, NULL, 0, OCI_HTYPE_ERROR);
 570 
 571         if (error_code == 1010) {
 572                 return SUCCESS;
 573         }
 574         return FAILURE;
 575 }
 576 /* }}} */
 577 
 578 static struct pdo_dbh_methods oci_methods = {
 579         oci_handle_closer,
 580         oci_handle_preparer,
 581         oci_handle_doer,
 582         oci_handle_quoter,
 583         oci_handle_begin,
 584         oci_handle_commit,
 585         oci_handle_rollback,
 586         oci_handle_set_attribute,
 587         NULL,
 588         pdo_oci_fetch_error_func,
 589         oci_handle_get_attribute,
 590         pdo_oci_check_liveness, /* check_liveness */
 591         NULL    /* get_driver_methods */
 592 };
 593 
 594 static int pdo_oci_handle_factory(pdo_dbh_t *dbh, zval *driver_options) /* {{{ */
 595 {
 596         pdo_oci_db_handle *H;
 597         int i, ret = 0;
 598         struct pdo_data_src_parser vars[] = {
 599                 { "charset",  NULL,     0 },
 600                 { "dbname",   "",       0 }
 601         };
 602 
 603         php_pdo_parse_data_source(dbh->data_source, dbh->data_source_len, vars, 2);
 604 
 605         H = pecalloc(1, sizeof(*H), dbh->is_persistent);
 606         dbh->driver_data = H;
 607 
 608         H->prefetch = PDO_OCI_PREFETCH_DEFAULT;
 609 
 610         /* allocate an environment */
 611 #if HAVE_OCIENVNLSCREATE
 612         if (vars[0].optval) {
 613                 H->charset = OCINlsCharSetNameToId(pdo_oci_Env, (const oratext *)vars[0].optval);
 614                 if (!H->charset) {
 615                         oci_init_error("OCINlsCharSetNameToId: unknown character set name");
 616                         goto cleanup;
 617                 } else {
 618                         if (OCIEnvNlsCreate(&H->env, PDO_OCI_INIT_MODE, 0, NULL, NULL, NULL, 0, NULL, H->charset, H->charset) != OCI_SUCCESS) {
 619                                 oci_init_error("OCIEnvNlsCreate: Check the character set is valid and that PHP has access to Oracle libraries and NLS data");
 620                                 goto cleanup;
 621                         }
 622                 }
 623         }
 624 #endif
 625         if (H->env == NULL) {
 626                 /* use the global environment */
 627                 H->env = pdo_oci_Env;
 628         }
 629 
 630         /* something to hold errors */
 631         OCIHandleAlloc(H->env, (dvoid **)&H->err, OCI_HTYPE_ERROR, 0, NULL);
 632 
 633         /* handle for the server */
 634         OCIHandleAlloc(H->env, (dvoid **)&H->server, OCI_HTYPE_SERVER, 0, NULL);
 635 
 636         H->last_err = OCIServerAttach(H->server, H->err, (text*)vars[1].optval,
 637                         (sb4) strlen(vars[1].optval), OCI_DEFAULT);
 638 
 639         if (H->last_err) {
 640                 oci_drv_error("pdo_oci_handle_factory");
 641                 goto cleanup;
 642         }
 643 
 644         H->attached = 1;
 645 
 646         /* create a service context */
 647         H->last_err = OCIHandleAlloc(H->env, (dvoid**)&H->svc, OCI_HTYPE_SVCCTX, 0, NULL);
 648         if (H->last_err) {
 649                 oci_drv_error("OCIHandleAlloc: OCI_HTYPE_SVCCTX");
 650                 goto cleanup;
 651         }
 652 
 653         H->last_err = OCIHandleAlloc(H->env, (dvoid**)&H->session, OCI_HTYPE_SESSION, 0, NULL);
 654         if (H->last_err) {
 655                 oci_drv_error("OCIHandleAlloc: OCI_HTYPE_SESSION");
 656                 goto cleanup;
 657         }
 658 
 659         /* set server handle into service handle */
 660         H->last_err = OCIAttrSet(H->svc, OCI_HTYPE_SVCCTX, H->server, 0, OCI_ATTR_SERVER, H->err);
 661         if (H->last_err) {
 662                 oci_drv_error("OCIAttrSet: OCI_ATTR_SERVER");
 663                 goto cleanup;
 664         }
 665 
 666         /* username */
 667         if (dbh->username) {
 668                 H->last_err = OCIAttrSet(H->session, OCI_HTYPE_SESSION,
 669                                 dbh->username, (ub4) strlen(dbh->username),
 670                                 OCI_ATTR_USERNAME, H->err);
 671                 if (H->last_err) {
 672                         oci_drv_error("OCIAttrSet: OCI_ATTR_USERNAME");
 673                         goto cleanup;
 674                 }
 675         }
 676 
 677         /* password */
 678         if (dbh->password) {
 679                 H->last_err = OCIAttrSet(H->session, OCI_HTYPE_SESSION,
 680                                 dbh->password, (ub4) strlen(dbh->password),
 681                                 OCI_ATTR_PASSWORD, H->err);
 682                 if (H->last_err) {
 683                         oci_drv_error("OCIAttrSet: OCI_ATTR_PASSWORD");
 684                         goto cleanup;
 685                 }
 686         }
 687 
 688         /* Now fire up the session */
 689         H->last_err = OCISessionBegin(H->svc, H->err, H->session, OCI_CRED_RDBMS, OCI_DEFAULT);
 690         if (H->last_err) {
 691                 oci_drv_error("OCISessionBegin");
 692                 goto cleanup;
 693         }
 694 
 695         /* set the server handle into service handle */
 696         H->last_err = OCIAttrSet(H->svc, OCI_HTYPE_SVCCTX, H->session, 0, OCI_ATTR_SESSION, H->err);
 697         if (H->last_err) {
 698                 oci_drv_error("OCIAttrSet: OCI_ATTR_SESSION");
 699                 goto cleanup;
 700         }
 701 
 702         dbh->methods = &oci_methods;
 703         dbh->alloc_own_columns = 1;
 704         dbh->native_case = PDO_CASE_UPPER;
 705 
 706         ret = 1;
 707 
 708 cleanup:
 709         for (i = 0; i < sizeof(vars)/sizeof(vars[0]); i++) {
 710                 if (vars[i].freeme) {
 711                         efree(vars[i].optval);
 712                 }
 713         }
 714 
 715         if (!ret) {
 716                 oci_handle_closer(dbh);
 717         }
 718 
 719         return ret;
 720 }
 721 /* }}} */
 722 
 723 pdo_driver_t pdo_oci_driver = {
 724         PDO_DRIVER_HEADER(oci),
 725         pdo_oci_handle_factory
 726 };
 727 
 728 static inline ub4 pdo_oci_sanitize_prefetch(long prefetch) /* {{{ */
 729 {
 730         if (prefetch < 0) {
 731                 prefetch = 0;
 732         } else if (prefetch > UB4MAXVAL / PDO_OCI_PREFETCH_ROWSIZE) {
 733                 prefetch = PDO_OCI_PREFETCH_DEFAULT;
 734         }
 735         return ((ub4)prefetch);
 736 }
 737 /* }}} */
 738 
 739 
 740 /*
 741  * Local variables:
 742  * tab-width: 4
 743  * c-basic-offset: 4
 744  * End:
 745  * vim600: noet sw=4 ts=4 fdm=marker
 746  * vim<600: noet sw=4 ts=4
 747  */
/* [<][>][^][v][top][bottom][index][help] */
root/ext/pdo_oci/oci_driver.c

DEFINITIONS
