/** * Generates a pseudo random token key to be used as input's name in a CSRF check * * @param int $numberBytes * @return string */ PHP_METHOD(Phalcon_Security, getTokenKey){ zval *number_bytes = NULL, *random_bytes, *base64bytes; zval *safe_bytes, *dependency_injector, *service; zval *session, *key; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 1, &number_bytes); if (!number_bytes) { PHALCON_INIT_VAR(number_bytes); ZVAL_LONG(number_bytes, 12); } if (phalcon_function_exists_ex(SS("openssl_random_pseudo_bytes") TSRMLS_CC) == FAILURE) { PHALCON_THROW_EXCEPTION_STR(phalcon_security_exception_ce, "Openssl extension must be loaded"); return; } PHALCON_INIT_VAR(random_bytes); phalcon_call_func_p1(random_bytes, "openssl_random_pseudo_bytes", number_bytes); PHALCON_INIT_VAR(base64bytes); phalcon_base64_encode(base64bytes, random_bytes); PHALCON_INIT_VAR(safe_bytes); phalcon_filter_alphanum(safe_bytes, base64bytes); PHALCON_OBS_VAR(dependency_injector); phalcon_read_property_this(&dependency_injector, this_ptr, SL("_dependencyInjector"), PH_NOISY_CC); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_flash_exception_ce, "A dependency injection container is required to access the 'session' service"); return; } PHALCON_INIT_VAR(service); ZVAL_STRING(service, "session", 1); PHALCON_INIT_VAR(session); phalcon_call_method_p1(session, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(session, phalcon_session_adapterinterface_ce); PHALCON_INIT_VAR(key); ZVAL_STRING(key, "$PHALCON/CSRF/KEY$", 1); phalcon_call_method_p2_noret(session, "set", key, safe_bytes); RETURN_CTOR(safe_bytes); }
/** * Generate a >22-length pseudo random string to be used as salt for passwords * * @return string */ PHP_METHOD(Phalcon_Security, getSaltBytes){ zval *number_bytes, *random_bytes = NULL, *base64bytes = NULL; zval *safe_bytes = NULL, *bytes_length = NULL; PHALCON_MM_GROW(); if (phalcon_function_exists_ex(SS("openssl_random_pseudo_bytes") TSRMLS_CC) == FAILURE) { PHALCON_THROW_EXCEPTION_STR(phalcon_security_exception_ce, "Openssl extension must be loaded"); return; } PHALCON_OBS_VAR(number_bytes); phalcon_read_property_this(&number_bytes, this_ptr, SL("_numberBytes"), PH_NOISY_CC); while (1) { PHALCON_INIT_NVAR(random_bytes); phalcon_call_func_p1(random_bytes, "openssl_random_pseudo_bytes", number_bytes); PHALCON_INIT_NVAR(base64bytes); phalcon_base64_encode(base64bytes, random_bytes); PHALCON_INIT_NVAR(safe_bytes); phalcon_filter_alphanum(safe_bytes, base64bytes); if (!zend_is_true(safe_bytes)) { continue; } PHALCON_INIT_NVAR(bytes_length); phalcon_fast_strlen(bytes_length, safe_bytes); if (PHALCON_LT_LONG(bytes_length, 22)) { continue; } break; } RETURN_CTOR(safe_bytes); }
/** * Routes to a controller/action using a string or array uri * * @param string $uri */ PHP_METHOD(Phalcon_Dispatcher, forward){ zval *uri = NULL, *parts = NULL, *params = NULL, *value = NULL, *key = NULL; zval *c0 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL, *r10 = NULL, *r11 = NULL, *r12 = NULL; zval *a0 = NULL; HashTable *ah0; HashPosition hp0; zval **hd; char *hash_index; uint hash_index_len; ulong hash_num; int hash_type; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &uri) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (Z_TYPE_P(uri) == IS_ARRAY) { PHALCON_CPY_WRT(parts, uri); } else { PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "/", 1); PHALCON_ALLOC_ZVAL_MM(r0); phalcon_fast_explode(r0, c0, uri TSRMLS_CC); PHALCON_CPY_WRT(parts, r0); } eval_int = phalcon_array_isset_long(parts, 0); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_long(&r1, parts, 0, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r2); phalcon_filter_alphanum(r2, r1); phalcon_update_property_zval(this_ptr, SL("_controllerName"), r2 TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_long(parts, 0); } else { eval_int = phalcon_array_isset_string(parts, SL("controller")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r3); phalcon_array_fetch_string(&r3, parts, SL("controller"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r4); phalcon_filter_alphanum(r4, r3); phalcon_update_property_zval(this_ptr, SL("_controllerName"), r4 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(r5); PHALCON_CALL_METHOD(r5, this_ptr, "getcontrollername", PHALCON_NO_CHECK); phalcon_update_property_zval(this_ptr, SL("_controllerName"), r5 TSRMLS_CC); } } eval_int = phalcon_array_isset_long(parts, 1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r6); phalcon_array_fetch_long(&r6, parts, 1, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r7); phalcon_filter_alphanum(r7, r6); phalcon_update_property_zval(this_ptr, SL("_actionName"), r7 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r8); phalcon_array_fetch_long(&r8, parts, 1, PHALCON_NOISY TSRMLS_CC); phalcon_update_property_zval(this_ptr, SL("_actionName"), r8 TSRMLS_CC); PHALCON_SEPARATE(parts); phalcon_array_unset_long(parts, 1); } else { eval_int = phalcon_array_isset_string(parts, SL("action")+1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r9); phalcon_array_fetch_string(&r9, parts, SL("action"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r10); phalcon_filter_alphanum(r10, r9); phalcon_update_property_zval(this_ptr, SL("_actionName"), r10 TSRMLS_CC); } else { PHALCON_ALLOC_ZVAL_MM(r11); PHALCON_CALL_METHOD(r11, this_ptr, "getactionname", PHALCON_NO_CHECK); phalcon_update_property_zval(this_ptr, SL("_actionName"), r11 TSRMLS_CC); } } PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(params, a0); if (phalcon_valid_foreach(parts TSRMLS_CC)) { ah0 = Z_ARRVAL_P(parts); zend_hash_internal_pointer_reset_ex(ah0, &hp0); fes_e10f_1: if(zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) != SUCCESS){ goto fee_e10f_1; } else { PHALCON_INIT_VAR(key); PHALCON_GET_FOREACH_KEY(key, ah0, hp0); } PHALCON_INIT_VAR(value); ZVAL_ZVAL(value, *hd, 1, 0); if (Z_TYPE_P(key) == IS_LONG) { PHALCON_INIT_VAR(r12); phalcon_array_fetch(&r12, parts, key, PHALCON_NOISY TSRMLS_CC); phalcon_array_append(¶ms, r12, PHALCON_SEPARATE_PLZ TSRMLS_CC); } zend_hash_move_forward_ex(ah0, &hp0); goto fes_e10f_1; fee_e10f_1: if(0){} } else { return; } phalcon_update_property_zval(this_ptr, SL("_params"), params TSRMLS_CC); phalcon_update_property_bool(this_ptr, SL("_finished"), 0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Stores cached content into the file backend and stops the frontend * * @param int|string $keyName * @param string $content * @param long $lifetime * @param boolean $stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_File, save){ zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL; zval *last_key = NULL, *prefix, *filtered, *frontend, *options; zval *cache_dir, *cache_file, *cached_content = NULL; zval *prepared_content, *is_buffering; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zzzz", &key_name, &content, &lifetime, &stop_buffer) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!key_name) { PHALCON_INIT_NVAR(key_name); } if (!content) { PHALCON_INIT_NVAR(content); } if (!lifetime) { PHALCON_INIT_NVAR(lifetime); } if (!stop_buffer) { PHALCON_INIT_NVAR(stop_buffer); ZVAL_BOOL(stop_buffer, 1); } if (Z_TYPE_P(key_name) == IS_NULL) { PHALCON_INIT_VAR(last_key); phalcon_read_property(&last_key, this_ptr, SL("_lastKey"), PH_NOISY_CC); } else { PHALCON_INIT_VAR(prefix); phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); PHALCON_INIT_VAR(filtered); phalcon_filter_alphanum(filtered, key_name); PHALCON_INIT_NVAR(last_key); PHALCON_CONCAT_VV(last_key, prefix, filtered); } if (!zend_is_true(last_key)) { PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first"); return; } PHALCON_INIT_VAR(frontend); phalcon_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); PHALCON_INIT_VAR(options); phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC); PHALCON_INIT_VAR(cache_dir); phalcon_array_fetch_string(&cache_dir, options, SL("cacheDir"), PH_NOISY_CC); PHALCON_INIT_VAR(cache_file); PHALCON_CONCAT_VV(cache_file, cache_dir, last_key); if (!zend_is_true(content)) { PHALCON_INIT_VAR(cached_content); PHALCON_CALL_METHOD(cached_content, frontend, "getcontent", PH_NO_CHECK); } else { PHALCON_CPY_WRT(cached_content, content); } /** * We use file_put_contents to repect open-base-dir directive */ PHALCON_INIT_VAR(prepared_content); PHALCON_CALL_METHOD_PARAMS_1(prepared_content, frontend, "beforestore", cached_content, PH_NO_CHECK); PHALCON_CALL_FUNC_PARAMS_2_NORETURN("file_put_contents", cache_file, prepared_content); PHALCON_INIT_VAR(is_buffering); PHALCON_CALL_METHOD(is_buffering, frontend, "isbuffering", PH_NO_CHECK); if (PHALCON_IS_TRUE(stop_buffer)) { PHALCON_CALL_METHOD_NORETURN(frontend, "stop", PH_NO_CHECK); } if (PHALCON_IS_TRUE(is_buffering)) { zend_print_zval(cached_content, 0); } phalcon_update_property_bool(this_ptr, SL("_started"), 0 TSRMLS_CC); PHALCON_MM_RESTORE(); }
/** * Returns a cached content * * @param int|string $keyName * @param long $lifetime * @return mixed */ PHP_METHOD(Phalcon_Cache_Backend_File, get){ zval *key_name, *lifetime = NULL, *options, *prefix, *filtered; zval *prefixed_key, *cache_dir, *cache_file; zval *frontend, *time, *ttl = NULL, *modified_time, *difference; zval *not_expired, *cached_content, *processed; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &key_name, &lifetime) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!lifetime) { PHALCON_INIT_NVAR(lifetime); } PHALCON_INIT_VAR(options); phalcon_read_property(&options, this_ptr, SL("_options"), PH_NOISY_CC); PHALCON_INIT_VAR(prefix); phalcon_read_property(&prefix, this_ptr, SL("_prefix"), PH_NOISY_CC); PHALCON_INIT_VAR(filtered); phalcon_filter_alphanum(filtered, key_name); PHALCON_INIT_VAR(prefixed_key); PHALCON_CONCAT_VV(prefixed_key, prefix, filtered); phalcon_update_property_zval(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC); PHALCON_INIT_VAR(cache_dir); phalcon_array_fetch_string(&cache_dir, options, SL("cacheDir"), PH_NOISY_CC); PHALCON_INIT_VAR(cache_file); PHALCON_CONCAT_VV(cache_file, cache_dir, prefixed_key); if (phalcon_file_exists(cache_file TSRMLS_CC) == SUCCESS) { PHALCON_INIT_VAR(frontend); phalcon_read_property(&frontend, this_ptr, SL("_frontend"), PH_NOISY_CC); /** * Check if the file has expired */ PHALCON_INIT_VAR(time); PHALCON_CALL_FUNC(time, "time"); if (Z_TYPE_P(lifetime) == IS_NULL) { PHALCON_INIT_VAR(ttl); PHALCON_CALL_METHOD(ttl, frontend, "getlifetime", PH_NO_CHECK); } else { PHALCON_CPY_WRT(ttl, lifetime); } PHALCON_INIT_VAR(modified_time); PHALCON_CALL_FUNC_PARAMS_1(modified_time, "filemtime", cache_file); PHALCON_INIT_VAR(difference); sub_function(difference, time, ttl TSRMLS_CC); PHALCON_INIT_VAR(not_expired); is_smaller_function(not_expired, difference, modified_time TSRMLS_CC); /** * The content is only retrieved if the content has not expired */ if (PHALCON_IS_TRUE(not_expired)) { PHALCON_INIT_VAR(cached_content); PHALCON_CALL_FUNC_PARAMS_1(cached_content, "file_get_contents", cache_file); PHALCON_INIT_VAR(processed); PHALCON_CALL_METHOD_PARAMS_1(processed, frontend, "afterretrieve", cached_content, PH_NO_CHECK); RETURN_CCTOR(processed); } } PHALCON_MM_RESTORE(); RETURN_NULL(); }
/** * Internal sanizite wrapper to filter_var * * @param mixed $value * @param string $filter * @return mixed */ PHP_METHOD(Phalcon_Filter, _sanitize){ zval *value, *filter, *filters, *filter_object; zval *arguments, *filtered = NULL, *type = NULL, *quote, *empty_str; zval *escaped, *allow_fraction, *options, *exception_message; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &value, &filter) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_INIT_VAR(filters); phalcon_read_property(&filters, this_ptr, SL("_filters"), PH_NOISY_CC); eval_int = phalcon_array_isset(filters, filter); if (eval_int) { PHALCON_INIT_VAR(filter_object); phalcon_array_fetch(&filter_object, filters, filter, PH_NOISY_CC); /** * If the filter is a closure we call it in the PHP userland */ if (phalcon_is_instance_of(filter_object, SL("Closure") TSRMLS_CC)) { PHALCON_INIT_VAR(arguments); array_init(arguments); phalcon_array_append(&arguments, value, PH_SEPARATE TSRMLS_CC); PHALCON_INIT_VAR(filtered); PHALCON_CALL_USER_FUNC_ARRAY(filtered, filter_object, arguments); } else { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_METHOD_PARAMS_1(filtered, filter_object, "filter", value, PH_NO_CHECK); } RETURN_CCTOR(filtered); } PHALCON_INIT_NVAR(filtered); if (PHALCON_COMPARE_STRING(filter, "email")) { /** * The 'email' filter uses the filter extension */ PHALCON_INIT_VAR(type); ZVAL_LONG(type, 517); PHALCON_INIT_VAR(quote); ZVAL_STRING(quote, "'", 1); PHALCON_INIT_VAR(empty_str); ZVAL_STRING(empty_str, "", 1); PHALCON_INIT_VAR(escaped); phalcon_fast_str_replace(escaped, quote, empty_str, value TSRMLS_CC); PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", escaped, type); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "int")) { /** * 'int' filter sanitizes a numeric input */ PHALCON_INIT_NVAR(type); ZVAL_LONG(type, 519); PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", value, type); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "string")) { PHALCON_INIT_NVAR(type); ZVAL_LONG(type, 513); PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_2(filtered, "filter_var", value, type); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "float")) { /** * The 'float' filter uses the filter extension */ PHALCON_INIT_VAR(allow_fraction); ZVAL_LONG(allow_fraction, 4096); PHALCON_INIT_VAR(options); array_init(options); phalcon_array_update_string(&options, SL("flags"), &allow_fraction, PH_COPY | PH_SEPARATE TSRMLS_CC); PHALCON_INIT_NVAR(type); ZVAL_LONG(type, 520); PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_3(filtered, "filter_var", value, type, options); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "alphanum")) { PHALCON_INIT_NVAR(filtered); phalcon_filter_alphanum(filtered, value); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "trim")) { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "trim", value); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "striptags")) { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "strip_tags", value); goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "lower")) { if (phalcon_function_exists_ex(SS("mb_strtolower") TSRMLS_CC) == SUCCESS) { /** * 'lower' checks for the mbstring extension to make a correct lowercase * transformation */ PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "mb_strtolower", value); } else { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "strtolower", value); } goto ph_end_0; } if (PHALCON_COMPARE_STRING(filter, "upper")) { if (phalcon_function_exists_ex(SS("mb_strtoupper") TSRMLS_CC) == SUCCESS) { /** * 'upper' checks for the mbstring extension to make a correct lowercase * transformation */ PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "mb_strtoupper", value); } else { PHALCON_INIT_NVAR(filtered); PHALCON_CALL_FUNC_PARAMS_1(filtered, "strtoupper", value); } goto ph_end_0; } PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Sanitize filter ", filter, " is not supported"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_filter_exception_ce, exception_message); return; ph_end_0: RETURN_CCTOR(filtered); }
/** * Stores cached content into the file backend * * @param string $keyName * @param string $content * @param boolean $stopBuffer */ PHP_METHOD(Phalcon_Cache_Backend_File, save){ zval *key_name = NULL, *content = NULL, *stop_buffer = NULL, *last_key = NULL; zval *front_end = NULL, *backend = NULL, *cache_dir = NULL, *cache_file = NULL; zval *cached_content = NULL, *prepared_content = NULL, *is_buffering = NULL; zval *t0 = NULL, *t1 = NULL, *t2 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *i0 = NULL, *i1 = NULL; zval *c0 = NULL, *c1 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zzz", &key_name, &content, &stop_buffer) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!key_name) { PHALCON_INIT_VAR(key_name); ZVAL_NULL(key_name); } if (!content) { PHALCON_INIT_VAR(content); ZVAL_NULL(content); } if (!stop_buffer) { PHALCON_INIT_VAR(stop_buffer); ZVAL_BOOL(stop_buffer, 1); } if (Z_TYPE_P(key_name) == IS_NULL) { PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_lastKey", sizeof("_lastKey")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(last_key, t0); } else { PHALCON_ALLOC_ZVAL_MM(r0); phalcon_filter_alphanum(r0, key_name); PHALCON_CPY_WRT(last_key, r0); } if (!zend_is_true(last_key)) { PHALCON_ALLOC_ZVAL_MM(i0); object_init_ex(i0, phalcon_cache_exception_ce); PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "The cache must be started first", 1); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i0, "__construct", c0, PHALCON_CHECK); phalcon_throw_exception(i0 TSRMLS_CC); return; } PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_frontendObject", sizeof("_frontendObject")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(front_end, t1); PHALCON_ALLOC_ZVAL_MM(t2); phalcon_read_property(&t2, this_ptr, "_backendOptions", sizeof("_backendOptions")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(backend, t2); PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_string(&r1, backend, "cacheDir", strlen("cacheDir"), PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(cache_dir, r1); PHALCON_ALLOC_ZVAL_MM(r2); PHALCON_CALL_FUNC_PARAMS_1(r2, "is_writable", cache_dir, 0x017); if (!zend_is_true(r2)) { PHALCON_ALLOC_ZVAL_MM(i1); object_init_ex(i1, phalcon_cache_exception_ce); PHALCON_INIT_VAR(c1); ZVAL_STRING(c1, "The cache file is not writable", 1); PHALCON_CALL_METHOD_PARAMS_1_NORETURN(i1, "__construct", c1, PHALCON_CHECK); phalcon_throw_exception(i1 TSRMLS_CC); return; } PHALCON_ALLOC_ZVAL_MM(r3); concat_function(r3, cache_dir, last_key TSRMLS_CC); PHALCON_CPY_WRT(cache_file, r3); if (!zend_is_true(content)) { PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_CALL_METHOD(r4, front_end, "getcontent", PHALCON_NO_CHECK); PHALCON_CPY_WRT(cached_content, r4); } else { PHALCON_CPY_WRT(cached_content, content); } PHALCON_ALLOC_ZVAL_MM(r5); PHALCON_CALL_METHOD_PARAMS_1(r5, front_end, "beforestore", cached_content, PHALCON_NO_CHECK); PHALCON_CPY_WRT(prepared_content, r5); PHALCON_CALL_FUNC_PARAMS_2_NORETURN("file_put_contents", cache_file, prepared_content, 0x01B); PHALCON_ALLOC_ZVAL_MM(r6); PHALCON_CALL_METHOD(r6, front_end, "isbuffering", PHALCON_NO_CHECK); PHALCON_CPY_WRT(is_buffering, r6); if (zend_is_true(stop_buffer)) { PHALCON_CALL_METHOD_NORETURN(front_end, "stop", PHALCON_NO_CHECK); } if (zend_is_true(is_buffering)) { zend_print_zval(cached_content, 1); } PHALCON_MM_RESTORE(); }
/** * Returns a cached content * * @param string $keyName * @return mixed */ PHP_METHOD(Phalcon_Cache_Backend_File, get){ zval *key_name = NULL, *backend = NULL, *front_end = NULL, *sanitize_key = NULL; zval *cache_file = NULL, *time = NULL, *lifetime = NULL, *cached_content = NULL; zval *t0 = NULL, *t1 = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL, *r9 = NULL; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &key_name) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_backendOptions", sizeof("_backendOptions")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(backend, t0); PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_frontendObject", sizeof("_frontendObject")-1, PHALCON_NOISY TSRMLS_CC); PHALCON_CPY_WRT(front_end, t1); PHALCON_ALLOC_ZVAL_MM(r0); phalcon_filter_alphanum(r0, key_name); PHALCON_CPY_WRT(sanitize_key, r0); phalcon_update_property_zval(this_ptr, "_lastKey", strlen("_lastKey"), sanitize_key TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r1); phalcon_array_fetch_string(&r1, backend, "cacheDir", strlen("cacheDir"), PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r2); concat_function(r2, r1, sanitize_key TSRMLS_CC); PHALCON_CPY_WRT(cache_file, r2); if (phalcon_file_exists(cache_file TSRMLS_CC) == SUCCESS) { PHALCON_ALLOC_ZVAL_MM(r3); PHALCON_CALL_FUNC(r3, "time", 0x018); PHALCON_CPY_WRT(time, r3); PHALCON_ALLOC_ZVAL_MM(r4); PHALCON_CALL_METHOD(r4, front_end, "getlifetime", PHALCON_NO_CHECK); PHALCON_CPY_WRT(lifetime, r4); PHALCON_ALLOC_ZVAL_MM(r5); sub_function(r5, time, lifetime TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r6); PHALCON_CALL_FUNC_PARAMS_1(r6, "filemtime", cache_file, 0x019); PHALCON_INIT_VAR(r7); is_smaller_function(r7, r5, r6 TSRMLS_CC); if (zend_is_true(r7)) { PHALCON_ALLOC_ZVAL_MM(r8); PHALCON_CALL_FUNC_PARAMS_1(r8, "file_get_contents", cache_file, 0x01A); PHALCON_CPY_WRT(cached_content, r8); PHALCON_ALLOC_ZVAL_MM(r9); PHALCON_CALL_METHOD_PARAMS_1(r9, front_end, "afterretrieve", cached_content, PHALCON_NO_CHECK); PHALCON_RETURN_DZVAL(r9); } } PHALCON_MM_RESTORE(); RETURN_NULL(); }
/** * Handles routing information received from the rewrite engine * * @param string $uri */ PHP_METHOD(Phalcon_Router_Rewrite, handle) { zval *uri = NULL, *parts = NULL, *params = NULL, *number_parts = NULL, *i = NULL; zval *r0 = NULL, *r1 = NULL, *r2 = NULL, *r3 = NULL, *r4 = NULL, *r5 = NULL, *r6 = NULL; zval *r7 = NULL, *r8 = NULL; zval *c0 = NULL; zval *t0 = NULL, *t1 = NULL; zval *a0 = NULL; int eval_int; PHALCON_MM_GROW(); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &uri) == FAILURE) { PHALCON_MM_RESTORE(); RETURN_NULL(); } if (!uri) { PHALCON_INIT_VAR(uri); ZVAL_NULL(uri); } else { PHALCON_SEPARATE_PARAM(uri); } if (!zend_is_true(uri)) { PHALCON_ALLOC_ZVAL_MM(r0); PHALCON_CALL_METHOD(r0, this_ptr, "_getrewriteuri", PHALCON_NO_CHECK); PHALCON_CPY_WRT(uri, r0); } if (zend_is_true(uri)) { PHALCON_INIT_VAR(c0); ZVAL_STRING(c0, "/", 1); PHALCON_ALLOC_ZVAL_MM(r1); phalcon_fast_explode(r1, c0, uri TSRMLS_CC); PHALCON_CPY_WRT(parts, r1); eval_int = phalcon_array_isset_long(parts, 0); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r2); phalcon_array_fetch_long(&r2, parts, 0, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r3); phalcon_filter_alphanum(r3, r2); phalcon_update_property_zval(this_ptr, "_controller", strlen("_controller"), r3 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t0); phalcon_read_property(&t0, this_ptr, "_controller", sizeof("_controller")-1, PHALCON_NOISY TSRMLS_CC); if (!zend_is_true(t0)) { phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC); } } else { phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC); } eval_int = phalcon_array_isset_long(parts, 1); if (eval_int) { PHALCON_ALLOC_ZVAL_MM(r4); phalcon_array_fetch_long(&r4, parts, 1, PHALCON_NOISY TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(r5); phalcon_filter_alphanum(r5, r4); phalcon_update_property_zval(this_ptr, "_action", strlen("_action"), r5 TSRMLS_CC); PHALCON_ALLOC_ZVAL_MM(t1); phalcon_read_property(&t1, this_ptr, "_action", sizeof("_action")-1, PHALCON_NOISY TSRMLS_CC); if (!zend_is_true(t1)) { phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC); } } else { phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC); } PHALCON_INIT_VAR(a0); array_init(a0); PHALCON_CPY_WRT(params, a0); PHALCON_ALLOC_ZVAL_MM(r6); phalcon_fast_count(r6, parts TSRMLS_CC); PHALCON_CPY_WRT(number_parts, r6); PHALCON_INIT_VAR(i); ZVAL_LONG(i, 2); fs_ef57_0: PHALCON_INIT_VAR(r7); is_smaller_function(r7, i, number_parts TSRMLS_CC); if (!zend_is_true(r7)) { goto fe_ef57_0; } PHALCON_INIT_VAR(r8); phalcon_array_fetch(&r8, parts, i, PHALCON_NOISY TSRMLS_CC); phalcon_array_append(¶ms, r8, PHALCON_SEPARATE_PLZ TSRMLS_CC); PHALCON_SEPARATE(i); increment_function(i); goto fs_ef57_0; fe_ef57_0: phalcon_update_property_zval(this_ptr, "_params", strlen("_params"), params TSRMLS_CC); } else { phalcon_update_property_null(this_ptr, "_controller", strlen("_controller") TSRMLS_CC); phalcon_update_property_null(this_ptr, "_action", strlen("_action") TSRMLS_CC); } PHALCON_MM_RESTORE(); }