PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/pdo_oci - oci_driver.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 251 326 77.0 %
Date: 2016-05-22 Functions: 14 14 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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          24 : static int pdo_oci_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *info) /* {{{ */
      37             : {
      38          24 :         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
      39             :         pdo_oci_error_info *einfo;
      40             : 
      41          24 :         einfo = &H->einfo;
      42             : 
      43          24 :         if (stmt) {
      44          10 :                 pdo_oci_stmt *S = (pdo_oci_stmt*)stmt->driver_data;
      45             : 
      46          10 :                 if (S->einfo.errmsg) {
      47           6 :                         einfo = &S->einfo;
      48             :                 }
      49             :         }
      50             : 
      51          24 :         if (einfo->errcode) {
      52          20 :                 add_next_index_long(info, einfo->errcode);
      53          20 :                 add_next_index_string(info, einfo->errmsg);
      54             :         }
      55             : 
      56          24 :         return 1;
      57             : }
      58             : /* }}} */
      59             : 
      60      143045 : 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      143045 :         text errbuf[1024] = "<<Unknown>>";
      63             :         char tmp_buf[2048];
      64      143045 :         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
      65             :         pdo_oci_error_info *einfo;
      66      143045 :         pdo_oci_stmt *S = NULL;
      67      143045 :         pdo_error_type *pdo_err = &dbh->error_code;
      68             : 
      69      143045 :         if (stmt) {
      70      142595 :                 S = (pdo_oci_stmt*)stmt->driver_data;
      71      142595 :                 einfo = &S->einfo;
      72      142595 :                 pdo_err = &stmt->error_code;
      73             :         }
      74             :         else {
      75         450 :                 einfo = &H->einfo;
      76             :         }
      77             : 
      78      143045 :         if (einfo->errmsg) {
      79         287 :                 pefree(einfo->errmsg, dbh->is_persistent);
      80             :         }
      81             : 
      82      143045 :         einfo->errmsg = NULL;
      83      143045 :         einfo->errcode = 0;
      84      143045 :         einfo->file = file;
      85      143045 :         einfo->line = line;
      86             : 
      87      143045 :         if (isinit) { /* Initialization error */
      88           1 :                 strcpy(*pdo_err, "HY000");
      89           1 :                 slprintf(tmp_buf, sizeof(tmp_buf), "%s (%s:%d)", what, file, line);
      90           1 :                 einfo->errmsg = pestrdup(tmp_buf, dbh->is_persistent);
      91             :         }
      92             :         else {
      93      143044 :                 switch (status) {
      94             :                         case OCI_SUCCESS:
      95      142590 :                                 strcpy(*pdo_err, "00000");
      96      142590 :                                 break;
      97             :                         case OCI_ERROR:
      98         454 :                                 OCIErrorGet(err, (ub4)1, NULL, &einfo->errcode, errbuf, (ub4)sizeof(errbuf), OCI_HTYPE_ERROR);
      99         454 :                                 slprintf(tmp_buf, sizeof(tmp_buf), "%s: %s (%s:%d)", what, errbuf, file, line);
     100         454 :                                 einfo->errmsg = pestrdup(tmp_buf, dbh->is_persistent);
     101         454 :                                 break;
     102             :                         case OCI_SUCCESS_WITH_INFO:
     103           0 :                                 OCIErrorGet(err, (ub4)1, NULL, &einfo->errcode, errbuf, (ub4)sizeof(errbuf), OCI_HTYPE_ERROR);
     104           0 :                                 slprintf(tmp_buf, sizeof(tmp_buf), "%s: OCI_SUCCESS_WITH_INFO: %s (%s:%d)", what, errbuf, file, line);
     105           0 :                                 einfo->errmsg = pestrdup(tmp_buf, dbh->is_persistent);
     106           0 :                                 break;
     107             :                         case OCI_NEED_DATA:
     108           0 :                                 slprintf(tmp_buf, sizeof(tmp_buf), "%s: OCI_NEED_DATA (%s:%d)", what, file, line);
     109           0 :                                 einfo->errmsg = pestrdup(tmp_buf, dbh->is_persistent);
     110           0 :                                 break;
     111             :                         case OCI_NO_DATA:
     112           0 :                                 slprintf(tmp_buf, sizeof(tmp_buf), "%s: OCI_NO_DATA (%s:%d)", what, file, line);
     113           0 :                                 einfo->errmsg = pestrdup(tmp_buf, dbh->is_persistent);
     114           0 :                                 break;
     115             :                         case OCI_INVALID_HANDLE:
     116           0 :                                 slprintf(tmp_buf, sizeof(tmp_buf), "%s: OCI_INVALID_HANDLE (%s:%d)", what, file, line);
     117           0 :                                 einfo->errmsg = pestrdup(tmp_buf, dbh->is_persistent);
     118           0 :                                 break;
     119             :                         case OCI_STILL_EXECUTING:
     120           0 :                                 slprintf(tmp_buf, sizeof(tmp_buf), "%s: OCI_STILL_EXECUTING (%s:%d)", what, file, line);
     121           0 :                                 einfo->errmsg = pestrdup(tmp_buf, dbh->is_persistent);
     122           0 :                                 break;
     123             :                         case OCI_CONTINUE:
     124           0 :                                 slprintf(tmp_buf, sizeof(tmp_buf), "%s: OCI_CONTINUE (%s:%d)", what, file, line);
     125           0 :                                 einfo->errmsg = pestrdup(tmp_buf, dbh->is_persistent);
     126             :                                 break;
     127             :                 }
     128             : 
     129      143044 :                 if (einfo->errcode) {
     130         454 :                         switch (einfo->errcode) {
     131             :                                 case 1013:      /* user requested cancel of current operation */
     132           0 :                                         zend_bailout();
     133           0 :                                         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           0 :                                         strcpy(*pdo_err, "42S02");
     143           0 :                                         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           0 :                                         dbh->is_closed = 1;
     167           0 :                                         H->attached = 0;
     168           0 :                                         strcpy(*pdo_err, "01002"); /* FIXME */
     169           0 :                                         break;
     170             : 
     171             :                                 default:
     172         454 :                                         strcpy(*pdo_err, "HY000");
     173             :                         }
     174             :                 }
     175             : 
     176      143044 :                 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      142595 :                         if (H->einfo.errmsg) {
     181          73 :                                 pefree(H->einfo.errmsg, dbh->is_persistent);
     182             :                         }
     183      142595 :                         H->einfo = *einfo;
     184      142595 :                         H->einfo.errmsg = einfo->errmsg ? pestrdup(einfo->errmsg, dbh->is_persistent) : NULL;
     185      142595 :                         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      143045 :         if (!dbh->methods) {
     191           1 :                 zend_throw_exception_ex(php_pdo_get_exception(), einfo->errcode, "SQLSTATE[%s]: %s", *pdo_err, einfo->errmsg);
     192             :         }
     193             : 
     194      143045 :         return einfo->errcode;
     195             : }
     196             : /* }}} */
     197             : 
     198         165 : static int oci_handle_closer(pdo_dbh_t *dbh) /* {{{ */
     199             : {
     200         165 :         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
     201             : 
     202         165 :         if (H->svc) {
     203             :                 /* rollback any outstanding work */
     204         164 :                 OCITransRollback(H->svc, H->err, 0);
     205             :         }
     206             : 
     207         165 :         if (H->session) {
     208         164 :                 OCIHandleFree(H->session, OCI_HTYPE_SESSION);
     209         164 :                 H->session = NULL;
     210             :         }
     211             : 
     212         165 :         if (H->svc) {
     213         164 :                 OCIHandleFree(H->svc, OCI_HTYPE_SVCCTX);
     214         164 :                 H->svc = NULL;
     215             :         }
     216             : 
     217         165 :         if (H->server && H->attached) {
     218         164 :                 H->last_err = OCIServerDetach(H->server, H->err, OCI_DEFAULT);
     219         164 :                 if (H->last_err) {
     220           0 :                         oci_drv_error("OCIServerDetach");
     221             :                 }
     222         164 :                 H->attached = 0;
     223             :         }
     224             : 
     225         165 :         if (H->server) {
     226         164 :                 OCIHandleFree(H->server, OCI_HTYPE_SERVER);
     227         164 :                 H->server = NULL;
     228             :         }
     229             : 
     230         165 :         if (H->err) {
     231         164 :                 OCIHandleFree(H->err, OCI_HTYPE_ERROR);
     232         164 :                 H->err = NULL;
     233             :         }
     234             : 
     235         165 :         if (H->charset && H->env) {
     236         164 :                 OCIHandleFree(H->env, OCI_HTYPE_ENV);
     237         164 :                 H->env = NULL;
     238             :         }
     239             : 
     240         165 :         if (H->einfo.errmsg) {
     241          96 :                 pefree(H->einfo.errmsg, dbh->is_persistent);
     242          96 :                 H->einfo.errmsg = NULL;
     243             :         }
     244             : 
     245         165 :         pefree(H, dbh->is_persistent);
     246             : 
     247         165 :         return 0;
     248             : }
     249             : /* }}} */
     250             : 
     251       10180 : 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       10180 :         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
     254       10180 :         pdo_oci_stmt *S = ecalloc(1, sizeof(*S));
     255             :         ub4 prefetch;
     256       10180 :         char *nsql = NULL;
     257       10180 :         size_t nsql_len = 0;
     258             :         int ret;
     259             : 
     260             : #if HAVE_OCISTMTFETCH2
     261       10180 :         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       10180 :         S->H = H;
     269       10180 :         stmt->supports_placeholders = PDO_PLACEHOLDER_NAMED;
     270       10180 :         ret = pdo_parse_params(stmt, (char*)sql, sql_len, &nsql, &nsql_len);
     271             : 
     272       10180 :         if (ret == 1) {
     273             :                 /* query was re-written */
     274          11 :                 sql = nsql;
     275          11 :                 sql_len = nsql_len;
     276       10169 :         } else if (ret == -1) {
     277             :                 /* couldn't grok it */
     278           0 :                 strcpy(dbh->error_code, stmt->error_code);
     279           0 :                 efree(S);
     280           0 :                 return 0;
     281             :         }
     282             : 
     283             :         /* create an OCI statement handle */
     284       10180 :         OCIHandleAlloc(H->env, (dvoid*)&S->stmt, OCI_HTYPE_STMT, 0, NULL);
     285             : 
     286             :         /* and our own private error handle */
     287       10180 :         OCIHandleAlloc(H->env, (dvoid*)&S->err, OCI_HTYPE_ERROR, 0, NULL);
     288             : 
     289       10180 :         if (sql_len) {
     290       10180 :                 H->last_err = OCIStmtPrepare(S->stmt, H->err, (text*)sql, (ub4) sql_len, OCI_NTV_SYNTAX, OCI_DEFAULT);
     291       10180 :                 if (nsql) {
     292          11 :                         efree(nsql);
     293          11 :                         nsql = NULL;
     294             :                 }
     295       10180 :                 if (H->last_err) {
     296           0 :                         H->last_err = oci_drv_error("OCIStmtPrepare");
     297           0 :                         OCIHandleFree(S->stmt, OCI_HTYPE_STMT);
     298           0 :                         OCIHandleFree(S->err, OCI_HTYPE_ERROR);
     299           0 :                         efree(S);
     300           0 :                         return 0;
     301             :                 }
     302             : 
     303             :         }
     304             : 
     305       10180 :         prefetch = H->prefetch;  /* Note 0 is allowed so in future REF CURSORs can be used & then passed with no row loss*/
     306       10180 :         H->last_err = OCIAttrSet(S->stmt, OCI_HTYPE_STMT, &prefetch, 0,
     307             :                                                          OCI_ATTR_PREFETCH_ROWS, H->err);
     308       10180 :         if (!H->last_err) {
     309       10180 :                 prefetch *= PDO_OCI_PREFETCH_ROWSIZE;
     310       10180 :                 H->last_err = OCIAttrSet(S->stmt, OCI_HTYPE_STMT, &prefetch, 0,
     311             :                                                                  OCI_ATTR_PREFETCH_MEMORY, H->err);
     312             :         }
     313             : 
     314       10180 :         stmt->driver_data = S;
     315       10180 :         stmt->methods = &oci_stmt_methods;
     316       10180 :         if (nsql) {
     317           0 :                 efree(nsql);
     318           0 :                 nsql = NULL;
     319             :         }
     320             : 
     321       10180 :         return 1;
     322             : }
     323             : /* }}} */
     324             : 
     325         690 : static zend_long oci_handle_doer(pdo_dbh_t *dbh, const char *sql, size_t sql_len) /* {{{ */
     326             : {
     327         690 :         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
     328             :         OCIStmt         *stmt;
     329             :         ub2 stmt_type;
     330             :         ub4 rowcount;
     331         690 :         int ret = -1;
     332             : 
     333         690 :         OCIHandleAlloc(H->env, (dvoid*)&stmt, OCI_HTYPE_STMT, 0, NULL);
     334             : 
     335         690 :         H->last_err = OCIStmtPrepare(stmt, H->err, (text*)sql, (ub4) sql_len, OCI_NTV_SYNTAX, OCI_DEFAULT);
     336         690 :         if (H->last_err) {
     337           0 :                 H->last_err = oci_drv_error("OCIStmtPrepare");
     338           0 :                 OCIHandleFree(stmt, OCI_HTYPE_STMT);
     339           0 :                 return -1;
     340             :         }
     341             : 
     342         690 :         H->last_err = OCIAttrGet(stmt, OCI_HTYPE_STMT, &stmt_type, 0, OCI_ATTR_STMT_TYPE, H->err);
     343             : 
     344         690 :         if (stmt_type == OCI_STMT_SELECT) {
     345             :                 /* invalid usage; cancel it */
     346           0 :                 OCIHandleFree(stmt, OCI_HTYPE_STMT);
     347           0 :                 php_error_docref(NULL, E_WARNING, "issuing a SELECT query here is invalid");
     348           0 :                 return -1;
     349             :         }
     350             : 
     351             :         /* now we are good to go */
     352        1365 :         H->last_err = OCIStmtExecute(H->svc, stmt, H->err, 1, 0, NULL, NULL,
     353        1365 :                         (dbh->auto_commit && !dbh->in_txn) ? OCI_COMMIT_ON_SUCCESS : OCI_DEFAULT);
     354             : 
     355         690 :         if (H->last_err) {
     356         449 :                 H->last_err = oci_drv_error("OCIStmtExecute");
     357             :         } else {
     358             :                 /* return the number of affected rows */
     359         241 :                 H->last_err = OCIAttrGet(stmt, OCI_HTYPE_STMT, &rowcount, 0, OCI_ATTR_ROW_COUNT, H->err);
     360         241 :                 ret = rowcount;
     361             :         }
     362             : 
     363         690 :         OCIHandleFree(stmt, OCI_HTYPE_STMT);
     364             : 
     365         690 :         return ret;
     366             : }
     367             : /* }}} */
     368             : 
     369          14 : 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          14 :         int qcount = 0;
     372             :         char const *cu, *l, *r;
     373             :         char *c;
     374             : 
     375          14 :         if (!unquotedlen) {
     376           2 :                 *quotedlen = 2;
     377           2 :                 *quoted = emalloc(*quotedlen+1);
     378           2 :                 strcpy(*quoted, "''");
     379           2 :                 return 1;
     380             :         }
     381             : 
     382             :         /* count single quotes */
     383          12 :         for (cu = unquoted; (cu = strchr(cu,'\'')); qcount++, cu++)
     384             :                 ; /* empty loop */
     385             : 
     386          12 :         *quotedlen = unquotedlen + qcount + 2;
     387          12 :         *quoted = c = emalloc(*quotedlen+1);
     388          12 :         *c++ = '\'';
     389             : 
     390             :         /* foreach (chunk that ends in a quote) */
     391          21 :         for (l = unquoted; (r = strchr(l,'\'')); l = r+1) {
     392           9 :                 strncpy(c, l, r-l+1);
     393           9 :                 c += (r-l+1);
     394           9 :                 *c++ = '\'';                    /* add second quote */
     395             :         }
     396             : 
     397             :     /* Copy remainder and add enclosing quote */
     398          12 :         strncpy(c, l, *quotedlen-(c-*quoted)-1);
     399          12 :         (*quoted)[*quotedlen-1] = '\'';
     400          12 :         (*quoted)[*quotedlen]   = '\0';
     401             : 
     402          12 :         return 1;
     403             : }
     404             : /* }}} */
     405             : 
     406       10011 : static int oci_handle_begin(pdo_dbh_t *dbh) /* {{{ */
     407             : {
     408             :         /* with Oracle, there is nothing special to be done */
     409       10011 :         return 1;
     410             : }
     411             : /* }}} */
     412             : 
     413       10004 : static int oci_handle_commit(pdo_dbh_t *dbh) /* {{{ */
     414             : {
     415       10004 :         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
     416             : 
     417       10004 :         H->last_err = OCITransCommit(H->svc, H->err, 0);
     418             : 
     419       10004 :         if (H->last_err) {
     420           0 :                 H->last_err = oci_drv_error("OCITransCommit");
     421           0 :                 return 0;
     422             :         }
     423       10004 :         return 1;
     424             : }
     425             : /* }}} */
     426             : 
     427           6 : static int oci_handle_rollback(pdo_dbh_t *dbh) /* {{{ */
     428             : {
     429           6 :         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
     430             : 
     431           6 :         H->last_err = OCITransRollback(H->svc, H->err, 0);
     432             : 
     433           6 :         if (H->last_err) {
     434           0 :                 H->last_err = oci_drv_error("OCITransRollback");
     435           0 :                 return 0;
     436             :         }
     437           6 :         return 1;
     438             : }
     439             : /* }}} */
     440             : 
     441          16 : static int oci_handle_set_attribute(pdo_dbh_t *dbh, zend_long attr, zval *val) /* {{{ */
     442             : {
     443          16 :         zend_long lval = zval_get_long(val);
     444          16 :         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
     445             : 
     446          16 :         if (attr == PDO_ATTR_AUTOCOMMIT) {
     447           6 :                 if (dbh->in_txn) {
     448             :                         /* Assume they want to commit whatever is outstanding */
     449           1 :                         H->last_err = OCITransCommit(H->svc, H->err, 0);
     450             : 
     451           1 :                         if (H->last_err) {
     452           0 :                                 H->last_err = oci_drv_error("OCITransCommit");
     453           0 :                                 return 0;
     454             :                         }
     455           1 :                         dbh->in_txn = 0;
     456             :                 }
     457             : 
     458           6 :                 dbh->auto_commit = (unsigned int)lval? 1 : 0;
     459           6 :                 return 1;
     460          10 :         } else if (attr == PDO_ATTR_PREFETCH) {
     461           4 :                 H->prefetch = pdo_oci_sanitize_prefetch(lval);
     462           4 :                 return 1;
     463             :         } else {
     464           6 :                 return 0;
     465             :         }
     466             : 
     467             : }
     468             : /* }}} */
     469             : 
     470          14 : static int oci_handle_get_attribute(pdo_dbh_t *dbh, zend_long attr, zval *return_value)  /* {{{ */
     471             : {
     472          14 :         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
     473             : 
     474          14 :         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           2 :                         if (OCIServerRelease(H->svc, H->err, infostr, (ub4)sizeof(infostr), (ub1)OCI_HTYPE_SVCCTX, &vernum))
     483             :                         {
     484           0 :                                 ZVAL_STRING(return_value, "<<Unknown>>");
     485             :                         } else {
     486           2 :                                 if (attr == PDO_ATTR_SERVER_INFO) {
     487           2 :                                         ZVAL_STRING(return_value, (char *)infostr);
     488             :                                 } else {
     489           5 :                                         slprintf(verstr, sizeof(verstr), "%d.%d.%d.%d.%d",
     490           1 :                                                          (int)((vernum>>24) & 0xFF),  /* version number */
     491           1 :                                                          (int)((vernum>>20) & 0x0F),  /* release number*/
     492           1 :                                                          (int)((vernum>>12) & 0xFF),  /* update number */
     493           1 :                                                          (int)((vernum>>8)  & 0x0F),  /* port release number */
     494             :                                                          (int)((vernum>>0)  & 0xFF)); /* port update number */
     495             : 
     496           2 :                                         ZVAL_STRING(return_value, verstr);
     497             :                                 }
     498             :                         }
     499           2 :                         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           1 :                         OCIClientVersion(&major, &minor, &update, &patch, &port_update);
     510           1 :                         slprintf(verstr, sizeof(verstr), "%d.%d.%d.%d.%d", major, minor, update, patch, port_update);
     511           2 :                         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           1 :                         return TRUE;
     521             :                 }
     522             : 
     523             :                 case PDO_ATTR_AUTOCOMMIT:
     524           7 :                         ZVAL_BOOL(return_value, dbh->auto_commit);
     525           7 :                         return TRUE;
     526             : 
     527             :                 case PDO_ATTR_PREFETCH:
     528           4 :                         ZVAL_LONG(return_value, H->prefetch);
     529           4 :                         return TRUE;
     530             :                 default:
     531           0 :                         return FALSE;
     532             : 
     533             :         }
     534             :         return FALSE;
     535             : 
     536             : }
     537             : /* }}} */
     538             : 
     539           1 : static int pdo_oci_check_liveness(pdo_dbh_t *dbh) /* {{{ */
     540             : {
     541           1 :         pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
     542           1 :         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           1 :         if (H->attached == 0) {
     549           0 :                 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           1 :         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           1 :         if (H->last_err == OCI_SUCCESS) {
     566           1 :                 return SUCCESS;
     567             :         }
     568             : 
     569           0 :         OCIErrorGet (H->err, (ub4)1, NULL, &error_code, NULL, 0, OCI_HTYPE_ERROR);
     570             : 
     571           0 :         if (error_code == 1010) {
     572           0 :                 return SUCCESS;
     573             :         }
     574           0 :         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         165 : static int pdo_oci_handle_factory(pdo_dbh_t *dbh, zval *driver_options) /* {{{ */
     595             : {
     596             :         pdo_oci_db_handle *H;
     597         165 :         int i, ret = 0;
     598             :         struct pdo_data_src_parser vars[] = {
     599             :                 { "charset",  NULL,   0 },
     600             :                 { "dbname",   "",   0 }
     601         165 :         };
     602             : 
     603         165 :         php_pdo_parse_data_source(dbh->data_source, dbh->data_source_len, vars, 2);
     604             : 
     605         165 :         H = pecalloc(1, sizeof(*H), dbh->is_persistent);
     606         165 :         dbh->driver_data = H;
     607             : 
     608         165 :         H->prefetch = PDO_OCI_PREFETCH_DEFAULT;
     609             : 
     610             :         /* allocate an environment */
     611             : #if HAVE_OCIENVNLSCREATE
     612         165 :         if (vars[0].optval) {
     613         165 :                 H->charset = OCINlsCharSetNameToId(pdo_oci_Env, (const oratext *)vars[0].optval);
     614         165 :                 if (!H->charset) {
     615           1 :                         oci_init_error("OCINlsCharSetNameToId: unknown character set name");
     616           1 :                         goto cleanup;
     617             :                 } else {
     618         164 :                         if (OCIEnvNlsCreate(&H->env, PDO_OCI_INIT_MODE, 0, NULL, NULL, NULL, 0, NULL, H->charset, H->charset) != OCI_SUCCESS) {
     619           0 :                                 oci_init_error("OCIEnvNlsCreate: Check the character set is valid and that PHP has access to Oracle libraries and NLS data");
     620           0 :                                 goto cleanup;
     621             :                         }
     622             :                 }
     623             :         }
     624             : #endif
     625         164 :         if (H->env == NULL) {
     626             :                 /* use the global environment */
     627           0 :                 H->env = pdo_oci_Env;
     628             :         }
     629             : 
     630             :         /* something to hold errors */
     631         164 :         OCIHandleAlloc(H->env, (dvoid **)&H->err, OCI_HTYPE_ERROR, 0, NULL);
     632             : 
     633             :         /* handle for the server */
     634         164 :         OCIHandleAlloc(H->env, (dvoid **)&H->server, OCI_HTYPE_SERVER, 0, NULL);
     635             : 
     636         164 :         H->last_err = OCIServerAttach(H->server, H->err, (text*)vars[1].optval,
     637         164 :                         (sb4) strlen(vars[1].optval), OCI_DEFAULT);
     638             : 
     639         164 :         if (H->last_err) {
     640           0 :                 oci_drv_error("pdo_oci_handle_factory");
     641           0 :                 goto cleanup;
     642             :         }
     643             : 
     644         164 :         H->attached = 1;
     645             : 
     646             :         /* create a service context */
     647         164 :         H->last_err = OCIHandleAlloc(H->env, (dvoid**)&H->svc, OCI_HTYPE_SVCCTX, 0, NULL);
     648         164 :         if (H->last_err) {
     649           0 :                 oci_drv_error("OCIHandleAlloc: OCI_HTYPE_SVCCTX");
     650           0 :                 goto cleanup;
     651             :         }
     652             : 
     653         164 :         H->last_err = OCIHandleAlloc(H->env, (dvoid**)&H->session, OCI_HTYPE_SESSION, 0, NULL);
     654         164 :         if (H->last_err) {
     655           0 :                 oci_drv_error("OCIHandleAlloc: OCI_HTYPE_SESSION");
     656           0 :                 goto cleanup;
     657             :         }
     658             : 
     659             :         /* set server handle into service handle */
     660         164 :         H->last_err = OCIAttrSet(H->svc, OCI_HTYPE_SVCCTX, H->server, 0, OCI_ATTR_SERVER, H->err);
     661         164 :         if (H->last_err) {
     662           0 :                 oci_drv_error("OCIAttrSet: OCI_ATTR_SERVER");
     663           0 :                 goto cleanup;
     664             :         }
     665             : 
     666             :         /* username */
     667         164 :         if (dbh->username) {
     668         492 :                 H->last_err = OCIAttrSet(H->session, OCI_HTYPE_SESSION,
     669         328 :                                 dbh->username, (ub4) strlen(dbh->username),
     670             :                                 OCI_ATTR_USERNAME, H->err);
     671         164 :                 if (H->last_err) {
     672           0 :                         oci_drv_error("OCIAttrSet: OCI_ATTR_USERNAME");
     673           0 :                         goto cleanup;
     674             :                 }
     675             :         }
     676             : 
     677             :         /* password */
     678         164 :         if (dbh->password) {
     679         492 :                 H->last_err = OCIAttrSet(H->session, OCI_HTYPE_SESSION,
     680         328 :                                 dbh->password, (ub4) strlen(dbh->password),
     681             :                                 OCI_ATTR_PASSWORD, H->err);
     682         164 :                 if (H->last_err) {
     683           0 :                         oci_drv_error("OCIAttrSet: OCI_ATTR_PASSWORD");
     684           0 :                         goto cleanup;
     685             :                 }
     686             :         }
     687             : 
     688             :         /* Now fire up the session */
     689         164 :         H->last_err = OCISessionBegin(H->svc, H->err, H->session, OCI_CRED_RDBMS, OCI_DEFAULT);
     690         164 :         if (H->last_err) {
     691           0 :                 oci_drv_error("OCISessionBegin");
     692           0 :                 goto cleanup;
     693             :         }
     694             : 
     695             :         /* set the server handle into service handle */
     696         164 :         H->last_err = OCIAttrSet(H->svc, OCI_HTYPE_SVCCTX, H->session, 0, OCI_ATTR_SESSION, H->err);
     697         164 :         if (H->last_err) {
     698           0 :                 oci_drv_error("OCIAttrSet: OCI_ATTR_SESSION");
     699           0 :                 goto cleanup;
     700             :         }
     701             : 
     702         164 :         dbh->methods = &oci_methods;
     703         164 :         dbh->alloc_own_columns = 1;
     704         164 :         dbh->native_case = PDO_CASE_UPPER;
     705             : 
     706         164 :         ret = 1;
     707             : 
     708             : cleanup:
     709         495 :         for (i = 0; i < sizeof(vars)/sizeof(vars[0]); i++) {
     710         330 :                 if (vars[i].freeme) {
     711         330 :                         efree(vars[i].optval);
     712             :                 }
     713             :         }
     714             : 
     715         165 :         if (!ret) {
     716           1 :                 oci_handle_closer(dbh);
     717             :         }
     718             : 
     719         165 :         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           4 : static inline ub4 pdo_oci_sanitize_prefetch(long prefetch) /* {{{ */
     729             : {
     730           4 :         if (prefetch < 0) {
     731           1 :                 prefetch = 0;
     732           3 :         } else if (prefetch > UB4MAXVAL / PDO_OCI_PREFETCH_ROWSIZE) {
     733           1 :                 prefetch = PDO_OCI_PREFETCH_DEFAULT;
     734             :         }
     735           4 :         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             :  */

Generated by: LCOV version 1.10

Generated at Sun, 22 May 2016 10:53:01 +0000 (43 hours ago)

Copyright © 2005-2016 The PHP Group
All rights reserved.