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 | Author: Ard Biesheuvel <abies@php.net> |
14 +----------------------------------------------------------------------+
15 */
16
17 #ifdef HAVE_CONFIG_H
18 #include "config.h"
19 #endif
20
21 #include "php.h"
22 #include "php_ini.h"
23 #include "ext/standard/info.h"
24 #include "pdo/php_pdo.h"
25 #include "pdo/php_pdo_driver.h"
26 #include "php_pdo_firebird.h"
27 #include "php_pdo_firebird_int.h"
28
29 #include <time.h>
30
31 #define READ_AND_RETURN_USING_MEMCPY(type, sqldata) do { \
32 type ret; \
33 memcpy(&ret, sqldata, sizeof(ret)); \
34 return ret; \
35 } while (0);
36
php_get_isc_int64_from_sqldata(const ISC_SCHAR * sqldata)37 static zend_always_inline ISC_INT64 php_get_isc_int64_from_sqldata(const ISC_SCHAR *sqldata)
38 {
39 READ_AND_RETURN_USING_MEMCPY(ISC_INT64, sqldata);
40 }
41
php_get_isc_long_from_sqldata(const ISC_SCHAR * sqldata)42 static zend_always_inline ISC_LONG php_get_isc_long_from_sqldata(const ISC_SCHAR *sqldata)
43 {
44 READ_AND_RETURN_USING_MEMCPY(ISC_LONG, sqldata);
45 }
46
php_get_double_from_sqldata(const ISC_SCHAR * sqldata)47 static zend_always_inline double php_get_double_from_sqldata(const ISC_SCHAR *sqldata)
48 {
49 READ_AND_RETURN_USING_MEMCPY(double, sqldata);
50 }
51
php_get_float_from_sqldata(const ISC_SCHAR * sqldata)52 static zend_always_inline float php_get_float_from_sqldata(const ISC_SCHAR *sqldata)
53 {
54 READ_AND_RETURN_USING_MEMCPY(float, sqldata);
55 }
56
php_get_isc_timestamp_from_sqldata(const ISC_SCHAR * sqldata)57 static zend_always_inline ISC_TIMESTAMP php_get_isc_timestamp_from_sqldata(const ISC_SCHAR *sqldata)
58 {
59 READ_AND_RETURN_USING_MEMCPY(ISC_TIMESTAMP, sqldata);
60 }
61
php_get_isc_quad_from_sqldata(const ISC_SCHAR * sqldata)62 static zend_always_inline ISC_QUAD php_get_isc_quad_from_sqldata(const ISC_SCHAR *sqldata)
63 {
64 READ_AND_RETURN_USING_MEMCPY(ISC_QUAD, sqldata);
65 }
66
67 /* free the allocated space for passing field values to the db and back */
php_firebird_free_sqlda(XSQLDA const * sqlda)68 static void php_firebird_free_sqlda(XSQLDA const *sqlda) /* {{{ */
69 {
70 int i;
71
72 for (i = 0; i < sqlda->sqld; ++i) {
73 XSQLVAR const *var = &sqlda->sqlvar[i];
74
75 if (var->sqlind) {
76 efree(var->sqlind);
77 }
78 }
79 }
80 /* }}} */
81
82 /* called by PDO to clean up a statement handle */
pdo_firebird_stmt_dtor(pdo_stmt_t * stmt)83 static int pdo_firebird_stmt_dtor(pdo_stmt_t *stmt) /* {{{ */
84 {
85 pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
86 int result = 1;
87
88 /* release the statement */
89 if (isc_dsql_free_statement(S->H->isc_status, &S->stmt, DSQL_drop)) {
90 php_firebird_error_stmt(stmt);
91 result = 0;
92 }
93
94 zend_hash_destroy(S->named_params);
95 FREE_HASHTABLE(S->named_params);
96
97 /* clean up the input descriptor */
98 if (S->in_sqlda) {
99 php_firebird_free_sqlda(S->in_sqlda);
100 efree(S->in_sqlda);
101 }
102
103 php_firebird_free_sqlda(&S->out_sqlda);
104 efree(S);
105
106 return result;
107 }
108 /* }}} */
109
110 /* called by PDO to execute a prepared query */
pdo_firebird_stmt_execute(pdo_stmt_t * stmt)111 static int pdo_firebird_stmt_execute(pdo_stmt_t *stmt) /* {{{ */
112 {
113 pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
114 pdo_firebird_db_handle *H = S->H;
115 zend_ulong affected_rows = 0;
116 static char info_count[] = {isc_info_sql_records};
117 char result[64];
118
119 do {
120 /* named or open cursors should be closed first */
121 if ((*S->name || S->cursor_open) && isc_dsql_free_statement(H->isc_status, &S->stmt, DSQL_close)) {
122 break;
123 }
124 S->cursor_open = 0;
125
126 /* allocate storage for the output data */
127 if (S->out_sqlda.sqld) {
128 unsigned int i;
129 for (i = 0; i < S->out_sqlda.sqld; i++) {
130 XSQLVAR *var = &S->out_sqlda.sqlvar[i];
131 if (var->sqlind) {
132 efree(var->sqlind);
133 }
134 var->sqlind = (void*)ecalloc(1, var->sqllen + 2 * sizeof(short));
135 var->sqldata = &((char*)var->sqlind)[sizeof(short)];
136 }
137 }
138
139 if (S->statement_type == isc_info_sql_stmt_exec_procedure) {
140 if (isc_dsql_execute2(H->isc_status, &H->tr, &S->stmt, PDO_FB_SQLDA_VERSION, S->in_sqlda, &S->out_sqlda)) {
141 break;
142 }
143 } else if (isc_dsql_execute(H->isc_status, &H->tr, &S->stmt, PDO_FB_SQLDA_VERSION, S->in_sqlda)) {
144 break;
145 }
146
147 /* Determine how many rows have changed. In this case we are
148 * only interested in rows changed, not rows retrieved. That
149 * should be handled by the client when fetching. */
150 stmt->row_count = affected_rows;
151
152 switch (S->statement_type) {
153 case isc_info_sql_stmt_insert:
154 case isc_info_sql_stmt_update:
155 case isc_info_sql_stmt_delete:
156 case isc_info_sql_stmt_exec_procedure:
157 if (isc_dsql_sql_info(H->isc_status, &S->stmt, sizeof ( info_count),
158 info_count, sizeof(result), result)) {
159 break;
160 }
161 if (result[0] == isc_info_sql_records) {
162 unsigned i = 3, result_size = isc_vax_integer(&result[1], 2);
163 if (result_size > sizeof(result)) {
164 goto error;
165 }
166 while (result[i] != isc_info_end && i < result_size) {
167 short len = (short) isc_vax_integer(&result[i + 1], 2);
168 if (len != 1 && len != 2 && len != 4) {
169 goto error;
170 }
171 if (result[i] != isc_info_req_select_count) {
172 affected_rows += isc_vax_integer(&result[i + 3], len);
173 }
174 i += len + 3;
175 }
176 stmt->row_count = affected_rows;
177 }
178 /* TODO Dead code or assert one of the previous cases are hit? */
179 default:
180 ;
181 }
182
183 if (stmt->dbh->auto_commit && !S->H->in_manually_txn && !php_firebird_commit_transaction(stmt->dbh, /* retain */ true)) {
184 break;
185 }
186
187 *S->name = 0;
188 S->cursor_open = S->out_sqlda.sqln && (S->statement_type != isc_info_sql_stmt_exec_procedure);
189 S->exhausted = !S->out_sqlda.sqln; /* There are data to fetch */
190
191 return 1;
192 } while (0);
193
194 error:
195 php_firebird_error_stmt(stmt);
196
197 return 0;
198 }
199 /* }}} */
200
201 /* called by PDO to fetch the next row from a statement */
pdo_firebird_stmt_fetch(pdo_stmt_t * stmt,enum pdo_fetch_orientation ori,zend_long offset)202 static int pdo_firebird_stmt_fetch(pdo_stmt_t *stmt, /* {{{ */
203 enum pdo_fetch_orientation ori, zend_long offset)
204 {
205 pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
206 pdo_firebird_db_handle *H = S->H;
207
208 if (!stmt->executed) {
209 const char *msg = "Cannot fetch from a closed cursor";
210 php_firebird_error_stmt_with_info(stmt, "HY000", strlen("HY000"), msg, strlen(msg));
211 } else if (!S->exhausted) {
212 if (S->statement_type == isc_info_sql_stmt_exec_procedure) {
213 stmt->row_count = 1;
214 S->exhausted = 1;
215 return 1;
216 }
217 if (isc_dsql_fetch(H->isc_status, &S->stmt, PDO_FB_SQLDA_VERSION, &S->out_sqlda)) {
218 if (H->isc_status[0] && H->isc_status[1]) {
219 php_firebird_error_stmt(stmt);
220 }
221 S->exhausted = 1;
222 return 0;
223 }
224 stmt->row_count++;
225 return 1;
226 }
227 return 0;
228 }
229 /* }}} */
230
231 /* called by PDO to retrieve information about the fields being returned */
pdo_firebird_stmt_describe(pdo_stmt_t * stmt,int colno)232 static int pdo_firebird_stmt_describe(pdo_stmt_t *stmt, int colno) /* {{{ */
233 {
234 pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
235 struct pdo_column_data *col = &stmt->columns[colno];
236 XSQLVAR *var = &S->out_sqlda.sqlvar[colno];
237 int colname_len;
238 char *cp;
239
240 if ((var->sqltype & ~1) == SQL_TEXT) {
241 var->sqltype = SQL_VARYING | (var->sqltype & 1);
242 }
243 colname_len = (S->H->fetch_table_names && var->relname_length)
244 ? (var->aliasname_length + var->relname_length + 1)
245 : (var->aliasname_length);
246 col->precision = -var->sqlscale;
247 col->maxlen = var->sqllen;
248 col->name = zend_string_alloc(colname_len, 0);
249 cp = ZSTR_VAL(col->name);
250 if (colname_len > var->aliasname_length) {
251 memmove(cp, var->relname, var->relname_length);
252 cp += var->relname_length;
253 *cp++ = '.';
254 }
255 memmove(cp, var->aliasname, var->aliasname_length);
256 *(cp+var->aliasname_length) = '\0';
257
258 return 1;
259 }
260 /* }}} */
261
pdo_firebird_stmt_get_column_meta(pdo_stmt_t * stmt,zend_long colno,zval * return_value)262 static int pdo_firebird_stmt_get_column_meta(pdo_stmt_t *stmt, zend_long colno, zval *return_value)
263 {
264 pdo_firebird_stmt *S = (pdo_firebird_stmt *) stmt->driver_data;
265 XSQLVAR *var = &S->out_sqlda.sqlvar[colno];
266
267 enum pdo_param_type param_type;
268 if (var->sqlscale < 0) {
269 param_type = PDO_PARAM_STR;
270 } else {
271 switch (var->sqltype & ~1) {
272 case SQL_SHORT:
273 case SQL_LONG:
274 #if SIZEOF_ZEND_LONG >= 8
275 case SQL_INT64:
276 #endif
277 param_type = PDO_PARAM_INT;
278 break;
279 #ifdef SQL_BOOLEAN
280 case SQL_BOOLEAN:
281 param_type = PDO_PARAM_BOOL;
282 break;
283 #endif
284 default:
285 param_type = PDO_PARAM_STR;
286 break;
287 }
288 }
289
290 array_init(return_value);
291 add_assoc_long(return_value, "pdo_type", param_type);
292 return 1;
293 }
294
295 /* fetch a blob into a fetch buffer */
php_firebird_fetch_blob(pdo_stmt_t * stmt,int colno,zval * result,ISC_QUAD * blob_id)296 static int php_firebird_fetch_blob(pdo_stmt_t *stmt, int colno, zval *result, ISC_QUAD *blob_id)
297 {
298 pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
299 pdo_firebird_db_handle *H = S->H;
300 isc_blob_handle blobh = PDO_FIREBIRD_HANDLE_INITIALIZER;
301 char const bl_item = isc_info_blob_total_length;
302 char bl_info[20];
303 unsigned short i;
304 int retval = 0;
305 size_t len = 0;
306
307 if (isc_open_blob(H->isc_status, &H->db, &H->tr, &blobh, blob_id)) {
308 php_firebird_error_stmt(stmt);
309 return 0;
310 }
311
312 if (isc_blob_info(H->isc_status, &blobh, 1, const_cast(&bl_item),
313 sizeof(bl_info), bl_info)) {
314 php_firebird_error_stmt(stmt);
315 goto fetch_blob_end;
316 }
317
318 /* find total length of blob's data */
319 for (i = 0; i < sizeof(bl_info); ) {
320 unsigned short item_len;
321 char item = bl_info[i++];
322
323 if (item == isc_info_end || item == isc_info_truncated || item == isc_info_error
324 || i >= sizeof(bl_info)) {
325 const char *msg = "Couldn't determine BLOB size";
326 php_firebird_error_stmt_with_info(stmt, "HY000", strlen("HY000"), msg, strlen(msg));
327 goto fetch_blob_end;
328 }
329
330 item_len = (unsigned short) isc_vax_integer(&bl_info[i], 2);
331
332 if (item == isc_info_blob_total_length) {
333 len = isc_vax_integer(&bl_info[i+2], item_len);
334 break;
335 }
336 i += item_len+2;
337 }
338
339 /* we've found the blob's length, now fetch! */
340
341 if (len) {
342 zend_ulong cur_len;
343 unsigned short seg_len;
344 ISC_STATUS stat;
345 zend_string *str;
346
347 /* prevent overflow */
348 if (len > ZSTR_MAX_LEN) {
349 result = 0;
350 goto fetch_blob_end;
351 }
352
353 str = zend_string_alloc(len, 0);
354
355 for (cur_len = stat = 0; (!stat || stat == isc_segment) && cur_len < len; cur_len += seg_len) {
356
357 unsigned short chunk_size = (len - cur_len) > USHRT_MAX ? USHRT_MAX
358 : (unsigned short)(len - cur_len);
359
360 stat = isc_get_segment(H->isc_status, &blobh, &seg_len, chunk_size, ZSTR_VAL(str) + cur_len);
361 }
362
363 ZSTR_VAL(str)[len] = '\0';
364 ZVAL_STR(result, str);
365
366 if (H->isc_status[0] == 1 && (stat != 0 && stat != isc_segstr_eof && stat != isc_segment)) {
367 const char *msg = "Error reading from BLOB";
368 php_firebird_error_stmt_with_info(stmt, "HY000", strlen("HY000"), msg, strlen(msg));
369 goto fetch_blob_end;
370 }
371 }
372 retval = 1;
373
374 fetch_blob_end:
375 if (isc_close_blob(H->isc_status, &blobh)) {
376 php_firebird_error_stmt(stmt);
377 return 0;
378 }
379 return retval;
380 }
381 /* }}} */
382
pdo_firebird_stmt_get_col(pdo_stmt_t * stmt,int colno,zval * result,enum pdo_param_type * type)383 static int pdo_firebird_stmt_get_col(
384 pdo_stmt_t *stmt, int colno, zval *result, enum pdo_param_type *type)
385 {
386 pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
387 XSQLVAR const *var = &S->out_sqlda.sqlvar[colno];
388
389 if (*var->sqlind == -1) {
390 ZVAL_NULL(result);
391 } else {
392 if (var->sqlscale < 0) {
393 static ISC_INT64 const scales[] = { 1, 10, 100, 1000,
394 10000,
395 100000,
396 1000000,
397 10000000,
398 100000000,
399 1000000000,
400 LL_LIT(10000000000),
401 LL_LIT(100000000000),
402 LL_LIT(1000000000000),
403 LL_LIT(10000000000000),
404 LL_LIT(100000000000000),
405 LL_LIT(1000000000000000),
406 LL_LIT(10000000000000000),
407 LL_LIT(100000000000000000),
408 LL_LIT(1000000000000000000)
409 };
410 ISC_INT64 n, f = scales[-var->sqlscale];
411 zend_string *str;
412
413 switch (var->sqltype & ~1) {
414 case SQL_SHORT:
415 n = *(short*)var->sqldata;
416 break;
417 case SQL_LONG:
418 n = php_get_isc_long_from_sqldata(var->sqldata);
419 break;
420 case SQL_INT64:
421 n = php_get_isc_int64_from_sqldata(var->sqldata);
422 break;
423 case SQL_DOUBLE:
424 break;
425 EMPTY_SWITCH_DEFAULT_CASE()
426 }
427
428 if ((var->sqltype & ~1) == SQL_DOUBLE) {
429 str = zend_strpprintf(0, "%.*F", -var->sqlscale, php_get_double_from_sqldata(var->sqldata));
430 } else if (n >= 0) {
431 str = zend_strpprintf(0, "%" LL_MASK "d.%0*" LL_MASK "d",
432 n / f, -var->sqlscale, n % f);
433 } else if (n <= -f) {
434 str = zend_strpprintf(0, "%" LL_MASK "d.%0*" LL_MASK "d",
435 n / f, -var->sqlscale, -n % f);
436 } else {
437 str = zend_strpprintf(0, "-0.%0*" LL_MASK "d", -var->sqlscale, -n % f);
438 }
439 ZVAL_STR(result, str);
440 } else {
441 switch (var->sqltype & ~1) {
442 struct tm t;
443 char *fmt;
444
445 case SQL_VARYING:
446 ZVAL_STRINGL_FAST(result, &var->sqldata[2], *(short*)var->sqldata);
447 break;
448 case SQL_TEXT:
449 ZVAL_STRINGL_FAST(result, var->sqldata, var->sqllen);
450 break;
451 case SQL_SHORT:
452 ZVAL_LONG(result, *(short*)var->sqldata);
453 break;
454 case SQL_LONG:
455 ZVAL_LONG(result, php_get_isc_long_from_sqldata(var->sqldata));
456 break;
457 case SQL_INT64:
458 #if SIZEOF_ZEND_LONG >= 8
459 ZVAL_LONG(result, php_get_isc_int64_from_sqldata(var->sqldata));
460 #else
461 ZVAL_STR(result, zend_strpprintf(0, "%" LL_MASK "d", php_get_isc_int64_from_sqldata(var->sqldata)));
462 #endif
463 break;
464 case SQL_FLOAT:
465 /* TODO: Why is this not returned as the native type? */
466 ZVAL_STR(result, zend_strpprintf_unchecked(0, "%.8H", php_get_float_from_sqldata(var->sqldata)));
467 break;
468 case SQL_DOUBLE:
469 /* TODO: Why is this not returned as the native type? */
470 ZVAL_STR(result, zend_strpprintf_unchecked(0, "%.16H", php_get_double_from_sqldata(var->sqldata)));
471 break;
472 #ifdef SQL_BOOLEAN
473 case SQL_BOOLEAN:
474 ZVAL_BOOL(result, *(FB_BOOLEAN*)var->sqldata);
475 break;
476 #endif
477 case SQL_TYPE_DATE:
478 isc_decode_sql_date((ISC_DATE*)var->sqldata, &t);
479 fmt = S->H->date_format ? S->H->date_format : PDO_FB_DEF_DATE_FMT;
480 if (0) {
481 case SQL_TYPE_TIME:
482 isc_decode_sql_time((ISC_TIME*)var->sqldata, &t);
483 fmt = S->H->time_format ? S->H->time_format : PDO_FB_DEF_TIME_FMT;
484 } else if (0) {
485 case SQL_TIMESTAMP:
486 {
487 ISC_TIMESTAMP timestamp = php_get_isc_timestamp_from_sqldata(var->sqldata);
488 isc_decode_timestamp(×tamp, &t);
489 }
490 fmt = S->H->timestamp_format ? S->H->timestamp_format : PDO_FB_DEF_TIMESTAMP_FMT;
491 }
492 /* convert the timestamp into a string */
493 char buf[80];
494 size_t len = strftime(buf, sizeof(buf), fmt, &t);
495 ZVAL_STRINGL(result, buf, len);
496 break;
497 case SQL_BLOB: {
498 ISC_QUAD quad = php_get_isc_quad_from_sqldata(var->sqldata);
499 return php_firebird_fetch_blob(stmt, colno, result, &quad);
500 }
501 }
502 }
503 }
504 return 1;
505 }
506
php_firebird_bind_blob(pdo_stmt_t * stmt,ISC_QUAD * blob_id,zval * param)507 static int php_firebird_bind_blob(pdo_stmt_t *stmt, ISC_QUAD *blob_id, zval *param)
508 {
509 pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
510 pdo_firebird_db_handle *H = S->H;
511 isc_blob_handle h = PDO_FIREBIRD_HANDLE_INITIALIZER;
512 zval data;
513 zend_ulong put_cnt = 0, rem_cnt;
514 unsigned short chunk_size;
515 int result = 1;
516
517 if (isc_create_blob(H->isc_status, &H->db, &H->tr, &h, blob_id)) {
518 php_firebird_error_stmt(stmt);
519 return 0;
520 }
521
522 if (Z_TYPE_P(param) != IS_STRING) {
523 ZVAL_STR(&data, zval_get_string_func(param));
524 } else {
525 ZVAL_COPY_VALUE(&data, param);
526 }
527
528 for (rem_cnt = Z_STRLEN(data); rem_cnt > 0; rem_cnt -= chunk_size) {
529 chunk_size = rem_cnt > USHRT_MAX ? USHRT_MAX : (unsigned short)rem_cnt;
530 if (isc_put_segment(H->isc_status, &h, chunk_size, &Z_STRVAL(data)[put_cnt])) {
531 php_firebird_error_stmt(stmt);
532 result = 0;
533 break;
534 }
535 put_cnt += chunk_size;
536 }
537
538 if (Z_TYPE_P(param) != IS_STRING) {
539 zval_ptr_dtor_str(&data);
540 }
541
542 if (isc_close_blob(H->isc_status, &h)) {
543 php_firebird_error_stmt(stmt);
544 return 0;
545 }
546 return result;
547 }
548
pdo_firebird_stmt_param_hook(pdo_stmt_t * stmt,struct pdo_bound_param_data * param,enum pdo_param_event event_type)549 static int pdo_firebird_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *param, /* {{{ */
550 enum pdo_param_event event_type)
551 {
552 pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
553 XSQLDA *sqlda = param->is_param ? S->in_sqlda : &S->out_sqlda;
554 XSQLVAR *var;
555
556 if (event_type == PDO_PARAM_EVT_FREE) { /* not used */
557 return 1;
558 }
559
560 if (!sqlda || param->paramno >= sqlda->sqld) {
561 const char *msg = "Invalid parameter index";
562 php_firebird_error_stmt_with_info(stmt, "HY093", strlen("HY093"), msg, strlen(msg));
563 return 0;
564 }
565 if (param->is_param && param->paramno == -1) {
566 zval *index;
567
568 /* try to determine the index by looking in the named_params hash */
569 if ((index = zend_hash_find(S->named_params, param->name)) != NULL) {
570 param->paramno = Z_LVAL_P(index);
571 } else {
572 /* ... or by looking in the input descriptor */
573 int i;
574
575 for (i = 0; i < sqlda->sqld; ++i) {
576 XSQLVAR *var = &sqlda->sqlvar[i];
577
578 if ((var->aliasname_length && !strncasecmp(ZSTR_VAL(param->name), var->aliasname,
579 min(ZSTR_LEN(param->name), var->aliasname_length)))
580 || (var->sqlname_length && !strncasecmp(ZSTR_VAL(param->name), var->sqlname,
581 min(ZSTR_LEN(param->name), var->sqlname_length)))) {
582 param->paramno = i;
583 break;
584 }
585 }
586 if (i >= sqlda->sqld) {
587 const char *msg = "Invalid parameter name";
588 php_firebird_error_stmt_with_info(stmt, "HY093", strlen("HY093"), msg, strlen(msg));
589 return 0;
590 }
591 }
592 }
593
594 var = &sqlda->sqlvar[param->paramno];
595
596 switch (event_type) {
597 zval *parameter;
598
599 case PDO_PARAM_EVT_ALLOC:
600 if (param->is_param) {
601 /* allocate the parameter */
602 if (var->sqlind) {
603 efree(var->sqlind);
604 }
605 var->sqlind = (void*)emalloc(var->sqllen + 2*sizeof(short));
606 var->sqldata = &((char*)var->sqlind)[sizeof(short)];
607 }
608 break;
609
610 case PDO_PARAM_EVT_EXEC_PRE:
611 if (!param->is_param) {
612 break;
613 }
614
615 *var->sqlind = 0;
616 if (Z_ISREF(param->parameter)) {
617 parameter = Z_REFVAL(param->parameter);
618 } else {
619 parameter = ¶m->parameter;
620 }
621
622 if (Z_TYPE_P(parameter) == IS_RESOURCE) {
623 php_stream *stm = NULL;
624
625 php_stream_from_zval_no_verify(stm, parameter);
626 if (stm) {
627 zend_string *mem = php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0);
628 zval_ptr_dtor(parameter);
629 ZVAL_STR(parameter, mem ? mem : ZSTR_EMPTY_ALLOC());
630 } else {
631 pdo_raise_impl_error(stmt->dbh, stmt, "HY105", "Expected a stream resource");
632 return 0;
633 }
634 }
635
636 switch (var->sqltype & ~1) {
637 case SQL_ARRAY:
638 {
639 const char *msg = "Cannot bind to array field";
640 php_firebird_error_stmt_with_info(stmt, "HY000", strlen("HY000"), msg, strlen(msg));
641 }
642 return 0;
643
644 case SQL_BLOB: {
645 if (Z_TYPE_P(parameter) == IS_NULL) {
646 /* Check if field allow NULL values */
647 if (~var->sqltype & 1) {
648 const char *msg = "Parameter requires non-null value";
649 php_firebird_error_stmt_with_info(stmt, "HY105", strlen("HY105"), msg, strlen(msg));
650 return 0;
651 }
652 *var->sqlind = -1;
653 return 1;
654 }
655 ISC_QUAD quad = php_get_isc_quad_from_sqldata(var->sqldata);
656 if (php_firebird_bind_blob(stmt, &quad, parameter) != 0) {
657 memcpy(var->sqldata, &quad, sizeof(quad));
658 return 1;
659 }
660 return 0;
661 }
662 }
663
664 #ifdef SQL_BOOLEAN
665 /* keep native BOOLEAN type */
666 if ((var->sqltype & ~1) == SQL_BOOLEAN) {
667 switch (Z_TYPE_P(parameter)) {
668 case IS_LONG:
669 case IS_DOUBLE:
670 case IS_TRUE:
671 case IS_FALSE:
672 *(FB_BOOLEAN*)var->sqldata = zend_is_true(parameter) ? FB_TRUE : FB_FALSE;
673 break;
674 case IS_STRING:
675 {
676 zend_long lval;
677 double dval;
678
679 if (Z_STRLEN_P(parameter) == 0) {
680 *(FB_BOOLEAN*)var->sqldata = FB_FALSE;
681 break;
682 }
683
684 switch (is_numeric_string(Z_STRVAL_P(parameter), Z_STRLEN_P(parameter), &lval, &dval, 0)) {
685 case IS_LONG:
686 *(FB_BOOLEAN*)var->sqldata = (lval != 0) ? FB_TRUE : FB_FALSE;
687 break;
688 case IS_DOUBLE:
689 *(FB_BOOLEAN*)var->sqldata = (dval != 0) ? FB_TRUE : FB_FALSE;
690 break;
691 default:
692 if (!zend_binary_strncasecmp(Z_STRVAL_P(parameter), Z_STRLEN_P(parameter), "true", 4, 4)) {
693 *(FB_BOOLEAN*)var->sqldata = FB_TRUE;
694 } else if (!zend_binary_strncasecmp(Z_STRVAL_P(parameter), Z_STRLEN_P(parameter), "false", 5, 5)) {
695 *(FB_BOOLEAN*)var->sqldata = FB_FALSE;
696 } else {
697 const char *msg = "Cannot convert string to boolean";
698 php_firebird_error_stmt_with_info(stmt, "HY105", strlen("HY105"), msg, strlen(msg));
699 return 0;
700 }
701
702 }
703 }
704 break;
705 case IS_NULL:
706 *var->sqlind = -1;
707 break;
708 default:
709 {
710 const char *msg = "Binding arrays/objects is not supported";
711 php_firebird_error_stmt_with_info(stmt, "HY105", strlen("HY105"), msg, strlen(msg));
712 }
713 return 0;
714 }
715 break;
716 }
717 #endif
718
719
720 /* check if a NULL should be inserted */
721 switch (Z_TYPE_P(parameter)) {
722 int force_null;
723
724 case IS_LONG:
725 /* keep the allow-NULL flag */
726 var->sqltype = (sizeof(zend_long) == 8 ? SQL_INT64 : SQL_LONG) | (var->sqltype & 1);
727 var->sqldata = (void*)&Z_LVAL_P(parameter);
728 var->sqllen = sizeof(zend_long);
729 break;
730 case IS_DOUBLE:
731 /* keep the allow-NULL flag */
732 var->sqltype = SQL_DOUBLE | (var->sqltype & 1);
733 var->sqldata = (void*)&Z_DVAL_P(parameter);
734 var->sqllen = sizeof(double);
735 break;
736 case IS_STRING:
737 force_null = 0;
738
739 /* for these types, an empty string can be handled like a NULL value */
740 switch (var->sqltype & ~1) {
741 case SQL_SHORT:
742 case SQL_LONG:
743 case SQL_INT64:
744 case SQL_FLOAT:
745 case SQL_DOUBLE:
746 case SQL_TIMESTAMP:
747 case SQL_TYPE_DATE:
748 case SQL_TYPE_TIME:
749 force_null = (Z_STRLEN_P(parameter) == 0);
750 }
751 if (!force_null) {
752 /* keep the allow-NULL flag */
753 var->sqltype = SQL_TEXT | (var->sqltype & 1);
754 var->sqldata = Z_STRVAL_P(parameter);
755 var->sqllen = Z_STRLEN_P(parameter);
756 break;
757 }
758 ZEND_FALLTHROUGH;
759 case IS_NULL:
760 /* complain if this field doesn't allow NULL values */
761 if (~var->sqltype & 1) {
762 const char *msg = "Parameter requires non-null value";
763 php_firebird_error_stmt_with_info(stmt, "HY105", strlen("HY105"), msg, strlen(msg));
764 return 0;
765 }
766 *var->sqlind = -1;
767 break;
768 default:
769 {
770 const char *msg = "Binding arrays/objects is not supported";
771 php_firebird_error_stmt_with_info(stmt, "HY105", strlen("HY105"), msg, strlen(msg));
772 }
773 return 0;
774 }
775 break;
776
777 case PDO_PARAM_EVT_FETCH_POST:
778 if (param->paramno == -1) {
779 return 0;
780 }
781 if (param->is_param) {
782 break;
783 }
784 if (Z_ISREF(param->parameter)) {
785 parameter = Z_REFVAL(param->parameter);
786 } else {
787 parameter = ¶m->parameter;
788 }
789 zval_ptr_dtor(parameter);
790 ZVAL_NULL(parameter);
791 return pdo_firebird_stmt_get_col(stmt, param->paramno, parameter, NULL);
792 default:
793 ;
794 }
795 return 1;
796 }
797 /* }}} */
798
pdo_firebird_stmt_set_attribute(pdo_stmt_t * stmt,zend_long attr,zval * val)799 static int pdo_firebird_stmt_set_attribute(pdo_stmt_t *stmt, zend_long attr, zval *val) /* {{{ */
800 {
801 pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
802
803 switch (attr) {
804 default:
805 return 0;
806 case PDO_ATTR_CURSOR_NAME:
807 if (!try_convert_to_string(val)) {
808 return 0;
809 }
810
811 if (isc_dsql_set_cursor_name(S->H->isc_status, &S->stmt, Z_STRVAL_P(val),0)) {
812 php_firebird_error_stmt(stmt);
813 return 0;
814 }
815 strlcpy(S->name, Z_STRVAL_P(val), sizeof(S->name));
816 break;
817 }
818 return 1;
819 }
820 /* }}} */
821
pdo_firebird_stmt_get_attribute(pdo_stmt_t * stmt,zend_long attr,zval * val)822 static int pdo_firebird_stmt_get_attribute(pdo_stmt_t *stmt, zend_long attr, zval *val) /* {{{ */
823 {
824 pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
825
826 switch (attr) {
827 default:
828 return 0;
829 case PDO_ATTR_CURSOR_NAME:
830 if (*S->name) {
831 ZVAL_STRING(val, S->name);
832 } else {
833 ZVAL_NULL(val);
834 }
835 break;
836 }
837 return 1;
838 }
839 /* }}} */
840
pdo_firebird_stmt_cursor_closer(pdo_stmt_t * stmt)841 static int pdo_firebird_stmt_cursor_closer(pdo_stmt_t *stmt) /* {{{ */
842 {
843 pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data;
844
845 /* close the statement handle */
846 if ((*S->name || S->cursor_open) && isc_dsql_free_statement(S->H->isc_status, &S->stmt, DSQL_close)) {
847 php_firebird_error_stmt(stmt);
848 return 0;
849 }
850 *S->name = 0;
851 S->cursor_open = 0;
852 return 1;
853 }
854 /* }}} */
855
856
857 const struct pdo_stmt_methods firebird_stmt_methods = { /* {{{ */
858 pdo_firebird_stmt_dtor,
859 pdo_firebird_stmt_execute,
860 pdo_firebird_stmt_fetch,
861 pdo_firebird_stmt_describe,
862 pdo_firebird_stmt_get_col,
863 pdo_firebird_stmt_param_hook,
864 pdo_firebird_stmt_set_attribute,
865 pdo_firebird_stmt_get_attribute,
866 pdo_firebird_stmt_get_column_meta,
867 NULL, /* next_rowset_func */
868 pdo_firebird_stmt_cursor_closer
869 };
870 /* }}} */
871
