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
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	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
470static 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
539static 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
578static 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
594static 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
708cleanup:
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
723pdo_driver_t pdo_oci_driver = {
724	PDO_DRIVER_HEADER(oci),
725	pdo_oci_handle_factory
726};
727
728static 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 */
748