/**
* Executes a prepared statement binding. This function uses integer indexes starting from zero
*
*<code>
* $statement = $connection->prepare('SELECT * FROM robots WHERE name = :name');
* $pdoResult = $connection->executePrepared($statement, array('name' => 'Voltron'));
*</code>
*
* @param \PDOStatement $statement
* @param array $placeholders
* @param array $dataTypes
* @return \PDOStatement
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, executePrepared){
zval *statement = NULL, *placeholders = NULL, *data_types = NULL;
zval *z_one, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = NULL;
zval *profiler, *sql_statement;
HashTable *ah0;
HashPosition hp0;
zval **hd;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &statement, &placeholders, &data_types) == FAILURE) {
RETURN_NULL();
}
PHALCON_MM_GROW();
z_one = PHALCON_GLOBAL(z_one);
phalcon_is_iterable(placeholders, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(wildcard, ah0, hp0);
PHALCON_GET_HVALUE(value);
if (Z_TYPE_P(wildcard) == IS_LONG) {
PHALCON_INIT_NVAR(parameter);
phalcon_add_function(parameter, wildcard, z_one);
} else {
if (Z_TYPE_P(wildcard) == IS_STRING) {
PHALCON_CPY_WRT(parameter, wildcard);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
if (Z_TYPE_P(data_types) == IS_ARRAY) {
if (likely(phalcon_array_isset(data_types, wildcard))) {
/**
* The bind type is double so we try to get the double value
*/
PHALCON_OBS_NVAR(type);
phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY);
if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) {
PHALCON_INIT_NVAR(cast_value);
phalcon_cast(cast_value, value, IS_DOUBLE);
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 1024);
} else {
PHALCON_CPY_WRT(cast_value, value);
}
/**
* 1024 is ignore the bind type
*/
Z_SET_ISREF_P(cast_value);
if (phalcon_compare_strict_long(type, 1024 TSRMLS_CC)) {
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, cast_value);
} else {
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, cast_value, type);
}
Z_UNSET_ISREF_P(cast_value);
} else {
PHALCON_INIT_NVAR(type);
if (Z_TYPE_P(value) == IS_LONG) {
ZVAL_LONG(type, 1 /* BIND_PARAM_INT */);
}
else {
ZVAL_LONG(type, 2 /* BIND_PARAM_STR */);
}
Z_SET_ISREF_P(value);
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, value, type);
Z_UNSET_ISREF_P(value);
/*
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter");
return;
*/
}
} else {
Z_SET_ISREF_P(value);
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, value);
Z_UNSET_ISREF_P(value);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
profiler = phalcon_fetch_nproperty_this(this_ptr, SL("_profiler"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(profiler) == IS_OBJECT) {
sql_statement = phalcon_fetch_nproperty_this(this_ptr, SL("_sqlStatement"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(NULL, profiler, "startprofile", sql_statement, placeholders, data_types);
PHALCON_CALL_METHOD(NULL, statement, "execute");
PHALCON_CALL_METHOD(NULL, profiler, "stopprofile");
} else {
PHALCON_CALL_METHOD(NULL, statement, "execute");
}
RETURN_CTOR(statement);
}
/**
* Encrypts a text
*
*<code>
* $encrypted = $crypt->encrypt("Ultra-secret text", "encrypt password");
*</code>
*
* @param string $text
* @param string $key
* @return string
*/
PHP_METHOD(Phalcon_Crypt, encrypt){
zval *source, *text, *key = NULL, *encrypt_key = NULL, *cipher, *mode, *padding_type, *iv_size = NULL;
zval *rand, *iv = NULL, *encrypt = NULL, *block_size = NULL, *padded;
zval *handler, *arguments = NULL, *value = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &source, &key);
PHALCON_OBS_VAR(handler);
phalcon_read_property_this(&handler, this_ptr, SL("_beforeEncrypt"), PH_NOISY TSRMLS_CC);
if (phalcon_is_callable(handler TSRMLS_CC)) {
PHALCON_SEPARATE_PARAM(source);
PHALCON_INIT_NVAR(arguments);
array_init_size(arguments, 1);
phalcon_array_append(&arguments, source, 0);
PHALCON_INIT_NVAR(value);
PHALCON_CALL_USER_FUNC_ARRAY(value, handler, arguments);
PHALCON_CPY_WRT(source, value);
}
/* Do not use make_printable_zval() here: we need the conversion with type juggling */
if (Z_TYPE_P(source) != IS_STRING) {
PHALCON_INIT_VAR(text);
phalcon_cast(text, source, IS_STRING);
}
else {
text = source;
}
if (phalcon_function_exists_ex(SS("mcrypt_get_iv_size") TSRMLS_CC) == FAILURE) {
PHALCON_THROW_EXCEPTION_STR(phalcon_crypt_exception_ce, "mcrypt extension is required");
return;
}
if (!key || Z_TYPE_P(key) == IS_NULL) {
encrypt_key = phalcon_fetch_nproperty_this(this_ptr, SL("_key"), PH_NOISY TSRMLS_CC);
} else {
PHALCON_CPY_WRT_CTOR(encrypt_key, key);
if (Z_TYPE_P(encrypt_key) != IS_STRING) {
convert_to_string(encrypt_key);
}
}
if (PHALCON_IS_EMPTY(encrypt_key)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_crypt_exception_ce, "Encryption key cannot be empty");
return;
}
cipher = phalcon_fetch_nproperty_this(this_ptr, SL("_cipher"), PH_NOISY TSRMLS_CC);
mode = phalcon_fetch_nproperty_this(this_ptr, SL("_mode"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_FUNCTION(&iv_size, "mcrypt_get_iv_size", cipher, mode);
if (unlikely(Z_TYPE_P(iv_size) != IS_LONG)) {
convert_to_long(iv_size);
}
if (Z_STRLEN_P(encrypt_key) > Z_LVAL_P(iv_size)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_crypt_exception_ce, "Size of key is too large for this algorithm");
return;
}
PHALCON_INIT_VAR(rand);
ZVAL_LONG(rand, 2);
PHALCON_CALL_FUNCTION(&iv, "mcrypt_create_iv", iv_size, rand);
if (unlikely(Z_TYPE_P(iv) != IS_STRING)) {
convert_to_string(iv);
}
PHALCON_CALL_FUNCTION(&block_size, "mcrypt_get_block_size", cipher, mode);
if (unlikely(Z_TYPE_P(block_size) != IS_LONG)) {
convert_to_long(block_size);
}
padding_type = phalcon_fetch_nproperty_this(this_ptr, SL("_padding"), PH_NOISY TSRMLS_CC);
assert(Z_TYPE_P(padding_type) == IS_LONG);
assert(Z_TYPE_P(block_size) == IS_LONG);
assert(Z_TYPE_P(mode) == IS_STRING);
assert(Z_TYPE_P(text) == IS_STRING);
PHALCON_INIT_VAR(padded);
phalcon_crypt_pad_text(padded, text, mode, Z_LVAL_P(block_size), Z_LVAL_P(padding_type) TSRMLS_CC);
assert(Z_TYPE_P(padded) == IS_STRING);
PHALCON_CALL_FUNCTION(&encrypt, "mcrypt_encrypt", cipher, encrypt_key, padded, mode, iv);
PHALCON_CONCAT_VV(return_value, iv, encrypt);
PHALCON_OBS_NVAR(handler);
phalcon_read_property_this(&handler, this_ptr, SL("_afterEncrypt"), PH_NOISY TSRMLS_CC);
if (phalcon_is_callable(handler TSRMLS_CC)) {
PHALCON_INIT_NVAR(arguments);
array_init_size(arguments, 1);
phalcon_array_append(&arguments, return_value, 0);
PHALCON_INIT_NVAR(value);
PHALCON_CALL_USER_FUNC_ARRAY(value, handler, arguments);
RETURN_CTOR(value);
}
RETURN_MM();
}
/**
* Executes a prepared statement binding. This function uses integer indexes starting from zero
*
*<code>
* $statement = $db->prepare('SELECT * FROM robots WHERE name = :name');
* $result = $connection->executePrepared($statement, array('name' => 'Voltron'));
*</code>
*
* @param \PDOStatement $statement
* @param array $placeholders
* @param array $dataTypes
* @return \PDOStatement
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, executePrepared){
zval *statement = NULL, *placeholders = NULL, *data_types = NULL;
zval *one, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &statement, &placeholders, &data_types) == FAILURE) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(one);
ZVAL_LONG(one, 1);
if (!phalcon_is_iterable_ex(placeholders, &ah0, &hp0, 0, 0)) {
return;
}
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_FOREACH_KEY(wildcard, ah0, hp0);
PHALCON_GET_FOREACH_VALUE(value);
if (Z_TYPE_P(wildcard) == IS_LONG) {
PHALCON_INIT_NVAR(parameter);
phalcon_add_function(parameter, wildcard, one TSRMLS_CC);
} else {
if (Z_TYPE_P(wildcard) == IS_STRING) {
PHALCON_CPY_WRT(parameter, wildcard);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
if (Z_TYPE_P(data_types) == IS_ARRAY) {
if (likely(phalcon_array_isset(data_types, wildcard))) {
/**
* The bind type is double so we try to get the double value
*/
PHALCON_OBS_NVAR(type);
phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY);
if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) {
PHALCON_INIT_NVAR(cast_value);
phalcon_cast(cast_value, value, IS_DOUBLE);
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 1024);
} else {
PHALCON_CPY_WRT(cast_value, value);
}
/**
* 1024 is ignore the bind type
*/
Z_SET_ISREF_P(cast_value);
if (phalcon_compare_strict_long(type, 1024 TSRMLS_CC)) {
phalcon_call_method_p2_noret(statement, "bindparam", parameter, cast_value);
} else {
phalcon_call_method_p3_noret(statement, "bindparam", parameter, cast_value, type);
}
Z_UNSET_ISREF_P(cast_value);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter");
return;
}
} else {
Z_SET_ISREF_P(value);
phalcon_call_method_p2_noret(statement, "bindparam", parameter, value);
Z_UNSET_ISREF_P(value);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
phalcon_call_method_noret(statement, "execute");
RETURN_CCTOR(statement);
}
/**
* Decrypts an encrypted text
*
*<code>
* echo $crypt->decrypt($encrypted, "decrypt password");
*</code>
*
* @param string $text
* @param string $key
* @param int $options
* @return string
*/
PHP_METHOD(Phalcon_Crypt, decrypt){
zval *source, *key = NULL, *options = NULL, handler = {}, arguments = {}, value = {}, text = {}, encrypt_key = {}, encrypt_options = {};
zval method = {}, iv_size = {}, iv = {}, text_to_decipher = {};
phalcon_fetch_params(0, 1, 2, &source, &key, &options);
if (phalcon_function_exists_ex(SL("openssl_encrypt")) == FAILURE) {
PHALCON_THROW_EXCEPTION_STRW(phalcon_crypt_exception_ce, "openssl extension is required");
return;
}
phalcon_read_property(&handler, getThis(), SL("_beforeDecrypt"), PH_NOISY);
if (phalcon_is_callable(&handler)) {
PHALCON_SEPARATE_PARAM(source);
array_init_size(&arguments, 1);
phalcon_array_append(&arguments, source, PH_COPY);
PHALCON_CALL_USER_FUNC_ARRAYW(&value, &handler, &arguments);
source = &value;
}
/* Do not use make_printable_zval() here: we need the conversion with type juggling */
if (Z_TYPE_P(source) != IS_STRING) {
phalcon_cast(&text, source, IS_STRING);
} else {
PHALCON_CPY_WRT_CTOR(&text, source);
}
if (!key || Z_TYPE_P(key) == IS_NULL) {
phalcon_return_property(&encrypt_key, getThis(), SL("_key"));
} else {
PHALCON_CPY_WRT_CTOR(&encrypt_key, key);
if (Z_TYPE(encrypt_key) != IS_STRING) {
convert_to_string(&encrypt_key);
}
}
if (!options || Z_TYPE_P(options) == IS_NULL) {
phalcon_return_property(&encrypt_options, getThis(), SL("_options"));
} else {
PHALCON_CPY_WRT_CTOR(&encrypt_options, options);
}
phalcon_read_property(&method, getThis(), SL("_method"), PH_NOISY);
PHALCON_CALL_FUNCTIONW(&iv_size, "openssl_cipher_iv_length", &method);
if (Z_LVAL(iv_size) <= 0) {
ZVAL_NULL(&iv);
PHALCON_CPY_WRT_CTOR(&text_to_decipher, &text);
} else {
phalcon_substr(&iv, &text, 0, Z_LVAL(iv_size));
phalcon_substr(&text_to_decipher, &text, Z_LVAL(iv_size), 0);
}
PHALCON_CALL_FUNCTIONW(return_value, "openssl_decrypt", &text_to_decipher, &method, &encrypt_key, &encrypt_options, &iv);
if (unlikely(Z_TYPE_P(return_value) != IS_STRING)) {
convert_to_string(return_value);
}
phalcon_read_property(&handler, getThis(), SL("_afterDecrypt"), PH_NOISY);
if (phalcon_is_callable(&handler)) {
array_init_size(&arguments, 1);
phalcon_array_append(&arguments, return_value, PH_COPY);
PHALCON_CALL_USER_FUNC_ARRAYW(&value, &handler, &arguments);
RETURN_CTORW(&value);
}
}
