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