/**
* Check if an annotation exists in a collection
*/
PHP_METHOD(Phalcon_Annotations_Collection, has) {
HashTable *_1$$3;
HashPosition _0$$3;
int ZEPHIR_LAST_CALL_STATUS;
zval *name_param = NULL, *annotations = NULL, *annotation = NULL, **_2$$3, *_3$$4 = NULL;
zval *name = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &name_param);
zephir_get_strval(name, name_param);
ZEPHIR_OBS_VAR(annotations);
zephir_read_property_this(&annotations, this_ptr, SL("_annotations"), PH_NOISY_CC);
if (Z_TYPE_P(annotations) == IS_ARRAY) {
zephir_is_iterable(annotations, &_1$$3, &_0$$3, 0, 0, "phalcon/annotations/collection.zep", 186);
for (
; zephir_hash_get_current_data_ex(_1$$3, (void**) &_2$$3, &_0$$3) == SUCCESS
; zephir_hash_move_forward_ex(_1$$3, &_0$$3)
) {
ZEPHIR_GET_HVALUE(annotation, _2$$3);
ZEPHIR_CALL_METHOD(&_3$$4, annotation, "getname", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_EQUAL(name, _3$$4)) {
RETURN_MM_BOOL(1);
}
}
}
RETURN_MM_BOOL(0);
}
/**
* Removes transactions from the TransactionManager
*/
PHP_METHOD(Phalcon_Mvc_Model_Transaction_Manager, _collectTransaction) {
HashTable *_1$$3;
HashPosition _0$$3;
zval *transaction, *transactions = NULL, *newTransactions = NULL, *managedTransaction = NULL, **_2$$3;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &transaction);
ZEPHIR_OBS_VAR(transactions);
zephir_read_property_this(&transactions, this_ptr, SL("_transactions"), PH_NOISY_CC);
if (zephir_fast_count_int(transactions TSRMLS_CC)) {
ZEPHIR_INIT_VAR(newTransactions);
array_init(newTransactions);
zephir_is_iterable(transactions, &_1$$3, &_0$$3, 0, 0, "phalcon/mvc/model/transaction/manager.zep", 295);
for (
; zend_hash_get_current_data_ex(_1$$3, (void**) &_2$$3, &_0$$3) == SUCCESS
; zend_hash_move_forward_ex(_1$$3, &_0$$3)
) {
ZEPHIR_GET_HVALUE(managedTransaction, _2$$3);
if (!ZEPHIR_IS_EQUAL(managedTransaction, transaction)) {
zephir_array_append(&newTransactions, transaction, PH_SEPARATE, "phalcon/mvc/model/transaction/manager.zep", 289);
} else {
RETURN_ON_FAILURE(zephir_property_decr(this_ptr, SL("_number") TSRMLS_CC));
}
}
zephir_update_property_this(getThis(), SL("_transactions"), newTransactions TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
/**
* Returns a route object by its name
*
* @param string name
* @return Test\Router\Route
*/
PHP_METHOD(Test_Router, getRouteByName) {
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_2;
HashPosition _1;
zval *name, *route = NULL, *_0, **_3, *_4 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &name);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC);
zephir_is_iterable(_0, &_2, &_1, 0, 0);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(route, _3);
ZEPHIR_CALL_METHOD(&_4, route, "getname", NULL);
zephir_check_call_status();
if (ZEPHIR_IS_EQUAL(_4, name)) {
RETURN_CCTOR(route);
}
}
RETURN_MM_BOOL(0);
}
/**
* Returns a route object by its id
*
* @param string id
* @return Test\Router\Route
*/
PHP_METHOD(Test_Router, getRouteById) {
HashTable *_2;
HashPosition _1;
zval *id, *route = NULL, *_0, **_3, *_4 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &id);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC);
zephir_is_iterable(_0, &_2, &_1, 0, 0);
for (
; zend_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zend_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(route, _3);
ZEPHIR_INIT_NVAR(_4);
zephir_call_method(_4, route, "getrouteid");
if (ZEPHIR_IS_EQUAL(_4, id)) {
RETURN_CCTOR(route);
}
}
RETURN_MM_BOOL(0);
}
/**
* Returns all the annotations that match a name
*/
PHP_METHOD(Phalcon_Annotations_Collection, getAll) {
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_1;
HashPosition _0;
zval *name_param = NULL, *annotations, *found, *annotation = NULL, **_2, *_3 = NULL;
zval *name = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &name_param);
zephir_get_strval(name, name_param);
ZEPHIR_INIT_VAR(found);
array_init(found);
ZEPHIR_OBS_VAR(annotations);
zephir_read_property_this(&annotations, this_ptr, SL("_annotations"), PH_NOISY_CC);
if (Z_TYPE_P(annotations) == IS_ARRAY) {
zephir_is_iterable(annotations, &_1, &_0, 0, 0, "phalcon/annotations/collection.zep", 167);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HVALUE(annotation, _2);
ZEPHIR_CALL_METHOD(&_3, annotation, "getname", NULL);
zephir_check_call_status();
if (ZEPHIR_IS_EQUAL(name, _3)) {
zephir_array_append(&found, annotation, PH_SEPARATE, "phalcon/annotations/collection.zep", 164);
}
}
}
RETURN_CCTOR(found);
}
/**
* Returns a route object by its id
*/
PHP_METHOD(Phalcon_Mvc_Router, getRouteById) {
HashTable *_2;
HashPosition _1;
int ZEPHIR_LAST_CALL_STATUS;
zval *id, *route = NULL, *_0, **_3, *_4$$3 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &id);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC);
zephir_is_iterable(_0, &_2, &_1, 0, 0, "phalcon/mvc/router.zep", 893);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(route, _3);
ZEPHIR_CALL_METHOD(&_4$$3, route, "getrouteid", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_EQUAL(_4$$3, id)) {
RETURN_CCTOR(route);
}
}
RETURN_MM_BOOL(0);
}
PHP_METHOD(Owl_Router_Router, match) {
zend_bool _5, _7;
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_2;
HashPosition _1;
zval *uri_param = NULL, *method_param = NULL, *router = NULL, *_0, **_3, *_4 = NULL, *_6 = NULL, *_8 = NULL;
zval *uri = NULL, *method = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &uri_param, &method_param);
zephir_get_strval(uri, uri_param);
if (!method_param) {
ZEPHIR_INIT_VAR(method);
ZVAL_STRING(method, "GET", 1);
} else {
zephir_get_strval(method, method_param);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("routers"), PH_NOISY_CC);
zephir_is_iterable(_0, &_2, &_1, 0, 0, "owl/Router/Router.zep", 56);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(router, _3);
ZEPHIR_CALL_METHOD(&_4, router, "match", NULL, 0, uri);
zephir_check_call_status();
_5 = zephir_is_true(_4);
if (_5) {
ZEPHIR_OBS_NVAR(_6);
zephir_read_property(&_6, router, SL("method"), PH_NOISY_CC);
_7 = ZEPHIR_IS_LONG(_6, 7);
if (!(_7)) {
ZEPHIR_OBS_NVAR(_8);
zephir_read_property(&_8, router, SL("method"), PH_NOISY_CC);
_7 = ZEPHIR_IS_EQUAL(_8, method);
}
_5 = _7;
}
if (_5) {
RETURN_CCTOR(router);
}
}
RETURN_MM_BOOL(0);
}
/**
* Filters the message group by field name
*
* @param string fieldName
* @return array
*/
PHP_METHOD(Phalcon_Validation_Message_Group, filter) {
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_1;
HashPosition _0;
zval *fieldName_param = NULL, *filtered, *messages, *message = NULL, **_2, *_3 = NULL;
zval *fieldName = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &fieldName_param);
if (unlikely(Z_TYPE_P(fieldName_param) != IS_STRING && Z_TYPE_P(fieldName_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'fieldName' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(fieldName_param) == IS_STRING)) {
zephir_get_strval(fieldName, fieldName_param);
} else {
ZEPHIR_INIT_VAR(fieldName);
ZVAL_EMPTY_STRING(fieldName);
}
ZEPHIR_INIT_VAR(filtered);
array_init(filtered);
ZEPHIR_OBS_VAR(messages);
zephir_read_property_this(&messages, this_ptr, SL("_messages"), PH_NOISY_CC);
if (Z_TYPE_P(messages) == IS_ARRAY) {
zephir_is_iterable(messages, &_1, &_0, 0, 0, "phalcon/validation/message/group.zep", 201);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HVALUE(message, _2);
if ((zephir_method_exists_ex(message, SS("getfield") TSRMLS_CC) == SUCCESS)) {
ZEPHIR_CALL_METHOD(&_3, message, "getfield", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_EQUAL(fieldName, _3)) {
zephir_array_append(&filtered, message, PH_SEPARATE, "phalcon/validation/message/group.zep", 196);
}
}
}
}
RETURN_CCTOR(filtered);
}
/**
* Returns the first annotation that match a name
*/
PHP_METHOD(Phalcon_Annotations_Collection, get) {
zephir_nts_static zephir_fcall_cache_entry *_6 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_1;
HashPosition _0;
zval *name_param = NULL, *annotation = NULL, *annotations, **_2, *_3 = NULL, *_4;
zval *name = NULL, *_5;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &name_param);
zephir_get_strval(name, name_param);
ZEPHIR_OBS_VAR(annotations);
zephir_read_property_this(&annotations, this_ptr, SL("_annotations"), PH_NOISY_CC);
if (Z_TYPE_P(annotations) == IS_ARRAY) {
zephir_is_iterable(annotations, &_1, &_0, 0, 0, "phalcon/annotations/collection.zep", 147);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HVALUE(annotation, _2);
ZEPHIR_CALL_METHOD(&_3, annotation, "getname", NULL);
zephir_check_call_status();
if (ZEPHIR_IS_EQUAL(name, _3)) {
RETURN_CCTOR(annotation);
}
}
}
ZEPHIR_INIT_VAR(_4);
object_init_ex(_4, phalcon_annotations_exception_ce);
ZEPHIR_INIT_VAR(_5);
ZEPHIR_CONCAT_SVS(_5, "Collection doesn't have an annotation called '", name, "'");
ZEPHIR_CALL_METHOD(NULL, _4, "__construct", &_6, _5);
zephir_check_call_status();
zephir_throw_exception_debug(_4, "phalcon/annotations/collection.zep", 149 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
/**
* Returns the annotations found in a specific property
*
* @param string className
* @param string propertyName
* @return Phalcon\Annotations\Collection
*/
PHP_METHOD(Phalcon_Annotations_Adapter, getProperty) {
zephir_nts_static zephir_fcall_cache_entry *_3 = NULL;
HashTable *_1;
HashPosition _0;
int ZEPHIR_LAST_CALL_STATUS;
zval *className_param = NULL, *propertyName_param = NULL, *classAnnotations = NULL, *properties = NULL, *name = NULL, *property = NULL, **_2;
zval *className = NULL, *propertyName = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &className_param, &propertyName_param);
zephir_get_strval(className, className_param);
zephir_get_strval(propertyName, propertyName_param);
ZEPHIR_CALL_METHOD(&classAnnotations, this_ptr, "get", NULL, className);
zephir_check_call_status();
if (Z_TYPE_P(classAnnotations) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&properties, classAnnotations, "getpropertiesannotations", NULL);
zephir_check_call_status();
if (Z_TYPE_P(properties) == IS_ARRAY) {
zephir_is_iterable(properties, &_1, &_0, 0, 0, "phalcon/annotations/adapter.zep", 233);
for (
; zephir_hash_get_current_data_ex(_1, (void**) &_2, &_0) == SUCCESS
; zephir_hash_move_forward_ex(_1, &_0)
) {
ZEPHIR_GET_HMKEY(name, _1, _0);
ZEPHIR_GET_HVALUE(property, _2);
if (ZEPHIR_IS_EQUAL(name, propertyName)) {
RETURN_CCTOR(property);
}
}
}
}
object_init_ex(return_value, phalcon_annotations_collection_ce);
ZEPHIR_CALL_METHOD(NULL, return_value, "__construct", &_3);
zephir_check_call_status();
RETURN_MM();
}
/**
* Compare strings
*/
PHP_METHOD(Phalcon_Validation_Validator_Confirmation, compare) {
zephir_fcall_cache_entry *_5 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *a_param = NULL, *b_param = NULL, *_0 = NULL, *_1, *_2, _3$$3 = zval_used_for_init, *_4$$3 = NULL, *_6$$3 = NULL;
zval *a = NULL, *b = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &a_param, &b_param);
zephir_get_strval(a, a_param);
zephir_get_strval(b, b_param);
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "ignoreCase", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_2);
ZVAL_BOOL(_2, 0);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "getoption", NULL, 0, _1, _2);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (zephir_is_true(_0)) {
if (!((zephir_function_exists_ex(SS("mb_strtolower") TSRMLS_CC) == SUCCESS))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_validation_exception_ce, "Extension 'mbstring' is required", "phalcon/validation/validator/confirmation.zep", 122);
return;
}
ZEPHIR_SINIT_VAR(_3$$3);
ZVAL_STRING(&_3$$3, "utf-8", 0);
ZEPHIR_CALL_FUNCTION(&_4$$3, "mb_strtolower", &_5, 200, a, &_3$$3);
zephir_check_call_status();
zephir_get_strval(a, _4$$3);
ZEPHIR_SINIT_NVAR(_3$$3);
ZVAL_STRING(&_3$$3, "utf-8", 0);
ZEPHIR_CALL_FUNCTION(&_6$$3, "mb_strtolower", &_5, 200, b, &_3$$3);
zephir_check_call_status();
zephir_get_strval(b, _6$$3);
}
RETURN_MM_BOOL(ZEPHIR_IS_EQUAL(a, b));
}
/**
* Returns a route object by its name
*/
PHP_METHOD(Phalcon_Cli_Router, getRouteByName) {
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_2;
HashPosition _1;
zval *name_param = NULL, *route = NULL, *_0, **_3, *_4 = NULL;
zval *name = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &name_param);
if (unlikely(Z_TYPE_P(name_param) != IS_STRING && Z_TYPE_P(name_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'name' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(name_param) == IS_STRING)) {
zephir_get_strval(name, name_param);
} else {
ZEPHIR_INIT_VAR(name);
ZVAL_EMPTY_STRING(name);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC);
zephir_is_iterable(_0, &_2, &_1, 0, 0, "phalcon/cli/router.zep", 501);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_forward_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(route, _3);
ZEPHIR_CALL_METHOD(&_4, route, "getname", NULL, 0);
zephir_check_call_status();
if (ZEPHIR_IS_EQUAL(_4, name)) {
RETURN_CCTOR(route);
}
}
RETURN_MM_BOOL(0);
}
/**
* Handles routing information received from the rewrite engine
*
*<code>
* //Read the info from the rewrite engine
* $router->handle();
*
* //Manually passing an URL
* $router->handle('/posts/edit/1');
*</code>
*
* @param string uri
*/
PHP_METHOD(Test_Router, handle) {
zephir_nts_static zephir_fcall_cache_entry *_12 = NULL;
HashTable *_2, *_9;
HashPosition _1, _8;
int ZEPHIR_LAST_CALL_STATUS;
zval *uri = NULL, *realUri = NULL, *request = NULL, *currentHostName = NULL, *routeFound = NULL, *parts = NULL, *params, *matches, *notFoundPaths, *vnamespace, *module, *controller, *action, *paramsStr, *strParams = NULL, *paramsMerge = NULL, *route = NULL, *methods = NULL, *dependencyInjector = NULL, *hostname = NULL, *regexHostName = NULL, *matched = NULL, *pattern = NULL, *handledUri = NULL, *beforeMatch = NULL, *paths = NULL, *converters = NULL, *part = NULL, *position = NULL, *matchPosition = NULL, *_0, **_3, *_4, *_5 = NULL, *_6 = NULL, *_7 = NULL, **_10, _11, *_13, *_14, *_15, *_16;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &uri);
if (!uri) {
uri = ZEPHIR_GLOBAL(global_null);
}
if (!(zephir_is_true(uri))) {
ZEPHIR_CALL_METHOD(&realUri, this_ptr, "getrewriteuri", NULL);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(realUri, uri);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_removeExtraSlashes"), PH_NOISY_CC);
if (zephir_is_true(_0)) {
ZEPHIR_CALL_METHOD(&handledUri, this_ptr, "doremoveextraslashes", NULL, realUri);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(handledUri, realUri);
}
ZEPHIR_INIT_VAR(request);
ZVAL_NULL(request);
ZEPHIR_INIT_VAR(currentHostName);
ZVAL_NULL(currentHostName);
ZEPHIR_INIT_VAR(routeFound);
ZVAL_BOOL(routeFound, 0);
ZEPHIR_INIT_VAR(parts);
array_init(parts);
ZEPHIR_INIT_VAR(params);
array_init(params);
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_matchedRoute"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC);
zephir_is_iterable(_0, &_2, &_1, 0, 1);
for (
; zephir_hash_get_current_data_ex(_2, (void**) &_3, &_1) == SUCCESS
; zephir_hash_move_backwards_ex(_2, &_1)
) {
ZEPHIR_GET_HVALUE(route, _3);
ZEPHIR_CALL_METHOD(&methods, route, "gethttpmethods", NULL);
zephir_check_call_status();
if (Z_TYPE_P(methods) != IS_NULL) {
if (Z_TYPE_P(request) == IS_NULL) {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _4);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "A dependency injection container is required to access the 'request' service");
return;
}
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "request", 0);
ZEPHIR_CALL_METHOD(&request, dependencyInjector, "getshared", NULL, _5);
zephir_check_temp_parameter(_5);
zephir_check_call_status();
}
ZEPHIR_CALL_METHOD(&_6, request, "ismethod", NULL, methods);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE(_6)) {
continue;
}
}
ZEPHIR_CALL_METHOD(&hostname, route, "gethostname", NULL);
zephir_check_call_status();
if (Z_TYPE_P(hostname) != IS_NULL) {
if (Z_TYPE_P(request) == IS_NULL) {
ZEPHIR_OBS_NVAR(dependencyInjector);
zephir_read_property_this(&dependencyInjector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "A dependency injection container is required to access the 'request' service");
return;
}
ZEPHIR_INIT_NVAR(_5);
ZVAL_STRING(_5, "request", 0);
ZEPHIR_CALL_METHOD(&request, dependencyInjector, "getshared", NULL, _5);
zephir_check_temp_parameter(_5);
zephir_check_call_status();
}
if (Z_TYPE_P(currentHostName) != IS_OBJECT) {
ZEPHIR_CALL_METHOD(¤tHostName, request, "gethttphost", NULL);
zephir_check_call_status();
}
if (Z_TYPE_P(currentHostName) != IS_NULL) {
continue;
}
ZEPHIR_INIT_NVAR(matched);
if (zephir_memnstr_str(hostname, SL("("), "test/router.zep", 381)) {
if (zephir_memnstr_str(hostname, SL("#"), "test/router.zep", 382)) {
ZEPHIR_INIT_NVAR(regexHostName);
ZEPHIR_CONCAT_SVS(regexHostName, "#^", hostname, "$#");
} else {
ZEPHIR_CPY_WRT(regexHostName, hostname);
}
ZEPHIR_INIT_NVAR(_7);
zephir_preg_match(matched, &(matched), regexHostName, currentHostName, _7, 0, 0 , 0 TSRMLS_CC);
} else {
ZVAL_BOOL(matched, ZEPHIR_IS_EQUAL(currentHostName, hostname));
}
if (!(zephir_is_true(matched))) {
continue;
}
}
ZEPHIR_CALL_METHOD(&pattern, route, "getcompiledpattern", NULL);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(routeFound);
if (zephir_memnstr_str(pattern, SL("^"), "test/router.zep", 400)) {
zephir_preg_match(routeFound, &(routeFound), pattern, handledUri, matches, 0, 0 , 0 TSRMLS_CC);
} else {
ZVAL_BOOL(routeFound, ZEPHIR_IS_EQUAL(pattern, handledUri));
}
if (zephir_is_true(routeFound)) {
ZEPHIR_CALL_METHOD(&beforeMatch, route, "getbeforematch", NULL);
zephir_check_call_status();
if (Z_TYPE_P(beforeMatch) != IS_NULL) {
if (zephir_is_callable(beforeMatch TSRMLS_CC)) {
ZEPHIR_THROW_EXCEPTION_STR(test_router_exception_ce, "Before-Match callback is not callable in matched route");
return;
}
}
}
if (zephir_is_true(routeFound)) {
ZEPHIR_CALL_METHOD(&paths, route, "getpaths", NULL);
zephir_check_call_status();
ZEPHIR_CPY_WRT(parts, paths);
if (Z_TYPE_P(matches) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&converters, route, "getconverters", NULL);
zephir_check_call_status();
zephir_is_iterable(paths, &_9, &_8, 0, 0);
for (
; zephir_hash_get_current_data_ex(_9, (void**) &_10, &_8) == SUCCESS
; zephir_hash_move_forward_ex(_9, &_8)
) {
ZEPHIR_GET_HMKEY(part, _9, _8);
ZEPHIR_GET_HVALUE(position, _10);
ZEPHIR_OBS_NVAR(matchPosition);
if (zephir_array_isset_fetch(&matchPosition, matches, position, 0 TSRMLS_CC)) {
if (Z_TYPE_P(converters) == IS_ARRAY) {
if (zephir_array_isset(converters, part)) {
continue;
}
}
zephir_array_update_zval(&parts, part, &matchPosition, PH_COPY | PH_SEPARATE);
} else {
if (Z_TYPE_P(converters) == IS_ARRAY) {
if (zephir_array_isset(converters, part)) {
}
}
}
}
zephir_update_property_this(this_ptr, SL("_matches"), matches TSRMLS_CC);
}
zephir_update_property_this(this_ptr, SL("_matchedRoute"), route TSRMLS_CC);
break;
}
}
if (zephir_is_true(routeFound)) {
zephir_update_property_this(this_ptr, SL("_wasMatched"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
}
if (!(zephir_is_true(routeFound))) {
ZEPHIR_OBS_VAR(notFoundPaths);
zephir_read_property_this(¬FoundPaths, this_ptr, SL("_notFoundPaths"), PH_NOISY_CC);
if (Z_TYPE_P(notFoundPaths) != IS_NULL) {
ZEPHIR_CPY_WRT(parts, notFoundPaths);
ZEPHIR_INIT_BNVAR(routeFound);
ZVAL_BOOL(routeFound, 1);
}
}
if (zephir_is_true(routeFound)) {
ZEPHIR_OBS_VAR(vnamespace);
if (zephir_array_isset_string_fetch(&vnamespace, parts, SS("namespace"), 0 TSRMLS_CC)) {
if (!(zephir_is_numeric(vnamespace))) {
zephir_update_property_this(this_ptr, SL("_namespace"), vnamespace TSRMLS_CC);
}
zephir_array_unset_string(&parts, SS("namespace"), PH_SEPARATE);
} else {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultNamespace"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_namespace"), _4 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(module);
if (zephir_array_isset_string_fetch(&module, parts, SS("module"), 0 TSRMLS_CC)) {
if (!(zephir_is_numeric(module))) {
zephir_update_property_this(this_ptr, SL("_module"), module TSRMLS_CC);
}
zephir_array_unset_string(&parts, SS("module"), PH_SEPARATE);
} else {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_module"), _4 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(controller);
if (zephir_array_isset_string_fetch(&controller, parts, SS("controller"), 0 TSRMLS_CC)) {
if (!(zephir_is_numeric(controller))) {
zephir_update_property_this(this_ptr, SL("_controller"), controller TSRMLS_CC);
}
zephir_array_unset_string(&parts, SS("controller"), PH_SEPARATE);
} else {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultController"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_controller"), _4 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(action);
if (zephir_array_isset_string_fetch(&action, parts, SS("action"), 0 TSRMLS_CC)) {
if (!(zephir_is_numeric(action))) {
zephir_update_property_this(this_ptr, SL("_action"), action TSRMLS_CC);
}
zephir_array_unset_string(&parts, SS("action"), PH_SEPARATE);
} else {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_action"), _4 TSRMLS_CC);
}
ZEPHIR_OBS_VAR(paramsStr);
if (zephir_array_isset_string_fetch(¶msStr, parts, SS("params"), 0 TSRMLS_CC)) {
ZEPHIR_SINIT_VAR(_11);
ZVAL_LONG(&_11, 1);
ZEPHIR_CALL_FUNCTION(&strParams, "substr", &_12, paramsStr, &_11);
zephir_check_call_status();
if (zephir_is_true(strParams)) {
ZEPHIR_INIT_BNVAR(params);
zephir_fast_explode_str(params, SL("/"), strParams, LONG_MAX TSRMLS_CC);
}
zephir_array_unset_string(&parts, SS("params"), PH_SEPARATE);
}
if (zephir_fast_count_int(params TSRMLS_CC)) {
ZEPHIR_INIT_VAR(paramsMerge);
zephir_fast_array_merge(paramsMerge, &(params), &(parts) TSRMLS_CC);
} else {
ZEPHIR_CPY_WRT(paramsMerge, parts);
}
zephir_update_property_this(this_ptr, SL("_params"), paramsMerge TSRMLS_CC);
} else {
_4 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultNamespace"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_namespace"), _4 TSRMLS_CC);
_13 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_module"), _13 TSRMLS_CC);
_14 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultController"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_controller"), _14 TSRMLS_CC);
_15 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_action"), _15 TSRMLS_CC);
_16 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultParams"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_params"), _16 TSRMLS_CC);
}
ZEPHIR_MM_RESTORE();
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Identical, validate) {
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *message = NULL, *label = NULL, *replacePairs, *_0 = NULL, *_1 = NULL, *_2 = NULL, *_3 = NULL, *_4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(field_param) == IS_STRING)) {
zephir_get_strval(field, field_param);
} else {
ZEPHIR_INIT_VAR(field);
ZVAL_EMPTY_STRING(field);
}
ZEPHIR_CALL_METHOD(&_0, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "accepted", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1, this_ptr, "getoption", NULL, 0, _2);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
if (!ZEPHIR_IS_EQUAL(_0, _1)) {
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _2);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _2);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "Identical", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _2);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_2);
object_init_ex(_2, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_3, "strtr", NULL, 53, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_4);
ZVAL_STRING(_4, "Identical", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _2, "__construct", NULL, 430, _3, field, _4);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _2);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Listens for notifications from the models manager
*/
PHP_METHOD(Phalcon_Mvc_Model_Behavior_SoftDelete, notify) {
HashTable *_5$$7;
HashPosition _4$$7;
zend_bool _9$$6;
zephir_fcall_cache_entry *_7 = NULL;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *type_param = NULL, *model, *options = NULL, *value = NULL, *field = NULL, *updateModel = NULL, *message = NULL, *modelsManager = NULL, *metaData = NULL, *columnMap = NULL, *_0$$3, *_1$$3 = NULL, *_2$$6 = NULL, *_8$$6 = NULL, *_3$$7 = NULL, **_6$$7, *_10$$9 = NULL, *_11$$9 = NULL;
zval *type = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &type_param, &model);
if (UNEXPECTED(Z_TYPE_P(type_param) != IS_STRING && Z_TYPE_P(type_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'type' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(type_param) == IS_STRING)) {
zephir_get_strval(type, type_param);
} else {
ZEPHIR_INIT_VAR(type);
ZVAL_EMPTY_STRING(type);
}
if (ZEPHIR_IS_STRING(type, "beforeDelete")) {
ZEPHIR_CALL_METHOD(&options, this_ptr, "getoptions", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_VAR(value);
if (!(zephir_array_isset_string_fetch(&value, options, SS("value"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "The option 'value' is required", "phalcon/mvc/model/behavior/softdelete.zep", 50);
return;
}
ZEPHIR_OBS_VAR(field);
if (!(zephir_array_isset_string_fetch(&field, options, SS("field"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_model_exception_ce, "The option 'field' is required", "phalcon/mvc/model/behavior/softdelete.zep", 57);
return;
}
ZEPHIR_INIT_VAR(_0$$3);
ZVAL_BOOL(_0$$3, 1);
ZEPHIR_CALL_METHOD(NULL, model, "skipoperation", NULL, 0, _0$$3);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_1$$3, model, "readattribute", NULL, 0, field);
zephir_check_call_status();
if (!ZEPHIR_IS_EQUAL(_1$$3, value)) {
ZEPHIR_CALL_METHOD(&modelsManager, model, "getmodelsmanager", NULL, 0);
zephir_check_call_status();
ZEPHIR_INIT_VAR(updateModel);
if (zephir_clone(updateModel, model TSRMLS_CC) == FAILURE) {
RETURN_MM();
}
ZEPHIR_CALL_METHOD(NULL, updateModel, "writeattribute", NULL, 0, field, value);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_2$$6, updateModel, "save", NULL, 0);
zephir_check_call_status();
if (!(zephir_is_true(_2$$6))) {
ZEPHIR_CALL_METHOD(&_3$$7, updateModel, "getmessages", NULL, 0);
zephir_check_call_status();
zephir_is_iterable(_3$$7, &_5$$7, &_4$$7, 0, 0, "phalcon/mvc/model/behavior/softdelete.zep", 91);
for (
; zend_hash_get_current_data_ex(_5$$7, (void**) &_6$$7, &_4$$7) == SUCCESS
; zend_hash_move_forward_ex(_5$$7, &_4$$7)
) {
ZEPHIR_GET_HVALUE(message, _6$$7);
ZEPHIR_CALL_METHOD(NULL, model, "appendmessage", &_7, 0, message);
zephir_check_call_status();
}
RETURN_MM_BOOL(0);
}
ZEPHIR_CALL_METHOD(NULL, model, "writeattribute", NULL, 0, field, value);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_8$$6, modelsManager, "iskeepingsnapshots", NULL, 0, model);
zephir_check_call_status();
_9$$6 = zephir_is_true(_8$$6);
if (_9$$6) {
_9$$6 = ZEPHIR_GLOBAL(orm).update_snapshot_on_save;
}
if (_9$$6) {
ZEPHIR_CALL_METHOD(&metaData, model, "getmodelsmetadata", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&columnMap, metaData, "getcolumnmap", NULL, 0, model);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_10$$9, updateModel, "getsnapshotdata", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, model, "setsnapshotdata", NULL, 0, _10$$9, columnMap);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_11$$9, updateModel, "getoldsnapshotdata", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, model, "setoldsnapshotdata", NULL, 0, _11$$9, columnMap);
zephir_check_call_status();
}
}
}
ZEPHIR_MM_RESTORE();
}
/**
* Handles routing information received from command-line arguments
*
* @param array arguments
*/
PHP_METHOD(Phalcon_Cli_Router, handle) {
zephir_fcall_cache_entry *_18 = NULL;
zval *_15 = NULL;
zval *_5 = NULL, *_10 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
HashTable *_3, *_7;
HashPosition _2, _6;
zend_bool _0;
zval *arguments = NULL, *moduleName = NULL, *taskName = NULL, *actionName = NULL, *params = NULL, *route = NULL, *parts = NULL, *pattern = NULL, *routeFound = NULL, *matches, *paths = NULL, *beforeMatch = NULL, *converters = NULL, *converter = NULL, *part = NULL, *position = NULL, *matchPosition = NULL, *strParams, *_1, **_4, **_8, *_9 = NULL, *_11, *_12, *_13, *_14, _16, *_17 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 1, &arguments);
if (!arguments) {
arguments = ZEPHIR_GLOBAL(global_null);
}
ZEPHIR_INIT_VAR(routeFound);
ZVAL_BOOL(routeFound, 0);
ZEPHIR_INIT_VAR(parts);
array_init(parts);
ZEPHIR_INIT_VAR(params);
array_init(params);
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_matchedRoute"), ZEPHIR_GLOBAL(global_null) TSRMLS_CC);
if (Z_TYPE_P(arguments) != IS_ARRAY) {
_0 = Z_TYPE_P(arguments) != IS_STRING;
if (_0) {
_0 = Z_TYPE_P(arguments) != IS_NULL;
}
if (_0) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Arguments must be an array or string", "phalcon/cli/router.zep", 204);
return;
}
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_routes"), PH_NOISY_CC);
zephir_is_iterable(_1, &_3, &_2, 0, 1, "phalcon/cli/router.zep", 304);
for (
; zephir_hash_get_current_data_ex(_3, (void**) &_4, &_2) == SUCCESS
; zephir_hash_move_backwards_ex(_3, &_2)
) {
ZEPHIR_GET_HVALUE(route, _4);
ZEPHIR_CALL_METHOD(&pattern, route, "getcompiledpattern", NULL, 0);
zephir_check_call_status();
if (zephir_memnstr_str(pattern, SL("^"), "phalcon/cli/router.zep", 214)) {
ZEPHIR_INIT_NVAR(routeFound);
zephir_preg_match(routeFound, pattern, arguments, matches, 0, 0 , 0 TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(routeFound);
ZVAL_BOOL(routeFound, ZEPHIR_IS_EQUAL(pattern, arguments));
}
if (zephir_is_true(routeFound)) {
ZEPHIR_CALL_METHOD(&beforeMatch, route, "getbeforematch", NULL, 0);
zephir_check_call_status();
if (Z_TYPE_P(beforeMatch) != IS_NULL) {
if (!(zephir_is_callable(beforeMatch TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_cli_router_exception_ce, "Before-Match callback is not callable in matched route", "phalcon/cli/router.zep", 232);
return;
}
ZEPHIR_INIT_NVAR(_5);
zephir_create_array(_5, 3, 0 TSRMLS_CC);
zephir_array_fast_append(_5, arguments);
zephir_array_fast_append(_5, route);
zephir_array_fast_append(_5, this_ptr);
ZEPHIR_INIT_NVAR(routeFound);
ZEPHIR_CALL_USER_FUNC_ARRAY(routeFound, beforeMatch, _5);
zephir_check_call_status();
}
}
if (zephir_is_true(routeFound)) {
ZEPHIR_CALL_METHOD(&paths, route, "getpaths", NULL, 0);
zephir_check_call_status();
ZEPHIR_CPY_WRT(parts, paths);
if (Z_TYPE_P(matches) == IS_ARRAY) {
ZEPHIR_CALL_METHOD(&converters, route, "getconverters", NULL, 0);
zephir_check_call_status();
zephir_is_iterable(paths, &_7, &_6, 0, 0, "phalcon/cli/router.zep", 293);
for (
; zephir_hash_get_current_data_ex(_7, (void**) &_8, &_6) == SUCCESS
; zephir_hash_move_forward_ex(_7, &_6)
) {
ZEPHIR_GET_HMKEY(part, _7, _6);
ZEPHIR_GET_HVALUE(position, _8);
ZEPHIR_OBS_NVAR(matchPosition);
if (zephir_array_isset_fetch(&matchPosition, matches, position, 0 TSRMLS_CC)) {
if (Z_TYPE_P(converters) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(converter);
if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_9);
ZEPHIR_INIT_NVAR(_5);
zephir_create_array(_5, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_5, matchPosition);
ZEPHIR_CALL_USER_FUNC_ARRAY(_9, converter, _5);
zephir_check_call_status();
zephir_array_update_zval(&parts, part, &_9, PH_COPY | PH_SEPARATE);
continue;
}
}
zephir_array_update_zval(&parts, part, &matchPosition, PH_COPY | PH_SEPARATE);
} else {
if (Z_TYPE_P(converters) == IS_ARRAY) {
ZEPHIR_OBS_NVAR(converter);
if (zephir_array_isset_fetch(&converter, converters, part, 0 TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_9);
ZEPHIR_INIT_NVAR(_10);
zephir_create_array(_10, 1, 0 TSRMLS_CC);
zephir_array_fast_append(_10, position);
ZEPHIR_CALL_USER_FUNC_ARRAY(_9, converter, _10);
zephir_check_call_status();
zephir_array_update_zval(&parts, part, &_9, PH_COPY | PH_SEPARATE);
}
}
}
}
zephir_update_property_this(this_ptr, SL("_matches"), matches TSRMLS_CC);
}
zephir_update_property_this(this_ptr, SL("_matchedRoute"), route TSRMLS_CC);
break;
}
}
if (zephir_is_true(routeFound)) {
zephir_update_property_this(this_ptr, SL("_wasMatched"), (1) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
} else {
zephir_update_property_this(this_ptr, SL("_wasMatched"), (0) ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false) TSRMLS_CC);
_11 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultModule"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_module"), _11 TSRMLS_CC);
_12 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultTask"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_task"), _12 TSRMLS_CC);
_13 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultAction"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_action"), _13 TSRMLS_CC);
_14 = zephir_fetch_nproperty_this(this_ptr, SL("_defaultParams"), PH_NOISY_CC);
zephir_update_property_this(this_ptr, SL("_params"), _14 TSRMLS_CC);
RETURN_THIS();
}
} else {
ZEPHIR_CPY_WRT(parts, arguments);
}
ZEPHIR_INIT_VAR(moduleName);
ZVAL_NULL(moduleName);
ZEPHIR_INIT_VAR(taskName);
ZVAL_NULL(taskName);
ZEPHIR_INIT_VAR(actionName);
ZVAL_NULL(actionName);
ZEPHIR_OBS_NVAR(moduleName);
if (zephir_array_isset_string_fetch(&moduleName, parts, SS("module"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&parts, SS("module"), PH_SEPARATE);
} else {
ZEPHIR_OBS_NVAR(moduleName);
zephir_read_property_this(&moduleName, this_ptr, SL("_defaultModule"), PH_NOISY_CC);
}
ZEPHIR_OBS_NVAR(taskName);
if (zephir_array_isset_string_fetch(&taskName, parts, SS("task"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&parts, SS("task"), PH_SEPARATE);
} else {
ZEPHIR_OBS_NVAR(taskName);
zephir_read_property_this(&taskName, this_ptr, SL("_defaultTask"), PH_NOISY_CC);
}
ZEPHIR_OBS_NVAR(actionName);
if (zephir_array_isset_string_fetch(&actionName, parts, SS("action"), 0 TSRMLS_CC)) {
zephir_array_unset_string(&parts, SS("action"), PH_SEPARATE);
} else {
ZEPHIR_OBS_NVAR(actionName);
zephir_read_property_this(&actionName, this_ptr, SL("_defaultAction"), PH_NOISY_CC);
}
if (zephir_is_true(routeFound)) {
ZEPHIR_OBS_NVAR(params);
if (zephir_array_isset_string_fetch(¶ms, parts, SS("params"), 0 TSRMLS_CC)) {
if (Z_TYPE_P(params) != IS_ARRAY) {
zephir_get_strval(_15, params);
ZEPHIR_SINIT_VAR(_16);
ZVAL_LONG(&_16, 1);
ZEPHIR_INIT_VAR(strParams);
zephir_substr(strParams, _15, 1 , 0, ZEPHIR_SUBSTR_NO_LENGTH);
if (zephir_is_true(strParams)) {
ZEPHIR_CALL_CE_STATIC(&_17, phalcon_cli_router_route_ce, "getdelimiter", &_18, 121);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(params);
zephir_fast_explode(params, _17, strParams, LONG_MAX TSRMLS_CC);
} else {
ZEPHIR_INIT_NVAR(params);
array_init(params);
}
}
zephir_array_unset_string(&parts, SS("params"), PH_SEPARATE);
}
if (zephir_fast_count_int(params TSRMLS_CC)) {
ZEPHIR_INIT_NVAR(_9);
zephir_fast_array_merge(_9, &(params), &(parts) TSRMLS_CC);
ZEPHIR_CPY_WRT(params, _9);
} else {
ZEPHIR_CPY_WRT(params, parts);
}
} else {
ZEPHIR_CPY_WRT(params, parts);
}
zephir_update_property_this(this_ptr, SL("_module"), moduleName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_task"), taskName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_action"), actionName TSRMLS_CC);
zephir_update_property_this(this_ptr, SL("_params"), params TSRMLS_CC);
ZEPHIR_MM_RESTORE();
}
/**
* Removes padding @a padding_type from @a text
* If the function detects that the text was not padded, it will return it unmodified
*
* @param string text Message to be unpadded
* @param string mode Encryption mode; unpadding is applied only in CBC or ECB mode
* @param int blockSize Cipher block size
* @param int paddingType Padding scheme
*/
PHP_METHOD(Phalcon_Crypt, _cryptUnpadText) {
unsigned char _23$$11, _25$$11, _27$$15, _30$$17;
zend_bool _0, _1, _2, _22$$11, _24$$11, _26$$15, _28$$15, _29$$17, _31$$17, _32$$3;
long length = 0;
zephir_fcall_cache_entry *_6 = NULL, *_9 = NULL, *_11 = NULL;
int blockSize, paddingType, ZEPHIR_LAST_CALL_STATUS, i = 0, paddingSize, ord = 0;
zval *text_param = NULL, *mode_param = NULL, *blockSize_param = NULL, *paddingType_param = NULL, *padding = NULL, *last = NULL, _3$$4, _4$$4, *_5$$4 = NULL, _7$$5 = zval_used_for_init, *_8$$5 = NULL, *_10$$5 = NULL, *_12$$5, _13$$7, _14$$7, *_15$$7 = NULL, _16$$8 = zval_used_for_init, *_17$$8 = NULL, *_18$$8, _19$$10, _20$$10, *_21$$10 = NULL, _33$$21, _34$$21;
zval *text = NULL, *mode = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &text_param, &mode_param, &blockSize_param, &paddingType_param);
zephir_get_strval(text, text_param);
if (unlikely(Z_TYPE_P(mode_param) != IS_STRING && Z_TYPE_P(mode_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'mode' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(mode_param) == IS_STRING)) {
zephir_get_strval(mode, mode_param);
} else {
ZEPHIR_INIT_VAR(mode);
ZVAL_EMPTY_STRING(mode);
}
if (unlikely(Z_TYPE_P(blockSize_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'blockSize' must be a int") TSRMLS_CC);
RETURN_MM_NULL();
}
blockSize = Z_LVAL_P(blockSize_param);
if (unlikely(Z_TYPE_P(paddingType_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'paddingType' must be a int") TSRMLS_CC);
RETURN_MM_NULL();
}
paddingType = Z_LVAL_P(paddingType_param);
paddingSize = 0;
length = zephir_fast_strlen_ev(text);
_0 = length > 0;
if (_0) {
_0 = (zephir_safe_mod_long_long(length, blockSize TSRMLS_CC) == 0);
}
_1 = _0;
if (_1) {
_2 = ZEPHIR_IS_STRING(mode, "cbc");
if (!(_2)) {
_2 = ZEPHIR_IS_STRING(mode, "ecb");
}
_1 = _2;
}
if (_1) {
do {
if (paddingType == 1) {
ZEPHIR_SINIT_VAR(_3$$4);
ZVAL_LONG(&_3$$4, (length - 1));
ZEPHIR_SINIT_VAR(_4$$4);
ZVAL_LONG(&_4$$4, 1);
ZEPHIR_INIT_VAR(last);
zephir_substr(last, text, zephir_get_intval(&_3$$4), 1 , 0);
ZEPHIR_CALL_FUNCTION(&_5$$4, "ord", &_6, 134, last);
zephir_check_call_status();
ord = zephir_get_intval(_5$$4);
if (ord <= blockSize) {
paddingSize = ord;
ZEPHIR_SINIT_VAR(_7$$5);
ZVAL_LONG(&_7$$5, 0);
ZEPHIR_CALL_FUNCTION(&_8$$5, "chr", &_9, 132, &_7$$5);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_7$$5);
ZVAL_LONG(&_7$$5, (paddingSize - 1));
ZEPHIR_CALL_FUNCTION(&_10$$5, "str_repeat", &_11, 133, _8$$5, &_7$$5);
zephir_check_call_status();
ZEPHIR_INIT_VAR(padding);
ZEPHIR_CONCAT_VV(padding, _10$$5, last);
ZEPHIR_SINIT_NVAR(_7$$5);
ZVAL_LONG(&_7$$5, (length - paddingSize));
ZEPHIR_INIT_VAR(_12$$5);
zephir_substr(_12$$5, text, zephir_get_intval(&_7$$5), 0, ZEPHIR_SUBSTR_NO_LENGTH);
if (!ZEPHIR_IS_EQUAL(_12$$5, padding)) {
paddingSize = 0;
}
}
break;
}
if (paddingType == 2) {
ZEPHIR_SINIT_VAR(_13$$7);
ZVAL_LONG(&_13$$7, (length - 1));
ZEPHIR_SINIT_VAR(_14$$7);
ZVAL_LONG(&_14$$7, 1);
ZEPHIR_INIT_NVAR(last);
zephir_substr(last, text, zephir_get_intval(&_13$$7), 1 , 0);
ZEPHIR_CALL_FUNCTION(&_15$$7, "ord", &_6, 134, last);
zephir_check_call_status();
ord = zephir_get_intval(_15$$7);
if (ord <= blockSize) {
paddingSize = ord;
ZEPHIR_SINIT_VAR(_16$$8);
ZVAL_LONG(&_16$$8, paddingSize);
ZEPHIR_CALL_FUNCTION(&_17$$8, "chr", &_9, 132, &_16$$8);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_16$$8);
ZVAL_LONG(&_16$$8, paddingSize);
ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_11, 133, _17$$8, &_16$$8);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_16$$8);
ZVAL_LONG(&_16$$8, (length - paddingSize));
ZEPHIR_INIT_VAR(_18$$8);
zephir_substr(_18$$8, text, zephir_get_intval(&_16$$8), 0, ZEPHIR_SUBSTR_NO_LENGTH);
if (!ZEPHIR_IS_EQUAL(_18$$8, padding)) {
paddingSize = 0;
}
}
break;
}
if (paddingType == 3) {
ZEPHIR_SINIT_VAR(_19$$10);
ZVAL_LONG(&_19$$10, (length - 1));
ZEPHIR_SINIT_VAR(_20$$10);
ZVAL_LONG(&_20$$10, 1);
ZEPHIR_INIT_NVAR(last);
zephir_substr(last, text, zephir_get_intval(&_19$$10), 1 , 0);
ZEPHIR_CALL_FUNCTION(&_21$$10, "ord", &_6, 134, last);
zephir_check_call_status();
paddingSize = zephir_get_intval(_21$$10);
break;
}
if (paddingType == 4) {
i = (length - 1);
while (1) {
_22$$11 = i > 0;
if (_22$$11) {
_23$$11 = ZEPHIR_STRING_OFFSET(text, i);
_22$$11 = _23$$11 == 0x00;
}
_24$$11 = _22$$11;
if (_24$$11) {
_24$$11 = paddingSize < blockSize;
}
if (!(_24$$11)) {
break;
}
paddingSize++;
i--;
}
_25$$11 = ZEPHIR_STRING_OFFSET(text, i);
if (_25$$11 == 0x80) {
paddingSize++;
} else {
paddingSize = 0;
}
break;
}
if (paddingType == 5) {
i = (length - 1);
while (1) {
_26$$15 = i >= 0;
if (_26$$15) {
_27$$15 = ZEPHIR_STRING_OFFSET(text, i);
_26$$15 = _27$$15 == 0x00;
}
_28$$15 = _26$$15;
if (_28$$15) {
_28$$15 = paddingSize <= blockSize;
}
if (!(_28$$15)) {
break;
}
paddingSize++;
i--;
}
break;
}
if (paddingType == 6) {
i = (length - 1);
while (1) {
_29$$17 = i >= 0;
if (_29$$17) {
_30$$17 = ZEPHIR_STRING_OFFSET(text, i);
_29$$17 = _30$$17 == 0x20;
}
_31$$17 = _29$$17;
if (_31$$17) {
_31$$17 = paddingSize <= blockSize;
}
if (!(_31$$17)) {
break;
}
paddingSize++;
i--;
}
break;
}
break;
} while(0);
_32$$3 = (paddingSize) ? 1 : 0;
if (_32$$3) {
_32$$3 = paddingSize <= blockSize;
}
if (_32$$3) {
if (paddingSize < length) {
ZEPHIR_SINIT_VAR(_33$$21);
ZVAL_LONG(&_33$$21, 0);
ZEPHIR_SINIT_VAR(_34$$21);
ZVAL_LONG(&_34$$21, (length - paddingSize));
zephir_substr(return_value, text, 0 , zephir_get_intval(&_34$$21), 0);
RETURN_MM();
}
RETURN_MM_STRING("", 1);
} else {
paddingSize = 0;
}
}
if (!(paddingSize)) {
RETURN_CTOR(text);
}
ZEPHIR_MM_RESTORE();
}
/**
* Do a role inherit from another existing role
*/
PHP_METHOD(Phalcon_Acl_Adapter_Memory, addInherit) {
zephir_fcall_cache_entry *_8 = NULL;
HashTable *_6;
HashPosition _5;
int ZEPHIR_LAST_CALL_STATUS;
zval *roleName_param = NULL, *roleToInherit, *roleInheritName = NULL, *rolesNames, *deepInheritName = NULL, *_0 = NULL, *_2, *_3, *_4, **_7, *_9;
zval *roleName = NULL, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &roleName_param, &roleToInherit);
zephir_get_strval(roleName, roleName_param);
ZEPHIR_OBS_VAR(rolesNames);
zephir_read_property_this(&rolesNames, this_ptr, SL("_rolesNames"), PH_NOISY_CC);
if (!(zephir_array_isset(rolesNames, roleName))) {
ZEPHIR_INIT_VAR(_0);
object_init_ex(_0, phalcon_acl_exception_ce);
ZEPHIR_INIT_VAR(_1);
ZEPHIR_CONCAT_SVS(_1, "Role '", roleName, "' does not exist in the role list");
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 9, _1);
zephir_check_call_status();
zephir_throw_exception_debug(_0, "phalcon/acl/adapter/memory.zep", 194 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (Z_TYPE_P(roleToInherit) == IS_OBJECT) {
ZEPHIR_CALL_METHOD(&roleInheritName, roleToInherit, "getname", NULL, 0);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(roleInheritName, roleToInherit);
}
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_roleInherits"), PH_NOISY_CC);
if (zephir_array_isset(_2, roleInheritName)) {
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_roleInherits"), PH_NOISY_CC);
zephir_array_fetch(&_4, _3, roleInheritName, PH_NOISY | PH_READONLY, "phalcon/acl/adapter/memory.zep", 207 TSRMLS_CC);
zephir_is_iterable(_4, &_6, &_5, 0, 0, "phalcon/acl/adapter/memory.zep", 210);
for (
; zephir_hash_get_current_data_ex(_6, (void**) &_7, &_5) == SUCCESS
; zephir_hash_move_forward_ex(_6, &_5)
) {
ZEPHIR_GET_HVALUE(deepInheritName, _7);
ZEPHIR_CALL_METHOD(NULL, this_ptr, "addinherit", &_8, 80, roleName, deepInheritName);
zephir_check_call_status();
}
}
if (!(zephir_array_isset(rolesNames, roleInheritName))) {
ZEPHIR_INIT_NVAR(_0);
object_init_ex(_0, phalcon_acl_exception_ce);
ZEPHIR_INIT_VAR(_9);
ZEPHIR_CONCAT_SVS(_9, "Role '", roleInheritName, "' (to inherit) does not exist in the role list");
ZEPHIR_CALL_METHOD(NULL, _0, "__construct", NULL, 9, _9);
zephir_check_call_status();
zephir_throw_exception_debug(_0, "phalcon/acl/adapter/memory.zep", 216 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (ZEPHIR_IS_EQUAL(roleName, roleInheritName)) {
RETURN_MM_BOOL(0);
}
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_roleInherits"), PH_NOISY_CC);
if (!(zephir_array_isset(_3, roleName))) {
zephir_update_property_array(this_ptr, SL("_roleInherits"), roleName, ZEPHIR_GLOBAL(global_true) TSRMLS_CC);
}
zephir_update_property_array_multi(this_ptr, SL("_roleInherits"), &roleInheritName TSRMLS_CC, SL("za"), 2, roleName);
RETURN_MM_BOOL(1);
}
/**
* Validates the data from the decoded JWT.
*
* @return boolean TRUE if the JWT request is valid and can be decoded. Otherwise, FALSE is returned.
*
* @see OAuth2\GrantType\GrantTypeInterface::getTokenData()
*/
PHP_METHOD(OAuth2_GrantType_JwtBearer, validateRequest) {
zend_bool _14, _21;
zephir_fcall_cache_entry *_9 = NULL, *_12 = NULL;
zval *_6;
int ZEPHIR_LAST_CALL_STATUS;
zval *request, *response, *undecodedJWT = NULL, *jwt = NULL, *notBefore, *jti = NULL, *key = NULL, *_0 = NULL, *_1 = NULL, *_2 = NULL, *_3 = NULL, *_4, *_5 = NULL, *_7, *_8 = NULL, *_10, *_11 = NULL, *_13 = NULL, *_15, *_16, *_17, *_18, *_19, *_20, *_22, *_23, *_24, *_25, *_26, *_27, *_28;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &request, &response);
if (!(zephir_instance_of_ev(request, oauth2_requestinterface_ce TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'request' must be an instance of 'OAuth2\\RequestInterface'", "", 0);
return;
}
if (!(zephir_instance_of_ev(response, oauth2_responseinterface_ce TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(spl_ce_InvalidArgumentException, "Parameter 'response' must be an instance of 'OAuth2\\ResponseInterface'", "", 0);
return;
}
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "assertion", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, request, "request", NULL, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (!(zephir_is_true(_0))) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 400);
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "invalid_request", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_VAR(_3);
ZVAL_STRING(_3, "Missing parameters: \"assertion\" required", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, response, "seterror", NULL, _1, _2, _3);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "assertion", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&undecodedJWT, request, "request", NULL, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
_4 = zephir_fetch_nproperty_this(this_ptr, SL("jwtUtil"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "assertion", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_5, request, "request", NULL, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
ZEPHIR_INIT_NVAR(_1);
ZVAL_NULL(_1);
ZEPHIR_INIT_NVAR(_2);
ZVAL_BOOL(_2, 0);
ZEPHIR_CALL_METHOD(&jwt, _4, "decode", NULL, _5, _1, _2);
zephir_check_call_status();
if (!(zephir_is_true(jwt))) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 400);
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "invalid_request", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "JWT is malformed", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, response, "seterror", NULL, _1, _2, _3);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_INIT_NVAR(_1);
ZEPHIR_INIT_VAR(_6);
array_init_size(_6, 12);
zephir_array_update_string(&_6, SL("scope"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_6, SL("iss"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_6, SL("sub"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_6, SL("aud"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_6, SL("exp"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_6, SL("nbf"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_6, SL("iat"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_6, SL("jti"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_array_update_string(&_6, SL("typ"), &ZEPHIR_GLOBAL(global_null), PH_COPY | PH_SEPARATE);
zephir_fast_array_merge(_1, &(_6), &(jwt) TSRMLS_CC);
ZEPHIR_CPY_WRT(jwt, _1);
if (!(zephir_array_isset_string(jwt, SS("iss")))) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 400);
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "invalid_grant", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "Invalid issuer (iss) provided", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, response, "seterror", NULL, _1, _2, _3);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
if (!(zephir_array_isset_string(jwt, SS("sub")))) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 400);
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "invalid_grant", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "Invalid subject (sub) provided", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, response, "seterror", NULL, _1, _2, _3);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
if (!(zephir_array_isset_string(jwt, SS("exp")))) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 400);
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "invalid_grant", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "Expiration (exp) time must be present", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, response, "seterror", NULL, _1, _2, _3);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
zephir_array_fetch_string(&_7, jwt, SL("exp"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 115 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_8, "ctype_digit", &_9, _7);
zephir_check_call_status();
if (zephir_is_true(_8)) {
zephir_array_fetch_string(&_10, jwt, SL("exp"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 116 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_11, "time", &_12);
zephir_check_call_status();
if (ZEPHIR_LE(_10, _11)) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 400);
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "invalid_grant", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "JWT has expired", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, response, "seterror", NULL, _1, _2, _3);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
} else {
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 400);
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "invalid_grant", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "Expiration (exp) time must be a unix time stamp", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, response, "seterror", NULL, _1, _2, _3);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
ZEPHIR_OBS_VAR(notBefore);
zephir_array_fetch_string(¬Before, jwt, SL("nbf"), PH_NOISY, "oauth2/granttype/jwtbearer.zep", 126 TSRMLS_CC);
if (zephir_is_true(notBefore)) {
ZEPHIR_CALL_FUNCTION(&_11, "ctype_digit", &_9, notBefore);
zephir_check_call_status();
if (zephir_is_true(_11)) {
ZEPHIR_CALL_FUNCTION(&_13, "time", &_12);
zephir_check_call_status();
if (ZEPHIR_GT(notBefore, _13)) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 400);
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "invalid_grant", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "JWT cannot be used before the Not Before (nbf) time", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, response, "seterror", NULL, _1, _2, _3);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
} else {
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 400);
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "invalid_grant", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "Not Before (nbf) time must be a unix time stamp", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, response, "seterror", NULL, _1, _2, _3);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
}
_14 = !zephir_array_isset_string(jwt, SS("aud"));
if (!(_14)) {
zephir_array_fetch_string(&_10, jwt, SL("aud"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 140 TSRMLS_CC);
_15 = zephir_fetch_nproperty_this(this_ptr, SL("audience"), PH_NOISY_CC);
_14 = !ZEPHIR_IS_EQUAL(_10, _15);
}
if (_14) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 400);
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "invalid_grant", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "Invalid audience (aud)", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, response, "seterror", NULL, _1, _2, _3);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
if (zephir_array_isset_string(jwt, SS("jti"))) {
_16 = zephir_fetch_nproperty_this(this_ptr, SL("storage"), PH_NOISY_CC);
zephir_array_fetch_string(&_10, jwt, SL("iss"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 148 TSRMLS_CC);
zephir_array_fetch_string(&_17, jwt, SL("sub"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 148 TSRMLS_CC);
zephir_array_fetch_string(&_18, jwt, SL("aud"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 148 TSRMLS_CC);
zephir_array_fetch_string(&_19, jwt, SL("exp"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 148 TSRMLS_CC);
zephir_array_fetch_string(&_20, jwt, SL("jti"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 148 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&jti, _16, "getjti", NULL, _10, _17, _18, _19, _20);
zephir_check_call_status();
_21 = zephir_is_true(jti);
if (_21) {
zephir_array_fetch_string(&_22, jti, SL("expires"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 151 TSRMLS_CC);
ZEPHIR_CALL_FUNCTION(&_11, "time", &_12);
zephir_check_call_status();
_21 = ZEPHIR_GT(_22, _11);
}
if (_21) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 400);
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "invalid_grant", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "JSON Token Identifier (jti) has already been used", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, response, "seterror", NULL, _1, _2, _3);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
} else {
_23 = zephir_fetch_nproperty_this(this_ptr, SL("storage"), PH_NOISY_CC);
zephir_array_fetch_string(&_24, jwt, SL("iss"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 155 TSRMLS_CC);
zephir_array_fetch_string(&_25, jwt, SL("sub"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 155 TSRMLS_CC);
zephir_array_fetch_string(&_26, jwt, SL("aud"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 155 TSRMLS_CC);
zephir_array_fetch_string(&_27, jwt, SL("exp"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 155 TSRMLS_CC);
zephir_array_fetch_string(&_28, jwt, SL("jti"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 155 TSRMLS_CC);
ZEPHIR_CALL_METHOD(NULL, _23, "setjti", NULL, _24, _25, _26, _27, _28);
zephir_check_call_status();
}
}
_16 = zephir_fetch_nproperty_this(this_ptr, SL("storage"), PH_NOISY_CC);
zephir_array_fetch_string(&_10, jwt, SL("iss"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 161 TSRMLS_CC);
zephir_array_fetch_string(&_17, jwt, SL("sub"), PH_NOISY | PH_READONLY, "oauth2/granttype/jwtbearer.zep", 161 TSRMLS_CC);
ZEPHIR_CALL_METHOD(&key, _16, "getclientkey", NULL, _10, _17);
zephir_check_call_status();
if (!(zephir_is_true(key))) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 400);
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "invalid_grant", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "Invalid issuer (iss) or subject (sub) provided", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, response, "seterror", NULL, _1, _2, _3);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
_16 = zephir_fetch_nproperty_this(this_ptr, SL("jwtUtil"), PH_NOISY_CC);
ZEPHIR_INIT_NVAR(_1);
ZVAL_BOOL(_1, 1);
ZEPHIR_CALL_METHOD(&_11, _16, "decode", NULL, undecodedJWT, key, _1);
zephir_check_call_status();
if (!(zephir_is_true(_11))) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_LONG(_1, 400);
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "invalid_grant", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_INIT_NVAR(_3);
ZVAL_STRING(_3, "JWT failed signature verification", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, response, "seterror", NULL, _1, _2, _3);
zephir_check_temp_parameter(_2);
zephir_check_temp_parameter(_3);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
zephir_update_property_this(this_ptr, SL("jwt"), jwt TSRMLS_CC);
RETURN_MM_BOOL(1);
}
/**
* Adds an element to the form
*/
PHP_METHOD(Phalcon_Forms_Form, add) {
HashTable *_4$$4;
HashPosition _3$$4;
zend_long ZEPHIR_LAST_CALL_STATUS;
zend_bool type, _0;
zval *position = NULL;
zval *element, *position_param = NULL, *type_param = NULL, *name = NULL, *key = NULL, *value = NULL, *elements = NULL, *_1, *_2$$4, **_5$$4;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 2, &element, &position_param, &type_param);
if (!position_param) {
ZEPHIR_INIT_VAR(position);
ZVAL_EMPTY_STRING(position);
} else {
zephir_get_strval(position, position_param);
}
if (!type_param) {
type = 0;
} else {
type = zephir_get_boolval(type_param);
}
ZEPHIR_CALL_METHOD(&name, element, "getname", NULL, 0);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, element, "setform", NULL, 0, this_ptr);
zephir_check_call_status();
_0 = ZEPHIR_IS_STRING(position, "");
if (!(_0)) {
_1 = zephir_fetch_nproperty_this(this_ptr, SL("_elements"), PH_NOISY_CC);
_0 = ZEPHIR_IS_EMPTY(_1);
}
if (_0) {
zephir_update_property_array(this_ptr, SL("_elements"), name, element TSRMLS_CC);
} else {
ZEPHIR_INIT_VAR(elements);
array_init(elements);
_2$$4 = zephir_fetch_nproperty_this(this_ptr, SL("_elements"), PH_NOISY_CC);
zephir_is_iterable(_2$$4, &_4$$4, &_3$$4, 0, 0, "phalcon/forms/form.zep", 449);
for (
; zend_hash_get_current_data_ex(_4$$4, (void**) &_5$$4, &_3$$4) == SUCCESS
; zend_hash_move_forward_ex(_4$$4, &_3$$4)
) {
ZEPHIR_GET_HMKEY(key, _4$$4, _3$$4);
ZEPHIR_GET_HVALUE(value, _5$$4);
if (ZEPHIR_IS_EQUAL(key, position)) {
if (type) {
zephir_array_update_zval(&elements, name, &element, PH_COPY | PH_SEPARATE);
zephir_array_update_zval(&elements, key, &value, PH_COPY | PH_SEPARATE);
} else {
zephir_array_update_zval(&elements, key, &value, PH_COPY | PH_SEPARATE);
zephir_array_update_zval(&elements, name, &element, PH_COPY | PH_SEPARATE);
}
} else {
zephir_array_update_zval(&elements, key, &value, PH_COPY | PH_SEPARATE);
}
}
zephir_update_property_this(getThis(), SL("_elements"), elements TSRMLS_CC);
}
RETURN_THIS();
}
/**
* Check if the CSRF token sent in the request is the same that the current in session
*/
PHP_METHOD(Phalcon_Security, checkToken) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool destroyIfValid, returnValue, _4;
zval *tokenKey = NULL, *tokenValue = NULL, *destroyIfValid_param = NULL, *dependencyInjector = NULL, *session = NULL, *request = NULL, *token = NULL, *_0, *_1 = NULL, *_2 = NULL, *_3, *_5, *_6;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 0, 3, &tokenKey, &tokenValue, &destroyIfValid_param);
if (!tokenKey) {
ZEPHIR_CPY_WRT(tokenKey, ZEPHIR_GLOBAL(global_null));
} else {
ZEPHIR_SEPARATE_PARAM(tokenKey);
}
if (!tokenValue) {
tokenValue = ZEPHIR_GLOBAL(global_null);
}
if (!destroyIfValid_param) {
destroyIfValid = 1;
} else {
destroyIfValid = zephir_get_boolval(destroyIfValid_param);
}
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(dependencyInjector, _0);
if (Z_TYPE_P(dependencyInjector) != IS_OBJECT) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_security_exception_ce, "A dependency injection container is required to access the 'session' service", "phalcon/security.zep", 341);
return;
}
ZEPHIR_INIT_VAR(_2);
ZVAL_STRING(_2, "session", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_1, dependencyInjector, "getshared", NULL, _2);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
ZEPHIR_CPY_WRT(session, _1);
if (!(zephir_is_true(tokenKey))) {
_0 = zephir_fetch_nproperty_this(this_ptr, SL("_tokenKeySessionID"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&tokenKey, session, "get", NULL, _0);
zephir_check_call_status();
}
if (!(zephir_is_true(tokenKey))) {
RETURN_MM_BOOL(0);
}
if (!(zephir_is_true(tokenValue))) {
ZEPHIR_INIT_NVAR(_2);
ZVAL_STRING(_2, "request", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&request, dependencyInjector, "getshared", NULL, _2);
zephir_check_temp_parameter(_2);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&token, request, "getpost", NULL, tokenKey);
zephir_check_call_status();
} else {
ZEPHIR_CPY_WRT(token, tokenValue);
}
_3 = zephir_fetch_nproperty_this(this_ptr, SL("_tokenValueSessionID"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(&_1, session, "get", NULL, _3);
zephir_check_call_status();
returnValue = ZEPHIR_IS_EQUAL(token, _1);
_4 = returnValue;
if (_4) {
_4 = destroyIfValid;
}
if (_4) {
_5 = zephir_fetch_nproperty_this(this_ptr, SL("_tokenKeySessionID"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, session, "remove", NULL, _5);
zephir_check_call_status();
_6 = zephir_fetch_nproperty_this(this_ptr, SL("_tokenValueSessionID"), PH_NOISY_CC);
ZEPHIR_CALL_METHOD(NULL, session, "remove", NULL, _6);
zephir_check_call_status();
}
RETURN_MM_BOOL(returnValue);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Identical, validate) {
zend_bool valid = 0;
int ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *value = NULL, *_0 = NULL, *_1, *_2$$3 = NULL, *_3$$3, *_4$$4 = NULL, *_5$$4, *_6$$5 = NULL, *_7$$5, *_8$$6 = NULL, *_10$$6 = NULL, *_11$$6, *_9$$8;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(field_param) == IS_STRING)) {
zephir_get_strval(field, field_param);
} else {
ZEPHIR_INIT_VAR(field);
ZVAL_EMPTY_STRING(field);
}
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "accepted", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "hasoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (zephir_is_true(_0)) {
ZEPHIR_INIT_VAR(_3$$3);
ZVAL_STRING(_3$$3, "accepted", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_2$$3, this_ptr, "getoption", NULL, 0, _3$$3);
zephir_check_temp_parameter(_3$$3);
zephir_check_call_status();
valid = ZEPHIR_IS_EQUAL(value, _2$$3);
} else {
ZEPHIR_INIT_VAR(_5$$4);
ZVAL_STRING(_5$$4, "value", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_4$$4, this_ptr, "hasoption", NULL, 0, _5$$4);
zephir_check_temp_parameter(_5$$4);
zephir_check_call_status();
if (zephir_is_true(_4$$4)) {
ZEPHIR_INIT_VAR(_7$$5);
ZVAL_STRING(_7$$5, "value", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_6$$5, this_ptr, "getoption", NULL, 0, _7$$5);
zephir_check_temp_parameter(_7$$5);
zephir_check_call_status();
valid = ZEPHIR_IS_EQUAL(value, _6$$5);
}
}
if (!(valid)) {
ZEPHIR_INIT_VAR(_8$$6);
ZVAL_STRING(_8$$6, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _8$$6);
zephir_check_temp_parameter(_8$$6);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_8$$6);
ZVAL_STRING(_8$$6, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _8$$6);
zephir_check_temp_parameter(_8$$6);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_VAR(_9$$8);
ZVAL_STRING(_9$$8, "Identical", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _9$$8);
zephir_check_temp_parameter(_9$$8);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_8$$6);
object_init_ex(_8$$6, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_10$$6, "strtr", NULL, 55, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_11$$6);
ZVAL_STRING(_11$$6, "Identical", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _8$$6, "__construct", NULL, 438, _10$$6, field, _11$$6);
zephir_check_temp_parameter(_11$$6);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _8$$6);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Identical, validate) {
zend_bool valid = 0;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *field = NULL;
zval *validation, *field_param = NULL, *message = NULL, *label = NULL, *replacePairs = NULL, *value = NULL, *accepted = NULL, *valueOption = NULL, *code = NULL, *_0 = NULL, *_1, *_2$$3, *_3$$4, *_4$$5 = NULL, *_5$$5, *_6$$6, *_7$$7, *_8$$8 = NULL, *_9$$8 = NULL, *_10$$8;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (UNEXPECTED(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (EXPECTED(Z_TYPE_P(field_param) == IS_STRING)) {
zephir_get_strval(field, field_param);
} else {
ZEPHIR_INIT_VAR(field);
ZVAL_EMPTY_STRING(field);
}
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "accepted", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "hasoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (zephir_is_true(_0)) {
ZEPHIR_INIT_VAR(_2$$3);
ZVAL_STRING(_2$$3, "accepted", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&accepted, this_ptr, "getoption", NULL, 0, _2$$3);
zephir_check_temp_parameter(_2$$3);
zephir_check_call_status();
if (Z_TYPE_P(accepted) == IS_ARRAY) {
zephir_array_fetch(&_3$$4, accepted, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/identical.zep", 82 TSRMLS_CC);
ZEPHIR_CPY_WRT(accepted, _3$$4);
}
valid = ZEPHIR_IS_EQUAL(value, accepted);
} else {
ZEPHIR_INIT_VAR(_5$$5);
ZVAL_STRING(_5$$5, "value", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_4$$5, this_ptr, "hasoption", NULL, 0, _5$$5);
zephir_check_temp_parameter(_5$$5);
zephir_check_call_status();
if (zephir_is_true(_4$$5)) {
ZEPHIR_INIT_VAR(_6$$6);
ZVAL_STRING(_6$$6, "value", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&valueOption, this_ptr, "getoption", NULL, 0, _6$$6);
zephir_check_temp_parameter(_6$$6);
zephir_check_call_status();
if (Z_TYPE_P(valueOption) == IS_ARRAY) {
zephir_array_fetch(&_7$$7, valueOption, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/identical.zep", 89 TSRMLS_CC);
ZEPHIR_CPY_WRT(valueOption, _7$$7);
}
valid = ZEPHIR_IS_EQUAL(value, valueOption);
}
}
if (!(valid)) {
ZEPHIR_CALL_METHOD(&label, this_ptr, "preparelabel", NULL, 0, validation, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_8$$8);
ZVAL_STRING(_8$$8, "Identical", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, _8$$8);
zephir_check_temp_parameter(_8$$8);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&code, this_ptr, "preparecode", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(_8$$8);
object_init_ex(_8$$8, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_9$$8, "strtr", NULL, 27, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_10$$8);
ZVAL_STRING(_10$$8, "Identical", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _8$$8, "__construct", NULL, 471, _9$$8, field, _10$$8, code);
zephir_check_temp_parameter(_10$$8);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _8$$8);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Regex, validate) {
int ZEPHIR_LAST_CALL_STATUS;
zend_bool failed, _2;
zval *field = NULL;
zval *validation, *field_param = NULL, *matches, *message = NULL, *value = NULL, *label = NULL, *replacePairs, *_0 = NULL, *_1 = NULL, *_3 = NULL, *_4 = NULL, *_5, *_6 = NULL, *_7;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field_param);
if (unlikely(Z_TYPE_P(field_param) != IS_STRING && Z_TYPE_P(field_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'field' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(field_param) == IS_STRING)) {
zephir_get_strval(field, field_param);
} else {
ZEPHIR_INIT_VAR(field);
ZVAL_EMPTY_STRING(field);
}
ZEPHIR_INIT_VAR(matches);
ZVAL_NULL(matches);
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "allowEmpty", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, this_ptr, "issetoption", NULL, 0, _1);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
_2 = zephir_is_true(_0);
if (_2) {
_2 = ZEPHIR_IS_EMPTY(value);
}
if (_2) {
RETURN_MM_BOOL(1);
}
ZEPHIR_INIT_NVAR(_1);
ZEPHIR_INIT_VAR(_4);
ZVAL_STRING(_4, "pattern", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_3, this_ptr, "getoption", NULL, 0, _4);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
zephir_preg_match(_1, _3, value, matches, 0, 0 , 0 TSRMLS_CC);
if (zephir_is_true(_1)) {
zephir_array_fetch_long(&_5, matches, 0, PH_NOISY | PH_READONLY, "phalcon/validation/validator/regex.zep", 62 TSRMLS_CC);
failed = !ZEPHIR_IS_EQUAL(_5, value);
} else {
failed = 1;
}
if (failed == 1) {
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "label", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&label, this_ptr, "getoption", NULL, 0, _4);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
if (ZEPHIR_IS_EMPTY(label)) {
ZEPHIR_CALL_METHOD(&label, validation, "getlabel", NULL, 0, field);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "message", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, this_ptr, "getoption", NULL, 0, _4);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
ZEPHIR_INIT_VAR(replacePairs);
zephir_create_array(replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
if (ZEPHIR_IS_EMPTY(message)) {
ZEPHIR_INIT_NVAR(_4);
ZVAL_STRING(_4, "Regex", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&message, validation, "getdefaultmessage", NULL, 0, _4);
zephir_check_temp_parameter(_4);
zephir_check_call_status();
}
ZEPHIR_INIT_NVAR(_4);
object_init_ex(_4, phalcon_validation_message_ce);
ZEPHIR_CALL_FUNCTION(&_6, "strtr", NULL, 53, message, replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(_7);
ZVAL_STRING(_7, "Regex", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, _4, "__construct", NULL, 432, _6, field, _7);
zephir_check_temp_parameter(_7);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, _4);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Listens for notifications from the models manager
*/
PHP_METHOD(Phalcon_Mvc_Collection_Behavior_SoftDelete, notify) {
HashTable *_5$$7;
HashPosition _4$$7;
zephir_fcall_cache_entry *_7 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *type_param = NULL, *model, *options = NULL, *value = NULL, *field = NULL, *updateModel = NULL, *message = NULL, *_0$$3, *_1$$3 = NULL, *_2$$6 = NULL, *_3$$7 = NULL, **_6$$7;
zval *type = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &type_param, &model);
if (unlikely(Z_TYPE_P(type_param) != IS_STRING && Z_TYPE_P(type_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'type' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(type_param) == IS_STRING)) {
zephir_get_strval(type, type_param);
} else {
ZEPHIR_INIT_VAR(type);
ZVAL_EMPTY_STRING(type);
}
if (ZEPHIR_IS_STRING(type, "beforeDelete")) {
ZEPHIR_CALL_METHOD(&options, this_ptr, "getoptions", NULL, 0);
zephir_check_call_status();
ZEPHIR_OBS_VAR(value);
if (!(zephir_array_isset_string_fetch(&value, options, SS("value"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_collection_exception_ce, "The option 'value' is required", "phalcon/mvc/collection/behavior/softdelete.zep", 51);
return;
}
ZEPHIR_OBS_VAR(field);
if (!(zephir_array_isset_string_fetch(&field, options, SS("field"), 0 TSRMLS_CC))) {
ZEPHIR_THROW_EXCEPTION_DEBUG_STR(phalcon_mvc_collection_exception_ce, "The option 'field' is required", "phalcon/mvc/collection/behavior/softdelete.zep", 58);
return;
}
ZEPHIR_INIT_VAR(_0$$3);
ZVAL_BOOL(_0$$3, 1);
ZEPHIR_CALL_METHOD(NULL, model, "skipoperation", NULL, 0, _0$$3);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_1$$3, model, "readattribute", NULL, 0, field);
zephir_check_call_status();
if (!ZEPHIR_IS_EQUAL(_1$$3, value)) {
ZEPHIR_INIT_VAR(updateModel);
if (zephir_clone(updateModel, model TSRMLS_CC) == FAILURE) {
RETURN_MM();
}
ZEPHIR_CALL_METHOD(NULL, updateModel, "writeattribute", NULL, 0, field, value);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&_2$$6, updateModel, "save", NULL, 0);
zephir_check_call_status();
if (!(zephir_is_true(_2$$6))) {
ZEPHIR_CALL_METHOD(&_3$$7, updateModel, "getmessages", NULL, 0);
zephir_check_call_status();
zephir_is_iterable(_3$$7, &_5$$7, &_4$$7, 0, 0, "phalcon/mvc/collection/behavior/softdelete.zep", 90);
for (
; zephir_hash_get_current_data_ex(_5$$7, (void**) &_6$$7, &_4$$7) == SUCCESS
; zephir_hash_move_forward_ex(_5$$7, &_4$$7)
) {
ZEPHIR_GET_HVALUE(message, _6$$7);
ZEPHIR_CALL_METHOD(NULL, model, "appendmessage", &_7, 0, message);
zephir_check_call_status();
}
RETURN_MM_BOOL(0);
}
ZEPHIR_CALL_METHOD(NULL, model, "writeattribute", NULL, 0, field, value);
zephir_check_call_status();
}
}
ZEPHIR_MM_RESTORE();
}
PHP_METHOD(Fox_MsgCrypt, decrypt) {
zephir_fcall_cache_entry *_6 = NULL;
int ZEPHIR_LAST_CALL_STATUS;
zval *encrypted, *ciphertext_dec = NULL, *module = NULL, *iv = NULL, *decrypted = NULL, *e = NULL, *pkc_encoder = NULL, *result = NULL, *content = NULL, *len_list = NULL, *xml_len = NULL, *xml_content = NULL, *from_appid = NULL, *_18, *_21, *_22, _0$$3 = zval_used_for_init, _1$$3 = zval_used_for_init, _2$$3, _3$$3, *_4$$3, *_5$$3, *_7$$4, *_8$$4, _9$$5, _10$$5, _11$$5, _12$$5, *_13$$5, _14$$5 = zval_used_for_init, _15$$5, *_16$$7, *_17$$7, *_19$$8, *_20$$8;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &encrypted);
/* try_start_1: */
ZEPHIR_CALL_FUNCTION(&ciphertext_dec, "base64_decode", NULL, 12, encrypted);
zephir_check_call_status_or_jump(try_end_1);
ZEPHIR_SINIT_VAR(_0$$3);
ZVAL_STRING(&_0$$3, "rijndael-128", 0);
ZEPHIR_SINIT_VAR(_1$$3);
ZVAL_STRING(&_1$$3, "", 0);
ZEPHIR_SINIT_VAR(_2$$3);
ZVAL_STRING(&_2$$3, "cbc", 0);
ZEPHIR_SINIT_VAR(_3$$3);
ZVAL_STRING(&_3$$3, "", 0);
ZEPHIR_CALL_FUNCTION(&module, "mcrypt_module_open", NULL, 4, &_0$$3, &_1$$3, &_2$$3, &_3$$3);
zephir_check_call_status_or_jump(try_end_1);
_4$$3 = zephir_fetch_nproperty_this(this_ptr, SL("appkey"), PH_NOISY_CC);
ZEPHIR_SINIT_NVAR(_0$$3);
ZVAL_LONG(&_0$$3, 0);
ZEPHIR_SINIT_NVAR(_1$$3);
ZVAL_LONG(&_1$$3, 16);
ZEPHIR_INIT_VAR(iv);
zephir_substr(iv, _4$$3, 0 , 16 , 0);
_5$$3 = zephir_fetch_nproperty_this(this_ptr, SL("appkey"), PH_NOISY_CC);
ZEPHIR_CALL_FUNCTION(NULL, "mcrypt_generic_init", NULL, 6, module, _5$$3, iv);
zephir_check_call_status_or_jump(try_end_1);
ZEPHIR_CALL_FUNCTION(&decrypted, "mdecrypt_generic", NULL, 13, module, ciphertext_dec);
zephir_check_call_status_or_jump(try_end_1);
ZEPHIR_CALL_FUNCTION(NULL, "mcrypt_generic_deinit", NULL, 8, module);
zephir_check_call_status_or_jump(try_end_1);
ZEPHIR_CALL_FUNCTION(NULL, "mcrypt_module_close", NULL, 9, module);
zephir_check_call_status_or_jump(try_end_1);
try_end_1:
if (EG(exception)) {
ZEPHIR_CPY_WRT(e, EG(exception));
if (zephir_instance_of_ev(e, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) {
zend_clear_exception(TSRMLS_C);
ZEPHIR_INIT_VAR(_7$$4);
ZVAL_BOOL(_7$$4, 0);
ZEPHIR_INIT_VAR(_8$$4);
ZVAL_STRING(_8$$4, "DecryptAESError", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_RETURN_CALL_CE_STATIC(fox_common_ce, "rtn", &_6, 10, _7$$4, _8$$4);
zephir_check_temp_parameter(_8$$4);
zephir_check_call_status();
RETURN_MM();
}
}
/* try_start_2: */
ZEPHIR_INIT_VAR(pkc_encoder);
object_init_ex(pkc_encoder, fox_pkcs7encoder_ce);
if (zephir_has_constructor(pkc_encoder TSRMLS_CC)) {
ZEPHIR_CALL_METHOD(NULL, pkc_encoder, "__construct", NULL, 0);
zephir_check_call_status_or_jump(try_end_1);
}
ZEPHIR_CALL_METHOD(&result, pkc_encoder, "decode", NULL, 14, decrypted);
zephir_check_call_status_or_jump(try_end_1);
if (zephir_fast_strlen_ev(result) < 16) {
RETURN_MM_STRING("", 1);
}
ZEPHIR_SINIT_VAR(_9$$5);
ZVAL_LONG(&_9$$5, 16);
ZEPHIR_SINIT_VAR(_10$$5);
ZVAL_LONG(&_10$$5, zephir_fast_strlen_ev(result));
ZEPHIR_INIT_VAR(content);
zephir_substr(content, result, 16 , zephir_get_intval(&_10$$5), 0);
ZEPHIR_SINIT_VAR(_11$$5);
ZVAL_LONG(&_11$$5, 0);
ZEPHIR_SINIT_VAR(_12$$5);
ZVAL_LONG(&_12$$5, 4);
ZEPHIR_INIT_VAR(_13$$5);
zephir_substr(_13$$5, content, 0 , 4 , 0);
ZEPHIR_SINIT_VAR(_14$$5);
ZVAL_STRING(&_14$$5, "N", 0);
ZEPHIR_CALL_FUNCTION(&len_list, "unpack", NULL, 15, &_14$$5, _13$$5);
zephir_check_call_status_or_jump(try_end_1);
ZEPHIR_OBS_VAR(xml_len);
zephir_array_fetch_long(&xml_len, len_list, 1, PH_NOISY, "fox/MsgCrypt.zep", 86 TSRMLS_CC);
ZEPHIR_SINIT_NVAR(_14$$5);
ZVAL_LONG(&_14$$5, 4);
ZEPHIR_INIT_VAR(xml_content);
zephir_substr(xml_content, content, 4 , zephir_get_intval(xml_len), 0);
ZEPHIR_SINIT_VAR(_15$$5);
ZVAL_LONG(&_15$$5, (zephir_get_numberval(xml_len) + 4));
ZEPHIR_INIT_VAR(from_appid);
zephir_substr(from_appid, content, zephir_get_intval(&_15$$5), 0, ZEPHIR_SUBSTR_NO_LENGTH);
try_end_2:
if (EG(exception)) {
ZEPHIR_CPY_WRT(e, EG(exception));
if (zephir_instance_of_ev(e, zend_exception_get_default(TSRMLS_C) TSRMLS_CC)) {
zend_clear_exception(TSRMLS_C);
ZEPHIR_INIT_VAR(_16$$7);
ZVAL_BOOL(_16$$7, 0);
ZEPHIR_INIT_VAR(_17$$7);
ZVAL_STRING(_17$$7, "IllegalBuffer", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_RETURN_CALL_CE_STATIC(fox_common_ce, "rtn", &_6, 10, _16$$7, _17$$7);
zephir_check_temp_parameter(_17$$7);
zephir_check_call_status();
RETURN_MM();
}
}
_18 = zephir_fetch_nproperty_this(this_ptr, SL("appid"), PH_NOISY_CC);
if (!ZEPHIR_IS_EQUAL(from_appid, _18)) {
ZEPHIR_INIT_VAR(_19$$8);
ZVAL_BOOL(_19$$8, 0);
ZEPHIR_INIT_VAR(_20$$8);
ZVAL_STRING(_20$$8, "ValidateAppidError", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_RETURN_CALL_CE_STATIC(fox_common_ce, "rtn", &_6, 10, _19$$8, _20$$8);
zephir_check_temp_parameter(_20$$8);
zephir_check_call_status();
RETURN_MM();
}
ZEPHIR_INIT_VAR(_21);
ZVAL_BOOL(_21, 1);
ZEPHIR_INIT_VAR(_22);
ZVAL_STRING(_22, "OK", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_RETURN_CALL_CE_STATIC(fox_common_ce, "rtn", &_6, 10, _21, _22, xml_content);
zephir_check_temp_parameter(_22);
zephir_check_call_status();
RETURN_MM();
}
/**
* Unregisters one or all listeners for an event.
*
* @param string|\Xpl\Event\Event event Event ID or object.
* @param callable callback [Optional] Callback to remove. If no callback is given,
* then all of the event's listeners are removed.
* @return \Xpl\Event\Manager
*
* @throws \InvalidArgumentException if event is not a string or Event instance.
*/
PHP_METHOD(Xpl_Event_Manager, off) {
HashTable *_6$$8;
HashPosition _5$$8;
int ZEPHIR_LAST_CALL_STATUS;
zval *event, *callback = NULL, *id = NULL, *listeners = NULL, *_4, *_0$$4, *_1$$5, *_2$$5, *_3$$5, *i$$8 = NULL, *listener$$8 = NULL, **_7$$8, *_8$$9 = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 1, &event, &callback);
if (!callback) {
callback = ZEPHIR_GLOBAL(global_null);
}
if (Z_TYPE_P(event) == IS_STRING) {
ZEPHIR_CPY_WRT(id, event);
} else if (zephir_instance_of_ev(event, xpl_event_event_ce TSRMLS_CC)) {
ZEPHIR_OBS_VAR(_0$$4);
zephir_read_property(&_0$$4, event, SL("id"), PH_NOISY_CC);
ZEPHIR_CPY_WRT(id, _0$$4);
} else {
ZEPHIR_INIT_VAR(_1$$5);
object_init_ex(_1$$5, spl_ce_InvalidArgumentException);
ZEPHIR_INIT_VAR(_2$$5);
zephir_gettype(_2$$5, event TSRMLS_CC);
ZEPHIR_INIT_VAR(_3$$5);
ZEPHIR_CONCAT_SV(_3$$5, "Event must be string or instance of Event, given: ", _2$$5);
ZEPHIR_CALL_METHOD(NULL, _1$$5, "__construct", NULL, 5, _3$$5);
zephir_check_call_status();
zephir_throw_exception_debug(_1$$5, "xpl/event/manager.zep", 118 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
ZEPHIR_OBS_VAR(listeners);
_4 = zephir_fetch_nproperty_this(this_ptr, SL("listeners"), PH_NOISY_CC);
if (zephir_array_isset_fetch(&listeners, _4, id, 0 TSRMLS_CC)) {
if (Z_TYPE_P(callback) == IS_NULL) {
zephir_array_unset(&listeners, id, PH_SEPARATE);
} else {
zephir_is_iterable(listeners, &_6$$8, &_5$$8, 1, 0, "xpl/event/manager.zep", 137);
for (
; zephir_hash_get_current_data_ex(_6$$8, (void**) &_7$$8, &_5$$8) == SUCCESS
; zephir_hash_move_forward_ex(_6$$8, &_5$$8)
) {
ZEPHIR_GET_HMKEY(i$$8, _6$$8, _5$$8);
ZEPHIR_GET_HVALUE(listener$$8, _7$$8);
ZEPHIR_OBS_NVAR(_8$$9);
zephir_read_property(&_8$$9, listener$$8, SL("callback"), PH_NOISY_CC);
if (ZEPHIR_IS_EQUAL(callback, _8$$9)) {
zephir_array_unset(&listeners, i$$8, PH_SEPARATE);
}
}
zend_hash_destroy(_6$$8);
FREE_HASHTABLE(_6$$8);
}
zephir_update_property_array(this_ptr, SL("listeners"), id, listeners TSRMLS_CC);
}
RETURN_THIS();
}
/**
* Tries to render the view with every engine registered in the component
*
* @param string path
* @param array params
*/
PHP_METHOD(Phalcon_Mvc_View_Simple, _internalRender) {
zephir_fcall_cache_entry *_11 = NULL, *_12 = NULL;
HashTable *_4;
HashPosition _3;
int ZEPHIR_LAST_CALL_STATUS;
zend_bool notExists, mustClean, _7, _9;
zval *path_param = NULL, *params, *eventsManager, *engines = NULL, *extension = NULL, *engine = NULL, *viewEnginePath = NULL, *viewsDirPath, *_0 = NULL, *_1 = NULL, *_2, **_5, *_6 = NULL, _8 = zval_used_for_init, *_10 = NULL;
zval *path = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &path_param, ¶ms);
if (unlikely(Z_TYPE_P(path_param) != IS_STRING && Z_TYPE_P(path_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'path' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(path_param) == IS_STRING)) {
zephir_get_strval(path, path_param);
} else {
ZEPHIR_INIT_VAR(path);
ZVAL_EMPTY_STRING(path);
}
ZEPHIR_OBS_VAR(eventsManager);
zephir_read_property_this(&eventsManager, this_ptr, SL("_eventsManager"), PH_NOISY_CC);
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
zephir_update_property_this(this_ptr, SL("_activeRenderPath"), path TSRMLS_CC);
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_VAR(_1);
ZVAL_STRING(_1, "view:beforeRender", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, eventsManager, "fire", NULL, 0, _1, this_ptr);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
RETURN_MM_NULL();
}
}
notExists = 1;
mustClean = 1;
_2 = zephir_fetch_nproperty_this(this_ptr, SL("_viewsDir"), PH_NOISY_CC);
ZEPHIR_INIT_VAR(viewsDirPath);
ZEPHIR_CONCAT_VV(viewsDirPath, _2, path);
ZEPHIR_CALL_METHOD(&engines, this_ptr, "_loadtemplateengines", NULL, 0);
zephir_check_call_status();
zephir_is_iterable(engines, &_4, &_3, 0, 0, "phalcon/mvc/view/simple.zep", 261);
for (
; zephir_hash_get_current_data_ex(_4, (void**) &_5, &_3) == SUCCESS
; zephir_hash_move_forward_ex(_4, &_3)
) {
ZEPHIR_GET_HMKEY(extension, _4, _3);
ZEPHIR_GET_HVALUE(engine, _5);
ZEPHIR_INIT_LNVAR(_6);
ZEPHIR_CONCAT_VV(_6, viewsDirPath, extension);
if ((zephir_file_exists(_6 TSRMLS_CC) == SUCCESS)) {
ZEPHIR_INIT_NVAR(viewEnginePath);
ZEPHIR_CONCAT_VV(viewEnginePath, viewsDirPath, extension);
} else {
_7 = zephir_is_true(extension);
if (_7) {
ZEPHIR_SINIT_NVAR(_8);
ZVAL_LONG(&_8, -zephir_fast_strlen_ev(extension));
ZEPHIR_INIT_NVAR(_1);
zephir_substr(_1, viewsDirPath, zephir_get_intval(&_8), 0, ZEPHIR_SUBSTR_NO_LENGTH);
_7 = ZEPHIR_IS_EQUAL(_1, extension);
}
_9 = _7;
if (_9) {
_9 = (zephir_file_exists(viewsDirPath TSRMLS_CC) == SUCCESS);
}
if (_9) {
ZEPHIR_CPY_WRT(viewEnginePath, viewsDirPath);
} else {
ZEPHIR_INIT_NVAR(viewEnginePath);
ZVAL_STRING(viewEnginePath, "", 1);
}
}
if (zephir_is_true(viewEnginePath)) {
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_10);
ZVAL_STRING(_10, "view:beforeRenderView", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(&_0, eventsManager, "fire", &_11, 0, _10, this_ptr, viewEnginePath);
zephir_check_temp_parameter(_10);
zephir_check_call_status();
if (ZEPHIR_IS_FALSE_IDENTICAL(_0)) {
continue;
}
}
ZEPHIR_CALL_METHOD(NULL, engine, "render", NULL, 0, viewEnginePath, params, (mustClean ? ZEPHIR_GLOBAL(global_true) : ZEPHIR_GLOBAL(global_false)));
zephir_check_call_status();
notExists = 0;
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_10);
ZVAL_STRING(_10, "view:afterRenderView", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", &_12, 0, _10, this_ptr);
zephir_check_temp_parameter(_10);
zephir_check_call_status();
}
break;
}
}
if (notExists == 1) {
ZEPHIR_INIT_NVAR(_1);
object_init_ex(_1, phalcon_mvc_view_exception_ce);
ZEPHIR_INIT_LNVAR(_6);
ZEPHIR_CONCAT_SVS(_6, "View '", viewsDirPath, "' was not found in the views directory");
ZEPHIR_CALL_METHOD(NULL, _1, "__construct", NULL, 9, _6);
zephir_check_call_status();
zephir_throw_exception_debug(_1, "phalcon/mvc/view/simple.zep", 262 TSRMLS_CC);
ZEPHIR_MM_RESTORE();
return;
}
if (Z_TYPE_P(eventsManager) == IS_OBJECT) {
ZEPHIR_INIT_NVAR(_1);
ZVAL_STRING(_1, "view:afterRender", ZEPHIR_TEMP_PARAM_COPY);
ZEPHIR_CALL_METHOD(NULL, eventsManager, "fire", NULL, 0, _1, this_ptr);
zephir_check_temp_parameter(_1);
zephir_check_call_status();
}
ZEPHIR_MM_RESTORE();
}
/**
* Executes the validation
*/
PHP_METHOD(Phalcon_Validation_Validator_Identical, validate) {
zend_bool valid = 0;
zend_long ZEPHIR_LAST_CALL_STATUS;
zval *validation, validation_sub, *field, field_sub, message, label, replacePairs, value, accepted, valueOption, code, _0, _1, _2$$3, _3$$4, _4$$5, _5$$5, _6$$6, _7$$7, _8$$8, _9$$8, _10$$8;
zval *this_ptr = getThis();
ZVAL_UNDEF(&validation_sub);
ZVAL_UNDEF(&field_sub);
ZVAL_UNDEF(&message);
ZVAL_UNDEF(&label);
ZVAL_UNDEF(&replacePairs);
ZVAL_UNDEF(&value);
ZVAL_UNDEF(&accepted);
ZVAL_UNDEF(&valueOption);
ZVAL_UNDEF(&code);
ZVAL_UNDEF(&_0);
ZVAL_UNDEF(&_1);
ZVAL_UNDEF(&_2$$3);
ZVAL_UNDEF(&_3$$4);
ZVAL_UNDEF(&_4$$5);
ZVAL_UNDEF(&_5$$5);
ZVAL_UNDEF(&_6$$6);
ZVAL_UNDEF(&_7$$7);
ZVAL_UNDEF(&_8$$8);
ZVAL_UNDEF(&_9$$8);
ZVAL_UNDEF(&_10$$8);
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 2, 0, &validation, &field);
ZEPHIR_CALL_METHOD(&value, validation, "getvalue", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_1);
ZVAL_STRING(&_1, "accepted");
ZEPHIR_CALL_METHOD(&_0, this_ptr, "hasoption", NULL, 0, &_1);
zephir_check_call_status();
if (zephir_is_true(&_0)) {
ZEPHIR_INIT_VAR(&_2$$3);
ZVAL_STRING(&_2$$3, "accepted");
ZEPHIR_CALL_METHOD(&accepted, this_ptr, "getoption", NULL, 0, &_2$$3);
zephir_check_call_status();
if (Z_TYPE_P(&accepted) == IS_ARRAY) {
zephir_array_fetch(&_3$$4, &accepted, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/identical.zep", 73 TSRMLS_CC);
ZEPHIR_CPY_WRT(&accepted, &_3$$4);
}
valid = ZEPHIR_IS_EQUAL(&value, &accepted);
} else {
ZEPHIR_INIT_VAR(&_5$$5);
ZVAL_STRING(&_5$$5, "value");
ZEPHIR_CALL_METHOD(&_4$$5, this_ptr, "hasoption", NULL, 0, &_5$$5);
zephir_check_call_status();
if (zephir_is_true(&_4$$5)) {
ZEPHIR_INIT_VAR(&_6$$6);
ZVAL_STRING(&_6$$6, "value");
ZEPHIR_CALL_METHOD(&valueOption, this_ptr, "getoption", NULL, 0, &_6$$6);
zephir_check_call_status();
if (Z_TYPE_P(&valueOption) == IS_ARRAY) {
zephir_array_fetch(&_7$$7, &valueOption, field, PH_NOISY | PH_READONLY, "phalcon/validation/validator/identical.zep", 80 TSRMLS_CC);
ZEPHIR_CPY_WRT(&valueOption, &_7$$7);
}
valid = ZEPHIR_IS_EQUAL(&value, &valueOption);
}
}
if (!(valid)) {
ZEPHIR_CALL_METHOD(&label, this_ptr, "preparelabel", NULL, 0, validation, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_8$$8);
ZVAL_STRING(&_8$$8, "Identical");
ZEPHIR_CALL_METHOD(&message, this_ptr, "preparemessage", NULL, 0, validation, field, &_8$$8);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(&code, this_ptr, "preparecode", NULL, 0, field);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&replacePairs);
zephir_create_array(&replacePairs, 1, 0 TSRMLS_CC);
zephir_array_update_string(&replacePairs, SL(":field"), &label, PH_COPY | PH_SEPARATE);
ZEPHIR_INIT_NVAR(&_8$$8);
object_init_ex(&_8$$8, phalcon_messages_message_ce);
ZEPHIR_CALL_FUNCTION(&_9$$8, "strtr", NULL, 50, &message, &replacePairs);
zephir_check_call_status();
ZEPHIR_INIT_VAR(&_10$$8);
ZVAL_STRING(&_10$$8, "Identical");
ZEPHIR_CALL_METHOD(NULL, &_8$$8, "__construct", NULL, 299, &_9$$8, field, &_10$$8, &code);
zephir_check_call_status();
ZEPHIR_CALL_METHOD(NULL, validation, "appendmessage", NULL, 0, &_8$$8);
zephir_check_call_status();
RETURN_MM_BOOL(0);
}
RETURN_MM_BOOL(1);
}
/**
* Removes padding @a padding_type from @a text
* If the function detects that the text was not padded, it will return it unmodified
*
* @param return_value Result, possibly unpadded
* @param text Message to be unpadded
* @param mode Encryption mode; unpadding is applied only in CBC or ECB mode
* @param block_size Cipher block size
* @param padding_type Padding scheme
*/
PHP_METHOD(Phalcon_Crypt, _cryptUnpadText) {
unsigned char _14, _16;
zephir_nts_static zephir_fcall_cache_entry *_6 = NULL, *_9 = NULL, *_11 = NULL;
zend_bool _0, _1, _2, _13, _15;
long length;
int blockSize, paddingType, i, paddingSize = 0, ord, ZEPHIR_LAST_CALL_STATUS;
zval *text_param = NULL, *mode_param = NULL, *blockSize_param = NULL, *paddingType_param = NULL, *padding = NULL, *last = NULL, _3 = zval_used_for_init, _4 = zval_used_for_init, *_5 = NULL, _7 = zval_used_for_init, *_8 = NULL, *_10 = NULL, *_12 = NULL;
zval *text = NULL, *mode = NULL;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 4, 0, &text_param, &mode_param, &blockSize_param, &paddingType_param);
if (unlikely(Z_TYPE_P(text_param) != IS_STRING && Z_TYPE_P(text_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'text' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(text_param) == IS_STRING)) {
zephir_get_strval(text, text_param);
} else {
ZEPHIR_INIT_VAR(text);
ZVAL_EMPTY_STRING(text);
}
if (unlikely(Z_TYPE_P(mode_param) != IS_STRING && Z_TYPE_P(mode_param) != IS_NULL)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'mode' must be a string") TSRMLS_CC);
RETURN_MM_NULL();
}
if (likely(Z_TYPE_P(mode_param) == IS_STRING)) {
zephir_get_strval(mode, mode_param);
} else {
ZEPHIR_INIT_VAR(mode);
ZVAL_EMPTY_STRING(mode);
}
if (unlikely(Z_TYPE_P(blockSize_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'blockSize' must be a long/integer") TSRMLS_CC);
RETURN_MM_NULL();
}
blockSize = Z_LVAL_P(blockSize_param);
if (unlikely(Z_TYPE_P(paddingType_param) != IS_LONG)) {
zephir_throw_exception_string(spl_ce_InvalidArgumentException, SL("Parameter 'paddingType' must be a long/integer") TSRMLS_CC);
RETURN_MM_NULL();
}
paddingType = Z_LVAL_P(paddingType_param);
length = zephir_fast_strlen_ev(text);
_0 = length > 0;
if (_0) {
_0 = (zephir_safe_mod_long_long(length, blockSize TSRMLS_CC) == 0);
}
_1 = _0;
if (_1) {
_2 = ZEPHIR_IS_STRING(mode, "cbc");
if (!(_2)) {
_2 = ZEPHIR_IS_STRING(mode, "ecb");
}
_1 = _2;
}
if (_1) {
do {
if (paddingType == 1) {
ZEPHIR_SINIT_VAR(_3);
ZVAL_LONG(&_3, (length - 1));
ZEPHIR_SINIT_VAR(_4);
ZVAL_LONG(&_4, 1);
ZEPHIR_INIT_VAR(last);
zephir_substr(last, text, zephir_get_intval(&_3), 1 , 0);
ZEPHIR_CALL_FUNCTION(&_5, "ord", &_6, last);
zephir_check_call_status();
ord = zephir_get_intval(_5);
if (ord <= blockSize) {
paddingSize = ord;
ZEPHIR_SINIT_VAR(_7);
ZVAL_LONG(&_7, 0);
ZEPHIR_CALL_FUNCTION(&_8, "chr", &_9, &_7);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_7);
ZVAL_LONG(&_7, (paddingSize - 1));
ZEPHIR_CALL_FUNCTION(&_10, "str_repeat", &_11, _8, &_7);
zephir_check_call_status();
ZEPHIR_INIT_VAR(padding);
ZEPHIR_CONCAT_VV(padding, _10, last);
ZEPHIR_SINIT_NVAR(_7);
ZVAL_LONG(&_7, (length - paddingSize));
ZEPHIR_INIT_VAR(_12);
zephir_substr(_12, text, zephir_get_intval(&_7), 0, ZEPHIR_SUBSTR_NO_LENGTH);
if (!ZEPHIR_IS_EQUAL(_12, padding)) {
paddingSize = 0;
}
}
break;
}
if (paddingType == 2) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, (length - 1));
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, 1);
ZEPHIR_INIT_NVAR(last);
zephir_substr(last, text, zephir_get_intval(&_3), 1 , 0);
ZEPHIR_CALL_FUNCTION(&_5, "ord", &_6, last);
zephir_check_call_status();
ord = zephir_get_intval(_5);
if (ord <= blockSize) {
paddingSize = ord;
ZEPHIR_SINIT_NVAR(_7);
ZVAL_LONG(&_7, paddingSize);
ZEPHIR_CALL_FUNCTION(&_8, "chr", &_9, &_7);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_7);
ZVAL_LONG(&_7, paddingSize);
ZEPHIR_CALL_FUNCTION(&padding, "str_repeat", &_11, _8, &_7);
zephir_check_call_status();
ZEPHIR_SINIT_NVAR(_7);
ZVAL_LONG(&_7, (length - paddingSize));
ZEPHIR_INIT_NVAR(_12);
zephir_substr(_12, text, zephir_get_intval(&_7), 0, ZEPHIR_SUBSTR_NO_LENGTH);
if (!ZEPHIR_IS_EQUAL(_12, padding)) {
paddingSize = 0;
}
}
break;
}
if (paddingType == 3) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, (length - 1));
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, 1);
ZEPHIR_INIT_NVAR(last);
zephir_substr(last, text, zephir_get_intval(&_3), 1 , 0);
ZEPHIR_CALL_FUNCTION(&_5, "ord", &_6, last);
zephir_check_call_status();
paddingSize = zephir_get_intval(_5);
break;
}
if (paddingType == 4) {
i = (length - 1);
while (1) {
_13 = i > 0;
if (_13) {
_14 = ZEPHIR_STRING_OFFSET(text, i);
_13 = _14 == 0x00;
}
_15 = _13;
if (_15) {
_15 = paddingSize < blockSize;
}
if (!(_15)) {
break;
}
paddingSize++;
i--;
}
_16 = ZEPHIR_STRING_OFFSET(text, i);
if (_16 == 0x80) {
paddingSize++;
} else {
paddingSize = 0;
}
break;
}
if (paddingType == 5) {
i = (length - 1);
while (1) {
_13 = i >= 0;
if (_13) {
_14 = ZEPHIR_STRING_OFFSET(text, i);
_13 = _14 == 0x00;
}
_15 = _13;
if (_15) {
_15 = paddingSize <= blockSize;
}
if (!(_15)) {
break;
}
paddingSize++;
i--;
}
break;
}
if (paddingType == 6) {
i = (length - 1);
while (1) {
_13 = i >= 0;
if (_13) {
_14 = ZEPHIR_STRING_OFFSET(text, i);
_13 = _14 == 0x20;
}
_15 = _13;
if (_15) {
_15 = paddingSize <= blockSize;
}
if (!(_15)) {
break;
}
paddingSize++;
i--;
}
break;
}
break;
} while(0);
_13 = (paddingSize) ? 1 : 0;
if (_13) {
_13 = paddingSize <= blockSize;
}
if (_13) {
if (paddingSize < length) {
ZEPHIR_SINIT_NVAR(_3);
ZVAL_LONG(&_3, 0);
ZEPHIR_SINIT_NVAR(_4);
ZVAL_LONG(&_4, (length - paddingSize));
zephir_substr(return_value, text, 0 , zephir_get_intval(&_4), 0);
RETURN_MM();
} else {
RETURN_MM_STRING("", 1);
}
} else {
paddingSize = 0;
}
}
if (!(paddingSize)) {
RETURN_CTOR(text);
}
ZEPHIR_MM_RESTORE();
}
