/** * Checks if a password hash is a valid bcrypt's hash * * @param string $password * @param string $passwordHash * @return boolean */ PHP_METHOD(Phalcon_Security, isLegacyHash){ zval *password_hash; phalcon_fetch_params(0, 1, 0, &password_hash); if (phalcon_start_with_str(password_hash, SL("$2a$"))) { RETURN_TRUE; } RETURN_FALSE; }
/** * Returns uri * * @return string */ PHP_METHOD(Phalcon_Http_Uri, build){ zval *parts, *uri, *scheme, *host, *user, *pass, *port, *path, *query, *fragment, *tmp = NULL; PHALCON_MM_GROW(); parts = phalcon_read_property(getThis(), SL("_parts"), PH_NOISY); PHALCON_INIT_VAR(uri); if (phalcon_array_isset_str_fetch(&scheme, parts, SL("scheme")) && PHALCON_IS_NOT_EMPTY(scheme)) { if (phalcon_array_isset_str_fetch(&host, parts, SL("host")) && PHALCON_IS_NOT_EMPTY(host)) { if (phalcon_array_isset_str_fetch(&user, parts, SL("user")) && PHALCON_IS_NOT_EMPTY(user)) { if (phalcon_array_isset_str_fetch(&pass, parts, SL("pass")) && PHALCON_IS_NOT_EMPTY(pass)) { PHALCON_CONCAT_VSVSVSV(uri, scheme, "://", user, ":", pass, "@", host); } else { PHALCON_CONCAT_VSVSV(uri, scheme, "://", user, "@", host); } } else { PHALCON_CONCAT_VSV(uri, scheme, "://", host); } } else { PHALCON_CONCAT_VS(uri, scheme, ":"); } } if (phalcon_array_isset_str_fetch(&port, parts, SL("port")) && PHALCON_IS_NOT_EMPTY(port)) { PHALCON_SCONCAT_SV(uri, ":", port); } if (phalcon_array_isset_str_fetch(&path, parts, SL("path")) && PHALCON_IS_NOT_EMPTY(path)) { if (!phalcon_start_with_str(path, SL("/"))) { PHALCON_SCONCAT_SV(uri, "/", path); } else { PHALCON_INIT_NVAR(tmp); PHALCON_CONCAT_VV(tmp, uri, path); PHALCON_CPY_WRT(uri, tmp); } } if (phalcon_array_isset_str_fetch(&query, parts, SL("query")) && PHALCON_IS_NOT_EMPTY(query)) { PHALCON_INIT_NVAR(tmp); phalcon_http_build_query(tmp, query, "&"); PHALCON_SCONCAT_SV(uri, "?", tmp); } if (phalcon_array_isset_str_fetch(&fragment, parts, SL("fragment")) && PHALCON_IS_NOT_EMPTY(fragment)) { PHALCON_SCONCAT_SV(uri, "#", fragment); } RETURN_CTOR(uri); }
/** * Magic method to get or set services using setters/getters * * @param string $method * @param array $arguments * @return mixed */ PHP_METHOD(Phalcon_DI, __call){ zval *method, *arguments = NULL, possible_service = {}, name = {}, definition = {}; phalcon_fetch_params(0, 1, 1, &method, &arguments); PHALCON_ENSURE_IS_STRING(method); if (!arguments) { arguments = &PHALCON_GLOBAL(z_null); } phalcon_substr(&possible_service, method, 3, 0); phalcon_lcfirst(&name, &possible_service); /** * If the magic method starts with "get" we try to get a service with that name */ if (phalcon_start_with_str(method, SL("get"))) { if (phalcon_isset_property_array(getThis(), SL("_services"), &name)) { PHALCON_RETURN_CALL_SELFW("get", &name, arguments); return; } } /** * If the magic method starts with "set" we try to set a service using that name */ if (phalcon_start_with_str(method, SL("set"))) { if (phalcon_array_isset_fetch_long(&definition, arguments, 0)) { PHALCON_CALL_SELFW(NULL, "set", &name, &definition); return; } } /** * The method doesn't start with set/get throw an exception */ zend_throw_exception_ex(phalcon_di_exception_ce, 0, "Call to undefined method or service '%s'", Z_STRVAL_P(method)); }
/** * Returns uri * * @return string */ PHP_METHOD(Phalcon_Http_Uri, build) { zval parts = {}, uri = {}, scheme = {}, host = {}, user = {}, pass = {}, port = {}, path = {}, query = {}, fragment = {}, tmp = {}; phalcon_read_property(&parts, getThis(), SL("_parts"), PH_NOISY); if (phalcon_array_isset_fetch_str(&scheme, &parts, SL("scheme")) && PHALCON_IS_NOT_EMPTY(&scheme)) { if (phalcon_array_isset_fetch_str(&host, &parts, SL("host")) && PHALCON_IS_NOT_EMPTY(&host)) { if (phalcon_array_isset_fetch_str(&user, &parts, SL("user")) && PHALCON_IS_NOT_EMPTY(&user)) { if (phalcon_array_isset_fetch_str(&pass, &parts, SL("pass")) && PHALCON_IS_NOT_EMPTY(&pass)) { PHALCON_CONCAT_VSVSVSV(&uri, &scheme, "://", &user, ":", &pass, "@", &host); } else { PHALCON_CONCAT_VSVSV(&uri, &scheme, "://", &user, "@", &host); } } else { PHALCON_CONCAT_VSV(&uri, &scheme, "://", &host); } } else { PHALCON_CONCAT_VS(&uri, &scheme, ":"); } } if (phalcon_array_isset_fetch_str(&port, &parts, SL("port")) && PHALCON_IS_NOT_EMPTY(&port)) { PHALCON_SCONCAT_SV(&uri, ":", &port); } if (phalcon_array_isset_fetch_str(&path, &parts, SL("path")) && PHALCON_IS_NOT_EMPTY(&path)) { if (!phalcon_start_with_str(&path, SL("/"))) { PHALCON_SCONCAT_SV(&uri, "/", &path); } else { PHALCON_SCONCAT(&uri, &path); } } if (phalcon_array_isset_fetch_str(&query, &parts, SL("query")) && PHALCON_IS_NOT_EMPTY(&query)) { phalcon_http_build_query(&tmp, &query, "&"); PHALCON_SCONCAT_SV(&uri, "?", &tmp); } if (phalcon_array_isset_fetch_str(&fragment, &parts, SL("fragment")) && PHALCON_IS_NOT_EMPTY(&fragment)) { PHALCON_SCONCAT_SV(&uri, "#", &fragment); } RETURN_CTORW(&uri); }
/** * Magic method to get or set services using setters/getters * * @param string $method * @param array $arguments * @return mixed */ PHP_METHOD(Phalcon_DI, __call){ zval *method, *arguments = NULL, *services, *service_name = NULL; zval *possible_service = NULL, *handler, *exception_message; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &method, &arguments); if (!arguments) { PHALCON_INIT_VAR(arguments); } /** * If the magic method starts with 'get' we try to get a service with that name */ if (phalcon_start_with_str(method, SL("get"))) { PHALCON_OBS_VAR(services); phalcon_read_property_this(&services, this_ptr, SL("_services"), PH_NOISY_CC); PHALCON_INIT_VAR(service_name); phalcon_substr(service_name, method, 3, 0); PHALCON_INIT_VAR(possible_service); phalcon_lcfirst(possible_service, service_name); if (phalcon_array_isset(services, possible_service)) { if (phalcon_fast_count_ev(arguments TSRMLS_CC)) { phalcon_call_method_p2(return_value, this_ptr, "get", possible_service, arguments); RETURN_MM(); } phalcon_call_method_p1(return_value, this_ptr, "get", possible_service); RETURN_MM(); } } /** * If the magic method starts with 'set' we try to set a service using that name */ if (phalcon_start_with_str(method, SL("set"))) { if (phalcon_array_isset_long(arguments, 0)) { PHALCON_INIT_NVAR(service_name); phalcon_substr(service_name, method, 3, 0); PHALCON_INIT_NVAR(possible_service); phalcon_lcfirst(possible_service, service_name); PHALCON_OBS_VAR(handler); phalcon_array_fetch_long(&handler, arguments, 0, PH_NOISY); phalcon_call_method_p2_noret(this_ptr, "set", possible_service, handler); RETURN_MM_NULL(); } } /** * The method doesn't start with set/get throw an exception */ PHALCON_INIT_VAR(exception_message); PHALCON_CONCAT_SVS(exception_message, "Call to undefined method or service '", method, "'"); PHALCON_THROW_EXCEPTION_ZVAL(phalcon_di_exception_ce, exception_message); return; }
PHP_METHOD(Phalcon_Http_Client_Header, parse){ zval *content, *content_parts = NULL, *key = NULL, *header = NULL, *header_parts = NULL, *name = NULL, *value = NULL, *trimmed = NULL; HashTable *ah0; HashPosition hp0; zval **hd; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 0, &content); if (PHALCON_IS_EMPTY(content)) { RETURN_MM_FALSE; } if (Z_TYPE_P(content) == IS_STRING) { PHALCON_INIT_VAR(content_parts); phalcon_fast_explode_str(content_parts, SL("\r\n"), content); } else if (Z_TYPE_P(content) == IS_ARRAY) { PHALCON_CPY_WRT_CTOR(content_parts, content); } else { RETURN_MM_FALSE; } phalcon_is_iterable(content_parts, &ah0, &hp0, 0, 0); while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) { PHALCON_GET_HKEY(key, ah0, hp0); PHALCON_GET_HVALUE(header); if (Z_TYPE_P(header) == IS_STRING) { PHALCON_INIT_NVAR(header_parts); if (phalcon_memnstr_str(header , SL(":"))) { phalcon_fast_explode_str(header_parts, SL(":"), header); } else { if (phalcon_start_with_str(header , SL("HTTP/"))) { phalcon_fast_explode_str(header_parts, SL(" "), header); if (Z_TYPE_P(header_parts) == IS_ARRAY && phalcon_array_isset_long(header_parts, 1) && phalcon_array_isset_long(header_parts, 2)) { PHALCON_OBS_NVAR(value); phalcon_array_fetch_long(&value, header_parts, 1, PH_NOISY); phalcon_update_property_this(this_ptr, SL("_status_code"), value TSRMLS_CC); PHALCON_OBS_NVAR(value); phalcon_array_fetch_long(&value, header_parts, 2, PH_NOISY); phalcon_update_property_this(this_ptr, SL("_status_message"), value TSRMLS_CC); } } zend_hash_move_forward_ex(ah0, &hp0); continue; } } else { PHALCON_CPY_WRT_CTOR(header_parts, header); } if (Z_TYPE_P(header_parts) == IS_ARRAY && phalcon_array_isset_long(header_parts, 0) && phalcon_array_isset_long(header_parts, 1)) { PHALCON_OBS_NVAR(name); phalcon_array_fetch_long(&name, header_parts, 0, PH_NOISY); PHALCON_OBS_NVAR(value); phalcon_array_fetch_long(&value, header_parts, 1, PH_NOISY); PHALCON_INIT_NVAR(trimmed); phalcon_fast_trim(trimmed, value, NULL, PHALCON_TRIM_BOTH TSRMLS_CC); PHALCON_CALL_METHOD(NULL, this_ptr, "set", name, trimmed); } zend_hash_move_forward_ex(ah0, &hp0); } PHALCON_MM_RESTORE(); }
/** * Gets number of rows returned by a resulset * *<code> * $result = $connection->query("SELECT * FROM robots ORDER BY name"); * echo 'There are ', $result->numRows(), ' rows in the resulset'; *</code> * * @return int */ PHP_METHOD(Phalcon_Db_Result_Pdo, numRows){ zval *row_count = NULL, *connection, *type = NULL, *pdo_statement = NULL; zval *sql_statement, *bind_params, *bind_types; zval *matches, *pattern, *match, *else_clauses; zval *sql, *result = NULL, *row = NULL; PHALCON_MM_GROW(); PHALCON_OBS_VAR(row_count); phalcon_read_property_this(&row_count, this_ptr, SL("_rowCount"), PH_NOISY TSRMLS_CC); if (PHALCON_IS_FALSE(row_count)) { PHALCON_OBS_VAR(connection); phalcon_read_property_this(&connection, this_ptr, SL("_connection"), PH_NOISY TSRMLS_CC); PHALCON_CALL_METHOD(&type, connection, "gettype"); /** * MySQL/PostgreSQL library property returns the number of records */ if (PHALCON_IS_STRING(type, "mysql") || PHALCON_IS_STRING(type, "pgsql")) { PHALCON_OBS_VAR(pdo_statement); phalcon_read_property_this(&pdo_statement, this_ptr, SL("_pdoStatement"), PH_NOISY TSRMLS_CC); PHALCON_CALL_METHOD(&row_count, pdo_statement, "rowcount"); } /** * We should get the count using a new statement :( */ if (PHALCON_IS_FALSE(row_count)) { /** * SQLite/Oracle/SQLServer returns resultsets that to the client eyes (PDO) has an * arbitrary number of rows, so we need to perform an extra count to know that */ PHALCON_OBS_VAR(sql_statement); phalcon_read_property_this(&sql_statement, this_ptr, SL("_sqlStatement"), PH_NOISY TSRMLS_CC); /** * If the sql_statement starts with SELECT COUNT(*) we don't make the count */ if (!phalcon_start_with_str(sql_statement, SL("SELECT COUNT(*) "))) { PHALCON_OBS_VAR(bind_params); phalcon_read_property_this(&bind_params, this_ptr, SL("_bindParams"), PH_NOISY TSRMLS_CC); PHALCON_OBS_VAR(bind_types); phalcon_read_property_this(&bind_types, this_ptr, SL("_bindTypes"), PH_NOISY TSRMLS_CC); PHALCON_INIT_VAR(matches); PHALCON_INIT_VAR(pattern); ZVAL_STRING(pattern, "/^SELECT\\s+(.*)$/i", 1); PHALCON_INIT_VAR(match); RETURN_MM_ON_FAILURE(phalcon_preg_match(match, pattern, sql_statement, matches TSRMLS_CC)); if (zend_is_true(match)) { PHALCON_OBS_VAR(else_clauses); phalcon_array_fetch_long(&else_clauses, matches, 1, PH_NOISY); PHALCON_INIT_VAR(sql); PHALCON_CONCAT_SVS(sql, "SELECT COUNT(*) \"numrows\" FROM (SELECT ", else_clauses, ")"); PHALCON_CALL_METHOD(&result, connection, "query", sql, bind_params, bind_types); PHALCON_CALL_METHOD(&row, result, "fetch"); PHALCON_OBS_NVAR(row_count); phalcon_array_fetch_string(&row_count, row, SL("numrows"), PH_NOISY); } } else { PHALCON_INIT_NVAR(row_count); ZVAL_LONG(row_count, 1); } } /** * Update the value to avoid further calculations */ phalcon_update_property_this(this_ptr, SL("_rowCount"), row_count TSRMLS_CC); } RETURN_CCTOR(row_count); }
/** * Reconfigure the route adding a new pattern and a set of paths * * @param string $pattern * @param array $paths */ PHP_METHOD(Phalcon_Mvc_Router_Route, reConfigure){ zval *pattern, *paths = NULL, *module_name = NULL, *controller_name = NULL; zval *action_name = NULL, *parts, *number_parts, *route_paths = NULL; zval *real_class_name = NULL, *namespace_name, *lower_name; zval *pcre_pattern = NULL, *compiled_pattern = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &pattern, &paths); if (!paths) { PHALCON_INIT_VAR(paths); } if (Z_TYPE_P(pattern) != IS_STRING) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_router_exception_ce, "The pattern must be string"); return; } if (Z_TYPE_P(paths) != IS_NULL) { if (Z_TYPE_P(paths) == IS_STRING) { PHALCON_INIT_VAR(module_name); PHALCON_INIT_VAR(controller_name); PHALCON_INIT_VAR(action_name); /** * Explode the short paths using the :: separator */ PHALCON_INIT_VAR(parts); phalcon_fast_explode_str(parts, SL("::"), paths); PHALCON_INIT_VAR(number_parts); phalcon_fast_count(number_parts, parts TSRMLS_CC); /** * Create the array paths dynamically */ switch (phalcon_get_intval(number_parts)) { case 3: PHALCON_OBS_NVAR(module_name); phalcon_array_fetch_long(&module_name, parts, 0, PH_NOISY); PHALCON_OBS_NVAR(controller_name); phalcon_array_fetch_long(&controller_name, parts, 1, PH_NOISY); PHALCON_OBS_NVAR(action_name); phalcon_array_fetch_long(&action_name, parts, 2, PH_NOISY); break; case 2: PHALCON_OBS_NVAR(controller_name); phalcon_array_fetch_long(&controller_name, parts, 0, PH_NOISY); PHALCON_OBS_NVAR(action_name); phalcon_array_fetch_long(&action_name, parts, 1, PH_NOISY); break; case 1: PHALCON_OBS_NVAR(controller_name); phalcon_array_fetch_long(&controller_name, parts, 0, PH_NOISY); break; } PHALCON_INIT_VAR(route_paths); array_init(route_paths); /** * Process module name */ if (Z_TYPE_P(module_name) != IS_NULL) { phalcon_array_update_string(&route_paths, SL("module"), &module_name, PH_COPY | PH_SEPARATE); } /** * Process controller name */ if (Z_TYPE_P(controller_name) != IS_NULL) { /** * Check if we need to obtain the namespace */ if (phalcon_memnstr_str(controller_name, SL("\\"))) { /** * Extract the real class name from the namespaced class */ PHALCON_INIT_VAR(real_class_name); phalcon_get_class_ns(real_class_name, controller_name, 0 TSRMLS_CC); /** * Extract the namespace from the namespaced class */ PHALCON_INIT_VAR(namespace_name); phalcon_get_ns_class(namespace_name, controller_name, 0 TSRMLS_CC); /** * Update the namespace */ if (zend_is_true(namespace_name)) { phalcon_array_update_string(&route_paths, SL("namespace"), &namespace_name, PH_COPY | PH_SEPARATE); } } else { PHALCON_CPY_WRT(real_class_name, controller_name); } /** * Always pass the controller to lowercase */ PHALCON_INIT_VAR(lower_name); phalcon_uncamelize(lower_name, real_class_name); /** * Update the controller path */ phalcon_array_update_string(&route_paths, SL("controller"), &lower_name, PH_COPY | PH_SEPARATE); } /** * Process action name */ if (Z_TYPE_P(action_name) != IS_NULL) { phalcon_array_update_string(&route_paths, SL("action"), &action_name, PH_COPY | PH_SEPARATE); } } else { PHALCON_CPY_WRT(route_paths, paths); } } else { PHALCON_INIT_NVAR(route_paths); array_init(route_paths); } if (Z_TYPE_P(route_paths) != IS_ARRAY) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_router_exception_ce, "The route contains invalid paths"); return; } /** * If the route starts with '#' we assume that it is a regular expression */ if (!phalcon_start_with_str(pattern, SL("#"))) { if (phalcon_memnstr_str(pattern, SL("{"))) { /** * The route has named parameters so we need to extract them */ PHALCON_INIT_VAR(pcre_pattern); phalcon_extract_named_params(pcre_pattern, pattern, route_paths); } else { PHALCON_CPY_WRT(pcre_pattern, pattern); } /** * Transform the route's pattern to a regular expression */ PHALCON_INIT_VAR(compiled_pattern); phalcon_call_method_p1(compiled_pattern, this_ptr, "compilepattern", pcre_pattern); } else { PHALCON_CPY_WRT(compiled_pattern, pattern); } /** * Update the original pattern */ phalcon_update_property_this(this_ptr, SL("_pattern"), pattern TSRMLS_CC); /** * Update the compiled pattern */ phalcon_update_property_this(this_ptr, SL("_compiledPattern"), compiled_pattern TSRMLS_CC); /** * Update the route's paths */ phalcon_update_property_this(this_ptr, SL("_paths"), route_paths TSRMLS_CC); PHALCON_MM_RESTORE(); }