1/*
2  +----------------------------------------------------------------------+
3  | PHP Version 7                                                        |
4  +----------------------------------------------------------------------+
5  | Copyright (c) 1997-2015 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
34static inline ub4 pdo_oci_sanitize_prefetch(long prefetch);
35
36static 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
60ub4 _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
198static 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
251static 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
325static 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
369static 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
406static 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
413static 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
427static 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
441static int oci_handle_set_attribute(pdo_dbh_t *dbh, zend_long attr, zval *val) /* {{{ */
442{
443    pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
444
445    if (attr == PDO_ATTR_AUTOCOMMIT) {
446        if (dbh->in_txn) {
447            /* Assume they want to commit whatever is outstanding */
448            H->last_err = OCITransCommit(H->svc, H->err, 0);
449
450            if (H->last_err) {
451                H->last_err = oci_drv_error("OCITransCommit");
452                return 0;
453            }
454            dbh->in_txn = 0;
455        }
456
457        convert_to_long(val);
458
459        dbh->auto_commit = (unsigned int) (Z_LVAL_P(val)) ? 1 : 0;
460        return 1;
461    } else if (attr == PDO_ATTR_PREFETCH) {
462        convert_to_long(val);
463        H->prefetch = pdo_oci_sanitize_prefetch(Z_LVAL_P(val));
464        return 1;
465    } else {
466        return 0;
467    }
468
469}
470/* }}} */
471
472static int oci_handle_get_attribute(pdo_dbh_t *dbh, zend_long attr, zval *return_value)  /* {{{ */
473{
474    pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
475
476    switch (attr) {
477        case PDO_ATTR_SERVER_VERSION:
478        case PDO_ATTR_SERVER_INFO:
479        {
480            text infostr[512];
481            char verstr[15];
482            ub4  vernum;
483
484            if (OCIServerRelease(H->svc, H->err, infostr, (ub4)sizeof(infostr), (ub1)OCI_HTYPE_SVCCTX, &vernum))
485            {
486                ZVAL_STRING(return_value, "<<Unknown>>");
487            } else {
488                if (attr == PDO_ATTR_SERVER_INFO) {
489                    ZVAL_STRING(return_value, (char *)infostr);
490                } else {
491                    slprintf(verstr, sizeof(verstr), "%d.%d.%d.%d.%d",
492                             (int)((vernum>>24) & 0xFF),  /* version number */
493                             (int)((vernum>>20) & 0x0F),  /* release number*/
494                             (int)((vernum>>12) & 0xFF),  /* update number */
495                             (int)((vernum>>8)  & 0x0F),  /* port release number */
496                             (int)((vernum>>0)  & 0xFF)); /* port update number */
497
498                    ZVAL_STRING(return_value, verstr);
499                }
500            }
501            return TRUE;
502        }
503
504        case PDO_ATTR_CLIENT_VERSION:
505        {
506#if OCI_MAJOR_VERSION > 10 || (OCI_MAJOR_VERSION == 10 && OCI_MINOR_VERSION >= 2)
507            /* Run time client version */
508            sword major, minor, update, patch, port_update;
509            char verstr[15];
510
511            OCIClientVersion(&major, &minor, &update, &patch, &port_update);
512            slprintf(verstr, sizeof(verstr), "%d.%d.%d.%d.%d", major, minor, update, patch, port_update);
513            ZVAL_STRING(return_value, verstr);
514#elif defined(PHP_PDO_OCI_CLIENT_VERSION)
515            /* Compile time client version */
516            ZVAL_STRING(return_value, PHP_PDO_OCI_CLIENT_VERSION);
517#else
518            return FALSE;
519
520#endif /* Check for OCIClientVersion() support */
521
522            return TRUE;
523        }
524
525        case PDO_ATTR_AUTOCOMMIT:
526            ZVAL_BOOL(return_value, dbh->auto_commit);
527            return TRUE;
528
529        case PDO_ATTR_PREFETCH:
530            ZVAL_LONG(return_value, H->prefetch);
531            return TRUE;
532        default:
533            return FALSE;
534
535    }
536    return FALSE;
537
538}
539/* }}} */
540
541static int pdo_oci_check_liveness(pdo_dbh_t *dbh) /* {{{ */
542{
543    pdo_oci_db_handle *H = (pdo_oci_db_handle *)dbh->driver_data;
544    sb4 error_code = 0;
545#if (!((OCI_MAJOR_VERSION > 10) || ((OCI_MAJOR_VERSION == 10) && (OCI_MINOR_VERSION >= 2))))
546    char version[256];
547#endif
548
549    /* TODO move attached check to PDO level */
550    if (H->attached == 0) {
551        return FAILURE;
552    }
553    /* TODO add persistent_timeout check at PDO level */
554
555
556    /* Use OCIPing instead of OCIServerVersion. If OCIPing returns ORA-1010 (invalid OCI operation)
557     * such as from Pre-10.1 servers, the error is still from the server and we would have
558     * successfully performed a roundtrip and validated the connection. Use OCIServerVersion for
559     * Pre-10.2 clients
560     */
561#if ((OCI_MAJOR_VERSION > 10) || ((OCI_MAJOR_VERSION == 10) && (OCI_MINOR_VERSION >= 2)))   /* OCIPing available 10.2 onwards */
562    H->last_err = OCIPing (H->svc, H->err, OCI_DEFAULT);
563#else
564    /* use good old OCIServerVersion() */
565    H->last_err = OCIServerVersion (H->svc, H->err, (text *)version, sizeof(version), OCI_HTYPE_SVCCTX);
566#endif
567    if (H->last_err == OCI_SUCCESS) {
568        return SUCCESS;
569    }
570
571    OCIErrorGet (H->err, (ub4)1, NULL, &error_code, NULL, 0, OCI_HTYPE_ERROR);
572
573    if (error_code == 1010) {
574        return SUCCESS;
575    }
576    return FAILURE;
577}
578/* }}} */
579
580static struct pdo_dbh_methods oci_methods = {
581    oci_handle_closer,
582    oci_handle_preparer,
583    oci_handle_doer,
584    oci_handle_quoter,
585    oci_handle_begin,
586    oci_handle_commit,
587    oci_handle_rollback,
588    oci_handle_set_attribute,
589    NULL,
590    pdo_oci_fetch_error_func,
591    oci_handle_get_attribute,
592    pdo_oci_check_liveness, /* check_liveness */
593    NULL    /* get_driver_methods */
594};
595
596static int pdo_oci_handle_factory(pdo_dbh_t *dbh, zval *driver_options) /* {{{ */
597{
598    pdo_oci_db_handle *H;
599    int i, ret = 0;
600    struct pdo_data_src_parser vars[] = {
601        { "charset",  NULL, 0 },
602        { "dbname",   "",   0 }
603    };
604
605    php_pdo_parse_data_source(dbh->data_source, dbh->data_source_len, vars, 2);
606
607    H = pecalloc(1, sizeof(*H), dbh->is_persistent);
608    dbh->driver_data = H;
609
610    H->prefetch = PDO_OCI_PREFETCH_DEFAULT;
611
612    /* allocate an environment */
613#if HAVE_OCIENVNLSCREATE
614    if (vars[0].optval) {
615        H->charset = OCINlsCharSetNameToId(pdo_oci_Env, (const oratext *)vars[0].optval);
616        if (!H->charset) {
617            oci_init_error("OCINlsCharSetNameToId: unknown character set name");
618            goto cleanup;
619        } else {
620            if (OCIEnvNlsCreate(&H->env, PDO_OCI_INIT_MODE, 0, NULL, NULL, NULL, 0, NULL, H->charset, H->charset) != OCI_SUCCESS) {
621                oci_init_error("OCIEnvNlsCreate: Check the character set is valid and that PHP has access to Oracle libraries and NLS data");
622                goto cleanup;
623            }
624        }
625    }
626#endif
627    if (H->env == NULL) {
628        /* use the global environment */
629        H->env = pdo_oci_Env;
630    }
631
632    /* something to hold errors */
633    OCIHandleAlloc(H->env, (dvoid **)&H->err, OCI_HTYPE_ERROR, 0, NULL);
634
635    /* handle for the server */
636    OCIHandleAlloc(H->env, (dvoid **)&H->server, OCI_HTYPE_SERVER, 0, NULL);
637
638    H->last_err = OCIServerAttach(H->server, H->err, (text*)vars[1].optval,
639            (sb4) strlen(vars[1].optval), OCI_DEFAULT);
640
641    if (H->last_err) {
642        oci_drv_error("pdo_oci_handle_factory");
643        goto cleanup;
644    }
645
646    H->attached = 1;
647
648    /* create a service context */
649    H->last_err = OCIHandleAlloc(H->env, (dvoid**)&H->svc, OCI_HTYPE_SVCCTX, 0, NULL);
650    if (H->last_err) {
651        oci_drv_error("OCIHandleAlloc: OCI_HTYPE_SVCCTX");
652        goto cleanup;
653    }
654
655    H->last_err = OCIHandleAlloc(H->env, (dvoid**)&H->session, OCI_HTYPE_SESSION, 0, NULL);
656    if (H->last_err) {
657        oci_drv_error("OCIHandleAlloc: OCI_HTYPE_SESSION");
658        goto cleanup;
659    }
660
661    /* set server handle into service handle */
662    H->last_err = OCIAttrSet(H->svc, OCI_HTYPE_SVCCTX, H->server, 0, OCI_ATTR_SERVER, H->err);
663    if (H->last_err) {
664        oci_drv_error("OCIAttrSet: OCI_ATTR_SERVER");
665        goto cleanup;
666    }
667
668    /* username */
669    if (dbh->username) {
670        H->last_err = OCIAttrSet(H->session, OCI_HTYPE_SESSION,
671                dbh->username, (ub4) strlen(dbh->username),
672                OCI_ATTR_USERNAME, H->err);
673        if (H->last_err) {
674            oci_drv_error("OCIAttrSet: OCI_ATTR_USERNAME");
675            goto cleanup;
676        }
677    }
678
679    /* password */
680    if (dbh->password) {
681        H->last_err = OCIAttrSet(H->session, OCI_HTYPE_SESSION,
682                dbh->password, (ub4) strlen(dbh->password),
683                OCI_ATTR_PASSWORD, H->err);
684        if (H->last_err) {
685            oci_drv_error("OCIAttrSet: OCI_ATTR_PASSWORD");
686            goto cleanup;
687        }
688    }
689
690    /* Now fire up the session */
691    H->last_err = OCISessionBegin(H->svc, H->err, H->session, OCI_CRED_RDBMS, OCI_DEFAULT);
692    if (H->last_err) {
693        oci_drv_error("OCISessionBegin");
694        goto cleanup;
695    }
696
697    /* set the server handle into service handle */
698    H->last_err = OCIAttrSet(H->svc, OCI_HTYPE_SVCCTX, H->session, 0, OCI_ATTR_SESSION, H->err);
699    if (H->last_err) {
700        oci_drv_error("OCIAttrSet: OCI_ATTR_SESSION");
701        goto cleanup;
702    }
703
704    dbh->methods = &oci_methods;
705    dbh->alloc_own_columns = 1;
706    dbh->native_case = PDO_CASE_UPPER;
707
708    ret = 1;
709
710cleanup:
711    for (i = 0; i < sizeof(vars)/sizeof(vars[0]); i++) {
712        if (vars[i].freeme) {
713            efree(vars[i].optval);
714        }
715    }
716
717    if (!ret) {
718        oci_handle_closer(dbh);
719    }
720
721    return ret;
722}
723/* }}} */
724
725pdo_driver_t pdo_oci_driver = {
726    PDO_DRIVER_HEADER(oci),
727    pdo_oci_handle_factory
728};
729
730static inline ub4 pdo_oci_sanitize_prefetch(long prefetch) /* {{{ */
731{
732    if (prefetch < 0) {
733        prefetch = 0;
734    } else if (prefetch > UB4MAXVAL / PDO_OCI_PREFETCH_ROWSIZE) {
735        prefetch = PDO_OCI_PREFETCH_DEFAULT;
736    }
737    return ((ub4)prefetch);
738}
739/* }}} */
740
741
742/*
743 * Local variables:
744 * tab-width: 4
745 * c-basic-offset: 4
746 * End:
747 * vim600: noet sw=4 ts=4 fdm=marker
748 * vim<600: noet sw=4 ts=4
749 */
750