xref: /PHP-8.2/ext/oci8/oci8_statement.c (revision 5cf2659f)
1 /*
2    +----------------------------------------------------------------------+
3    | Copyright (c) The PHP Group                                          |
4    +----------------------------------------------------------------------+
5    | This source file is subject to version 3.01 of the PHP license,      |
6    | that is bundled with this package in the file LICENSE, and is        |
7    | available through the world-wide-web at the following url:           |
8    | https://www.php.net/license/3_01.txt                                 |
9    | If you did not receive a copy of the PHP license and are unable to   |
10    | obtain it through the world-wide-web, please send a note to          |
11    | license@php.net so we can mail you a copy immediately.               |
12    +----------------------------------------------------------------------+
13    | Authors: Stig Sæther Bakken <ssb@php.net>                            |
14    |          Thies C. Arntzen <thies@thieso.net>                         |
15    |                                                                      |
16    | Collection support by Andy Sautins <asautins@veripost.net>           |
17    | Temporary LOB support by David Benson <dbenson@mancala.com>          |
18    | ZTS per process OCIPLogon by Harald Radi <harald.radi@nme.at>        |
19    |                                                                      |
20    | Redesigned by: Antony Dovgal <antony@zend.com>                       |
21    |                Andi Gutmans <andi@php.net>                           |
22    |                Wez Furlong <wez@omniti.com>                          |
23    +----------------------------------------------------------------------+
24 */
25 
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29 
30 #include "php.h"
31 #include "ext/standard/info.h"
32 #include "php_ini.h"
33 
34 #ifdef HAVE_OCI8
35 
36 #include "php_oci8.h"
37 #include "php_oci8_int.h"
38 
39 #if defined(__x86_64__) || defined(__LP64__) || defined(_LP64) || defined(_WIN64)
40 typedef ub8 oci_phpsized_int;
41 #else
42 typedef ub4 oci_phpsized_int;
43 #endif
44 
45 /* {{{ php_oci_statement_create()
46  Create statemend handle and allocate necessary resources */
php_oci_statement_create(php_oci_connection * connection,char * query,int query_len)47 php_oci_statement *php_oci_statement_create(php_oci_connection *connection, char *query, int query_len)
48 {
49 	php_oci_statement *statement;
50 	sword errstatus;
51 
52 	connection->errcode = 0; /* retain backwards compat with OCI8 1.4 */
53 
54 	statement = ecalloc(1,sizeof(php_oci_statement));
55 
56 	if (!query_len) {
57 		/* do not allocate stmt handle for refcursors, we'll get it from OCIStmtPrepare2() */
58 		PHP_OCI_CALL(OCIHandleAlloc, (connection->env, (dvoid **)&(statement->stmt), OCI_HTYPE_STMT, 0, NULL));
59 	}
60 
61 	PHP_OCI_CALL(OCIHandleAlloc, (connection->env, (dvoid **)&(statement->err), OCI_HTYPE_ERROR, 0, NULL));
62 
63 	if (query_len > 0) {
64 		PHP_OCI_CALL_RETURN(errstatus, OCIStmtPrepare2,
65 				(
66 				 connection->svc,
67 				 &(statement->stmt),
68 				 connection->err,
69 				 (text *)query,
70 				 query_len,
71 				 NULL,
72 				 0,
73 				 OCI_NTV_SYNTAX,
74 				 OCI_DEFAULT
75 				)
76 		);
77 #ifdef HAVE_OCI8_DTRACE
78 		if (DTRACE_OCI8_SQLTEXT_ENABLED()) {
79 			DTRACE_OCI8_SQLTEXT(connection, connection->client_id, statement, query);
80 		}
81 #endif /* HAVE_OCI8_DTRACE */
82 
83 		if (errstatus != OCI_SUCCESS) {
84 			connection->errcode = php_oci_error(connection->err, errstatus);
85 
86 			PHP_OCI_CALL(OCIStmtRelease, (statement->stmt, statement->err, NULL, 0, OCI_STRLS_CACHE_DELETE));
87 			PHP_OCI_CALL(OCIHandleFree,(statement->err, OCI_HTYPE_ERROR));
88 			PHP_OCI_HANDLE_ERROR(connection, connection->errcode);
89 			efree(statement);
90 			return NULL;
91 		}
92 	}
93 
94 	if (query && query_len) {
95 		statement->last_query = ecalloc(1, query_len + 1);
96 		memcpy(statement->last_query, query, query_len);
97 		statement->last_query_len = query_len;
98 	}
99 	else {
100 		statement->last_query = NULL;
101 		statement->last_query_len = 0;
102 	}
103 
104 	statement->connection = connection;
105 	statement->has_data = 0;
106 	statement->has_descr = 0;
107 	statement->parent_stmtid = 0;
108 	statement->impres_child_stmt = NULL;
109 	statement->impres_count = 0;
110 	statement->impres_flag = PHP_OCI_IMPRES_UNKNOWN;  /* may or may not have Implicit Result Set children */
111 	GC_ADDREF(statement->connection->id);
112 
113 	if (OCI_G(default_prefetch) >= 0) {
114 		php_oci_statement_set_prefetch(statement, (ub4)OCI_G(default_prefetch));
115 	} else {
116 		php_oci_statement_set_prefetch(statement, (ub4)100); /* semi-arbitrary, "sensible default" */
117 	}
118 
119 	if (OCI_G(prefetch_lob_size) > 0) {
120 		statement->prefetch_lob_size = (ub4)OCI_G(prefetch_lob_size);
121 	} else {
122 		statement->prefetch_lob_size = 0;
123 	}
124 
125 	PHP_OCI_REGISTER_RESOURCE(statement, le_statement);
126 
127 	OCI_G(num_statements)++;
128 
129 	return statement;
130 }
131 /* }}} */
132 
133 /* {{{ php_oci_get_implicit_resultset()
134    Fetch implicit result set statement resource */
php_oci_get_implicit_resultset(php_oci_statement * statement)135 php_oci_statement *php_oci_get_implicit_resultset(php_oci_statement *statement)
136 {
137 #if (OCI_MAJOR_VERSION < 12)
138 	php_error_docref(NULL, E_WARNING, "Implicit results are available in Oracle Database 12c onwards");
139 	return NULL;
140 #else
141 	void *result;
142 	ub4   rtype;
143 	php_oci_statement *statement2;  /* implicit result set statement handle */
144 	sword errstatus;
145 
146 	PHP_OCI_CALL_RETURN(errstatus, OCIStmtGetNextResult, (statement->stmt, statement->err, &result, &rtype, OCI_DEFAULT));
147 	if (errstatus == OCI_NO_DATA) {
148 		return NULL;
149 	}
150 
151 	if (rtype != OCI_RESULT_TYPE_SELECT) {
152 		/* Only OCI_RESULT_TYPE_SELECT is supported by Oracle DB 12cR1 */
153 		php_error_docref(NULL, E_WARNING, "Unexpected implicit result type returned from Oracle Database");
154 		return NULL;
155 	} else {
156 		statement2 = ecalloc(1,sizeof(php_oci_statement));
157 
158 		PHP_OCI_CALL(OCIHandleAlloc, (statement->connection->env, (dvoid **)&(statement2->err), OCI_HTYPE_ERROR, 0, NULL));
159 		statement2->stmt = (OCIStmt *)result;
160 		statement2->parent_stmtid = statement->id;
161 		statement2->impres_child_stmt = NULL;
162 		statement2->impres_count = 0;
163 		statement2->impres_flag = PHP_OCI_IMPRES_IS_CHILD;
164 		statement2->connection = statement->connection;
165 		statement2->errcode = 0;
166 		statement2->last_query = NULL;
167 		statement2->last_query_len = 0;
168 		statement2->columns = NULL;
169 		statement2->binds = NULL;
170 		statement2->defines = NULL;
171 		statement2->ncolumns = 0;
172 		statement2->executed = 0;
173 		statement2->has_data = 0;
174 		statement2->has_descr = 0;
175 		statement2->stmttype = 0;
176 
177 		GC_ADDREF(statement->id);
178 		GC_ADDREF(statement2->connection->id);
179 
180 		php_oci_statement_set_prefetch(statement2, statement->prefetch_count);
181 		statement2->prefetch_lob_size = statement->prefetch_lob_size;
182 
183 		PHP_OCI_REGISTER_RESOURCE(statement2, le_statement);
184 
185 		OCI_G(num_statements)++;
186 
187 		return statement2;
188 	}
189 #endif /* OCI_MAJOR_VERSION < 12 */
190 }
191 /* }}} */
192 
193 /* {{{ php_oci_statement_set_prefetch()
194  Set prefetch buffer size for the statement */
php_oci_statement_set_prefetch(php_oci_statement * statement,ub4 prefetch)195 int php_oci_statement_set_prefetch(php_oci_statement *statement, ub4 prefetch)
196 {
197 	sword errstatus;
198 
199 	if (prefetch > 20000) {
200 		prefetch = 20000;		/* keep it somewhat sane */
201 	}
202 
203 	PHP_OCI_CALL_RETURN(errstatus, OCIAttrSet, (statement->stmt, OCI_HTYPE_STMT, &prefetch, 0, OCI_ATTR_PREFETCH_ROWS, statement->err));
204 
205 	if (errstatus != OCI_SUCCESS) {
206 		statement->errcode = php_oci_error(statement->err, errstatus);
207 		PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
208 		statement->prefetch_count = 0;
209 		return 1;
210 	}
211 	statement->prefetch_count = prefetch;
212 	statement->errcode = 0; /* retain backwards compat with OCI8 1.4 */
213 	return 0;
214 }
215 /* }}} */
216 
217 /* {{{ php_oci_cleanup_pre_fetch()
218    Helper function to cleanup ref-cursors and descriptors from the previous row */
php_oci_cleanup_pre_fetch(zval * data)219 int php_oci_cleanup_pre_fetch(zval *data)
220 {
221 	php_oci_out_column *outcol = (php_oci_out_column*) Z_PTR_P(data);
222 
223 	if (!outcol->is_descr && !outcol->is_cursor)
224 		return ZEND_HASH_APPLY_KEEP;
225 
226 	switch(outcol->data_type) {
227 		case SQLT_CLOB:
228 		case SQLT_BLOB:
229 		case SQLT_RDD:
230 		case SQLT_BFILE:
231 			if (outcol->descid) {
232 				zend_list_delete(outcol->descid);
233 				outcol->descid = 0;
234 			}
235 			break;
236 		case SQLT_RSET:
237 			if (outcol->stmtid) {
238 				zend_list_delete(outcol->stmtid);
239 				outcol->stmtid = 0;
240 				outcol->nested_statement = NULL;
241 			}
242 			break;
243 		default:
244 			break;
245 	}
246 	return ZEND_HASH_APPLY_KEEP;
247 
248 }
249 /* }}} */
250 
251 /* {{{ php_oci_statement_fetch()
252  Fetch a row from the statement */
php_oci_statement_fetch(php_oci_statement * statement,ub4 nrows)253 int php_oci_statement_fetch(php_oci_statement *statement, ub4 nrows)
254 {
255 	int i;
256 	void *handlepp;
257 	ub4 typep, iterp, idxp;
258 	ub1 in_outp, piecep;
259 	bool piecewisecols = 0;
260 	php_oci_out_column *column;
261 	sword errstatus;
262 
263 	statement->errcode = 0; /* retain backwards compat with OCI8 1.4 */
264 
265 	if (statement->has_descr && statement->columns) {
266 		zend_hash_apply(statement->columns, php_oci_cleanup_pre_fetch);
267 	}
268 
269 	PHP_OCI_CALL_RETURN(errstatus, OCIStmtFetch2, (statement->stmt, statement->err, nrows, OCI_FETCH_NEXT, 0, OCI_DEFAULT));
270 
271 	if (errstatus == OCI_NO_DATA || nrows == 0) {
272 		if (statement->last_query == NULL) {
273 			/* reset define-list for refcursors */
274 			if (statement->columns) {
275 				zend_hash_destroy(statement->columns);
276 				efree(statement->columns);
277 				statement->columns = NULL;
278 				statement->ncolumns = 0;
279 			}
280 			statement->executed = 0;
281 		}
282 
283 		statement->has_data = 0;
284 
285 		if (nrows == 0) {
286 			/* this is exactly what we requested */
287 			return 0;
288 		}
289 		return 1;
290 	}
291 
292 	/* reset length for all piecewise columns */
293 	for (i = 0; i < statement->ncolumns; i++) {
294 		column = php_oci_statement_get_column(statement, i + 1, NULL, 0);
295 		if (column && column->piecewise) {
296 			column->retlen4 = 0;
297 			piecewisecols = 1;
298 		}
299 	}
300 
301 	while (errstatus == OCI_NEED_DATA) {
302 		if (piecewisecols) {
303 			PHP_OCI_CALL_RETURN(errstatus,
304 				OCIStmtGetPieceInfo,
305 				   (
306 					statement->stmt,
307 					statement->err,
308 					&handlepp,
309 					&typep,
310 					&in_outp,
311 					&iterp,
312 					&idxp,
313 					&piecep
314 				   )
315 			);
316 
317 			/* scan through our columns for a piecewise column with a matching handle */
318 			for (i = 0; i < statement->ncolumns; i++) {
319 				column = php_oci_statement_get_column(statement, i + 1, NULL, 0);
320 				if (column && column->piecewise && handlepp == column->oci_define)   {
321 					if (!column->data) {
322 						column->data = (text *) ecalloc(1, PHP_OCI_PIECE_SIZE + 1);
323 					} else {
324 						column->data = erealloc(column->data, column->retlen4 + PHP_OCI_PIECE_SIZE + 1);
325 					}
326 					column->cb_retlen = PHP_OCI_PIECE_SIZE;
327 
328 					/* and instruct fetch to fetch waiting piece into our buffer */
329 					PHP_OCI_CALL(OCIStmtSetPieceInfo,
330 						   (
331 							(void *) column->oci_define,
332 							OCI_HTYPE_DEFINE,
333 							statement->err,
334 							((char*)column->data) + column->retlen4,
335 							&(column->cb_retlen),
336 							piecep,
337 							&column->indicator,
338 							&column->retcode
339 						   )
340 					);
341 				}
342 			}
343 		}
344 
345 		PHP_OCI_CALL_RETURN(errstatus, OCIStmtFetch2, (statement->stmt, statement->err, nrows, OCI_FETCH_NEXT, 0, OCI_DEFAULT));
346 
347 		if (piecewisecols) {
348 			for (i = 0; i < statement->ncolumns; i++) {
349 				column = php_oci_statement_get_column(statement, i + 1, NULL, 0);
350 				if (column && column->piecewise && handlepp == column->oci_define)	{
351 					column->retlen4 += column->cb_retlen;
352 				}
353 			}
354 		}
355 	}
356 
357 	if (errstatus == OCI_SUCCESS_WITH_INFO || errstatus == OCI_SUCCESS) {
358 		statement->has_data = 1;
359 
360 		/* do the stuff needed for OCIDefineByPos */
361 		for (i = 0; i < statement->ncolumns; i++) {
362 			column = php_oci_statement_get_column(statement, i + 1, NULL, 0);
363 			if (column == NULL) {
364 				continue;
365 			}
366 
367 			if (!column->define) {
368 				continue;
369 			}
370 
371 			ZEND_ASSERT(Z_ISREF(column->define->val));
372 			zval_ptr_dtor(Z_REFVAL(column->define->val));
373 			ZVAL_NULL(Z_REFVAL(column->define->val));
374 			php_oci_column_to_zval(column, Z_REFVAL(column->define->val), 0);
375 		}
376 
377 		return 0;
378 	}
379 
380 	statement->errcode = php_oci_error(statement->err, errstatus);
381 	PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
382 
383 	statement->has_data = 0;
384 
385 	return 1;
386 }
387 /* }}} */
388 
389 /* {{{ php_oci_statement_get_column()
390  Get column from the result set */
php_oci_statement_get_column(php_oci_statement * statement,zend_long column_index,char * column_name,int column_name_len)391 php_oci_out_column *php_oci_statement_get_column(php_oci_statement *statement, zend_long column_index, char *column_name, int column_name_len)
392 {
393 	php_oci_out_column *column = NULL;
394 	int i;
395 
396 	if (statement->columns == NULL) { /* we release the columns at the end of a fetch */
397 		return NULL;
398 	}
399 
400 	if (column_name) {
401 		for (i = 0; i < statement->ncolumns; i++) {
402 			column = php_oci_statement_get_column(statement, i + 1, NULL, 0);
403 			if (column == NULL) {
404 				continue;
405 			} else if (((int) column->name_len == column_name_len) && (!strncmp(column->name, column_name, column_name_len))) {
406 				return column;
407 			}
408 		}
409 	} else if (column_index != -1) {
410 		if ((column = zend_hash_index_find_ptr(statement->columns, column_index)) == NULL) {
411 			return NULL;
412 		}
413 		return column;
414 	}
415 
416 	return NULL;
417 }
418 /* }}} */
419 
420 /* {{{ php_oci_define_callback() */
php_oci_define_callback(dvoid * ctx,OCIDefine * define,ub4 iter,dvoid ** bufpp,ub4 ** alenpp,ub1 * piecep,dvoid ** indpp,ub2 ** rcpp)421 sb4 php_oci_define_callback(dvoid *ctx, OCIDefine *define, ub4 iter, dvoid **bufpp, ub4 **alenpp, ub1 *piecep, dvoid **indpp, ub2 **rcpp)
422 {
423 	php_oci_out_column *outcol = (php_oci_out_column *)ctx;
424 
425 	if (!outcol) {
426 
427 		php_error_docref(NULL, E_WARNING, "Invalid context pointer value");
428 		return OCI_ERROR;
429 	}
430 
431 	switch(outcol->data_type) {
432 		case SQLT_RSET: {
433 				php_oci_statement *nested_stmt;
434 
435 				nested_stmt = php_oci_statement_create(outcol->statement->connection, NULL, 0);
436 				if (!nested_stmt) {
437 					return OCI_ERROR;
438 				}
439 				nested_stmt->parent_stmtid = outcol->statement->id;
440 				GC_ADDREF(outcol->statement->id);
441 				outcol->nested_statement = nested_stmt;
442 				outcol->stmtid = nested_stmt->id;
443 
444 				*bufpp = nested_stmt->stmt;
445 				*alenpp = &(outcol->retlen4);
446 				*piecep = OCI_ONE_PIECE;
447 				*indpp = &(outcol->indicator);
448 				*rcpp = &(outcol->retcode);
449 				return OCI_CONTINUE;
450 			}
451 			break;
452 		case SQLT_RDD:
453 		case SQLT_BLOB:
454 		case SQLT_CLOB:
455 		case SQLT_BFILE: {
456 				php_oci_descriptor *descr;
457 				int dtype;
458 
459 				if (outcol->data_type == SQLT_BFILE) {
460 					dtype = OCI_DTYPE_FILE;
461 				} else if (outcol->data_type == SQLT_RDD ) {
462 					dtype = OCI_DTYPE_ROWID;
463 				} else {
464 					dtype = OCI_DTYPE_LOB;
465 				}
466 
467 				descr = php_oci_lob_create(outcol->statement->connection, dtype);
468 				if (!descr) {
469 					return OCI_ERROR;
470 				}
471 				outcol->descid = descr->id;
472 				descr->charset_form = outcol->charset_form;
473 
474 				*bufpp = descr->descriptor;
475 				*alenpp = &(outcol->retlen4);
476 				*piecep = OCI_ONE_PIECE;
477 				*indpp = &(outcol->indicator);
478 				*rcpp = &(outcol->retcode);
479 
480 				return OCI_CONTINUE;
481 			}
482 			break;
483 	}
484 	return OCI_ERROR;
485 }
486 /* }}} */
487 
488 /* {{{ php_oci_statement_execute()
489  Execute statement */
php_oci_statement_execute(php_oci_statement * statement,ub4 mode)490 int php_oci_statement_execute(php_oci_statement *statement, ub4 mode)
491 {
492 	php_oci_out_column *outcol;
493 	OCIParam *param = NULL;
494 	text *colname;
495 	ub4 counter;
496 	ub2 define_type;
497 	ub4 iters;
498 	ub4 colcount;
499 	ub2 dynamic;
500 	dvoid *buf;
501 	sword errstatus;
502 
503 	switch (mode) {
504 		case OCI_COMMIT_ON_SUCCESS:
505 		case OCI_DESCRIBE_ONLY:
506 		case OCI_DEFAULT:
507 			/* only these are allowed */
508 #ifdef HAVE_OCI8_DTRACE
509 			if (DTRACE_OCI8_EXECUTE_MODE_ENABLED()) {
510 				DTRACE_OCI8_EXECUTE_MODE(statement->connection, statement->connection->client_id, statement, mode);
511 			}
512 #endif /* HAVE_OCI8_DTRACE */
513 			break;
514 		default:
515 			php_error_docref(NULL, E_WARNING, "Invalid execute mode given: %d", mode);
516 			return 1;
517 			break;
518 	}
519 
520 	if (!statement->stmttype) {
521 		/* get statement type */
522 		PHP_OCI_CALL_RETURN(errstatus, OCIAttrGet, ((dvoid *)statement->stmt, OCI_HTYPE_STMT, (ub2 *)&statement->stmttype, (ub4 *)0, OCI_ATTR_STMT_TYPE, statement->err));
523 
524 		if (errstatus != OCI_SUCCESS) {
525 			statement->errcode = php_oci_error(statement->err, errstatus);
526 			PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
527 			return 1;
528 		} else {
529 			statement->errcode = 0; /* retain backwards compat with OCI8 1.4 */
530 		}
531 	}
532 
533 	if (statement->stmttype == OCI_STMT_SELECT) {
534 		iters = 0;
535 	} else {
536 		iters = 1;
537 	}
538 
539 	if (statement->last_query) { /* Don't execute REFCURSORS or Implicit Result Set handles */
540 
541 		if (statement->binds) {
542 			int result = 0;
543 			zend_hash_apply_with_argument(statement->binds, php_oci_bind_pre_exec, (void *)&result);
544 			if (result) {
545 				return 1;
546 			}
547 		}
548 
549 		/* execute statement */
550 		PHP_OCI_CALL_RETURN(errstatus, OCIStmtExecute, (statement->connection->svc, statement->stmt, statement->err, iters, 0, NULL, NULL, mode));
551 
552 		if (errstatus != OCI_SUCCESS) {
553 			statement->errcode = php_oci_error(statement->err, errstatus);
554 			PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
555 			return 1;
556 		}
557 
558 		if (statement->binds) {
559 			zend_hash_apply(statement->binds, php_oci_bind_post_exec);
560 		}
561 
562 		if (mode & OCI_COMMIT_ON_SUCCESS) {
563 			/* No need to rollback on disconnect */
564 			statement->connection->rb_on_disconnect = 0;
565 		} else if (statement->stmttype != OCI_STMT_SELECT) {
566 			/* Assume some uncommitted DML occurred */
567 			statement->connection->rb_on_disconnect = 1;
568 		}
569 		/* else for SELECT with OCI_NO_AUTO_COMMIT, leave
570 		 * "rb_on_disconnect" at its previous value.  SELECT can't
571 		 * initiate uncommitted DML. (An AUTONOMOUS_TRANSACTION in
572 		 * invoked PL/SQL must explicitly rollback/commit else the
573 		 * SELECT fails).
574 		 */
575 
576 		statement->errcode = 0; /* retain backwards compat with OCI8 1.4 */
577 	}
578 
579 	if (statement->stmttype == OCI_STMT_SELECT && statement->executed == 0) {
580 		/* we only need to do the define step is this very statement is executed the first time! */
581 		statement->executed = 1;
582 
583 		ALLOC_HASHTABLE(statement->columns);
584 		zend_hash_init(statement->columns, 13, NULL, php_oci_column_hash_dtor, 0);
585 
586 		counter = 1;
587 
588 		/* get number of columns */
589 		PHP_OCI_CALL_RETURN(errstatus, OCIAttrGet, ((dvoid *)statement->stmt, OCI_HTYPE_STMT, (dvoid *)&colcount, (ub4 *)0, OCI_ATTR_PARAM_COUNT, statement->err));
590 
591 		if (errstatus != OCI_SUCCESS) {
592 			statement->errcode = php_oci_error(statement->err, errstatus);
593 			PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
594 			return 1;
595 		}
596 
597 		statement->ncolumns = colcount;
598 
599 		for (counter = 1; counter <= colcount; counter++) {
600 			outcol = (php_oci_out_column *) ecalloc(1, sizeof(php_oci_out_column));
601 
602 			outcol = zend_hash_index_update_ptr(statement->columns, counter, outcol);
603 
604 			/* get column */
605 			PHP_OCI_CALL_RETURN(errstatus, OCIParamGet, ((dvoid *)statement->stmt, OCI_HTYPE_STMT, statement->err, (dvoid**)&param, counter));
606 
607 			if (errstatus != OCI_SUCCESS) {
608 				statement->errcode = php_oci_error(statement->err, errstatus);
609 				PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
610 				return 1;
611 			}
612 
613 			/* get column datatype */
614 			PHP_OCI_CALL_RETURN(errstatus, OCIAttrGet, ((dvoid *)param, OCI_DTYPE_PARAM, (dvoid *)&outcol->data_type, (ub4 *)0, OCI_ATTR_DATA_TYPE, statement->err));
615 
616 			if (errstatus != OCI_SUCCESS) {
617 				PHP_OCI_CALL(OCIDescriptorFree, (param, OCI_DTYPE_PARAM));
618 				statement->errcode = php_oci_error(statement->err, errstatus);
619 				PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
620 				return 1;
621 			}
622 
623 			/* get character set form  */
624 			PHP_OCI_CALL_RETURN(errstatus, OCIAttrGet, ((dvoid *)param, OCI_DTYPE_PARAM, (dvoid *)&outcol->charset_form, (ub4 *)0, OCI_ATTR_CHARSET_FORM, statement->err));
625 
626 			if (errstatus != OCI_SUCCESS) {
627 				PHP_OCI_CALL(OCIDescriptorFree, (param, OCI_DTYPE_PARAM));
628 				statement->errcode = php_oci_error(statement->err, errstatus);
629 				PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
630 				return 1;
631 			}
632 
633 			/* get character set id	 */
634 			PHP_OCI_CALL_RETURN(errstatus, OCIAttrGet, ((dvoid *)param, OCI_DTYPE_PARAM, (dvoid *)&outcol->charset_id, (ub4 *)0, OCI_ATTR_CHARSET_ID, statement->err));
635 
636 			if (errstatus != OCI_SUCCESS) {
637 				PHP_OCI_CALL(OCIDescriptorFree, (param, OCI_DTYPE_PARAM));
638 				statement->errcode = php_oci_error(statement->err, errstatus);
639 				PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
640 				return 1;
641 			}
642 
643 			/* get size of the column */
644 			PHP_OCI_CALL_RETURN(errstatus, OCIAttrGet, ((dvoid *)param, OCI_DTYPE_PARAM, (dvoid *)&outcol->data_size, (dvoid *)0, OCI_ATTR_DATA_SIZE, statement->err));
645 
646 			if (errstatus != OCI_SUCCESS) {
647 				PHP_OCI_CALL(OCIDescriptorFree, (param, OCI_DTYPE_PARAM));
648 				statement->errcode = php_oci_error(statement->err, errstatus);
649 				PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
650 				return 1;
651 			}
652 
653 			outcol->storage_size4 = outcol->data_size;
654 			outcol->retlen = outcol->data_size;
655 
656 			/* get scale of the column */
657 			PHP_OCI_CALL_RETURN(errstatus, OCIAttrGet, ((dvoid *)param, OCI_DTYPE_PARAM, (dvoid *)&outcol->scale, (dvoid *)0, OCI_ATTR_SCALE, statement->err));
658 
659 			if (errstatus != OCI_SUCCESS) {
660 				PHP_OCI_CALL(OCIDescriptorFree, (param, OCI_DTYPE_PARAM));
661 				statement->errcode = php_oci_error(statement->err, errstatus);
662 				PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
663 				return 1;
664 			}
665 
666 			/* get precision of the column */
667 			PHP_OCI_CALL_RETURN(errstatus, OCIAttrGet, ((dvoid *)param, OCI_DTYPE_PARAM, (dvoid *)&outcol->precision, (dvoid *)0, OCI_ATTR_PRECISION, statement->err));
668 
669 			if (errstatus != OCI_SUCCESS) {
670 				PHP_OCI_CALL(OCIDescriptorFree, (param, OCI_DTYPE_PARAM));
671 				statement->errcode = php_oci_error(statement->err, errstatus);
672 				PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
673 				return 1;
674 			}
675 
676 			/* get name of the column */
677 			PHP_OCI_CALL_RETURN(errstatus, OCIAttrGet, ((dvoid *)param, OCI_DTYPE_PARAM, (dvoid **)&colname, (ub4 *)&outcol->name_len, (ub4)OCI_ATTR_NAME, statement->err));
678 
679 			if (errstatus != OCI_SUCCESS) {
680 				PHP_OCI_CALL(OCIDescriptorFree, (param, OCI_DTYPE_PARAM));
681 				statement->errcode = php_oci_error(statement->err, errstatus);
682 				PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
683 				return 1;
684 			}
685 			PHP_OCI_CALL(OCIDescriptorFree, (param, OCI_DTYPE_PARAM));
686 
687 			outcol->name = ecalloc(1, outcol->name_len + 1);
688 			memcpy(outcol->name, colname, outcol->name_len);
689 
690 			/* find a user-set define */
691 			if (statement->defines) {
692 				if ((outcol->define = zend_hash_str_find_ptr(statement->defines, outcol->name, outcol->name_len)) != NULL) {
693 					if (outcol->define->type) {
694 						outcol->data_type = outcol->define->type;
695 					}
696 				}
697 			}
698 
699 			buf = 0;
700 			switch (outcol->data_type) {
701 				case SQLT_RSET:
702 					outcol->statement = statement; /* parent handle */
703 
704 					define_type = SQLT_RSET;
705 					outcol->is_cursor = 1;
706 					outcol->statement->has_descr = 1;
707 					outcol->storage_size4 = -1;
708 					outcol->retlen = -1;
709 					dynamic = OCI_DYNAMIC_FETCH;
710 					break;
711 
712 				case SQLT_RDD:	 /* ROWID */
713 				case SQLT_BLOB:	 /* binary LOB */
714 				case SQLT_CLOB:	 /* character LOB */
715 				case SQLT_BFILE: /* binary file LOB */
716 					outcol->statement = statement; /* parent handle */
717 
718 					define_type = outcol->data_type;
719 					outcol->is_descr = 1;
720 					outcol->statement->has_descr = 1;
721 					outcol->storage_size4 = -1;
722 					outcol->chunk_size = 0;
723 					dynamic = OCI_DYNAMIC_FETCH;
724 					break;
725 
726 				case SQLT_LNG:
727 				case SQLT_LBI:
728 					if (outcol->data_type == SQLT_LBI) {
729 						define_type = SQLT_BIN;
730 					} else {
731 						define_type = SQLT_CHR;
732 					}
733 					outcol->storage_size4 = PHP_OCI_MAX_DATA_SIZE;
734 					outcol->piecewise = 1;
735 					dynamic = OCI_DYNAMIC_FETCH;
736 					break;
737 
738 				case SQLT_BIN:
739 				default:
740 					define_type = SQLT_CHR;
741 					if (outcol->data_type == SQLT_BIN) {
742 						define_type = SQLT_BIN;
743 					}
744 					if ((outcol->data_type == SQLT_DAT) || (outcol->data_type == SQLT_NUM)
745 #ifdef SQLT_TIMESTAMP
746 						|| (outcol->data_type == SQLT_TIMESTAMP)
747 #endif
748 #ifdef SQLT_TIMESTAMP_TZ
749 						|| (outcol->data_type == SQLT_TIMESTAMP_TZ)
750 #endif
751 #ifdef SQLT_TIMESTAMP_LTZ
752 						|| (outcol->data_type == SQLT_TIMESTAMP_LTZ)
753 #endif
754 #ifdef SQLT_INTERVAL_YM
755 						|| (outcol->data_type == SQLT_INTERVAL_YM)
756 #endif
757 #ifdef SQLT_INTERVAL_DS
758 						|| (outcol->data_type == SQLT_INTERVAL_DS)
759 #endif
760 						) {
761 						outcol->storage_size4 = 512; /* XXX this should fit "most" NLS date-formats and Numbers */
762 #if defined(SQLT_IBFLOAT) && defined(SQLT_IBDOUBLE)
763 					} else if (outcol->data_type == SQLT_IBFLOAT || outcol->data_type == SQLT_IBDOUBLE) {
764 						outcol->storage_size4 = 1024;
765 #endif
766 					} else {
767 						outcol->storage_size4++; /* add one for string terminator */
768 					}
769 
770 					outcol->storage_size4 *= 3;
771 
772 					dynamic = OCI_DEFAULT;
773 					buf = outcol->data = (text *) safe_emalloc(1, outcol->storage_size4, 0);
774 					memset(buf, 0, outcol->storage_size4);
775 					break;
776 			}
777 
778 			if (dynamic == OCI_DYNAMIC_FETCH) {
779 				PHP_OCI_CALL_RETURN(errstatus,
780 					OCIDefineByPos,
781 					(
782 						statement->stmt,							/* IN/OUT handle to the requested SQL query */
783 						(OCIDefine **)&outcol->oci_define,			/* IN/OUT pointer to a pointer to a define handle */
784 						statement->err,								/* IN/OUT An error handle  */
785 						counter,									/* IN	  position in the select list */
786 						(dvoid *)NULL,								/* IN/OUT pointer to a buffer */
787 						outcol->storage_size4,						/* IN	  The size of each valuep buffer in bytes */
788 						define_type,								/* IN	  The data type */
789 						(dvoid *)&outcol->indicator,				/* IN	  pointer to an indicator variable or arr */
790 						(ub2 *)NULL,								/* IN/OUT Pointer to array of length of data fetched */
791 						(ub2 *)NULL,								/* OUT	  Pointer to array of column-level return codes */
792 						OCI_DYNAMIC_FETCH							/* IN	  mode (OCI_DEFAULT, OCI_DYNAMIC_FETCH) */
793 					)
794 				);
795 			} else {
796 				PHP_OCI_CALL_RETURN(errstatus,
797 					OCIDefineByPos,
798 					(
799 						statement->stmt,							/* IN/OUT handle to the requested SQL query */
800 						(OCIDefine **)&outcol->oci_define,			/* IN/OUT pointer to a pointer to a define handle */
801 						statement->err,								/* IN/OUT An error handle  */
802 						counter,									/* IN	  position in the select list */
803 						(dvoid *)buf,								/* IN/OUT pointer to a buffer */
804 						outcol->storage_size4,						/* IN	  The size of each valuep buffer in bytes */
805 						define_type,								/* IN	  The data type */
806 						(dvoid *)&outcol->indicator,				/* IN	  pointer to an indicator variable or arr */
807 						(ub2 *)&outcol->retlen,						/* IN/OUT Pointer to array of length of data fetched */
808 						(ub2 *)&outcol->retcode,					/* OUT	  Pointer to array of column-level return codes */
809 						OCI_DEFAULT									/* IN	  mode (OCI_DEFAULT, OCI_DYNAMIC_FETCH) */
810 					)
811 				);
812 
813 			}
814 
815 			if (errstatus != OCI_SUCCESS) {
816 				statement->errcode = php_oci_error(statement->err, errstatus);
817 				PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
818 				return 1;
819 			}
820 
821 			/* Enable LOB data prefetching. */
822 #if (OCI_MAJOR_VERSION > 12 || (OCI_MAJOR_VERSION == 12 && OCI_MINOR_VERSION >= 2))
823 			if ((outcol->data_type == SQLT_CLOB || outcol->data_type == SQLT_BLOB) && statement->prefetch_lob_size > 0) {
824 				int get_lob_len = 1;  /* == true */
825 
826 				PHP_OCI_CALL_RETURN(errstatus, OCIAttrSet, (outcol->oci_define, OCI_HTYPE_DEFINE, &get_lob_len, 0, OCI_ATTR_LOBPREFETCH_LENGTH, statement->err));
827 				if (errstatus != OCI_SUCCESS) {
828 					statement->errcode = php_oci_error(statement->err, errstatus);
829 					PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
830 					return 1;
831 				}
832 
833 				PHP_OCI_CALL_RETURN(errstatus, OCIAttrSet, (outcol->oci_define, OCI_HTYPE_DEFINE, &(statement->prefetch_lob_size), 0, OCI_ATTR_LOBPREFETCH_SIZE, statement->err));
834 				if (errstatus != OCI_SUCCESS) {
835 					statement->errcode = php_oci_error(statement->err, errstatus);
836 					PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
837 					return 1;
838 				}
839 			}
840 #endif
841 
842 			/* additional define setup */
843 			switch (outcol->data_type) {
844 				case SQLT_RSET:
845 				case SQLT_BLOB:
846 				case SQLT_CLOB:
847 				case SQLT_RDD:
848 				case SQLT_BFILE:
849 					PHP_OCI_CALL_RETURN(errstatus,
850 						OCIDefineDynamic,
851 						(
852 							outcol->oci_define,
853 							statement->err,
854 							(dvoid *)outcol,
855 							php_oci_define_callback
856 						)
857 					);
858 
859 					if (errstatus != OCI_SUCCESS) {
860 						statement->errcode = php_oci_error(statement->err, errstatus);
861 						PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
862 						return 1;
863 					}
864 					break;
865 			}
866 		}
867 		statement->errcode = 0; /* retain backwards compat with OCI8 1.4 */
868 	}
869 
870 	return 0;
871 }
872 /* }}} */
873 
874 /* {{{ php_oci_statement_cancel()
875  Cancel statement */
php_oci_statement_cancel(php_oci_statement * statement)876 int php_oci_statement_cancel(php_oci_statement *statement)
877 {
878 	return php_oci_statement_fetch(statement, 0);
879 }
880 /* }}} */
881 
882 /* {{{ php_oci_statement_free()
883  Destroy statement handle and free associated resources */
php_oci_statement_free(php_oci_statement * statement)884 void php_oci_statement_free(php_oci_statement *statement)
885 {
886 	if (statement->stmt) {
887 		if (statement->last_query_len) { /* FIXME: magical */
888 			PHP_OCI_CALL(OCIStmtRelease, (statement->stmt, statement->err, NULL, 0, statement->errcode ? OCI_STRLS_CACHE_DELETE : OCI_DEFAULT));
889 		} else if (statement->impres_flag != PHP_OCI_IMPRES_IS_CHILD) {  /* Oracle doc says don't free Implicit Result Set handles */
890 			PHP_OCI_CALL(OCIHandleFree, (statement->stmt, OCI_HTYPE_STMT));
891 		}
892 		statement->stmt = NULL;
893 	}
894 
895 	if (statement->err) {
896 		PHP_OCI_CALL(OCIHandleFree, (statement->err, OCI_HTYPE_ERROR));
897 		statement->err = NULL;
898 	}
899 
900 	if (statement->last_query) {
901 		efree(statement->last_query);
902 	}
903 
904 	if (statement->binds) {
905 		zend_hash_destroy(statement->binds);
906 		efree(statement->binds);
907 	}
908 
909 	if (statement->defines) {
910 		zend_hash_destroy(statement->defines);
911 		efree(statement->defines);
912 	}
913 
914 	if (statement->columns) {
915 		zend_hash_destroy(statement->columns);
916 		efree(statement->columns);
917 	}
918 
919 	if (statement->parent_stmtid) {
920 		zend_list_delete(statement->parent_stmtid);
921 	}
922 
923 	zend_list_delete(statement->connection->id);
924 	efree(statement);
925 
926 	OCI_G(num_statements)--;
927 }
928 /* }}} */
929 
930 /* {{{ php_oci_bind_pre_exec()
931  Helper function */
php_oci_bind_pre_exec(zval * data,void * result)932 int php_oci_bind_pre_exec(zval *data, void *result)
933 {
934 	php_oci_bind *bind = (php_oci_bind *) Z_PTR_P(data);
935 	zval *zv = &bind->val;
936 
937 	*(int *)result = 0;
938 
939 	ZVAL_DEREF(zv);
940 	if (Z_TYPE_P(zv) == IS_ARRAY) {
941 		/* These checks are currently valid for oci_bind_by_name, not
942 		 * oci_bind_array_by_name.  Also bind->type and
943 		 * bind->indicator are not used for oci_bind_array_by_name.
944 		 */
945 		return 0;
946 	}
947 	switch (bind->type) {
948 		case SQLT_NTY:
949 		case SQLT_BFILEE:
950 		case SQLT_CFILEE:
951 		case SQLT_CLOB:
952 		case SQLT_BLOB:
953 		case SQLT_RDD:
954 			if (Z_TYPE_P(zv) != IS_OBJECT) {
955 				php_error_docref(NULL, E_WARNING, "Invalid variable used for bind");
956 				*(int *)result = 1;
957 			}
958 			break;
959 
960 		case SQLT_CHR:
961 		case SQLT_AFC:
962 		case SQLT_INT:
963 		case SQLT_NUM:
964 #if defined(OCI_MAJOR_VERSION) && OCI_MAJOR_VERSION >= 12
965 		case SQLT_BOL:
966 #endif
967 		case SQLT_LBI:
968 		case SQLT_BIN:
969 		case SQLT_LNG:
970 			if (Z_TYPE_P(zv) == IS_RESOURCE || Z_TYPE_P(zv) == IS_OBJECT) {
971 				php_error_docref(NULL, E_WARNING, "Invalid variable used for bind");
972 				*(int *)result = 1;
973 			}
974 			break;
975 
976 		case SQLT_RSET:
977 			if (Z_TYPE_P(zv) != IS_RESOURCE) {
978 				php_error_docref(NULL, E_WARNING, "Invalid variable used for bind");
979 				*(int *)result = 1;
980 			}
981 			break;
982 	}
983 
984 	/* reset all bind stuff to a normal state... */
985 	bind->indicator = 0;
986 
987 	return 0;
988 }
989 /* }}} */
990 
991 /* {{{ php_oci_bind_post_exec()
992  Helper function */
php_oci_bind_post_exec(zval * data)993 int php_oci_bind_post_exec(zval *data)
994 {
995 	php_oci_bind *bind = (php_oci_bind *) Z_PTR_P(data);
996 	php_oci_connection *connection = bind->parent_statement->connection;
997 	sword errstatus;
998 	zval *zv = &bind->val;
999 
1000 	ZVAL_DEREF(zv);
1001 	if (bind->indicator == -1) { /* NULL */
1002 		if (Z_TYPE_P(zv) == IS_STRING) {
1003 			*Z_STRVAL_P(zv) = '\0'; /* XXX avoid warning in debug mode */
1004 		}
1005 		zval_ptr_dtor(zv);
1006 		ZVAL_NULL(zv);
1007 	} else if (Z_TYPE_P(zv) == IS_STRING
1008 			   && Z_STRLEN_P(zv) > 0
1009 			   && Z_STRVAL_P(zv)[ Z_STRLEN_P(zv) ] != '\0') {
1010 		/* The post- PHP 5.3 feature for "interned" strings disallows
1011 		 * their reallocation but (i) any IN binds either interned or
1012 		 * not should already be null terminated and (ii) for OUT
1013 		 * binds, php_oci_bind_out_callback() should have allocated a
1014 		 * new string that we can modify here.
1015 		 */
1016 		ZVAL_NEW_STR(zv, zend_string_extend(Z_STR_P(zv), Z_STRLEN_P(zv)+1, 0));
1017 		Z_STRVAL_P(zv)[ Z_STRLEN_P(zv) ] = '\0';
1018 	} else if (Z_TYPE_P(zv) == IS_ARRAY) {
1019 		int i;
1020 		zval *entry = NULL;
1021 		HashTable *hash;
1022 
1023 		SEPARATE_ARRAY(zv);
1024 		hash = Z_ARRVAL_P(zv);
1025 		zend_hash_internal_pointer_reset(hash);
1026 
1027 		switch (bind->array.type) {
1028 			case SQLT_NUM:
1029 			case SQLT_INT:
1030 			case SQLT_LNG:
1031 				for (i = 0; i < (int) bind->array.current_length; i++) {
1032 					if ((i < (int) bind->array.old_length) && (entry = zend_hash_get_current_data(hash)) != NULL) {
1033 						zval_ptr_dtor(entry);
1034 						ZVAL_LONG(entry, ((oci_phpsized_int *)(bind->array.elements))[i]);
1035 						zend_hash_move_forward(hash);
1036 					} else {
1037 						add_next_index_long(zv, ((oci_phpsized_int *)(bind->array.elements))[i]);
1038 					}
1039 				}
1040 				break;
1041 			case SQLT_FLT:
1042 				for (i = 0; i < (int) bind->array.current_length; i++) {
1043 					if ((i < (int) bind->array.old_length) && (entry = zend_hash_get_current_data(hash)) != NULL) {
1044 						zval_ptr_dtor(entry);
1045 						ZVAL_DOUBLE(entry, ((double *)(bind->array.elements))[i]);
1046 						zend_hash_move_forward(hash);
1047 					} else {
1048 						add_next_index_double(zv, ((double *)(bind->array.elements))[i]);
1049 					}
1050 				}
1051 				break;
1052 			case SQLT_ODT:
1053 				for (i = 0; i < (int) bind->array.current_length; i++) {
1054 					oratext buff[1024];
1055 					ub4 buff_len = 1024;
1056 
1057 					memset((void*)buff,0,sizeof(buff));
1058 
1059 					if ((i < (int) bind->array.old_length) && (entry = zend_hash_get_current_data(hash)) != NULL) {
1060 						PHP_OCI_CALL_RETURN(errstatus, OCIDateToText, (connection->err, &(((OCIDate *)(bind->array.elements))[i]), 0, 0, 0, 0, &buff_len, buff));
1061 						zval_ptr_dtor(entry);
1062 
1063 						if (errstatus != OCI_SUCCESS) {
1064 							connection->errcode = php_oci_error(connection->err, errstatus);
1065 							PHP_OCI_HANDLE_ERROR(connection, connection->errcode);
1066 							ZVAL_NULL(entry);
1067 						} else {
1068 							connection->errcode = 0; /* retain backwards compat with OCI8 1.4 */
1069 							ZVAL_STRINGL(entry, (char *)buff, buff_len);
1070 						}
1071 						zend_hash_move_forward(hash);
1072 					} else {
1073 						PHP_OCI_CALL_RETURN(errstatus, OCIDateToText, (connection->err, &(((OCIDate *)(bind->array.elements))[i]), 0, 0, 0, 0, &buff_len, buff));
1074 						if (errstatus != OCI_SUCCESS) {
1075 							connection->errcode = php_oci_error(connection->err, errstatus);
1076 							PHP_OCI_HANDLE_ERROR(connection, connection->errcode);
1077 							add_next_index_null(zv);
1078 						} else {
1079 							connection->errcode = 0; /* retain backwards compat with OCI8 1.4 */
1080 							add_next_index_stringl(zv, (char *)buff, buff_len);
1081 						}
1082 					}
1083 				}
1084 				break;
1085 
1086 			case SQLT_AFC:
1087 			case SQLT_CHR:
1088 			case SQLT_VCS:
1089 			case SQLT_AVC:
1090 			case SQLT_STR:
1091 			case SQLT_LVC:
1092 				for (i = 0; i < (int) bind->array.current_length; i++) {
1093 					/* int curr_element_length = strlen(((text *)bind->array.elements)+i*bind->array.max_length); */
1094 					int curr_element_length = bind->array.element_lengths[i];
1095 					if ((i < (int) bind->array.old_length) && (entry = zend_hash_get_current_data(hash)) != NULL) {
1096 						zval_ptr_dtor(entry);
1097 						ZVAL_STRINGL(entry, (char *)(((text *)bind->array.elements)+i*bind->array.max_length), curr_element_length);
1098 						zend_hash_move_forward(hash);
1099 					} else {
1100 						add_next_index_stringl(zv, (char *)(((text *)bind->array.elements)+i*bind->array.max_length), curr_element_length);
1101 					}
1102 				}
1103 				break;
1104 		}
1105 	} else if ((Z_TYPE_P(zv) == IS_TRUE) || (Z_TYPE_P(zv) == IS_FALSE)) {
1106 		/* This convetrsion is done on purpose (ext/oci8 uses LVAL as a temporary value) */
1107 		if (Z_LVAL_P(zv) == 0)
1108 			ZVAL_FALSE(zv);
1109 		else if (Z_LVAL_P(zv) == 1)
1110 			ZVAL_TRUE(zv);
1111 	}
1112 
1113 	return 0;
1114 }
1115 /* }}} */
1116 
1117 /* {{{ php_oci_bind_by_name()
1118  Bind zval to the given placeholder */
php_oci_bind_by_name(php_oci_statement * statement,char * name,size_t name_len,zval * var,zend_long maxlength,ub2 type)1119 int php_oci_bind_by_name(php_oci_statement *statement, char *name, size_t name_len, zval *var, zend_long maxlength, ub2 type)
1120 {
1121 	php_oci_collection *bind_collection = NULL;
1122 	php_oci_descriptor *bind_descriptor = NULL;
1123 	php_oci_statement  *bind_statement	= NULL;
1124 	dvoid *oci_desc					= NULL;
1125 	/* dvoid *php_oci_collection		   = NULL; */
1126 	OCIStmt *oci_stmt				= NULL;
1127 	dvoid *bind_data				= NULL;
1128 	php_oci_bind *old_bind, *bindp;
1129 	int mode = OCI_DATA_AT_EXEC;
1130 	sb4 value_sz = -1;
1131 	sword errstatus;
1132 	zval *param = NULL;
1133 
1134 	ZEND_ASSERT(Z_ISREF_P(var));
1135 	param = Z_REFVAL_P(var);
1136 
1137 	switch (type) {
1138 		case SQLT_NTY:
1139 		{
1140 			zval *tmp;
1141 
1142 			if (Z_TYPE_P(param) != IS_OBJECT || (tmp = zend_hash_str_find(Z_OBJPROP_P(param), "collection", sizeof("collection")-1)) == NULL) {
1143 				php_error_docref(NULL, E_WARNING, "Unable to find collection property");
1144 				return 1;
1145 			}
1146 
1147 			PHP_OCI_ZVAL_TO_COLLECTION_EX(tmp, bind_collection);
1148 			value_sz = sizeof(void*);
1149 			mode = OCI_DEFAULT;
1150 
1151 			if (!bind_collection->collection) {
1152 				return 1;
1153 			}
1154 		}
1155 			break;
1156 		case SQLT_BFILEE:
1157 		case SQLT_CFILEE:
1158 		case SQLT_CLOB:
1159 		case SQLT_BLOB:
1160 		case SQLT_RDD:
1161 		{
1162 			zval *tmp;
1163 
1164 			if (Z_TYPE_P(param) != IS_OBJECT || (tmp = zend_hash_str_find(Z_OBJPROP_P(param), "descriptor", sizeof("descriptor")-1)) == NULL) {
1165 				php_error_docref(NULL, E_WARNING, "Unable to find descriptor property");
1166 				return 1;
1167 			}
1168 
1169 			PHP_OCI_ZVAL_TO_DESCRIPTOR_EX(tmp, bind_descriptor);
1170 
1171 			value_sz = sizeof(void*);
1172 
1173 			oci_desc = bind_descriptor->descriptor;
1174 
1175 			if (!oci_desc) {
1176 				return 1;
1177 			}
1178 		}
1179 			break;
1180 
1181 		case SQLT_INT:
1182 		case SQLT_NUM:
1183 			if (Z_TYPE_P(param) == IS_RESOURCE || Z_TYPE_P(param) == IS_OBJECT) {
1184 				php_error_docref(NULL, E_WARNING, "Invalid variable used for bind");
1185 				return 1;
1186 			}
1187 			convert_to_long(param);
1188 			bind_data = (oci_phpsized_int *)&Z_LVAL_P(param);
1189 			value_sz = sizeof(oci_phpsized_int);
1190 			mode = OCI_DEFAULT;
1191 			break;
1192 
1193 		case SQLT_LBI:
1194 		case SQLT_BIN:
1195 		case SQLT_LNG:
1196 		case SQLT_AFC:
1197 		case SQLT_CHR: /* SQLT_CHR is the default value when type was not specified */
1198 			if (Z_TYPE_P(param) == IS_RESOURCE || Z_TYPE_P(param) == IS_OBJECT) {
1199 				php_error_docref(NULL, E_WARNING, "Invalid variable used for bind");
1200 				return 1;
1201 			}
1202 			if (Z_TYPE_P(param) != IS_NULL) {
1203 				if (!try_convert_to_string(param)) {
1204 					return 1;
1205 				}
1206 			}
1207 			if ((maxlength == -1) || (maxlength == 0)) {
1208 				if (type == SQLT_LNG) {
1209 					value_sz = SB4MAXVAL;
1210 				} else if (Z_TYPE_P(param) == IS_STRING) {
1211 					value_sz = (sb4) Z_STRLEN_P(param);
1212 				} else {
1213 					/* Bug-72524: revert value_sz from PHP_OCI_PIECE_SIZE to 0. This restores PHP 5.6 behavior  */
1214 					value_sz = 0;
1215 				}
1216 			} else {
1217 				value_sz = (sb4) maxlength;
1218 			}
1219 			break;
1220 
1221 		case SQLT_RSET:
1222 			if (Z_TYPE_P(param) != IS_RESOURCE) {
1223 				php_error_docref(NULL, E_WARNING, "Invalid variable used for bind");
1224 				return 1;
1225 			}
1226 			PHP_OCI_ZVAL_TO_STATEMENT_EX(param, bind_statement);
1227 			value_sz = sizeof(void*);
1228 
1229 			oci_stmt = bind_statement->stmt;
1230 
1231 			if (!oci_stmt) {
1232 				return 1;
1233 			}
1234 			break;
1235 
1236 #if defined(OCI_MAJOR_VERSION) && OCI_MAJOR_VERSION >= 12
1237 		case SQLT_BOL:
1238 			if (Z_TYPE_P(param) == IS_RESOURCE || Z_TYPE_P(param) == IS_OBJECT) {
1239 				php_error_docref(NULL, E_WARNING, "Invalid variable used for bind");
1240 				return 1;
1241 			}
1242 			convert_to_boolean(param);
1243 			bind_data = (zend_long *)&Z_LVAL_P(param);
1244 			if (Z_TYPE_P(param) == IS_TRUE)
1245 				*(zend_long *)bind_data = 1;
1246 			else if (Z_TYPE_P(param) == IS_FALSE)
1247 				*(zend_long *)bind_data = 0;
1248 			else {
1249 				php_error_docref(NULL, E_WARNING, "Invalid variable used for bind");
1250 				return 1;
1251 			}
1252 
1253 			value_sz = sizeof(zend_long);
1254 
1255 			mode = OCI_DEFAULT;
1256 			break;
1257 #endif
1258 
1259 		default:
1260 			php_error_docref(NULL, E_WARNING, "Unknown or unsupported datatype given: %d", (int)type);
1261 			return 1;
1262 			break;
1263 	}
1264 
1265 	if (!statement->binds) {
1266 		ALLOC_HASHTABLE(statement->binds);
1267 		zend_hash_init(statement->binds, 13, NULL, php_oci_bind_hash_dtor, 0);
1268 	}
1269 
1270 	if ((old_bind = zend_hash_str_find_ptr(statement->binds, name, name_len)) != NULL) {
1271 		bindp = old_bind;
1272 		if (!Z_ISUNDEF(bindp->val)) {
1273 			zval_ptr_dtor(&bindp->val);
1274 			ZVAL_UNDEF(&bindp->val);
1275 		}
1276 	} else {
1277 		zend_string *zvtmp;
1278 		zvtmp = zend_string_init(name, name_len, 0);
1279 		bindp = (php_oci_bind *) ecalloc(1, sizeof(php_oci_bind));
1280 		bindp = zend_hash_update_ptr(statement->binds, zvtmp, bindp);
1281 		zend_string_release_ex(zvtmp, 0);
1282 	}
1283 
1284 	/* Make sure the minimum of value_sz is 1 to avoid ORA-3149
1285 	 * when both in/out parameters are bound with empty strings
1286 	 */
1287 	if (value_sz == 0)
1288 		value_sz = 1;
1289 
1290 	bindp->descriptor = oci_desc;
1291 	bindp->statement = oci_stmt;
1292 	bindp->parent_statement = statement;
1293 	ZVAL_COPY(&bindp->val, var);
1294 	bindp->type = type;
1295 	/* Storing max length set in OCIBindByName() to check it later in
1296 	 * php_oci_bind_in_callback() function to avoid ORA-1406 error while
1297 	 * executing OCIStmtExecute()
1298      */
1299 	bindp->dummy_len = value_sz;
1300 
1301 	PHP_OCI_CALL_RETURN(errstatus,
1302 		OCIBindByName,
1303 		(
1304 			statement->stmt,				 /* statement handle */
1305 			(OCIBind **)&bindp->bind,		 /* bind hdl (will alloc) */
1306 			statement->err,				  	 /* error handle */
1307 			(text*) name,					 /* placeholder name */
1308 			(sb4) name_len,					 /* placeholder length */
1309 			(dvoid *)bind_data,				 /* in/out data */
1310 			value_sz, /* PHP_OCI_MAX_DATA_SIZE, */ /* max size of input/output data */
1311 			type,							 /* in/out data type */
1312 			(dvoid *)&bindp->indicator,		 /* indicator (ignored) */
1313 			(ub2 *)0,						 /* size array (ignored) */
1314 			(ub2 *)&bindp->retcode,			 /* return code (ignored) */
1315 			(ub4)0,							 /* maxarr_len (PL/SQL only?) */
1316 			(ub4 *)0,						 /* actual array size (PL/SQL only?) */
1317 			mode							 /* mode */
1318 		)
1319 	);
1320 
1321 	if (errstatus != OCI_SUCCESS) {
1322 		statement->errcode = php_oci_error(statement->err, errstatus);
1323 		PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
1324 		return 1;
1325 	}
1326 
1327 	if (mode == OCI_DATA_AT_EXEC) {
1328 		PHP_OCI_CALL_RETURN(errstatus, OCIBindDynamic,
1329 				(
1330 				 bindp->bind,
1331 				 statement->err,
1332 				 (dvoid *)bindp,
1333 				 php_oci_bind_in_callback,
1334 				 (dvoid *)bindp,
1335 				 php_oci_bind_out_callback
1336 				)
1337 		);
1338 
1339 		if (errstatus != OCI_SUCCESS) {
1340 			statement->errcode = php_oci_error(statement->err, errstatus);
1341 			PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
1342 			return 1;
1343 		}
1344 	}
1345 
1346 	if (type == SQLT_NTY) {
1347 		/* Bind object */
1348 		PHP_OCI_CALL_RETURN(errstatus, OCIBindObject,
1349 				(
1350 				 bindp->bind,
1351 				 statement->err,
1352 				 bind_collection->tdo,
1353 				 (dvoid **) &(bind_collection->collection),
1354 				 (ub4 *) 0,
1355 				 (dvoid **) 0,
1356 				 (ub4 *) 0
1357 				)
1358 		);
1359 
1360 		if (errstatus) {
1361 			statement->errcode = php_oci_error(statement->err, errstatus);
1362 			PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
1363 			return 1;
1364 		}
1365 	}
1366 
1367 	statement->errcode = 0; /* retain backwards compat with OCI8 1.4 */
1368 	return 0;
1369 }
1370 /* }}} */
1371 
1372 /* {{{ php_oci_bind_in_callback()
1373  Callback used when binding LOBs and VARCHARs */
php_oci_bind_in_callback(dvoid * ictxp,OCIBind * bindp,ub4 iter,ub4 index,dvoid ** bufpp,ub4 * alenp,ub1 * piecep,dvoid ** indpp)1374 sb4 php_oci_bind_in_callback(
1375 					dvoid *ictxp,	  /* context pointer */
1376 					OCIBind *bindp,	  /* bind handle */
1377 					ub4 iter,		  /* 0-based execute iteration value */
1378 					ub4 index,		  /* index of current array for PL/SQL or row index for SQL */
1379 					dvoid **bufpp,	  /* pointer to data */
1380 					ub4 *alenp,		  /* size after value/piece has been read */
1381 					ub1 *piecep,	  /* which piece */
1382 					dvoid **indpp)	  /* indicator value */
1383 {
1384 	php_oci_bind *phpbind;
1385 	zval *val;
1386 
1387 	if (!(phpbind=(php_oci_bind *)ictxp) || Z_ISUNDEF(phpbind->val)) {
1388 		php_error_docref(NULL, E_WARNING, "Invalid phpbind pointer value");
1389 		return OCI_ERROR;
1390 	}
1391 
1392 	val = &phpbind->val;
1393 	ZVAL_DEREF(val);
1394 
1395 	if (Z_ISNULL_P(val)) {
1396 		/* we're going to insert a NULL column */
1397 		phpbind->indicator = -1;
1398 		*bufpp = 0;
1399 		*alenp = -1;
1400 		*indpp = (dvoid *)&phpbind->indicator;
1401 	} else	if ((phpbind->descriptor == 0) && (phpbind->statement == 0)) {
1402 		/* "normal" string bind */
1403 		if (!try_convert_to_string(val)) {
1404 			return OCI_ERROR;
1405 		}
1406 
1407 		*bufpp = Z_STRVAL_P(val);
1408 		*alenp = (ub4) Z_STRLEN_P(val);
1409 		/*
1410 		 * bind_char_1: If max length set in OCIBindByName is less than the
1411 		 * actual length of input string, then we have to overwrite alenp with
1412 		 * max value set in OCIBindByName (dummy_len). Or else it will cause
1413 		 * ORA-1406 error in OCIStmtExecute
1414 		 */
1415 		if ((phpbind->dummy_len > 0) && (phpbind->dummy_len < *alenp))
1416 			*alenp = phpbind->dummy_len;
1417 		*indpp = (dvoid *)&phpbind->indicator;
1418 	} else if (phpbind->statement != 0) {
1419 		/* RSET */
1420 		*bufpp = phpbind->statement;
1421 		*alenp = -1;		/* seems to be alright */
1422 		*indpp = (dvoid *)&phpbind->indicator;
1423 	} else {
1424 		/* descriptor bind */
1425 		*bufpp = phpbind->descriptor;
1426 		*alenp = -1;		/* seems to be alright */
1427 		*indpp = (dvoid *)&phpbind->indicator;
1428 	}
1429 
1430 	*piecep = OCI_ONE_PIECE; /* pass all data in one go */
1431 
1432 	return OCI_CONTINUE;
1433 }
1434 /* }}} */
1435 
1436 /* {{{ php_oci_bind_out_callback()
1437  Callback used when binding LOBs and VARCHARs */
php_oci_bind_out_callback(dvoid * octxp,OCIBind * bindp,ub4 iter,ub4 index,dvoid ** bufpp,ub4 ** alenpp,ub1 * piecep,dvoid ** indpp,ub2 ** rcodepp)1438 sb4 php_oci_bind_out_callback(
1439 					dvoid *octxp,	   /* context pointer */
1440 					OCIBind *bindp,	   /* bind handle */
1441 					ub4 iter,		   /* 0-based execute iteration value */
1442 					ub4 index,		   /* index of current array for PL/SQL or row index for SQL */
1443 					dvoid **bufpp,	   /* pointer to data */
1444 					ub4 **alenpp,	   /* size after value/piece has been read */
1445 					ub1 *piecep,	   /* which piece */
1446 					dvoid **indpp,	   /* indicator value */
1447 					ub2 **rcodepp)	   /* return code */
1448 {
1449 	php_oci_bind *phpbind;
1450 	zval *val;
1451 	sb4 retval = OCI_ERROR;
1452 
1453 	if (!(phpbind=(php_oci_bind *)octxp) || Z_ISUNDEF(phpbind->val)) {
1454 		php_error_docref(NULL, E_WARNING, "Invalid phpbind pointer value");
1455 		return retval;
1456 	}
1457 
1458 	val = &phpbind->val;
1459 	ZVAL_DEREF(val);
1460 
1461 	if (Z_TYPE_P(val) == IS_RESOURCE) {
1462 		/* Processing for ref-cursor out binds */
1463 		if (phpbind->statement != NULL) {
1464 			*bufpp = phpbind->statement;
1465 			*alenpp = &phpbind->dummy_len;
1466 			*piecep = OCI_ONE_PIECE;
1467 			*rcodepp = &phpbind->retcode;
1468 			*indpp = &phpbind->indicator;
1469 		}
1470 		retval = OCI_CONTINUE;
1471 	} else if (Z_TYPE_P(val) == IS_OBJECT) {
1472 		zval *tmp;
1473 		php_oci_descriptor *desc;
1474 
1475 		if (!phpbind->descriptor) {
1476 			return OCI_ERROR;
1477 		}
1478 
1479 		/* Do not use the cached lob size if the descriptor is an
1480 		 * out-bind as the contents would have been changed for in/out
1481 		 * binds (Bug #46994).
1482 		 */
1483 		if ((tmp = zend_hash_str_find(Z_OBJPROP_P(val), "descriptor", sizeof("descriptor")-1)) == NULL) {
1484 			php_error_docref(NULL, E_WARNING, "Unable to find object outbind descriptor property");
1485 			return OCI_ERROR;
1486 		}
1487 		PHP_OCI_ZVAL_TO_DESCRIPTOR_EX(tmp, desc);
1488 		desc->lob_size = -1;	/* force OCI8 to update cached size */
1489 
1490 		*alenpp = &phpbind->dummy_len;
1491 		*bufpp = phpbind->descriptor;
1492 		*piecep = OCI_ONE_PIECE;
1493 		*rcodepp = &phpbind->retcode;
1494 		*indpp = &phpbind->indicator;
1495 		retval = OCI_CONTINUE;
1496 	} else {
1497 		zval_ptr_dtor(val);
1498 
1499 		{
1500 			char *p = ecalloc(1, PHP_OCI_PIECE_SIZE);
1501 			ZVAL_STRINGL(val, p, PHP_OCI_PIECE_SIZE);
1502 			efree(p);
1503 		}
1504 
1505 		/* XXX we assume that zend-zval len has 4 bytes */
1506 		*alenpp = (ub4*) &Z_STRLEN_P(val);
1507 		*bufpp = Z_STRVAL_P(val);
1508 		*piecep = OCI_ONE_PIECE;
1509 		*rcodepp = &phpbind->retcode;
1510 		*indpp = &phpbind->indicator;
1511 		retval = OCI_CONTINUE;
1512 	}
1513 
1514 	return retval;
1515 }
1516 /* }}} */
1517 
1518 /* {{{ php_oci_statement_get_column_helper()
1519  Helper function to get column by name and index */
php_oci_statement_get_column_helper(INTERNAL_FUNCTION_PARAMETERS,int need_data)1520 php_oci_out_column *php_oci_statement_get_column_helper(INTERNAL_FUNCTION_PARAMETERS, int need_data)
1521 {
1522 	zval *z_statement;
1523 	zend_string *column_index_string;
1524 	zend_long column_index_int;
1525 
1526 	php_oci_statement *statement;
1527 	php_oci_out_column *column;
1528 
1529 	ZEND_PARSE_PARAMETERS_START(2, 2)
1530 		Z_PARAM_RESOURCE(z_statement)
1531 		Z_PARAM_STR_OR_LONG(column_index_string, column_index_int)
1532 	ZEND_PARSE_PARAMETERS_END_EX(return NULL);
1533 
1534 	statement = (php_oci_statement *) zend_fetch_resource_ex(z_statement, "oci8 statement", le_statement);
1535 
1536 	if (!statement) {
1537 		return NULL;
1538 	}
1539 
1540 	if (need_data && !statement->has_data) {
1541 		return NULL;
1542 	}
1543 
1544 	if (column_index_string != NULL) {
1545 		column = php_oci_statement_get_column(statement, -1, ZSTR_VAL(column_index_string), (int) ZSTR_LEN(column_index_string));
1546 		if (!column) {
1547 			php_error_docref(NULL, E_WARNING, "Invalid column name \"%s\"", ZSTR_VAL(column_index_string));
1548 			return NULL;
1549 		}
1550 	} else {
1551 		column = php_oci_statement_get_column(statement, column_index_int, NULL, 0);
1552 
1553 		if (!column) {
1554 			php_error_docref(NULL, E_WARNING, "Invalid column index \"" ZEND_LONG_FMT "\"", column_index_int);
1555 			return NULL;
1556 		}
1557 	}
1558 	return column;
1559 }
1560 /* }}} */
1561 
1562 /* {{{ php_oci_statement_get_type()
1563  Return type of the statement */
php_oci_statement_get_type(php_oci_statement * statement,ub2 * type)1564 int php_oci_statement_get_type(php_oci_statement *statement, ub2 *type)
1565 {
1566 	ub2 statement_type;
1567 	sword errstatus;
1568 
1569 	*type = 0;
1570 
1571 	PHP_OCI_CALL_RETURN(errstatus, OCIAttrGet, ((dvoid *)statement->stmt, OCI_HTYPE_STMT, (ub2 *)&statement_type, (ub4 *)0, OCI_ATTR_STMT_TYPE, statement->err));
1572 
1573 	if (errstatus != OCI_SUCCESS) {
1574 		statement->errcode = php_oci_error(statement->err, errstatus);
1575 		PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
1576 		return 1;
1577 	}
1578 	statement->errcode = 0; /* retain backwards compat with OCI8 1.4 */
1579 	*type = statement_type;
1580 
1581 	return 0;
1582 }
1583 /* }}} */
1584 
1585 /* {{{ php_oci_statement_get_numrows()
1586  Get the number of rows fetched to the clientside (NOT the number of rows in the result set) */
php_oci_statement_get_numrows(php_oci_statement * statement,ub4 * numrows)1587 int php_oci_statement_get_numrows(php_oci_statement *statement, ub4 *numrows)
1588 {
1589 	ub4 statement_numrows;
1590 	sword errstatus;
1591 
1592 	*numrows = 0;
1593 
1594 	PHP_OCI_CALL_RETURN(errstatus, OCIAttrGet, ((dvoid *)statement->stmt, OCI_HTYPE_STMT, (ub4 *)&statement_numrows, (ub4 *)0, OCI_ATTR_ROW_COUNT, statement->err));
1595 
1596 	if (errstatus != OCI_SUCCESS) {
1597 		statement->errcode = php_oci_error(statement->err, errstatus);
1598 		PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
1599 		return 1;
1600 	}
1601 	statement->errcode = 0; /* retain backwards compat with OCI8 1.4 */
1602 	*numrows = statement_numrows;
1603 
1604 	return 0;
1605 }
1606 /* }}} */
1607 
1608 /* {{{ php_oci_bind_array_by_name()
1609  Bind arrays to PL/SQL types */
php_oci_bind_array_by_name(php_oci_statement * statement,char * name,size_t name_len,zval * var,zend_long max_table_length,zend_long maxlength,zend_long type)1610 int php_oci_bind_array_by_name(php_oci_statement *statement, char *name, size_t name_len, zval *var, zend_long max_table_length, zend_long maxlength, zend_long type)
1611 {
1612 	php_oci_bind *bind;
1613 	sword errstatus;
1614 	zend_string *zvtmp;
1615 	zval *val;
1616 
1617 	ZEND_ASSERT(Z_ISREF_P(var));
1618 	val = Z_REFVAL_P(var);
1619 	convert_to_array(val);
1620 	SEPARATE_ARRAY(val);
1621 
1622 	if (maxlength < -1) {
1623 		php_error_docref(NULL, E_WARNING, "Invalid max length value (" ZEND_LONG_FMT ")", maxlength);
1624 		return 1;
1625 	}
1626 
1627 	switch(type) {
1628 		case SQLT_NUM:
1629 		case SQLT_INT:
1630 		case SQLT_LNG:
1631 			bind = php_oci_bind_array_helper_number(val, max_table_length);
1632 			break;
1633 
1634 		case SQLT_FLT:
1635 			bind = php_oci_bind_array_helper_double(val, max_table_length);
1636 			break;
1637 
1638 		case SQLT_AFC:
1639 		case SQLT_CHR:
1640 		case SQLT_VCS:
1641 		case SQLT_AVC:
1642 		case SQLT_STR:
1643 		case SQLT_LVC:
1644 			if (maxlength == -1 && zend_hash_num_elements(Z_ARRVAL_P(val)) == 0) {
1645 				php_error_docref(NULL, E_WARNING, "You must provide max length value for empty arrays");
1646 				return 1;
1647 			}
1648 			bind = php_oci_bind_array_helper_string(val, max_table_length, maxlength);
1649 			break;
1650 		case SQLT_ODT:
1651 			bind = php_oci_bind_array_helper_date(val, max_table_length, statement->connection);
1652 			break;
1653 		default:
1654 			php_error_docref(NULL, E_WARNING, "Unknown or unsupported datatype given: " ZEND_LONG_FMT, type);
1655 			return 1;
1656 			break;
1657 	}
1658 
1659 	if (bind == NULL) {
1660 		/* failed to generate bind struct */
1661 		return 1;
1662 	}
1663 
1664 	bind->descriptor = NULL;
1665 	bind->statement = NULL;
1666 	bind->parent_statement = statement;
1667 	bind->bind = NULL;
1668 	ZVAL_COPY(&bind->val, var);
1669 	bind->array.type = type;
1670 	bind->indicator = 0;  		/* not used for array binds */
1671 	bind->type = 0; 			/* not used for array binds */
1672 
1673 	PHP_OCI_CALL_RETURN(errstatus,
1674 							OCIBindByName,
1675 							(
1676 								statement->stmt,
1677 								(OCIBind **)&bind->bind,
1678 								statement->err,
1679 								(text *)name,
1680 								(sb4) name_len,
1681 								(dvoid *) bind->array.elements,
1682 								(sb4) bind->array.max_length,
1683 								(ub2)type,
1684 								(dvoid *)bind->array.indicators,
1685 								(ub2 *)bind->array.element_lengths,
1686 								(ub2 *)0, /* bindp->array.retcodes, */
1687 								(ub4) max_table_length,
1688 								(ub4 *) &(bind->array.current_length),
1689 								(ub4) OCI_DEFAULT
1690 							)
1691 						);
1692 
1693 
1694 	if (errstatus != OCI_SUCCESS) {
1695 		if (bind->array.elements) {
1696 			efree(bind->array.elements);
1697 		}
1698 
1699 		if (bind->array.element_lengths) {
1700 			efree(bind->array.element_lengths);
1701 		}
1702 
1703 		if (bind->array.indicators) {
1704 			efree(bind->array.indicators);
1705 		}
1706 
1707 		zval_ptr_dtor(&bind->val);
1708 
1709 		efree(bind);
1710 
1711 		statement->errcode = php_oci_error(statement->err, errstatus);
1712 		PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
1713 		return 1;
1714 	}
1715 
1716 	if (!statement->binds) {
1717 		ALLOC_HASHTABLE(statement->binds);
1718 		zend_hash_init(statement->binds, 13, NULL, php_oci_bind_hash_dtor, 0);
1719 	}
1720 
1721 	zvtmp = zend_string_init(name, name_len, 0);
1722 	zend_hash_update_ptr(statement->binds, zvtmp, bind);
1723 	zend_string_release_ex(zvtmp, 0);
1724 
1725 	statement->errcode = 0; /* retain backwards compat with OCI8 1.4 */
1726 	return 0;
1727 }
1728 /* }}} */
1729 
1730 /* {{{ php_oci_bind_array_helper_string()
1731  Bind arrays to PL/SQL types */
php_oci_bind_array_helper_string(zval * var,zend_long max_table_length,zend_long maxlength)1732 php_oci_bind *php_oci_bind_array_helper_string(zval *var, zend_long max_table_length, zend_long maxlength)
1733 {
1734 	php_oci_bind *bind;
1735 	ub4 i;
1736 	HashTable *hash;
1737 	zval *entry;
1738 
1739 	SEPARATE_ARRAY(var); /* TODO: may be use new HashTable iteration and prevent inplace modification */
1740 	hash = Z_ARRVAL_P(var);
1741 
1742 	if (maxlength == -1) {
1743 		zend_hash_internal_pointer_reset(hash);
1744 		while ((entry = zend_hash_get_current_data(hash)) != NULL) {
1745 			if (!try_convert_to_string(entry)) {
1746 				return NULL;
1747 			}
1748 
1749 			if (maxlength == -1 || Z_STRLEN_P(entry) > (size_t) maxlength) {
1750 				maxlength = Z_STRLEN_P(entry) + 1;
1751 			}
1752 
1753 			zend_hash_move_forward(hash);
1754 		}
1755 	}
1756 
1757 	bind = emalloc(sizeof(php_oci_bind));
1758 	ZVAL_UNDEF(&bind->val);
1759 	bind->array.elements		= (text *)safe_emalloc(max_table_length * (maxlength + 1), sizeof(text), 0);
1760 	memset(bind->array.elements, 0, max_table_length * (maxlength + 1) * sizeof(text));
1761 	bind->array.current_length	= zend_hash_num_elements(Z_ARRVAL_P(var));
1762 	bind->array.old_length		= bind->array.current_length;
1763 	bind->array.max_length		= (ub4) maxlength;
1764 	bind->array.element_lengths	= safe_emalloc(max_table_length, sizeof(ub2), 0);
1765 	memset(bind->array.element_lengths, 0, max_table_length*sizeof(ub2));
1766 	bind->array.indicators		= safe_emalloc(max_table_length, sizeof(sb2), 0);
1767 	memset(bind->array.indicators, 0, max_table_length*sizeof(sb2));
1768 
1769 	zend_hash_internal_pointer_reset(hash);
1770 
1771 	for (i = 0; i < bind->array.current_length; i++) {
1772 		if ((entry = zend_hash_get_current_data(hash)) != NULL) {
1773 			if (!try_convert_to_string(entry)) {
1774 				efree(bind->array.elements);
1775 				efree(bind->array.element_lengths);
1776 				efree(bind->array.indicators);
1777 				efree(bind);
1778 				return NULL;
1779 			}
1780 
1781 			bind->array.element_lengths[i] = (ub2) Z_STRLEN_P(entry);
1782 			if (Z_STRLEN_P(entry) == 0) {
1783 				bind->array.indicators[i] = -1;
1784 			}
1785 			zend_hash_move_forward(hash);
1786 		} else {
1787 			break;
1788 		}
1789 	}
1790 
1791 	zend_hash_internal_pointer_reset(hash);
1792 	for (i = 0; i < max_table_length; i++) {
1793 		if ((i < bind->array.current_length) && (entry = zend_hash_get_current_data(hash)) != NULL) {
1794 			int element_length;
1795 			if (!try_convert_to_string(entry)) {
1796 				efree(bind->array.elements);
1797 				efree(bind->array.element_lengths);
1798 				efree(bind->array.indicators);
1799 				efree(bind);
1800 				return NULL;
1801 			}
1802 
1803 			element_length = ((size_t) maxlength > Z_STRLEN_P(entry)) ? (int) Z_STRLEN_P(entry) : (int) maxlength;
1804 
1805 			memcpy((text *)bind->array.elements + i*maxlength, Z_STRVAL_P(entry), element_length);
1806 			((text *)bind->array.elements)[i*maxlength + element_length] = '\0';
1807 
1808 			zend_hash_move_forward(hash);
1809 		} else {
1810 			((text *)bind->array.elements)[i*maxlength] = '\0';
1811 		}
1812 	}
1813 	zend_hash_internal_pointer_reset(hash);
1814 
1815 	return bind;
1816 }
1817 /* }}} */
1818 
1819 /* {{{ php_oci_bind_array_helper_number()
1820  Bind arrays to PL/SQL types */
php_oci_bind_array_helper_number(zval * var,zend_long max_table_length)1821 php_oci_bind *php_oci_bind_array_helper_number(zval *var, zend_long max_table_length)
1822 {
1823 	php_oci_bind *bind;
1824 	ub4 i;
1825 	HashTable *hash;
1826 	zval *entry;
1827 
1828 	SEPARATE_ARRAY(var); /* TODO: may be use new HashTable iteration and prevent inplace modification */
1829 	hash = Z_ARRVAL_P(var);
1830 
1831 	bind = emalloc(sizeof(php_oci_bind));
1832 	ZVAL_UNDEF(&bind->val);
1833 	bind->array.elements		= (oci_phpsized_int *)safe_emalloc(max_table_length, sizeof(oci_phpsized_int), 0);
1834 	bind->array.current_length	= zend_hash_num_elements(Z_ARRVAL_P(var));
1835 	bind->array.old_length		= bind->array.current_length;
1836 	bind->array.max_length		= sizeof(oci_phpsized_int);
1837 	bind->array.element_lengths	= safe_emalloc(max_table_length, sizeof(ub2), 0);
1838 	memset(bind->array.element_lengths, 0, max_table_length * sizeof(ub2));
1839 	bind->array.indicators		= NULL;
1840 
1841 	zend_hash_internal_pointer_reset(hash);
1842 	for (i = 0; i < max_table_length; i++) {
1843 		if (i < bind->array.current_length) {
1844 			bind->array.element_lengths[i] = sizeof(oci_phpsized_int);
1845 		}
1846 		if ((i < bind->array.current_length) && (entry = zend_hash_get_current_data(hash)) != NULL) {
1847 			convert_to_long(entry);
1848 			((oci_phpsized_int *)bind->array.elements)[i] = (oci_phpsized_int) Z_LVAL_P(entry);
1849 			zend_hash_move_forward(hash);
1850 		} else {
1851 			((oci_phpsized_int *)bind->array.elements)[i] = 0;
1852 		}
1853 	}
1854 	zend_hash_internal_pointer_reset(hash);
1855 
1856 	return bind;
1857 }
1858 /* }}} */
1859 
1860 /* {{{ php_oci_bind_array_helper_double()
1861  Bind arrays to PL/SQL types */
php_oci_bind_array_helper_double(zval * var,zend_long max_table_length)1862 php_oci_bind *php_oci_bind_array_helper_double(zval *var, zend_long max_table_length)
1863 {
1864 	php_oci_bind *bind;
1865 	ub4 i;
1866 	HashTable *hash;
1867 	zval *entry;
1868 
1869 	SEPARATE_ARRAY(var); /* TODO: may be use new HashTable iteration and prevent inplace modification */
1870 	hash = Z_ARRVAL_P(var);
1871 
1872 	bind = emalloc(sizeof(php_oci_bind));
1873 	ZVAL_UNDEF(&bind->val);
1874 	bind->array.elements		= (double *)safe_emalloc(max_table_length, sizeof(double), 0);
1875 	bind->array.current_length	= zend_hash_num_elements(Z_ARRVAL_P(var));
1876 	bind->array.old_length		= bind->array.current_length;
1877 	bind->array.max_length		= sizeof(double);
1878 	bind->array.element_lengths	= safe_emalloc(max_table_length, sizeof(ub2), 0);
1879 	memset(bind->array.element_lengths, 0, max_table_length * sizeof(ub2));
1880 	bind->array.indicators		= NULL;
1881 
1882 	zend_hash_internal_pointer_reset(hash);
1883 	for (i = 0; i < max_table_length; i++) {
1884 		if (i < bind->array.current_length) {
1885 			bind->array.element_lengths[i] = sizeof(double);
1886 		}
1887 		if ((i < bind->array.current_length) && (entry = zend_hash_get_current_data(hash)) != NULL) {
1888 			convert_to_double(entry);
1889 			((double *)bind->array.elements)[i] = (double) Z_DVAL_P(entry);
1890 			zend_hash_move_forward(hash);
1891 		} else {
1892 			((double *)bind->array.elements)[i] = 0;
1893 		}
1894 	}
1895 	zend_hash_internal_pointer_reset(hash);
1896 
1897 	return bind;
1898 }
1899 /* }}} */
1900 
1901 /* {{{ php_oci_bind_array_helper_date()
1902  Bind arrays to PL/SQL types */
php_oci_bind_array_helper_date(zval * var,zend_long max_table_length,php_oci_connection * connection)1903 php_oci_bind *php_oci_bind_array_helper_date(zval *var, zend_long max_table_length, php_oci_connection *connection)
1904 {
1905 	php_oci_bind *bind;
1906 	ub4 i;
1907 	HashTable *hash;
1908 	zval *entry;
1909 	sword errstatus;
1910 
1911 	SEPARATE_ARRAY(var); /* TODO: may be use new HashTable iteration and prevent inplace modification */
1912 	hash = Z_ARRVAL_P(var);
1913 
1914 	bind = emalloc(sizeof(php_oci_bind));
1915 	ZVAL_UNDEF(&bind->val);
1916 	bind->array.elements		= (OCIDate *)safe_emalloc(max_table_length, sizeof(OCIDate), 0);
1917 	bind->array.current_length	= zend_hash_num_elements(Z_ARRVAL_P(var));
1918 	bind->array.old_length		= bind->array.current_length;
1919 	bind->array.max_length		= sizeof(OCIDate);
1920 	bind->array.element_lengths	= safe_emalloc(max_table_length, sizeof(ub2), 0);
1921 	memset(bind->array.element_lengths, 0, max_table_length * sizeof(ub2));
1922 	bind->array.indicators		= NULL;
1923 
1924 	zend_hash_internal_pointer_reset(hash);
1925 	for (i = 0; i < max_table_length; i++) {
1926 		OCIDate oci_date;
1927 		if (i < bind->array.current_length) {
1928 			bind->array.element_lengths[i] = sizeof(OCIDate);
1929 		}
1930 		if ((i < bind->array.current_length) && (entry = zend_hash_get_current_data(hash)) != NULL) {
1931 			zend_string *entry_str = zval_try_get_string(entry);
1932 			if (UNEXPECTED(!entry_str)) {
1933 				efree(bind->array.element_lengths);
1934 				efree(bind->array.elements);
1935 				efree(bind);
1936 				return NULL;
1937 			}
1938 
1939 			PHP_OCI_CALL_RETURN(errstatus, OCIDateFromText, (connection->err, (CONST text *)ZSTR_VAL(entry_str), (ub4) ZSTR_LEN(entry_str), NULL, 0, NULL, 0, &oci_date));
1940 			zend_string_release(entry_str);
1941 
1942 			if (errstatus != OCI_SUCCESS) {
1943 				/* failed to convert string to date */
1944 				efree(bind->array.element_lengths);
1945 				efree(bind->array.elements);
1946 				efree(bind);
1947 				connection->errcode = php_oci_error(connection->err, errstatus);
1948 				PHP_OCI_HANDLE_ERROR(connection, connection->errcode);
1949 				return NULL;
1950 			}
1951 
1952 			((OCIDate *)bind->array.elements)[i] = oci_date;
1953 			zend_hash_move_forward(hash);
1954 		} else {
1955 			PHP_OCI_CALL_RETURN(errstatus, OCIDateFromText, (connection->err, (CONST text *)"01-JAN-00", sizeof("01-JAN-00")-1, NULL, 0, NULL, 0, &oci_date));
1956 
1957 			if (errstatus != OCI_SUCCESS) {
1958 				/* failed to convert string to date */
1959 				efree(bind->array.element_lengths);
1960 				efree(bind->array.elements);
1961 				efree(bind);
1962 				connection->errcode = php_oci_error(connection->err, errstatus);
1963 				PHP_OCI_HANDLE_ERROR(connection, connection->errcode);
1964 				return NULL;
1965 			}
1966 
1967 			((OCIDate *)bind->array.elements)[i] = oci_date;
1968 		}
1969 		connection->errcode = 0; /* retain backwards compat with OCI8 1.4 */
1970 	}
1971 	zend_hash_internal_pointer_reset(hash);
1972 
1973 	return bind;
1974 }
1975 /* }}} */
1976 
1977 #endif /* HAVE_OCI8 */
1978