/* +----------------------------------------------------------------------+ | PHP Version 5 | +----------------------------------------------------------------------+ | Copyright (c) 1997-2015 The PHP Group | +----------------------------------------------------------------------+ | This source file is subject to version 3.01 of the PHP license, | | that is bundled with this package in the file LICENSE, and is | | available through the world-wide-web at the following url: | | http://www.php.net/license/3_01.txt | | If you did not receive a copy of the PHP license and are unable to | | obtain it through the world-wide-web, please send a note to | | license@php.net so we can mail you a copy immediately. | +----------------------------------------------------------------------+ | Author: Ard Biesheuvel | +----------------------------------------------------------------------+ */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include "php.h" #include "php_ini.h" #include "ext/standard/info.h" #include "pdo/php_pdo.h" #include "pdo/php_pdo_driver.h" #include "php_pdo_firebird.h" #include "php_pdo_firebird_int.h" #include #define RECORD_ERROR(stmt) _firebird_error(NULL, stmt, __FILE__, __LINE__ TSRMLS_CC) /* free the allocated space for passing field values to the db and back */ static void free_sqlda(XSQLDA const *sqlda) /* {{{ */ { int i; for (i = 0; i < sqlda->sqld; ++i) { XSQLVAR const *var = &sqlda->sqlvar[i]; if (var->sqlind) { efree(var->sqlind); } } } /* }}} */ /* called by PDO to clean up a statement handle */ static int firebird_stmt_dtor(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */ { pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; int result = 1, i; /* release the statement */ if (isc_dsql_free_statement(S->H->isc_status, &S->stmt, DSQL_drop)) { RECORD_ERROR(stmt); result = 0; } /* clean up the fetch buffers if they have been used */ for (i = 0; i < S->out_sqlda.sqld; ++i) { if (S->fetch_buf[i]) { efree(S->fetch_buf[i]); } } efree(S->fetch_buf); zend_hash_destroy(S->named_params); FREE_HASHTABLE(S->named_params); /* clean up the input descriptor */ if (S->in_sqlda) { free_sqlda(S->in_sqlda); efree(S->in_sqlda); } free_sqlda(&S->out_sqlda); efree(S); return result; } /* }}} */ /* called by PDO to execute a prepared query */ static int firebird_stmt_execute(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */ { pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; pdo_firebird_db_handle *H = S->H; unsigned long affected_rows = 0; static char info_count[] = {isc_info_sql_records}; char result[64]; do { /* named or open cursors should be closed first */ if ((*S->name || S->cursor_open) && isc_dsql_free_statement(H->isc_status, &S->stmt, DSQL_close)) { break; } S->cursor_open = 0; /* assume all params have been bound */ if (isc_dsql_execute(H->isc_status, &H->tr, &S->stmt, PDO_FB_SQLDA_VERSION, S->in_sqlda)) { break; } /* Determine how many rows have changed. In this case we are * only interested in rows changed, not rows retrieved. That * should be handled by the client when fetching. */ stmt->row_count = affected_rows; switch (S->statement_type) { case isc_info_sql_stmt_insert: case isc_info_sql_stmt_update: case isc_info_sql_stmt_delete: case isc_info_sql_stmt_exec_procedure: if (isc_dsql_sql_info(H->isc_status, &S->stmt, sizeof ( info_count), info_count, sizeof(result), result)) { break; } if (result[0] == isc_info_sql_records) { unsigned i = 3, result_size = isc_vax_integer(&result[1], 2); while (result[i] != isc_info_end && i < result_size) { short len = (short) isc_vax_integer(&result[i + 1], 2); if (result[i] != isc_info_req_select_count) { affected_rows += isc_vax_integer(&result[i + 3], len); } i += len + 3; } stmt->row_count = affected_rows; } default: ; } /* commit? */ if (stmt->dbh->auto_commit && isc_commit_retaining(H->isc_status, &H->tr)) { break; } *S->name = 0; S->cursor_open = (S->out_sqlda.sqln > 0); /* A cursor is opened, when more than zero columns returned */ S->exhausted = !S->cursor_open; return 1; } while (0); RECORD_ERROR(stmt); return 0; } /* }}} */ /* called by PDO to fetch the next row from a statement */ static int firebird_stmt_fetch(pdo_stmt_t *stmt, /* {{{ */ enum pdo_fetch_orientation ori, long offset TSRMLS_DC) { pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; pdo_firebird_db_handle *H = S->H; if (!stmt->executed) { strcpy(stmt->error_code, "HY000"); H->last_app_error = "Cannot fetch from a closed cursor"; } else if (!S->exhausted) { if (isc_dsql_fetch(H->isc_status, &S->stmt, PDO_FB_SQLDA_VERSION, &S->out_sqlda)) { if (H->isc_status[0] && H->isc_status[1]) { RECORD_ERROR(stmt); } S->exhausted = 1; return 0; } if (S->statement_type == isc_info_sql_stmt_exec_procedure) { S->exhausted = 1; } stmt->row_count++; return 1; } return 0; } /* }}} */ /* called by PDO to retrieve information about the fields being returned */ static int firebird_stmt_describe(pdo_stmt_t *stmt, int colno TSRMLS_DC) /* {{{ */ { pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; struct pdo_column_data *col = &stmt->columns[colno]; XSQLVAR *var = &S->out_sqlda.sqlvar[colno]; int colname_len; char *cp; /* allocate storage for the column */ var->sqlind = (void*)ecalloc(1, var->sqllen + 2*sizeof(short)); var->sqldata = &((char*)var->sqlind)[sizeof(short)]; colname_len = (S->H->fetch_table_names && var->relname_length) ? (var->aliasname_length + var->relname_length + 1) : (var->aliasname_length); col->precision = -var->sqlscale; col->maxlen = var->sqllen; col->namelen = colname_len; col->name = cp = emalloc(colname_len + 1); if (colname_len > var->aliasname_length) { memmove(cp, var->relname, var->relname_length); cp += var->relname_length; *cp++ = '.'; } memmove(cp, var->aliasname, var->aliasname_length); *(cp+var->aliasname_length) = '\0'; col->param_type = PDO_PARAM_STR; return 1; } /* }}} */ #define FETCH_BUF(buf,type,len,lenvar) ((buf) = (buf) ? (buf) : \ emalloc((len) ? (len * sizeof(type)) : ((*(unsigned long*)lenvar) = sizeof(type)))) #define CHAR_BUF_LEN 24 /* fetch a blob into a fetch buffer */ static int firebird_fetch_blob(pdo_stmt_t *stmt, int colno, char **ptr, /* {{{ */ unsigned long *len, ISC_QUAD *blob_id TSRMLS_DC) { pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; pdo_firebird_db_handle *H = S->H; isc_blob_handle blobh = NULL; char const bl_item = isc_info_blob_total_length; char bl_info[20]; unsigned short i; int result = *len = 0; if (isc_open_blob(H->isc_status, &H->db, &H->tr, &blobh, blob_id)) { RECORD_ERROR(stmt); return 0; } if (isc_blob_info(H->isc_status, &blobh, 1, const_cast(&bl_item), sizeof(bl_info), bl_info)) { RECORD_ERROR(stmt); goto fetch_blob_end; } /* find total length of blob's data */ for (i = 0; i < sizeof(bl_info); ) { unsigned short item_len; char item = bl_info[i++]; if (item == isc_info_end || item == isc_info_truncated || item == isc_info_error || i >= sizeof(bl_info)) { H->last_app_error = "Couldn't determine BLOB size"; goto fetch_blob_end; } item_len = (unsigned short) isc_vax_integer(&bl_info[i], 2); if (item == isc_info_blob_total_length) { *len = isc_vax_integer(&bl_info[i+2], item_len); break; } i += item_len+2; } /* we've found the blob's length, now fetch! */ if (*len) { unsigned long cur_len; unsigned short seg_len; ISC_STATUS stat; *ptr = S->fetch_buf[colno] = erealloc(*ptr, *len+1); for (cur_len = stat = 0; (!stat || stat == isc_segment) && cur_len < *len; cur_len += seg_len) { unsigned short chunk_size = (*len-cur_len) > USHRT_MAX ? USHRT_MAX : (unsigned short)(*len-cur_len); stat = isc_get_segment(H->isc_status, &blobh, &seg_len, chunk_size, &(*ptr)[cur_len]); } (*ptr)[*len++] = '\0'; if (H->isc_status[0] == 1 && (stat != 0 && stat != isc_segstr_eof && stat != isc_segment)) { H->last_app_error = "Error reading from BLOB"; goto fetch_blob_end; } } result = 1; fetch_blob_end: if (isc_close_blob(H->isc_status, &blobh)) { RECORD_ERROR(stmt); return 0; } return result; } /* }}} */ static int firebird_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, /* {{{ */ unsigned long *len, int *caller_frees TSRMLS_DC) { pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; XSQLVAR const *var = &S->out_sqlda.sqlvar[colno]; if (*var->sqlind == -1) { /* A NULL value */ *ptr = NULL; *len = 0; } else { if (var->sqlscale < 0) { static ISC_INT64 const scales[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, LL_LIT(10000000000), LL_LIT(100000000000), LL_LIT(1000000000000), LL_LIT(10000000000000), LL_LIT(100000000000000), LL_LIT(1000000000000000), LL_LIT(10000000000000000), LL_LIT(100000000000000000), LL_LIT(1000000000000000000) }; ISC_INT64 n, f = scales[-var->sqlscale]; switch (var->sqltype & ~1) { case SQL_SHORT: n = *(short*)var->sqldata; break; case SQL_LONG: n = *(ISC_LONG*)var->sqldata; break; case SQL_INT64: n = *(ISC_INT64*)var->sqldata; } *ptr = FETCH_BUF(S->fetch_buf[colno], char, CHAR_BUF_LEN, NULL); if (n >= 0) { *len = slprintf(*ptr, CHAR_BUF_LEN, "%" LL_MASK "d.%0*" LL_MASK "d", n / f, -var->sqlscale, n % f); } else if (n <= -f) { *len = slprintf(*ptr, CHAR_BUF_LEN, "%" LL_MASK "d.%0*" LL_MASK "d", n / f, -var->sqlscale, -n % f); } else { *len = slprintf(*ptr, CHAR_BUF_LEN, "-0.%0*" LL_MASK "d", -var->sqlscale, -n % f); } } else { switch (var->sqltype & ~1) { struct tm t; char *fmt; case SQL_VARYING: *ptr = &var->sqldata[2]; *len = *(short*)var->sqldata; break; case SQL_TEXT: *ptr = var->sqldata; *len = var->sqllen; break; case SQL_SHORT: *ptr = FETCH_BUF(S->fetch_buf[colno], char, CHAR_BUF_LEN, NULL); *len = slprintf(*ptr, CHAR_BUF_LEN, "%d", *(short*)var->sqldata); break; case SQL_LONG: *ptr = FETCH_BUF(S->fetch_buf[colno], char, CHAR_BUF_LEN, NULL); *len = slprintf(*ptr, CHAR_BUF_LEN, "%ld", *(ISC_LONG*)var->sqldata); break; case SQL_INT64: *ptr = FETCH_BUF(S->fetch_buf[colno], char, CHAR_BUF_LEN, NULL); *len = slprintf(*ptr, CHAR_BUF_LEN, "%" LL_MASK "d", *(ISC_INT64*)var->sqldata); break; case SQL_FLOAT: *ptr = FETCH_BUF(S->fetch_buf[colno], char, CHAR_BUF_LEN, NULL); *len = slprintf(*ptr, CHAR_BUF_LEN, "%F", *(float*)var->sqldata); break; case SQL_DOUBLE: *ptr = FETCH_BUF(S->fetch_buf[colno], char, CHAR_BUF_LEN, NULL); *len = slprintf(*ptr, CHAR_BUF_LEN, "%F" , *(double*)var->sqldata); break; case SQL_TYPE_DATE: isc_decode_sql_date((ISC_DATE*)var->sqldata, &t); fmt = S->H->date_format ? S->H->date_format : PDO_FB_DEF_DATE_FMT; if (0) { case SQL_TYPE_TIME: isc_decode_sql_time((ISC_TIME*)var->sqldata, &t); fmt = S->H->time_format ? S->H->time_format : PDO_FB_DEF_TIME_FMT; } else if (0) { case SQL_TIMESTAMP: isc_decode_timestamp((ISC_TIMESTAMP*)var->sqldata, &t); fmt = S->H->timestamp_format ? S->H->timestamp_format : PDO_FB_DEF_TIMESTAMP_FMT; } /* convert the timestamp into a string */ *len = 80; *ptr = FETCH_BUF(S->fetch_buf[colno], char, *len, NULL); *len = strftime(*ptr, *len, fmt, &t); break; case SQL_BLOB: return firebird_fetch_blob(stmt,colno,ptr,len, (ISC_QUAD*)var->sqldata TSRMLS_CC); } } } return 1; } /* }}} */ static int firebird_bind_blob(pdo_stmt_t *stmt, ISC_QUAD *blob_id, zval *param TSRMLS_DC) { pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; pdo_firebird_db_handle *H = S->H; isc_blob_handle h = NULL; unsigned long put_cnt = 0, rem_cnt; unsigned short chunk_size; int result = 1; if (isc_create_blob(H->isc_status, &H->db, &H->tr, &h, blob_id)) { RECORD_ERROR(stmt); return 0; } SEPARATE_ZVAL(¶m); convert_to_string_ex(¶m); for (rem_cnt = Z_STRLEN_P(param); rem_cnt > 0; rem_cnt -= chunk_size) { chunk_size = rem_cnt > USHRT_MAX ? USHRT_MAX : (unsigned short)rem_cnt; if (isc_put_segment(H->isc_status, &h, chunk_size, &Z_STRVAL_P(param)[put_cnt])) { RECORD_ERROR(stmt); result = 0; break; } put_cnt += chunk_size; } zval_dtor(param); if (isc_close_blob(H->isc_status, &h)) { RECORD_ERROR(stmt); return 0; } return result; } static int firebird_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *param, /* {{{ */ enum pdo_param_event event_type TSRMLS_DC) { pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; XSQLDA *sqlda = param->is_param ? S->in_sqlda : &S->out_sqlda; XSQLVAR *var; if (event_type == PDO_PARAM_EVT_FREE) { /* not used */ return 1; } if (!sqlda || param->paramno >= sqlda->sqld) { strcpy(stmt->error_code, "HY093"); S->H->last_app_error = "Invalid parameter index"; return 0; } if (param->is_param && param->paramno == -1) { long *index; /* try to determine the index by looking in the named_params hash */ if (SUCCESS == zend_hash_find(S->named_params, param->name, param->namelen+1, (void*)&index)) { param->paramno = *index; } else { /* ... or by looking in the input descriptor */ int i; for (i = 0; i < sqlda->sqld; ++i) { XSQLVAR *var = &sqlda->sqlvar[i]; if ((var->aliasname_length && !strncasecmp(param->name, var->aliasname, min(param->namelen, var->aliasname_length))) || (var->sqlname_length && !strncasecmp(param->name, var->sqlname, min(param->namelen, var->sqlname_length)))) { param->paramno = i; break; } } if (i >= sqlda->sqld) { strcpy(stmt->error_code, "HY093"); S->H->last_app_error = "Invalid parameter name"; return 0; } } } var = &sqlda->sqlvar[param->paramno]; switch (event_type) { char *value; unsigned long value_len; int caller_frees; case PDO_PARAM_EVT_ALLOC: if (param->is_param) { /* allocate the parameter */ if (var->sqlind) { efree(var->sqlind); } var->sqlind = (void*)emalloc(var->sqllen + 2*sizeof(short)); var->sqldata = &((char*)var->sqlind)[sizeof(short)]; } break; case PDO_PARAM_EVT_EXEC_PRE: if (!param->is_param) { break; } *var->sqlind = 0; switch (var->sqltype & ~1) { case SQL_ARRAY: strcpy(stmt->error_code, "HY000"); S->H->last_app_error = "Cannot bind to array field"; return 0; case SQL_BLOB: return firebird_bind_blob(stmt, (ISC_QUAD*)var->sqldata, param->parameter TSRMLS_CC); } /* check if a NULL should be inserted */ switch (Z_TYPE_P(param->parameter)) { int force_null; case IS_LONG: /* keep the allow-NULL flag */ var->sqltype = (sizeof(long) == 8 ? SQL_INT64 : SQL_LONG) | (var->sqltype & 1); var->sqldata = (void*)&Z_LVAL_P(param->parameter); var->sqllen = sizeof(long); break; case IS_DOUBLE: /* keep the allow-NULL flag */ var->sqltype = SQL_DOUBLE | (var->sqltype & 1); var->sqldata = (void*)&Z_DVAL_P(param->parameter); var->sqllen = sizeof(double); break; case IS_STRING: force_null = 0; /* for these types, an empty string can be handled like a NULL value */ switch (var->sqltype & ~1) { case SQL_SHORT: case SQL_LONG: case SQL_INT64: case SQL_FLOAT: case SQL_DOUBLE: case SQL_TIMESTAMP: case SQL_TYPE_DATE: case SQL_TYPE_TIME: force_null = (Z_STRLEN_P(param->parameter) == 0); } if (!force_null) { /* keep the allow-NULL flag */ var->sqltype = SQL_TEXT | (var->sqltype & 1); var->sqldata = Z_STRVAL_P(param->parameter); var->sqllen = Z_STRLEN_P(param->parameter); break; } case IS_NULL: /* complain if this field doesn't allow NULL values */ if (~var->sqltype & 1) { strcpy(stmt->error_code, "HY105"); S->H->last_app_error = "Parameter requires non-null value"; return 0; } *var->sqlind = -1; break; default: strcpy(stmt->error_code, "HY105"); S->H->last_app_error = "Binding arrays/objects is not supported"; return 0; } break; case PDO_PARAM_EVT_FETCH_POST: if (param->paramno == -1) { return 0; } if (param->is_param) { break; } value = NULL; value_len = 0; caller_frees = 0; if (firebird_stmt_get_col(stmt, param->paramno, &value, &value_len, &caller_frees TSRMLS_CC)) { switch (PDO_PARAM_TYPE(param->param_type)) { case PDO_PARAM_STR: if (value) { ZVAL_STRINGL(param->parameter, value, value_len, 1); break; } case PDO_PARAM_INT: if (value) { ZVAL_LONG(param->parameter, *(long*)value); break; } case PDO_PARAM_EVT_NORMALIZE: if (!param->is_param) { char *s = param->name; while (*s != '\0') { *s = toupper(*s); s++; } } break; default: ZVAL_NULL(param->parameter); } if (value && caller_frees) { efree(value); } return 1; } return 0; default: ; } return 1; } /* }}} */ static int firebird_stmt_set_attribute(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC) /* {{{ */ { pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; switch (attr) { default: return 0; case PDO_ATTR_CURSOR_NAME: convert_to_string(val); if (isc_dsql_set_cursor_name(S->H->isc_status, &S->stmt, Z_STRVAL_P(val),0)) { RECORD_ERROR(stmt); return 0; } strlcpy(S->name, Z_STRVAL_P(val), sizeof(S->name)); break; } return 1; } /* }}} */ static int firebird_stmt_get_attribute(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC) /* {{{ */ { pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; switch (attr) { default: return 0; case PDO_ATTR_CURSOR_NAME: if (*S->name) { ZVAL_STRING(val,S->name,1); } else { ZVAL_NULL(val); } break; } return 1; } /* }}} */ static int firebird_stmt_cursor_closer(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */ { pdo_firebird_stmt *S = (pdo_firebird_stmt*)stmt->driver_data; /* close the statement handle */ if ((*S->name || S->cursor_open) && isc_dsql_free_statement(S->H->isc_status, &S->stmt, DSQL_close)) { RECORD_ERROR(stmt); return 0; } *S->name = 0; S->cursor_open = 0; return 1; } /* }}} */ struct pdo_stmt_methods firebird_stmt_methods = { /* {{{ */ firebird_stmt_dtor, firebird_stmt_execute, firebird_stmt_fetch, firebird_stmt_describe, firebird_stmt_get_col, firebird_stmt_param_hook, firebird_stmt_set_attribute, firebird_stmt_get_attribute, NULL, /* get_column_meta_func */ NULL, /* next_rowset_func */ firebird_stmt_cursor_closer }; /* }}} */ /* * Local variables: * tab-width: 4 * c-basic-offset: 4 * End: * vim600: noet sw=4 ts=4 fdm=marker * vim<600: noet sw=4 ts=4 */