/**
* Decrypt a text that is coded as a base64 string
*
* @param string $text
* @param string $key
* @return string
*/
PHP_METHOD(Phalcon_Crypt, decryptBase64){
zval **text, **key = NULL, **safe = NULL, *decrypt_text;
char *decoded;
int decoded_len;
phalcon_fetch_params_ex(1, 2, &text, &key, &safe);
PHALCON_ENSURE_IS_STRING(text);
if (!key) {
key = &PHALCON_GLOBAL(z_null);
}
if (safe && zend_is_true(*safe)) {
char *tmp = estrndup(Z_STRVAL_PP(text), Z_STRLEN_PP(text));
php_strtr(tmp, Z_STRLEN_PP(text), "-_", "+/", 2);
decoded = (char*)php_base64_decode((unsigned char*)tmp, Z_STRLEN_PP(text), &decoded_len);
efree(tmp);
}
else {
decoded = (char*)php_base64_decode((unsigned char*)(Z_STRVAL_PP(text)), Z_STRLEN_PP(text), &decoded_len);
}
if (!decoded) {
RETURN_FALSE;
}
PHALCON_MM_GROW();
PHALCON_ALLOC_GHOST_ZVAL(decrypt_text);
ZVAL_STRINGL(decrypt_text, decoded, decoded_len, 0);
PHALCON_RETURN_CALL_METHOD(this_ptr, "decrypt", decrypt_text, *key);
RETURN_MM();
}
/**
* Encrypts a text returning the result as a base64 string
*
* @param string $text
* @param string $key
* @return string
*/
PHP_METHOD(Phalcon_Crypt, encryptBase64){
zval *text, *key = NULL, *safe = NULL, *encrypted = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 2, &text, &key, &safe);
if (!key) {
key = PHALCON_GLOBAL(z_null);
}
if (!safe) {
safe = PHALCON_GLOBAL(z_false);
}
PHALCON_CALL_METHOD(&encrypted, this_ptr, "encrypt", text, key);
phalcon_base64_encode(return_value, encrypted);
if (zend_is_true(safe)) {
php_strtr(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value), "+/", "-_", 2);
}
RETURN_MM();
}
/**
* Decrypt a text that is coded as a base64 string
*
* @param string $text
* @param string $key
* @return string
*/
PHP_METHOD(Phalcon_Crypt, decryptBase64){
zval *text, *key = NULL, *safe = NULL, decrypt_text = {}, decrypt_value = {};
phalcon_fetch_params(0, 1, 2, &text, &key, &safe);
PHALCON_ENSURE_IS_STRING(text);
if (!key) {
key = &PHALCON_GLOBAL(z_null);
}
if (!safe) {
safe = &PHALCON_GLOBAL(z_false);
}
if (zend_is_true(safe)) {
ZVAL_NEW_STR(&decrypt_text, zend_string_dup(Z_STR_P(text), 0));
php_strtr(Z_STRVAL(decrypt_text), Z_STRLEN(decrypt_text), "-_", "+/", 2);
} else {
PHALCON_CPY_WRT_CTOR(&decrypt_text, text);
}
phalcon_base64_decode(&decrypt_value, &decrypt_text);
PHALCON_RETURN_CALL_METHODW(getThis(), "decrypt", &decrypt_value, key);
}
/**
* Encrypts a text returning the result as a base64 string
*
* @param string $text
* @param string $key
* @return string
*/
PHP_METHOD(Phalcon_Crypt, encryptBase64){
zval *text, *key = NULL, *safe = NULL, encrypt_value = {};
phalcon_fetch_params(0, 1, 2, &text, &key, &safe);
if (!key) {
key = &PHALCON_GLOBAL(z_null);
}
if (!safe) {
safe = &PHALCON_GLOBAL(z_false);
}
PHALCON_CALL_METHODW(&encrypt_value, getThis(), "encrypt", text, key);
phalcon_base64_encode(return_value, &encrypt_value);
if (zend_is_true(safe)) {
php_strtr(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value), "+/", "-_", 2);
}
}
void pvt_normalize_str(char *input_str)
{
static char from[] = " \n\r";
php_strtr(input_str, strlen(input_str), from, "_", strlen(input_str));
}
static void dic_optimizer_get_handler(INTERNAL_FUNCTION_PARAMETERS)
{
char *id, should_free = 1;
zend_ulong id_hash;
int id_len, i;
long oninvalid, exception_on_invalid_reference_const;
zval **found_service, **alias, **method_in_map = NULL, *this_services, *this_aliases, *this_methodMap, *this_loading;
zend_function *method = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &id, &id_len, &oninvalid) == FAILURE) {
return;
}
if (strcasecmp(id, "service_container") == 0) {
RETURN_THIS;
}
this_services = zend_read_property(Z_OBJCE_P(getThis()), getThis(), SYMFONY_DIC_TOKEN_SERVICES_KEY, sizeof(SYMFONY_DIC_TOKEN_SERVICES_KEY) - 1, 0 TSRMLS_CC);
this_aliases = zend_read_property(Z_OBJCE_P(getThis()), getThis(), SYMFONY_DIC_TOKEN_ALIASES_KEY, sizeof(SYMFONY_DIC_TOKEN_ALIASES_KEY) - 1, 0 TSRMLS_CC);
this_loading = zend_read_property(Z_OBJCE_P(getThis()), getThis(), SYMFONY_DIC_TOKEN_LOADING_KEY, sizeof(SYMFONY_DIC_TOKEN_LOADING_KEY) - 1, 0 TSRMLS_CC);
this_methodMap = zend_read_property(Z_OBJCE_P(getThis()), getThis(), SYMFONY_DIC_TOKEN_METHODMAP_KEY, sizeof(SYMFONY_DIC_TOKEN_METHODMAP_KEY) - 1, 0 TSRMLS_CC);
if (!SYMFONY_DIC_G(cache_done)) {
zval invalidBehavior;
zend_class_entry **exception_ce;
zend_get_constant_ex("self::EXCEPTION_ON_INVALID_REFERENCE", sizeof("self::EXCEPTION_ON_INVALID_REFERENCE") - 1, &invalidBehavior, Z_OBJCE_P(getThis()), 0 TSRMLS_CC);
SYMFONY_DIC_G(invalid_behavior) = Z_LVAL(invalidBehavior);
if (FAILURE == zend_lookup_class(SYMFONY_DIC_TOKEN_SERVICE_CIRCULAR_REFERENCE_EXCEPTION_KEY_UP, sizeof(SYMFONY_DIC_TOKEN_SERVICE_CIRCULAR_REFERENCE_EXCEPTION_KEY_UP) - 1, &exception_ce TSRMLS_CC)) {
zend_error_noreturn(E_ERROR, "Class %s not found", SYMFONY_DIC_TOKEN_SERVICE_CIRCULAR_REFERENCE_EXCEPTION_KEY_UP);
}
SYMFONY_DIC_G(ServiceCircularReferenceException) = *exception_ce;
if (FAILURE == zend_lookup_class(SYMFONY_DIC_TOKEN_SERVICE_NOT_FOUND_EXCEPTION_KEY_UP, sizeof(SYMFONY_DIC_TOKEN_SERVICE_NOT_FOUND_EXCEPTION_KEY_UP) - 1, &exception_ce TSRMLS_CC)) {
zend_error_noreturn(E_ERROR, "Class %s not found", SYMFONY_DIC_TOKEN_SERVICE_NOT_FOUND_EXCEPTION_KEY_UP);
}
SYMFONY_DIC_G(ServiceNotFoundException) = *exception_ce;
if (FAILURE == zend_lookup_class(SYMFONY_DIC_TOKEN_INACTIVE_SCOPE_EXCEPTION_KEY_UP, sizeof(SYMFONY_DIC_TOKEN_INACTIVE_SCOPE_EXCEPTION_KEY_UP) - 1, &exception_ce TSRMLS_CC)) {
zend_error_noreturn(E_ERROR, "Class %s not found", SYMFONY_DIC_TOKEN_INACTIVE_SCOPE_EXCEPTION_KEY_UP);
}
SYMFONY_DIC_G(InactiveScopeException) = *exception_ce;
SYMFONY_DIC_G(cache_done) = 1;
}
exception_on_invalid_reference_const = SYMFONY_DIC_G(invalid_behavior);
if (ZEND_NUM_ARGS() <= 1) {
oninvalid = exception_on_invalid_reference_const;
}
if (IS_INTERNED(id)) {
id_hash = INTERNED_HASH(id);
} else {
id_hash = zend_inline_hash_func(id, id_len + 1);
}
id = estrndup(id, id_len); /* zend_str_tolower will change it otherwise */
for (i = 0; i <= 1; i++, zend_str_tolower(id, id_len), id_hash = zend_inline_hash_func(id, id_len + 1)) {
if (zend_hash_quick_find(Z_ARRVAL_P(this_aliases), id, id_len + 1, id_hash, (void **)&alias) == SUCCESS) {
should_free = 0;
efree(id);
id = Z_STRVAL_PP(alias);
id_len = Z_STRLEN_PP(alias);
id_hash = zend_inline_hash_func(id, id_len + 1);
}
if (zend_hash_quick_find(Z_ARRVAL_P(this_services), id, id_len + 1, id_hash, (void **)&found_service) == SUCCESS) {
RETVAL_ZVAL_FAST(*found_service);
goto free_and_return;
}
}
if (zend_hash_quick_exists(Z_ARRVAL_P(this_loading), id, id_len + 1, id_hash)) {
zval *ServiceCircularReferenceException;
ALLOC_INIT_ZVAL(ServiceCircularReferenceException); /* ctor_args */
object_init_ex(ServiceCircularReferenceException, SYMFONY_DIC_G(ServiceCircularReferenceException));
zend_throw_exception_object(ServiceCircularReferenceException TSRMLS_CC);
goto free_and_return;
}
zend_hash_quick_find(Z_ARRVAL_P(this_methodMap), id, id_len + 1, id_hash, (void **)&method_in_map);
if (!method_in_map) {
char *new_id;
for (i=0; i < id_len; i++) {
if (id[i] == '_') {
memmove(&id[i], &id[i + 1], --id_len);
}
}
php_strtr(id, id_len, ".\\", "__", 2);
id_len = spprintf(&new_id, 0, "get%sservice", id);
efree(id);
id = new_id;
id_hash = zend_inline_hash_func(id, id_len + 1);
zend_hash_quick_find(&Z_OBJCE_P(getThis())->function_table, id, id_len + 1, id_hash, (void **)&method);
if (!method) {
if (oninvalid == exception_on_invalid_reference_const) {
zval *ServiceNotFoundException;
ALLOC_INIT_ZVAL(ServiceNotFoundException);
object_init_ex(ServiceNotFoundException, SYMFONY_DIC_G(ServiceNotFoundException));
zend_throw_exception_object(ServiceNotFoundException TSRMLS_CC); /* ctor_args */
}
goto free_and_return;
}
} else {
char *method_name_lc;
method_name_lc = zend_str_tolower_dup(Z_STRVAL_PP(method_in_map), Z_STRLEN_PP(method_in_map));
zend_hash_find(&Z_OBJCE_P(getThis())->function_table, method_name_lc, Z_STRLEN_PP(method_in_map) + 1, (void **)&method);
efree(method_name_lc);
}
zend_fcall_info fci = {0};
zend_fcall_info_cache fcic = {0};
zval *loading, *result;
ALLOC_INIT_ZVAL(loading); ZVAL_BOOL(loading, 1);
zend_hash_quick_add(Z_ARRVAL_P(this_loading), id, id_len + 1, id_hash, &loading, sizeof(zval *), NULL);
fcic.called_scope = Z_OBJCE_P(getThis());
fcic.calling_scope = Z_OBJCE_P(getThis());
fcic.function_handler = method;
fcic.initialized = 1;
fcic.object_ptr = getThis();
fci.retval_ptr_ptr = &result;
fci.size = sizeof(zend_fcall_info);
zend_call_function(&fci, &fcic TSRMLS_CC);
zend_hash_quick_del(Z_ARRVAL_P(this_loading), id, id_len + 1, id_hash);
if (!EG(exception)) {
RETVAL_ZVAL_FAST(result);
} else {
zend_hash_quick_del(Z_ARRVAL_P(this_services), id, id_len, id_hash);
if (instanceof_function(Z_OBJCE_P(EG(exception)), SYMFONY_DIC_G(InactiveScopeException) TSRMLS_CC) && oninvalid == exception_on_invalid_reference_const) {
EG(exception) = NULL;
}
}
zval_ptr_dtor(&result);
free_and_return:
if (should_free) { efree(id); }
return;
}
