/**
*
* @param string $session_id optional, session id
*
* @return boolean
*/
PHP_METHOD(Phalcon_Session_Adapter_Memcache, destroy){
zval *sid = NULL;
zval *memcache;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &sid);
if (!sid) {
PHALCON_INIT_VAR(sid);
PHALCON_CALL_SELF(&sid, "getid");
}
memcache = phalcon_fetch_nproperty_this(this_ptr, SL("_memcache"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(memcache) == IS_OBJECT) {
PHALCON_RETURN_CALL_METHOD(memcache, "delete", sid);
RETURN_MM();
} else {
RETURN_MM_FALSE;
}
}
/**
* Deletes a value from the cache by its key
*
* @param int|string $keyName
* @return boolean
*/
PHP_METHOD(Phalcon_Cache_Backend_Memcache, delete){
zval *key_name, *memcache, *prefix, *prefixed_key;
zval *options, *special_key, *keys = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &key_name);
memcache = phalcon_fetch_nproperty_this(this_ptr, SL("_memcache"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(memcache) != IS_OBJECT) {
memcache = NULL;
PHALCON_CALL_METHOD(&memcache, this_ptr, "_connect");
}
prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(prefixed_key);
PHALCON_CONCAT_VV(prefixed_key, prefix, key_name);
options = phalcon_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY TSRMLS_CC);
if (unlikely(!phalcon_array_isset_string_fetch(&special_key, options, SS("statsKey")))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options");
return;
/**
* Applies a format to a message before sending it to the log
*
* @param string $message
* @param int $type
* @param int $timestamp
* @param array $context
* @return string
*/
PHP_METHOD(Phalcon_Logger_Formatter_Firephp, format) {
zval *message, *type, *type_str = NULL, *timestamp, *context, *interpolated = NULL;
zval *payload, *body, *backtrace = NULL, *meta, *encoded;
zval *show_backtrace, *enable_labels;
int i_show_backtrace, i_enable_labels;
smart_str result = { NULL, 0, 0 };
uint i;
Bucket *p;
phalcon_fetch_params(0, 4, 0, &message, &type, ×tamp, &context);
/*
* We intentionally do not use Phalcon's MM for better performance.
* All variables allocated with ALLOC_INIT_ZVAL() will have
* their reference count set to 1 and therefore they can be nicely
* put into the result array; when that array will be destroyed,
* all inserted variables will be automatically destroyed, too
* and we will just save some time by not using Z_ADDREF_P and Z_DELREF_P
*/
if (Z_TYPE_P(context) == IS_ARRAY) {
PHALCON_CALL_METHODW(&interpolated, this_ptr, "interpolate", message, context);
}
else {
interpolated = message;
Z_ADDREF_P(interpolated);
}
{
zval *params[] = { type };
if (FAILURE == phalcon_call_method(&type_str, this_ptr, "gettypestring", 1, params TSRMLS_CC)) {
zval_ptr_dtor(&interpolated);
return;
}
}
show_backtrace = phalcon_fetch_nproperty_this(getThis(), SL("_showBacktrace"), PH_NOISY TSRMLS_CC);
enable_labels = phalcon_fetch_nproperty_this(getThis(), SL("_enableLabels"), PH_NOISY TSRMLS_CC);
i_show_backtrace = zend_is_true(show_backtrace);
i_enable_labels = zend_is_true(enable_labels);
/*
* Get the backtrace. This differs for different PHP versions.
* 5.3.6+ allows us to skip the function arguments which will save some memory
* For 5.4+ there is an extra argument.
*/
if (i_show_backtrace) {
ALLOC_INIT_ZVAL(backtrace);
#if PHP_VERSION_ID < 50306
zend_fetch_debug_backtrace(backtrace, 1, 0 TSRMLS_CC);
#elif PHP_VERSION_ID < 50400
zend_fetch_debug_backtrace(backtrace, 1, DEBUG_BACKTRACE_IGNORE_ARGS TSRMLS_CC);
#else
zend_fetch_debug_backtrace(backtrace, 1, DEBUG_BACKTRACE_IGNORE_ARGS, 0 TSRMLS_CC);
#endif
if (Z_TYPE_P(backtrace) == IS_ARRAY) {
HashPosition pos;
HashTable *ht = Z_ARRVAL_P(backtrace);
zval **ppzval;
int found = 0;
ulong idx;
char *key;
uint key_len;
/*
* At this point we know that the backtrace is the array.
* Again, we intentionally do not use Phalcon's API because we know
* that we are working with the array / hash table and thus we can
* save some time by omitting Z_TYPE_P(x) == IS_ARRAY checks
*/
for (
zend_hash_internal_pointer_reset_ex(ht, &pos);
zend_hash_has_more_elements_ex(ht, &pos) == SUCCESS;
) {
zend_hash_get_current_data_ex(ht, (void**)&ppzval, &pos);
zend_hash_get_current_key_ex(ht, &key, &key_len, &idx, 0, &pos);
zend_hash_move_forward_ex(ht, &pos);
if (Z_TYPE_PP(ppzval) == IS_ARRAY) {
/*
* Here we need to skip the latest calls into Phalcon's core.
* Calls to Zend internal functions will have "file" index not set.
* We remove these entries from the array.
*/
if (!found && !zend_hash_quick_exists(Z_ARRVAL_PP(ppzval), SS("file"), zend_inline_hash_func(SS("file")))) {
zend_hash_index_del(ht, idx);
}
else {
/*
* Remove args and object indices. They usually give
* too much information; this is not suitable to send
* in the HTTP headers
*/
zend_hash_quick_del(Z_ARRVAL_PP(ppzval), "args", sizeof("args"), zend_inline_hash_func(SS("args")));
zend_hash_quick_del(Z_ARRVAL_PP(ppzval), "object", sizeof("object"), zend_inline_hash_func(SS("object")));
found = 1;
}
}
}
/*
* Now we need to renumber the hash table because we removed several
* heading elements. If we don't do this, json_encode() will convert
* this array to a JavaScript object which is an unwanted side effect
*/
p = ht->pListHead;
i = 0;
while (p != NULL) {
p->nKeyLength = 0;
p->h = i++;
p = p->pListNext;
}
ht->nNextFreeElement = i;
zend_hash_rehash(ht);
}
}
/*
* The result will looks like this:
*
* array(
* array('Type' => 'message type', 'Label' => 'message'),
* array('backtrace' => array(backtrace goes here)
* )
*/
MAKE_STD_ZVAL(payload);
array_init_size(payload, 2);
MAKE_STD_ZVAL(meta);
array_init_size(meta, 4);
add_assoc_zval_ex(meta, SS("Type"), type_str);
if (i_show_backtrace && Z_TYPE_P(backtrace) == IS_ARRAY) {
zval **ppzval;
if (likely(SUCCESS == zend_hash_index_find(Z_ARRVAL_P(backtrace), 0, (void**)&ppzval)) && likely(Z_TYPE_PP(ppzval) == IS_ARRAY)) {
zval **file = NULL, **line = NULL;
zend_hash_quick_find(Z_ARRVAL_PP(ppzval), SS("file"), zend_inline_hash_func(SS("file")), (void**)&file);
zend_hash_quick_find(Z_ARRVAL_PP(ppzval), SS("line"), zend_inline_hash_func(SS("line")), (void**)&line);
if (likely(file != NULL)) {
Z_ADDREF_PP(file);
add_assoc_zval_ex(meta, SS("File"), *file);
}
if (likely(line != NULL)) {
Z_ADDREF_PP(line);
add_assoc_zval_ex(meta, SS("Line"), *line);
}
}
}
if (i_enable_labels) {
add_assoc_zval_ex(meta, SS("Label"), interpolated);
}
if (!i_enable_labels && !i_show_backtrace) {
body = interpolated;
}
else if (i_enable_labels && !i_show_backtrace) {
MAKE_STD_ZVAL(body);
ZVAL_EMPTY_STRING(body);
}
else {
MAKE_STD_ZVAL(body);
array_init_size(body, 2);
if (i_show_backtrace) {
add_assoc_zval_ex(body, SS("backtrace"), backtrace);
}
if (!i_enable_labels) {
add_assoc_zval_ex(body, SS("message"), interpolated);
}
}
add_next_index_zval(payload, meta);
add_next_index_zval(payload, body);
/* Convert everything to JSON */
ALLOC_INIT_ZVAL(encoded);
if (FAILURE == phalcon_json_encode(encoded, payload, 0 TSRMLS_CC)) {
zval_ptr_dtor(&payload);
zval_ptr_dtor(&encoded);
return;
}
/* As promised, kill the payload and all associated elements */
zval_ptr_dtor(&payload);
/*
* We don't want to use Phalcon's concatenation API because it
* requires the memory manager. Therefore we fall back to using smart strings.
* smart_str_alloc4() will allocate all required memory amount (plus some more)
* in one go and this allows us to avoid performance penalties due to
* memory reallocations.
*/
if (Z_TYPE_P(encoded) == IS_STRING && Z_STRVAL_P(encoded) != NULL) {
smart_str_alloc4(&result, (uint)(Z_STRLEN_P(encoded) + 2 + 5), 0, i);
/*
* The format is:
*
* <size>|[meta,body]|
*
* Meta and body are contained in encoded inside the array, as required
* by the protocol specification
* @see http://www.firephp.org/Wiki/Reference/Protocol
*/
smart_str_append_long(&result, Z_STRLEN_P(encoded));
smart_str_appendc(&result, '|');
smart_str_appendl(&result, Z_STRVAL_P(encoded), Z_STRLEN_P(encoded));
smart_str_appendc(&result, '|');
smart_str_0(&result);
}
/* We don't need the JSON message anymore */
zval_ptr_dtor(&encoded);
/* Do not free the smart string because we steal its data for zval */
RETURN_STRINGL(result.c, result.len, 0);
}
/**
* 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;
zval *options, *prefix, *prefixed_key, *cache_dir;
zval *cache_file, *tmp = NULL;
zval *modified_time;
zval *cached_content, *exception_message;
long int now, ttl, mtime, diff;
int expired;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &key_name, &lifetime);
options = phalcon_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY TSRMLS_CC);
prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(prefixed_key);
PHALCON_CONCAT_VV(prefixed_key, prefix, key_name);
phalcon_update_property_this(this_ptr, SL("_lastKey"), prefixed_key TSRMLS_CC);
if (unlikely(!phalcon_array_isset_string_fetch(&cache_dir, options, SS("cacheDir")))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options");
return;
}
PHALCON_INIT_VAR(cache_file);
PHALCON_CONCAT_VV(cache_file, cache_dir, prefixed_key);
if (phalcon_file_exists(cache_file TSRMLS_CC) == SUCCESS) {
zval *frontend = phalcon_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY TSRMLS_CC);
/**
* Check if the file has expired
*/
now = (long int)time(NULL);
/**
* Take the lifetime from the frontend or read it from the set in start()
*/
if (!lifetime || Z_TYPE_P(lifetime) == IS_NULL) {
zval *last_lifetime = phalcon_fetch_nproperty_this(this_ptr, SL("_lastLifetime"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(last_lifetime) == IS_NULL) {
PHALCON_CALL_METHOD(&tmp, frontend, "getlifetime");
ttl = phalcon_get_intval(tmp);
} else {
ttl = phalcon_get_intval(last_lifetime);
}
} else {
ttl = phalcon_get_intval(lifetime);
}
PHALCON_INIT_VAR(modified_time);
phalcon_filemtime(modified_time, cache_file TSRMLS_CC);
if (unlikely(Z_TYPE_P(modified_time) != IS_LONG)) {
convert_to_long(modified_time);
}
mtime = Z_LVAL_P(modified_time);
diff = now - ttl;
expired = diff > mtime;
/**
* The content is only retrieved if the content has not expired
*/
if (!expired) {
/**
* Use file-get-contents to control that the openbase_dir can't be skipped
*/
PHALCON_INIT_VAR(cached_content);
phalcon_file_get_contents(cached_content, cache_file TSRMLS_CC);
if (PHALCON_IS_FALSE(cached_content)) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SVS(exception_message, "Cache file ", cache_file, " could not be opened");
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_cache_exception_ce, exception_message);
return;
}
if (phalcon_is_numeric(cached_content)) {
RETURN_CCTOR(cached_content);
} else {
/**
* Use the frontend to process the content of the cache
*/
PHALCON_RETURN_CALL_METHOD(frontend, "afterretrieve", cached_content);
}
RETURN_MM();
}
}
RETURN_MM_NULL();
}
RETURN_MEMBER(this_ptr, "_body");
}
/**
* Removes a job from the server entirely
*
* @return boolean
*/
PHP_METHOD(Phalcon_Queue_Beanstalk_Job, delete){
zval *id, *command, *queue, *response = NULL, *status;
PHALCON_MM_GROW();
id = phalcon_fetch_nproperty_this(this_ptr, SL("_id"), PH_NOISY TSRMLS_CC);
queue = phalcon_fetch_nproperty_this(this_ptr, SL("_queue"), PH_NOISY TSRMLS_CC);
PHALCON_ALLOC_GHOST_ZVAL(command);
PHALCON_CONCAT_SV(command, "delete ", id);
PHALCON_CALL_METHOD(NULL, queue, "write", command);
PHALCON_CALL_METHOD(&response, queue, "readstatus");
PHALCON_OBS_VAR(status);
phalcon_array_fetch_long(&status, response, 0, PH_NOISY);
if (PHALCON_IS_STRING(status, "DELETED")) {
RETURN_MM_TRUE;
}
RETURN_MM_FALSE;
/**
* Rollbacks the active transaction in the connection
*
* @param boolean $nesting
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, rollback){
zval *nesting = NULL, *pdo, *transaction_level, *events_manager = NULL;
zval *event_name = NULL, *ntw_savepoint = NULL, *savepoint_name = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &nesting);
if (!nesting) {
nesting = PHALCON_GLOBAL(z_true);
}
pdo = phalcon_fetch_nproperty_this(this_ptr, SL("_pdo"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(pdo) != IS_OBJECT) {
RETURN_MM_FALSE;
}
/**
* Check the transaction nesting level
*/
transaction_level = phalcon_fetch_nproperty_this(this_ptr, SL("_transactionLevel"), PH_NOISY TSRMLS_CC);
if (!zend_is_true(transaction_level)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "There is no active transaction");
return;
}
if (PHALCON_IS_LONG(transaction_level, 1)) {
events_manager = phalcon_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY TSRMLS_CC);
/**
* Notify the events manager about the rollbacked transaction
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "db:rollbackTransaction", 1);
PHALCON_CALL_METHOD(NULL, events_manager, "fire", event_name, this_ptr);
}
/**
* Reduce the transaction nesting level
*/
phalcon_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC);
PHALCON_RETURN_CALL_METHOD(pdo, "rollback");
RETURN_MM();
}
if (zend_is_true(transaction_level)) {
if (zend_is_true(nesting)) {
PHALCON_CALL_METHOD(&ntw_savepoint, this_ptr, "isnestedtransactionswithsavepoints");
if (zend_is_true(ntw_savepoint)) {
events_manager = phalcon_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(&savepoint_name, this_ptr, "getnestedtransactionsavepointname");
/**
* Notify the events manager about the rollbacked savepoint
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "db:rollbackSavepoint", 1);
PHALCON_CALL_METHOD(NULL, events_manager, "fire", event_name, this_ptr, savepoint_name);
}
/**
* Reduce the transaction nesting level
*/
phalcon_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC);
PHALCON_RETURN_CALL_METHOD(this_ptr, "rollbacksavepoint", savepoint_name);
RETURN_MM();
}
}
}
/**
* Reduce the transaction nesting level
*/
if (PHALCON_GT_LONG(transaction_level, 0)) {
phalcon_property_decr(this_ptr, SL("_transactionLevel") TSRMLS_CC);
}
RETURN_MM_FALSE;
}
/**
* Sends SQL statements to the database server returning the success state.
* Use this method only when the SQL statement sent to the server doesn't return any row
*
*<code>
* //Inserting data
* $success = $connection->execute("INSERT INTO robots VALUES (1, 'Astro Boy')");
* $success = $connection->execute("INSERT INTO robots VALUES (?, ?)", array(1, 'Astro Boy'));
*</code>
*
* @param string $sqlStatement
* @param array $bindParams
* @param array $bindTypes
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, execute){
zval *sql_statement, *bind_params = NULL, *bind_types = NULL, *profiler;
zval *events_manager, *event_name = NULL, *status = NULL, *affected_rows = NULL;
zval *pdo, *statement = NULL, *new_statement = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 2, &sql_statement, &bind_params, &bind_types);
if (!bind_params) {
bind_params = PHALCON_GLOBAL(z_null);
}
if (!bind_types) {
bind_types = PHALCON_GLOBAL(z_null);
}
phalcon_update_property_this(this_ptr, SL("_sqlStatement"), sql_statement TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_sqlVariables"), bind_params TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_sqlBindTypes"), bind_types TSRMLS_CC);
/**
* Execute the beforeQuery event if a EventsManager is available
*/
events_manager = phalcon_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "db:beforeQuery", 1);
PHALCON_CALL_METHOD(&status, events_manager, "fire", event_name, this_ptr, bind_params);
if (PHALCON_IS_FALSE(status)) {
RETURN_MM_FALSE;
}
}
if (Z_TYPE_P(bind_params) == IS_ARRAY) {
PHALCON_CALL_METHOD(&statement, this_ptr, "prepare", sql_statement);
if (Z_TYPE_P(statement) == IS_OBJECT) {
PHALCON_CALL_METHOD(&new_statement, this_ptr, "executeprepared", statement, bind_params, bind_types);
PHALCON_CALL_METHOD(&affected_rows, new_statement, "rowcount");
}
else {
PHALCON_INIT_VAR(affected_rows);
ZVAL_LONG(affected_rows, 0);
}
} else {
pdo = phalcon_fetch_nproperty_this(this_ptr, SL("_pdo"), PH_NOISY TSRMLS_CC);
profiler = phalcon_fetch_nproperty_this(this_ptr, SL("_profiler"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(profiler) == IS_OBJECT) {
PHALCON_CALL_METHOD(NULL, profiler, "startprofile", sql_statement);
PHALCON_CALL_METHOD(&affected_rows, pdo, "exec", sql_statement);
PHALCON_CALL_METHOD(NULL, profiler, "stopprofile");
} else {
PHALCON_CALL_METHOD(&affected_rows, pdo, "exec", sql_statement);
}
}
/**
* Execute the afterQuery event if a EventsManager is available
*/
if (Z_TYPE_P(affected_rows) == IS_LONG) {
phalcon_update_property_this(this_ptr, SL("_affectedRows"), affected_rows TSRMLS_CC);
}
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "db:afterQuery", 1);
PHALCON_CALL_METHOD(NULL, events_manager, "fire", event_name, this_ptr, bind_params);
}
RETURN_MM_TRUE;
}
/**
* Executes a prepared statement binding. This function uses integer indexes starting from zero
*
*<code>
* $statement = $connection->prepare('SELECT * FROM robots WHERE name = :name');
* $pdoResult = $connection->executePrepared($statement, array('name' => 'Voltron'));
*</code>
*
* @param \PDOStatement $statement
* @param array $placeholders
* @param array $dataTypes
* @return \PDOStatement
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, executePrepared){
zval *statement = NULL, *placeholders = NULL, *data_types = NULL;
zval *z_one, *value = NULL, *wildcard = NULL, *parameter = NULL, *type = NULL, *cast_value = NULL;
zval *profiler, *sql_statement;
HashTable *ah0;
HashPosition hp0;
zval **hd;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz", &statement, &placeholders, &data_types) == FAILURE) {
RETURN_NULL();
}
PHALCON_MM_GROW();
z_one = PHALCON_GLOBAL(z_one);
phalcon_is_iterable(placeholders, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(wildcard, ah0, hp0);
PHALCON_GET_HVALUE(value);
if (Z_TYPE_P(wildcard) == IS_LONG) {
PHALCON_INIT_NVAR(parameter);
phalcon_add_function(parameter, wildcard, z_one);
} else {
if (Z_TYPE_P(wildcard) == IS_STRING) {
PHALCON_CPY_WRT(parameter, wildcard);
} else {
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind parameter");
return;
}
}
if (Z_TYPE_P(data_types) == IS_ARRAY) {
if (likely(phalcon_array_isset(data_types, wildcard))) {
/**
* The bind type is double so we try to get the double value
*/
PHALCON_OBS_NVAR(type);
phalcon_array_fetch(&type, data_types, wildcard, PH_NOISY);
if (phalcon_compare_strict_long(type, 32 TSRMLS_CC)) {
PHALCON_INIT_NVAR(cast_value);
phalcon_cast(cast_value, value, IS_DOUBLE);
PHALCON_INIT_NVAR(type);
ZVAL_LONG(type, 1024);
} else {
PHALCON_CPY_WRT(cast_value, value);
}
/**
* 1024 is ignore the bind type
*/
Z_SET_ISREF_P(cast_value);
if (phalcon_compare_strict_long(type, 1024 TSRMLS_CC)) {
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, cast_value);
} else {
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, cast_value, type);
}
Z_UNSET_ISREF_P(cast_value);
} else {
PHALCON_INIT_NVAR(type);
if (Z_TYPE_P(value) == IS_LONG) {
ZVAL_LONG(type, 1 /* BIND_PARAM_INT */);
}
else {
ZVAL_LONG(type, 2 /* BIND_PARAM_STR */);
}
Z_SET_ISREF_P(value);
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, value, type);
Z_UNSET_ISREF_P(value);
/*
PHALCON_THROW_EXCEPTION_STR(phalcon_db_exception_ce, "Invalid bind type parameter");
return;
*/
}
} else {
Z_SET_ISREF_P(value);
PHALCON_CALL_METHOD(NULL, statement, "bindvalue", parameter, value);
Z_UNSET_ISREF_P(value);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
profiler = phalcon_fetch_nproperty_this(this_ptr, SL("_profiler"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(profiler) == IS_OBJECT) {
sql_statement = phalcon_fetch_nproperty_this(this_ptr, SL("_sqlStatement"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(NULL, profiler, "startprofile", sql_statement, placeholders, data_types);
PHALCON_CALL_METHOD(NULL, statement, "execute");
PHALCON_CALL_METHOD(NULL, profiler, "stopprofile");
} else {
PHALCON_CALL_METHOD(NULL, statement, "execute");
}
RETURN_CTOR(statement);
}
/**
* Prepare an HTML string of information about a single variable.
*/
PHP_METHOD(Phalcon_Debug_Dump, output){
zval *variable, *name = NULL, *tab = NULL, *space, *tmp = NULL, *new_tab = NULL;
zval *output = NULL, *str = NULL, *type = NULL, *style = NULL, *count = NULL, *key = NULL, *value = NULL, *replace_pairs = NULL;
zval *class_name = NULL, *objects, *detailed = NULL, *properties = NULL, *methods = NULL, *method = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 2, &variable, &name, &tab);
if (!name) {
name = PHALCON_GLOBAL(z_null);
} else if (!PHALCON_IS_EMPTY(name)) {
PHALCON_CONCAT_SVS(return_value, "var ", name, " ");
}
if (!tab) {
tab = PHALCON_GLOBAL(z_one);
}
PHALCON_INIT_VAR(space);
ZVAL_STRING(space, " ", 1);
if (Z_TYPE_P(variable) == IS_ARRAY) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "<b style =':style'>Array</b> (<span style =':style'>:count</span>) (\n", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "arr", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(count);
ZVAL_LONG(count, phalcon_fast_count_int(variable TSRMLS_CC));
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":count"), count, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
phalcon_concat_self(&return_value, output TSRMLS_CC);
phalcon_is_iterable(variable, &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(value);
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, tab);
phalcon_concat_self(&return_value, tmp TSRMLS_CC);
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "[<span style=':style'>:key</span>] => ", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "arr", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":key"), key, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
phalcon_concat_self(&return_value, output TSRMLS_CC);
if (PHALCON_IS_LONG(tab, 1) && !PHALCON_IS_EMPTY(name) && !phalcon_is_numeric(key) && PHALCON_IS_IDENTICAL(name, key)) {
zend_hash_move_forward_ex(ah0, &hp0);
continue;
} else {
PHALCON_INIT_NVAR(new_tab);
ZVAL_LONG(new_tab, Z_LVAL_P(tab) + 1);
PHALCON_CALL_SELF(&tmp, "output", value, PHALCON_GLOBAL(z_null), new_tab);
PHALCON_SCONCAT_VS(return_value, tmp, "\n");
}
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_NVAR(new_tab);
ZVAL_LONG(new_tab, Z_LVAL_P(tab) - 1);
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, tab);
PHALCON_SCONCAT(return_value, tmp);
} else if (Z_TYPE_P(variable) == IS_OBJECT) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "<b style=':style'>Object</b> :class", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "obj", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(class_name);
phalcon_get_class(class_name, variable, 0 TSRMLS_CC);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":class"), class_name, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
PHALCON_INIT_NVAR(class_name);
phalcon_get_parent_class(class_name, variable, 0 TSRMLS_CC);
if (zend_is_true(class_name)) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, " <b style=':style'>extends</b> :parent", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "obj", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":parent"), class_name, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
}
PHALCON_SCONCAT_STR(return_value, " (\n");
objects = phalcon_fetch_nproperty_this(this_ptr, SL("_objects"), PH_NOISY TSRMLS_CC);
if (phalcon_fast_in_array(variable, objects TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, tab);
PHALCON_SCONCAT_VS(return_value, tmp, "[already listed]\n");
PHALCON_INIT_NVAR(new_tab);
ZVAL_LONG(new_tab, Z_LVAL_P(tab) - 1);
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, tab);
PHALCON_SCONCAT_VS(return_value, tmp, ")");
RETURN_MM();
}
phalcon_update_property_array_append(this_ptr, SL("_objects"), variable TSRMLS_CC);
detailed = phalcon_fetch_nproperty_this(this_ptr, SL("_detailed"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_NVAR(properties);
phalcon_get_object_vars(properties, variable, !zend_is_true(detailed) TSRMLS_CC);
phalcon_is_iterable(properties, &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(value);
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, tab);
PHALCON_SCONCAT(return_value, tmp);
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "-><span style=':style'>:key</span> (<span style=':style'>:type</span>) = ", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "obj", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":key"), key, PH_COPY);
if (PHALCON_PROPERTY_IS_PUBLIC_ZVAL(variable, key)) {
phalcon_array_update_string_string(&replace_pairs, SL(":type"), SL("public"), PH_COPY);
} else if (PHALCON_PROPERTY_IS_PRIVATE_ZVAL(variable, key)) {
phalcon_array_update_string_string(&replace_pairs, SL(":type"), SL("private"), PH_COPY);
} else if (PHALCON_PROPERTY_IS_PROTECTED_ZVAL(variable, key)) {
phalcon_array_update_string_string(&replace_pairs, SL(":type"), SL("protected"), PH_COPY);
}
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
PHALCON_INIT_NVAR(new_tab);
ZVAL_LONG(new_tab, Z_LVAL_P(tab) + 1);
PHALCON_CALL_SELF(&tmp, "output", value, PHALCON_GLOBAL(z_null), new_tab);
PHALCON_SCONCAT_VS(return_value, tmp, ")\n");
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_NVAR(methods);
phalcon_get_class_methods(methods, variable, !zend_is_true(detailed) TSRMLS_CC);
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, tab);
PHALCON_SCONCAT(return_value, tmp);
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, ":class <b style=':style'>methods</b>: (<span style=':style'>:count</span>) (\n", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "obj", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(class_name);
phalcon_get_class(class_name, variable, 0 TSRMLS_CC);
PHALCON_INIT_NVAR(count);
ZVAL_LONG(count, phalcon_fast_count_int(methods TSRMLS_CC));
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":class"), class_name, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":count"), count, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
phalcon_is_iterable(methods, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(method);
PHALCON_INIT_NVAR(new_tab);
ZVAL_LONG(new_tab, Z_LVAL_P(tab) + 1);
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, new_tab);
PHALCON_SCONCAT(return_value, tmp);
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "-><span style=':style'>:method</span>();\n", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "obj", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":method"), method, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, tab);
PHALCON_SCONCAT_VS(return_value, tmp, "\n");
zend_hash_move_forward_ex(ah0, &hp0);
}
PHALCON_INIT_NVAR(new_tab);
ZVAL_LONG(new_tab, Z_LVAL_P(tab) - 1);
PHALCON_CALL_FUNCTION(&tmp, "str_repeat", space, tab);
PHALCON_SCONCAT_VS(return_value, tmp, ")");
} else if (Z_TYPE_P(variable) == IS_LONG) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "<b style=':style'>Integer</b> (<span style=':style'>:var</span>)", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "int", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":var"), variable, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
} else if (Z_TYPE_P(variable) == IS_DOUBLE) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "<b style=':style'>Float</b> (<span style=':style'>:var</span>)", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "float", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":var"), variable, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
} else if (phalcon_is_numeric_ex(variable)) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "<b style=':style'>Numeric string</b> (<span style=':style'>:length</span>) \"<span style=':style'>:var</span>\"", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "num", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string_long(&replace_pairs, SL(":length"), Z_STRLEN_P(variable), PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":var"), variable, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
} else if (Z_TYPE_P(variable) == IS_STRING) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "<b style=':style'>String</b> (<span style=':style'>:length</span>) \"<span style=':style'>:var</span>\"", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "str", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string_long(&replace_pairs, SL(":length"), Z_STRLEN_P(variable), PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":var"), variable, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
} else if (Z_TYPE_P(variable) == IS_BOOL) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "<b style=':style'>Boolean</b> (<span style=':style'>:var</span>)", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "bool", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
if (zend_is_true(variable)) {
phalcon_array_update_string_string(&replace_pairs, SL(":var"), SL("TRUE") , PH_COPY);
} else {
phalcon_array_update_string_string(&replace_pairs, SL(":var"), SL("FALSE") , PH_COPY);
}
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
} else if (Z_TYPE_P(variable) == IS_NULL) {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "<b style=':style'>NULL</b>", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "null", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
} else {
PHALCON_INIT_NVAR(str);
ZVAL_STRING(str, "(<span style=':style'>:var</span>)", 1);
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "other", 1);
PHALCON_CALL_SELF(&style, "getstyle", type);
PHALCON_INIT_NVAR(replace_pairs);
array_init(replace_pairs);
phalcon_array_update_string(&replace_pairs, SL(":style"), style, PH_COPY);
phalcon_array_update_string(&replace_pairs, SL(":var"), variable, PH_COPY);
PHALCON_INIT_NVAR(output);
phalcon_strtr_array(output, str, replace_pairs TSRMLS_CC);
PHALCON_SCONCAT(return_value, output);
}
RETURN_MM();
}
PHP_METHOD(Phalcon_Http_Client_Adapter_Stream, sendInternal){
zval *stream, *http, *option = NULL, *header, *handler, *base_uri, *url = NULL, *method, *useragent, *timeout;
zval *fp = NULL, *meta = NULL, *wrapper_data, *bodystr = NULL, *response;
PHALCON_MM_GROW();
stream = phalcon_fetch_nproperty_this(this_ptr, SL("_stream"), PH_NOISY TSRMLS_CC);
header = phalcon_fetch_nproperty_this(this_ptr, SL("_header"), PH_NOISY TSRMLS_CC);
method = phalcon_fetch_nproperty_this(this_ptr, SL("_method"), PH_NOISY TSRMLS_CC);
base_uri = phalcon_fetch_nproperty_this(this_ptr, SL("_base_uri"), PH_NOISY TSRMLS_CC);
useragent = phalcon_fetch_nproperty_this(this_ptr, SL("_useragent"), PH_NOISY TSRMLS_CC);
timeout = phalcon_fetch_nproperty_this(this_ptr, SL("_timeout"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(http);
ZVAL_STRING(http, "http", 1);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "method", 1);
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, method);
if (PHALCON_IS_NOT_EMPTY(useragent)) {
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "User-Agent", 1);
PHALCON_CALL_METHOD(NULL, header, "set", option, useragent);
}
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, useragent);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "timeout", 1);
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, timeout);
PHALCON_CALL_METHOD(&url, base_uri, "build");
PHALCON_CALL_SELF(NULL, "buildBody");
PHALCON_INIT_VAR(handler);
array_init_size(handler, 2);
phalcon_array_append(&handler, this_ptr, PH_SEPARATE);
add_next_index_stringl(handler, SL("errorHandler"), 1);
PHALCON_CALL_FUNCTION(NULL, "set_error_handler", handler);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "r", 1);
PHALCON_CALL_FUNCTION(&fp, "fopen", url, option, PHALCON_GLOBAL(z_false), stream);
PHALCON_CALL_FUNCTION(NULL, "restore_error_handler");
PHALCON_CALL_FUNCTION(&meta, "stream_get_meta_data", fp);
PHALCON_CALL_FUNCTION(&bodystr, "stream_get_contents", fp);
PHALCON_CALL_FUNCTION(NULL, "fclose", fp);
PHALCON_INIT_VAR(response);
object_init_ex(response, phalcon_http_client_response_ce);
PHALCON_CALL_METHOD(NULL, response, "__construct");
if (phalcon_array_isset_string_fetch(&wrapper_data, meta, SS("wrapper_data"))) {
PHALCON_CALL_METHOD(NULL, response, "setHeader", wrapper_data);
}
PHALCON_CALL_METHOD(NULL, response, "setbody", bodystr);
RETURN_CTOR(response);
}
PHP_METHOD(Phalcon_Http_Client_Adapter_Stream, buildBody){
zval *stream, *header, *data, *file, *username, *password, *authtype, *digest, *method, *entity_body;
zval *key = NULL, *value = NULL, *realm, *qop, *nonce, *nc, *cnonce, *qoc, *ha1 = NULL, *path = NULL, *md5_entity_body = NULL, *ha2 = NULL;
zval *http, *option = NULL, *body, *headers = NULL, *uniqid = NULL, *boundary;
zval *path_parts = NULL, *filename, *basename, *filedata = NULL, *tmp = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
stream = phalcon_fetch_nproperty_this(this_ptr, SL("_stream"), PH_NOISY TSRMLS_CC);
header = phalcon_fetch_nproperty_this(this_ptr, SL("_header"), PH_NOISY TSRMLS_CC);
data = phalcon_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY TSRMLS_CC);
file = phalcon_fetch_nproperty_this(this_ptr, SL("_file"), PH_NOISY TSRMLS_CC);
username = phalcon_fetch_nproperty_this(this_ptr, SL("_username"), PH_NOISY TSRMLS_CC);
password = phalcon_fetch_nproperty_this(this_ptr, SL("_password"), PH_NOISY TSRMLS_CC);
authtype = phalcon_fetch_nproperty_this(this_ptr, SL("_authtype"), PH_NOISY TSRMLS_CC);
digest = phalcon_fetch_nproperty_this(this_ptr, SL("_digest"), PH_NOISY TSRMLS_CC);
method = phalcon_fetch_nproperty_this(this_ptr, SL("_method"), PH_NOISY TSRMLS_CC);
entity_body = phalcon_fetch_nproperty_this(this_ptr, SL("_entity_body"), PH_NOISY TSRMLS_CC);
if (PHALCON_IS_NOT_EMPTY(username)) {
if (PHALCON_IS_STRING(authtype, "basic")) {
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Authorization", 1);
PHALCON_INIT_NVAR(value);
PHALCON_CONCAT_SVSV(value, "Basic ", username, ":", password);
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
} else if (PHALCON_IS_STRING(authtype, "digest") && PHALCON_IS_NOT_EMPTY(digest)) {
if (phalcon_array_isset_string_fetch(&realm, digest, SS("realm"))) {
PHALCON_INIT_VAR(realm);
ZVAL_NULL(realm);
}
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSVSV(tmp, username, ":", realm, ":", password);
PHALCON_CALL_FUNCTION(&ha1, "md5", tmp);
if (!phalcon_array_isset_string_fetch(&qop, digest, SS("qop"))) {
PHALCON_INIT_VAR(qop);
ZVAL_NULL(qop);
}
if (PHALCON_IS_EMPTY(qop) || phalcon_memnstr_str(qop, SL("auth"))) {
PHALCON_CALL_SELF(&path, "getpath");
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSV(tmp, method, ":", path);
PHALCON_CALL_FUNCTION(&ha2, "md5", tmp);
} else if (phalcon_memnstr_str(qop, SL("auth-int"))) {
PHALCON_CALL_SELF(&path, "getpath");
PHALCON_CALL_FUNCTION(&md5_entity_body, "md5", entity_body);
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSVSV(tmp, method, ":", path, ":", md5_entity_body);
PHALCON_CALL_FUNCTION(&ha2, "md5", tmp);
}
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Authorization", 1);
if (phalcon_array_isset_string_fetch(&nonce, digest, SS("nonce"))) {
PHALCON_INIT_VAR(nonce);
ZVAL_NULL(nonce);
}
if (PHALCON_IS_EMPTY(qop)) {
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSVSV(tmp, ha1, ":", nonce, ":", ha2);
PHALCON_CALL_FUNCTION(&value, "md5", tmp);
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_SV(tmp, "Digest ", value);
PHALCON_CALL_METHOD(NULL, header, "set", key, tmp);
} else {
if (phalcon_array_isset_string_fetch(&nc, digest, SS("nc"))) {
PHALCON_INIT_VAR(nc);
ZVAL_NULL(nc);
}
if (phalcon_array_isset_string_fetch(&cnonce, digest, SS("cnonce"))) {
PHALCON_INIT_VAR(cnonce);
ZVAL_NULL(cnonce);
}
if (phalcon_array_isset_string_fetch(&qoc, digest, SS("qoc"))) {
PHALCON_INIT_VAR(qoc);
ZVAL_NULL(qoc);
}
if (phalcon_array_isset_string_fetch(&qoc, digest, SS("qoc"))) {
PHALCON_INIT_VAR(qoc);
ZVAL_NULL(qoc);
}
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSVSVS(tmp, ha1, ":", nonce, ":", nc, ":");
PHALCON_SCONCAT_VSVSV(tmp, cnonce, ":", qoc, ":", ha2);
PHALCON_CALL_FUNCTION(&value, "md5", tmp);
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_SV(tmp, "Digest ", value);
PHALCON_CALL_METHOD(NULL, header, "set", key, tmp);
}
}
}
PHALCON_INIT_VAR(http);
ZVAL_STRING(http, "http", 1);
PHALCON_CALL_FUNCTION(&uniqid, "uniqid");
PHALCON_INIT_VAR(boundary);
PHALCON_CONCAT_SV(boundary, "--------------", uniqid);
PHALCON_INIT_VAR(body);
if (PHALCON_IS_NOT_EMPTY(data) && Z_TYPE_P(data) == IS_STRING){
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Type", 1);
PHALCON_INIT_NVAR(value);
ZVAL_STRING(value, "application/x-www-form-urlencoded", 1);
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_INIT_NVAR(option);
ZVAL_LONG(option, PHALCON_HTTP_CLIENT_HEADER_BUILD_FIELDS);
PHALCON_CALL_METHOD(&headers, header, "build", option);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "header", 1);
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, headers);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "content", 1);
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, data);
RETURN_MM();
}
if (Z_TYPE_P(data) == IS_ARRAY) {
phalcon_is_iterable(data, &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(value);
PHALCON_SCONCAT_SVS(body, "--", boundary, "\r\n");
PHALCON_SCONCAT_SVSVS(body, "Content-Disposition: form-data; name=\"", key, "\"\r\n\r\n", value, "\r\n");
zend_hash_move_forward_ex(ah0, &hp0);
}
}
if (PHALCON_IS_NOT_EMPTY(file)) {
PHALCON_CALL_FUNCTION(&path_parts, "pathinfo", file);
if (phalcon_array_isset_string_fetch(&filename, path_parts, SS("filename")) && phalcon_array_isset_string_fetch(&basename, path_parts, SS("basename"))) {
PHALCON_CALL_FUNCTION(&filedata, "file_get_contents", file);
PHALCON_SCONCAT_SVS(body, "--", boundary, "\r\n");
PHALCON_SCONCAT_SVSVS(body, "Content-Disposition: form-data; name=\"", filename, "\"; filename=\"", basename, "\"\r\n");
PHALCON_SCONCAT_SVS(body, "Content-Type: application/octet-stream\r\n\r\n", filedata, "\r\n");
}
}
if (!PHALCON_IS_EMPTY(body)) {
PHALCON_SCONCAT_SVS(body, "--", boundary, "--\r\n");
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Type", 1);
PHALCON_INIT_NVAR(value);
PHALCON_CONCAT_SV(value, "multipart/form-data; boundary=", boundary);
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Length", 1);
PHALCON_INIT_NVAR(value);
ZVAL_LONG(value, Z_STRLEN_P(body));
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_INIT_NVAR(option);
ZVAL_LONG(option, PHALCON_HTTP_CLIENT_HEADER_BUILD_FIELDS);
PHALCON_CALL_METHOD(&headers, header, "build", option);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "header", 1);
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, headers);
PHALCON_INIT_NVAR(option);
ZVAL_STRING(option, "content", 1);
PHALCON_CALL_FUNCTION(NULL, "stream_context_set_option", stream, http, option, body);
}
PHALCON_MM_RESTORE();
}
/**
* Decrypts an encrypted text
*
*<code>
* echo $crypt->decrypt($encrypted, "decrypt password");
*</code>
*
* @param string $text
* @param string $key
* @return string
*/
PHP_METHOD(Phalcon_Crypt, decrypt){
zval *text, *key = NULL, *decrypt_key = NULL, *cipher, *mode, *iv_size = NULL;
zval *key_size, *text_size, *iv, *text_to_decipher, *decrypted = NULL;
zval *padding_type, *block_size = NULL;
zval *handler, *arguments = NULL, *value = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &text, &key);
if (phalcon_function_exists_ex(SS("mcrypt_get_iv_size") TSRMLS_CC) == FAILURE) {
PHALCON_THROW_EXCEPTION_STR(phalcon_crypt_exception_ce, "mcrypt extension is required");
return;
}
PHALCON_OBS_VAR(handler);
phalcon_read_property_this(&handler, this_ptr, SL("_beforeDecrypt"), PH_NOISY TSRMLS_CC);
if (phalcon_is_callable(handler TSRMLS_CC)) {
PHALCON_SEPARATE_PARAM(text);
PHALCON_INIT_NVAR(arguments);
array_init_size(arguments, 1);
phalcon_array_append(&arguments, text, 0);
PHALCON_INIT_NVAR(value);
PHALCON_CALL_USER_FUNC_ARRAY(value, handler, arguments);
PHALCON_CPY_WRT(text, value);
}
if (!key || Z_TYPE_P(key) == IS_NULL) {
decrypt_key = phalcon_fetch_nproperty_this(this_ptr, SL("_key"), PH_NOISY TSRMLS_CC);
} else {
decrypt_key = key;
}
if (PHALCON_IS_EMPTY(decrypt_key)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_crypt_exception_ce, "Decryption key cannot be empty");
return;
}
cipher = phalcon_fetch_nproperty_this(this_ptr, SL("_cipher"), PH_NOISY TSRMLS_CC);
mode = phalcon_fetch_nproperty_this(this_ptr, SL("_mode"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_FUNCTION(&iv_size, "mcrypt_get_iv_size", cipher, mode);
if (unlikely(Z_TYPE_P(iv_size) != IS_LONG)) {
convert_to_long(iv_size);
}
PHALCON_INIT_VAR(key_size);
phalcon_fast_strlen(key_size, decrypt_key);
if (PHALCON_GT(key_size, iv_size)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_crypt_exception_ce, "Size of key is too large for this algorithm");
return;
}
PHALCON_INIT_VAR(text_size);
phalcon_fast_strlen(text_size, text);
if (PHALCON_GT(key_size, text_size)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_crypt_exception_ce, "Size of IV is larger than text to decrypt");
return;
}
PHALCON_INIT_VAR(iv);
phalcon_substr(iv, text, 0, Z_LVAL_P(iv_size));
PHALCON_INIT_VAR(text_to_decipher);
phalcon_substr(text_to_decipher, text, Z_LVAL_P(iv_size), 0);
PHALCON_CALL_FUNCTION(&decrypted, "mcrypt_decrypt", cipher, decrypt_key, text_to_decipher, mode, iv);
if (unlikely(Z_TYPE_P(decrypted) != IS_STRING)) {
convert_to_string(decrypted);
}
PHALCON_CALL_FUNCTION(&block_size, "mcrypt_get_block_size", cipher, mode);
if (unlikely(Z_TYPE_P(block_size) != IS_LONG)) {
convert_to_long(block_size);
}
padding_type = phalcon_fetch_nproperty_this(this_ptr, SL("_padding"), PH_NOISY TSRMLS_CC);
assert(Z_TYPE_P(padding_type) == IS_LONG);
assert(Z_TYPE_P(block_size) == IS_LONG);
assert(Z_TYPE_P(mode) == IS_STRING);
assert(Z_TYPE_P(decrypted) == IS_STRING);
phalcon_crypt_unpad_text(return_value, decrypted, mode, Z_LVAL_P(block_size), Z_LVAL_P(padding_type) TSRMLS_CC);
PHALCON_OBS_NVAR(handler);
phalcon_read_property_this(&handler, this_ptr, SL("_afterDecrypt"), PH_NOISY TSRMLS_CC);
if (phalcon_is_callable(handler TSRMLS_CC)) {
PHALCON_INIT_NVAR(arguments);
array_init_size(arguments, 1);
phalcon_array_append(&arguments, return_value, 0);
PHALCON_INIT_NVAR(value);
PHALCON_CALL_USER_FUNC_ARRAY(value, handler, arguments);
RETURN_CTOR(value);
}
RETURN_MM();
}
/**
* Encrypts a text
*
*<code>
* $encrypted = $crypt->encrypt("Ultra-secret text", "encrypt password");
*</code>
*
* @param string $text
* @param string $key
* @return string
*/
PHP_METHOD(Phalcon_Crypt, encrypt){
zval *source, *text, *key = NULL, *encrypt_key = NULL, *cipher, *mode, *padding_type, *iv_size = NULL;
zval *rand, *iv = NULL, *encrypt = NULL, *block_size = NULL, *padded;
zval *handler, *arguments = NULL, *value = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &source, &key);
PHALCON_OBS_VAR(handler);
phalcon_read_property_this(&handler, this_ptr, SL("_beforeEncrypt"), PH_NOISY TSRMLS_CC);
if (phalcon_is_callable(handler TSRMLS_CC)) {
PHALCON_SEPARATE_PARAM(source);
PHALCON_INIT_NVAR(arguments);
array_init_size(arguments, 1);
phalcon_array_append(&arguments, source, 0);
PHALCON_INIT_NVAR(value);
PHALCON_CALL_USER_FUNC_ARRAY(value, handler, arguments);
PHALCON_CPY_WRT(source, value);
}
/* Do not use make_printable_zval() here: we need the conversion with type juggling */
if (Z_TYPE_P(source) != IS_STRING) {
PHALCON_INIT_VAR(text);
phalcon_cast(text, source, IS_STRING);
}
else {
text = source;
}
if (phalcon_function_exists_ex(SS("mcrypt_get_iv_size") TSRMLS_CC) == FAILURE) {
PHALCON_THROW_EXCEPTION_STR(phalcon_crypt_exception_ce, "mcrypt extension is required");
return;
}
if (!key || Z_TYPE_P(key) == IS_NULL) {
encrypt_key = phalcon_fetch_nproperty_this(this_ptr, SL("_key"), PH_NOISY TSRMLS_CC);
} else {
PHALCON_CPY_WRT_CTOR(encrypt_key, key);
if (Z_TYPE_P(encrypt_key) != IS_STRING) {
convert_to_string(encrypt_key);
}
}
if (PHALCON_IS_EMPTY(encrypt_key)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_crypt_exception_ce, "Encryption key cannot be empty");
return;
}
cipher = phalcon_fetch_nproperty_this(this_ptr, SL("_cipher"), PH_NOISY TSRMLS_CC);
mode = phalcon_fetch_nproperty_this(this_ptr, SL("_mode"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_FUNCTION(&iv_size, "mcrypt_get_iv_size", cipher, mode);
if (unlikely(Z_TYPE_P(iv_size) != IS_LONG)) {
convert_to_long(iv_size);
}
if (Z_STRLEN_P(encrypt_key) > Z_LVAL_P(iv_size)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_crypt_exception_ce, "Size of key is too large for this algorithm");
return;
}
PHALCON_INIT_VAR(rand);
ZVAL_LONG(rand, 2);
PHALCON_CALL_FUNCTION(&iv, "mcrypt_create_iv", iv_size, rand);
if (unlikely(Z_TYPE_P(iv) != IS_STRING)) {
convert_to_string(iv);
}
PHALCON_CALL_FUNCTION(&block_size, "mcrypt_get_block_size", cipher, mode);
if (unlikely(Z_TYPE_P(block_size) != IS_LONG)) {
convert_to_long(block_size);
}
padding_type = phalcon_fetch_nproperty_this(this_ptr, SL("_padding"), PH_NOISY TSRMLS_CC);
assert(Z_TYPE_P(padding_type) == IS_LONG);
assert(Z_TYPE_P(block_size) == IS_LONG);
assert(Z_TYPE_P(mode) == IS_STRING);
assert(Z_TYPE_P(text) == IS_STRING);
PHALCON_INIT_VAR(padded);
phalcon_crypt_pad_text(padded, text, mode, Z_LVAL_P(block_size), Z_LVAL_P(padding_type) TSRMLS_CC);
assert(Z_TYPE_P(padded) == IS_STRING);
PHALCON_CALL_FUNCTION(&encrypt, "mcrypt_encrypt", cipher, encrypt_key, padded, mode, iv);
PHALCON_CONCAT_VV(return_value, iv, encrypt);
PHALCON_OBS_NVAR(handler);
phalcon_read_property_this(&handler, this_ptr, SL("_afterEncrypt"), PH_NOISY TSRMLS_CC);
if (phalcon_is_callable(handler TSRMLS_CC)) {
PHALCON_INIT_NVAR(arguments);
array_init_size(arguments, 1);
phalcon_array_append(&arguments, return_value, 0);
PHALCON_INIT_NVAR(value);
PHALCON_CALL_USER_FUNC_ARRAY(value, handler, arguments);
RETURN_CTOR(value);
}
RETURN_MM();
}
PHP_METHOD(Phalcon_Http_Client_Header, build){
zval *flags = NULL, *messages, *status_code, *message = NULL, *version, *lines, *line = NULL;
zval *fields, *filed = NULL, *value = NULL, *join_filed;
HashTable *ah0;
HashPosition hp0;
zval **hd;
int f = 0;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &flags);
if (flags) {
f = phalcon_get_intval(flags);
}
PHALCON_INIT_VAR(lines);
array_init(lines);
PHALCON_OBS_VAR(messages);
phalcon_read_static_property_ce(&messages, phalcon_http_client_header_ce, SL("_messages") TSRMLS_CC);
status_code = phalcon_fetch_nproperty_this(this_ptr, SL("_status_code"), PH_NOISY TSRMLS_CC);
if ((f & PHALCON_HTTP_CLIENT_HEADER_BUILD_STATUS) && phalcon_array_isset_fetch(&message, messages, status_code)) {
version = phalcon_fetch_nproperty_this(this_ptr, SL("_version "), PH_NOISY TSRMLS_CC);
PHALCON_INIT_NVAR(line);
PHALCON_CONCAT_SVS(line, "HTTP/", version, " ");
PHALCON_SCONCAT_VSV(line, status_code, " ", message);
phalcon_merge_append(lines, line);
}
fields = phalcon_fetch_nproperty_this(this_ptr, SL("_fields"), PH_NOISY TSRMLS_CC);
phalcon_is_iterable(fields, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(filed, ah0, hp0);
PHALCON_GET_HVALUE(value);
PHALCON_INIT_NVAR(line);
PHALCON_CONCAT_VSV(line, filed, ": ", value);
phalcon_merge_append(lines, line);
zend_hash_move_forward_ex(ah0, &hp0);
}
if (f & PHALCON_HTTP_CLIENT_HEADER_BUILD_FIELDS) {
PHALCON_INIT_VAR(join_filed);
phalcon_fast_join_str(join_filed, SL("\r\n"), lines TSRMLS_CC);
RETURN_CCTOR(join_filed);
}
RETURN_CCTOR(lines);
}
/**
* Stores cached content into the Memcached backend and stops the frontend
*
* @param int|string $keyName
* @param string $content
* @param long $lifetime
* @param boolean $stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Memcache, save){
zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL;
zval *cached_content = NULL, *prepared_content = NULL, *ttl = NULL, *flags, *success = NULL;
zval *keys = NULL, *is_buffering = NULL;
zval *last_key, *frontend, *memcache, *options, *special_key;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 4, &key_name, &content, &lifetime, &stop_buffer);
if (!key_name || Z_TYPE_P(key_name) == IS_NULL) {
last_key = phalcon_fetch_nproperty_this(this_ptr, SL("_lastKey"), PH_NOISY TSRMLS_CC);
} else {
zval *prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(last_key);
PHALCON_CONCAT_VV(last_key, prefix, key_name);
}
if (!zend_is_true(last_key)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first");
return;
}
frontend = phalcon_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY TSRMLS_CC);
/**
* Check if a connection is created or make a new one
*/
memcache = phalcon_fetch_nproperty_this(this_ptr, SL("_memcache"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(memcache) != IS_OBJECT) {
memcache = NULL;
PHALCON_CALL_METHOD(&memcache, this_ptr, "_connect");
}
if (!content || Z_TYPE_P(content) == IS_NULL) {
PHALCON_CALL_METHOD(&cached_content, frontend, "getcontent");
} else {
cached_content = content;
}
/**
* Prepare the content in the frontend
*/
PHALCON_CALL_METHOD(&prepared_content, frontend, "beforestore", cached_content);
if (!lifetime || Z_TYPE_P(lifetime) == IS_NULL) {
zval *tmp = phalcon_fetch_nproperty_this(this_ptr, SL("_lastLifetime"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(tmp) == IS_NULL) {
PHALCON_CALL_METHOD(&ttl, frontend, "getlifetime");
}
else {
ttl = tmp;
}
} else {
ttl = lifetime;
}
PHALCON_INIT_VAR(flags);
ZVAL_LONG(flags, 0);
/**
* We store without flags
*/
if (phalcon_is_numeric(cached_content)) {
PHALCON_CALL_METHOD(&success, memcache, "set", last_key, cached_content, flags, ttl);
} else {
PHALCON_CALL_METHOD(&success, memcache, "set", last_key, prepared_content, flags, ttl);
}
if (!zend_is_true(success)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Failed to store data in memcached");
return;
}
options = phalcon_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY TSRMLS_CC);
if (unlikely(!phalcon_array_isset_string_fetch(&special_key, options, SS("statsKey")))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options");
return;
}
if (Z_TYPE_P(special_key) != IS_NULL) {
/* Update the stats key */
PHALCON_CALL_METHOD(&keys, memcache, "get", special_key);
if (Z_TYPE_P(keys) != IS_ARRAY) {
PHALCON_INIT_NVAR(keys);
array_init(keys);
}
if (!phalcon_array_isset(keys, last_key)) {
phalcon_array_update_zval(&keys, last_key, ttl, PH_COPY);
PHALCON_CALL_METHOD(NULL, memcache, "set", special_key, keys);
}
}
PHALCON_CALL_METHOD(&is_buffering, frontend, "isbuffering");
if (!stop_buffer || PHALCON_IS_TRUE(stop_buffer)) {
PHALCON_CALL_METHOD(NULL, frontend, "stop");
}
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 MongoDb collection based on the backend parameters
*
* @return MongoCollection
*/
PHP_METHOD(Phalcon_Cache_Backend_Mongo, _getCollection){
zval *mongo_collection, *mongo_database = NULL;
zend_class_entry *ce0;
PHALCON_MM_GROW();
mongo_collection = phalcon_fetch_nproperty_this(this_ptr, SL("_collection"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(mongo_collection) != IS_OBJECT) {
zval *options, *mongo;
zval *server = NULL, *database = NULL, *collection = NULL;
options = phalcon_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY TSRMLS_CC);
/**
* If mongo is defined a valid Mongo object must be passed
*/
if (phalcon_array_isset_string_fetch(&mongo, options, SS("mongo"))) {
if (Z_TYPE_P(mongo) != IS_OBJECT) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The 'mongo' parameter must be a valid Mongo instance");
return;
}
} else {
/**
* Server must be defined otherwise
*/
phalcon_array_isset_string_fetch(&server, options, SS("server"));
if (!server || Z_TYPE_P(server) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The backend requires a valid MongoDB connection string");
return;
}
ce0 = zend_fetch_class(SL("MongoClient"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_VAR(mongo);
object_init_ex(mongo, ce0);
assert(phalcon_has_constructor(mongo TSRMLS_CC));
PHALCON_CALL_METHOD(NULL, mongo, "__construct", server);
}
/**
* Check if the database name is a string
*/
phalcon_array_isset_string_fetch(&database, options, SS("db"));
if (!database || Z_TYPE_P(database) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The backend requires a valid MongoDB db");
return;
}
/**
* Retrieve the connection name
*/
phalcon_array_isset_string_fetch(&collection, options, SS("collection"));
if (!collection || Z_TYPE_P(collection) != IS_STRING) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The backend requires a valid MongoDB collection");
return;
}
/**
* Make the connection and get the collection
*/
PHALCON_CALL_METHOD(&mongo_database, mongo, "selectdb", database);
PHALCON_RETURN_CALL_METHOD(mongo_database, "selectcollection", collection);
}
else {
RETVAL_ZVAL(mongo_collection, 1, 0);
}
PHALCON_MM_RESTORE();
}
/**
* Stores cached content into the Mongo backend and stops the frontend
*
* @param int|string $keyName
* @param string $content
* @param long $lifetime
* @param boolean $stopBuffer
*/
PHP_METHOD(Phalcon_Cache_Backend_Mongo, save){
zval *key_name = NULL, *content = NULL, *lifetime = NULL, *stop_buffer = NULL;
zval *last_key, *frontend, *cached_content = NULL;
zval *prepared_content = NULL, *ttl = NULL, *collection = NULL, *timestamp;
zval *conditions, *document = NULL, *data, *is_buffering = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 4, &key_name, &content, &lifetime, &stop_buffer);
if (!key_name || Z_TYPE_P(key_name) == IS_NULL) {
last_key = phalcon_fetch_nproperty_this(this_ptr, SL("_lastKey"), PH_NOISY TSRMLS_CC);
} else {
zval *prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(last_key);
PHALCON_CONCAT_VV(last_key, prefix, key_name);
}
if (!zend_is_true(last_key)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first");
return;
}
frontend = phalcon_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY TSRMLS_CC);
if (!content || Z_TYPE_P(content) == IS_NULL) {
PHALCON_CALL_METHOD(&cached_content, frontend, "getcontent");
} else {
cached_content = content;
}
if (!phalcon_is_numeric(cached_content)) {
PHALCON_CALL_METHOD(&prepared_content, frontend, "beforestore", cached_content);
}
if (!lifetime || Z_TYPE_P(lifetime) == IS_NULL) {
zval *tmp = phalcon_fetch_nproperty_this(this_ptr, SL("_lastLifetime"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(tmp) == IS_NULL) {
PHALCON_CALL_METHOD(&ttl, frontend, "getlifetime");
}
else {
ttl = tmp;
}
} else {
ttl = lifetime;
}
PHALCON_CALL_METHOD(&collection, this_ptr, "_getcollection");
PHALCON_INIT_VAR(timestamp);
ZVAL_LONG(timestamp, (long) time(NULL) + phalcon_get_intval(ttl));
PHALCON_INIT_VAR(conditions);
array_init_size(conditions, 1);
phalcon_array_update_string(&conditions, SL("key"), last_key, PH_COPY);
PHALCON_CALL_METHOD(&document, collection, "findone", conditions);
if (Z_TYPE_P(document) == IS_ARRAY) {
phalcon_array_update_string(&document, SL("time"), timestamp, PH_COPY);
if (prepared_content) {
phalcon_array_update_string(&document, SL("data"), prepared_content, PH_COPY);
} else {
phalcon_array_update_string(&document, SL("data"), cached_content, PH_COPY);
}
PHALCON_CALL_METHOD(NULL, collection, "save", document);
} else {
PHALCON_INIT_VAR(data);
array_init_size(data, 3);
phalcon_array_update_string(&data, SL("key"), last_key, PH_COPY);
phalcon_array_update_string(&data, SL("time"), timestamp, PH_COPY);
if (prepared_content) {
phalcon_array_update_string(&data, SL("data"), prepared_content, PH_COPY);
} else {
phalcon_array_update_string(&data, SL("data"), cached_content, PH_COPY);
}
PHALCON_CALL_METHOD(NULL, collection, "save", data);
}
PHALCON_CALL_METHOD(&is_buffering, frontend, "isbuffering");
if (!stop_buffer || PHALCON_IS_TRUE(stop_buffer)) {
PHALCON_CALL_METHOD(NULL, frontend, "stop");
}
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();
}
PHP_METHOD(Phalcon_Http_Client_Adapter_Curl, sendInternal){
zval *uri = NULL, *url = NULL, *method, *useragent, *data, *type, *files, *timeout, *curl, *username, *password, *authtype;
zval *file = NULL, *body, *uniqid = NULL, *boundary, *key = NULL, *value = NULL;
zval *path_parts = NULL, *filename, *basename, *filedata = NULL;
zval *constant, *header, *headers = NULL;
zval *content = NULL, *errorno = NULL, *error = NULL, *headersize = NULL, *httpcode = NULL, *headerstr, *bodystr, *response, *tmp = NULL;
zend_class_entry *curlfile_ce;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
PHALCON_MM_GROW();
PHALCON_CALL_SELF(&uri, "geturi");
PHALCON_CALL_METHOD(&url, uri, "build");
method = phalcon_fetch_nproperty_this(this_ptr, SL("_method"), PH_NOISY TSRMLS_CC);
useragent = phalcon_fetch_nproperty_this(this_ptr, SL("_useragent"), PH_NOISY TSRMLS_CC);
data = phalcon_fetch_nproperty_this(this_ptr, SL("_data"), PH_NOISY TSRMLS_CC);
type = phalcon_fetch_nproperty_this(this_ptr, SL("_type"), PH_NOISY TSRMLS_CC);
files = phalcon_fetch_nproperty_this(this_ptr, SL("_files"), PH_NOISY TSRMLS_CC);
timeout = phalcon_fetch_nproperty_this(this_ptr, SL("_timeout"), PH_NOISY TSRMLS_CC);
curl = phalcon_fetch_nproperty_this(this_ptr, SL("_curl"), PH_NOISY TSRMLS_CC);
username = phalcon_fetch_nproperty_this(this_ptr, SL("_username"), PH_NOISY TSRMLS_CC);
password = phalcon_fetch_nproperty_this(this_ptr, SL("_password"), PH_NOISY TSRMLS_CC);
authtype = phalcon_fetch_nproperty_this(this_ptr, SL("_authtype"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(constant);
if (!zend_get_constant(SL("CURLOPT_URL"), constant TSRMLS_CC)) {
RETURN_MM_FALSE;
}
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, url);
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_CONNECTTIMEOUT"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, timeout);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_TIMEOUT"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, timeout);
}
PHALCON_INIT_NVAR(constant);
if (PHALCON_IS_NOT_EMPTY(method) && zend_get_constant(SL("CURLOPT_CUSTOMREQUEST"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, method);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERAGENT"), constant TSRMLS_CC) && PHALCON_IS_NOT_EMPTY(useragent)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, useragent);
}
header = phalcon_fetch_nproperty_this(this_ptr, SL("_header"), PH_NOISY TSRMLS_CC);
if (PHALCON_IS_NOT_EMPTY(username)) {
if (PHALCON_IS_STRING(authtype, "any")) {
PHALCON_INIT_NVAR(constant);
PHALCON_INIT_NVAR(tmp);
if (zend_get_constant(SL("CURLOPT_HTTPAUTH"), constant TSRMLS_CC) && zend_get_constant(SL("CURLAUTH_ANY"), tmp TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERPWD"), constant TSRMLS_CC)) {
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSV(tmp, username, ":", password);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
}
}
} else if (PHALCON_IS_STRING(authtype, "basic")) {
PHALCON_INIT_NVAR(constant);
PHALCON_INIT_NVAR(tmp);
if (zend_get_constant(SL("CURLOPT_HTTPAUTH"), constant TSRMLS_CC) && zend_get_constant(SL("CURLAUTH_BASIC"), tmp TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERPWD"), constant TSRMLS_CC)) {
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSV(tmp, username, ":", password);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
}
}
} else if (PHALCON_IS_STRING(authtype, "digest")) {
PHALCON_INIT_NVAR(constant);
PHALCON_INIT_NVAR(tmp);
if (zend_get_constant(SL("CURLOPT_HTTPAUTH"), constant TSRMLS_CC) && zend_get_constant(SL("CURLAUTH_DIGEST"), tmp TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_USERPWD"), constant TSRMLS_CC)) {
PHALCON_INIT_NVAR(tmp);
PHALCON_CONCAT_VSV(tmp, username, ":", password);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, tmp);
}
}
}
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLOPT_SAFE_UPLOAD"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, PHALCON_GLOBAL(z_true));
}
if (Z_TYPE_P(data) == IS_STRING && PHALCON_IS_NOT_EMPTY(data)) {
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Type", 1);
if (PHALCON_IS_EMPTY(type)) {
PHALCON_INIT_NVAR(type);
ZVAL_STRING(type, "application/x-www-form-urlencoded", 1);
}
PHALCON_CALL_METHOD(NULL, header, "set", key, type);
PHALCON_INIT_NVAR(constant);
zend_get_constant(SL("CURLOPT_POSTFIELDS"), constant TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, data);
} else if (phalcon_class_exists(SL("CURLFile"), 0 TSRMLS_CC)) {
if (Z_TYPE_P(data) != IS_ARRAY) {
PHALCON_INIT_NVAR(data);
array_init(data);
}
if (Z_TYPE_P(files) == IS_ARRAY) {
phalcon_is_iterable(files, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(file);
if (PHALCON_IS_NOT_EMPTY(file)) {
curlfile_ce = zend_fetch_class(SL("CURLFile"), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
PHALCON_INIT_NVAR(tmp);
object_init_ex(tmp, curlfile_ce);
PHALCON_CALL_METHOD(NULL, tmp, "__construct", file);
phalcon_array_append(&data, tmp, PH_COPY);
}
zend_hash_move_forward_ex(ah0, &hp0);
}
}
PHALCON_INIT_NVAR(constant);
zend_get_constant(SL("CURLOPT_POSTFIELDS"), constant TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, data);
} else {
PHALCON_CALL_FUNCTION(&uniqid, "uniqid");
PHALCON_INIT_VAR(boundary);
PHALCON_CONCAT_SV(boundary, "--------------", uniqid);
PHALCON_INIT_VAR(body);
if (Z_TYPE_P(data) == IS_ARRAY) {
phalcon_is_iterable(data, &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(value);
PHALCON_SCONCAT_SVS(body, "--", boundary, "\r\n");
PHALCON_SCONCAT_SVSVS(body, "Content-Disposition: form-data; name=\"", key, "\"\r\n\r\n", value, "\r\n");
zend_hash_move_forward_ex(ah0, &hp0);
}
}
if (Z_TYPE_P(files) == IS_ARRAY) {
phalcon_is_iterable(files, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(file);
if (PHALCON_IS_NOT_EMPTY(file)) {
PHALCON_CALL_FUNCTION(&path_parts, "pathinfo", file);
if (phalcon_array_isset_string_fetch(&filename, path_parts, SS("filename")) && phalcon_array_isset_string_fetch(&basename, path_parts, SS("basename"))) {
PHALCON_CALL_FUNCTION(&filedata, "file_get_contents", file);
PHALCON_SCONCAT_SVS(body, "--", boundary, "\r\n");
PHALCON_SCONCAT_SVSVS(body, "Content-Disposition: form-data; name=\"", filename, "\"; filename=\"", basename, "\"\r\n");
PHALCON_SCONCAT_SVS(body, "Content-Type: application/octet-stream\r\n\r\n", filedata, "\r\n");
}
}
zend_hash_move_forward_ex(ah1, &hp1);
}
}
if (!PHALCON_IS_EMPTY(body)) {
PHALCON_SCONCAT_SVS(body, "--", boundary, "--\r\n");
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Type", 1);
PHALCON_INIT_NVAR(value);
PHALCON_CONCAT_SV(value, "multipart/form-data; boundary=", boundary);
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_INIT_NVAR(key);
ZVAL_STRING(key, "Content-Length", 1);
PHALCON_INIT_NVAR(value);
ZVAL_LONG(value, Z_STRLEN_P(body));
PHALCON_CALL_METHOD(NULL, header, "set", key, value);
PHALCON_CALL_METHOD(&headers, header, "build");
PHALCON_INIT_NVAR(constant);
zend_get_constant(SL("CURLOPT_POSTFIELDS"), constant TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, body);
PHALCON_INIT_NVAR(constant);
zend_get_constant(SL("CURLOPT_HTTPHEADER"), constant TSRMLS_CC);
PHALCON_CALL_FUNCTION(NULL, "curl_setopt", curl, constant, headers);
}
}
PHALCON_CALL_FUNCTION(&content, "curl_exec", curl);
PHALCON_CALL_FUNCTION(&errorno, "curl_errno", curl);
if (PHALCON_IS_TRUE(errorno)) {
PHALCON_CALL_FUNCTION(&error, "curl_error", curl);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_http_client_exception_ce, error);
return;
}
PHALCON_INIT_VAR(response);
object_init_ex(response, phalcon_http_client_response_ce);
PHALCON_CALL_METHOD(NULL, response, "__construct");
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLINFO_HTTP_CODE"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(&httpcode, "curl_getinfo", curl, constant);
PHALCON_CALL_METHOD(NULL, response, "setstatuscode", httpcode);
}
PHALCON_INIT_NVAR(constant);
if (zend_get_constant(SL("CURLINFO_HEADER_SIZE"), constant TSRMLS_CC)) {
PHALCON_CALL_FUNCTION(&headersize, "curl_getinfo", curl, constant);
PHALCON_INIT_VAR(headerstr);
phalcon_substr(headerstr, content, 0 , Z_LVAL_P(headersize));
PHALCON_INIT_VAR(bodystr);
phalcon_substr(bodystr, content, Z_LVAL_P(headersize) , Z_STRLEN_P(content));
PHALCON_CALL_METHOD(NULL, response, "setheader", headerstr);
PHALCON_CALL_METHOD(NULL, response, "setbody", bodystr);
}
RETURN_CTOR(response);
}
/**
* Sends SQL statements to the database server returning the success state.
* Use this method only when the SQL statement sent to the server is returning rows
*
*<code>
* //Querying data
* $resultset = $connection->query("SELECT * FROM robots WHERE type='mechanical'");
* $resultset = $connection->query("SELECT * FROM robots WHERE type=?", array("mechanical"));
*</code>
*
* @param string $sqlStatement
* @param array $bindParams
* @param array $bindTypes
* @return Phalcon\Db\ResultInterface
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, query){
zval *sql_statement, *bind_params = NULL, *bind_types = NULL, *profiler;
zval *events_manager, *event_name = NULL, *status = NULL, *pdo;
zval *statement = NULL, *new_statement = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 2, &sql_statement, &bind_params, &bind_types);
if (!bind_params) {
bind_params = PHALCON_GLOBAL(z_null);
}
if (!bind_types) {
bind_types = PHALCON_GLOBAL(z_null);
}
events_manager = phalcon_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY TSRMLS_CC);
/**
* Execute the beforeQuery event if a EventsManager is available
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "db:beforeQuery", 1);
phalcon_update_property_this(this_ptr, SL("_sqlStatement"), sql_statement TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_sqlVariables"), bind_params TSRMLS_CC);
phalcon_update_property_this(this_ptr, SL("_sqlBindTypes"), bind_types TSRMLS_CC);
PHALCON_CALL_METHOD(&status, events_manager, "fire", event_name, this_ptr, bind_params);
if (PHALCON_IS_FALSE(status)) {
RETURN_MM_FALSE;
}
}
if (Z_TYPE_P(bind_params) == IS_ARRAY) {
PHALCON_CALL_METHOD(&statement, this_ptr, "prepare", sql_statement);
if (Z_TYPE_P(statement) == IS_OBJECT) {
PHALCON_CALL_METHOD(&new_statement, this_ptr, "executeprepared", statement, bind_params, bind_types);
PHALCON_CPY_WRT(statement, new_statement);
}
} else {
pdo = phalcon_fetch_nproperty_this(this_ptr, SL("_pdo"), PH_NOISY TSRMLS_CC);
profiler = phalcon_fetch_nproperty_this(this_ptr, SL("_profiler"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(profiler) == IS_OBJECT) {
PHALCON_CALL_METHOD(NULL, profiler, "startprofile", sql_statement, bind_params, bind_types);
PHALCON_CALL_METHOD(&statement, pdo, "query", sql_statement);
PHALCON_CALL_METHOD(NULL, profiler, "stopprofile");
} else {
PHALCON_CALL_METHOD(&statement, pdo, "query", sql_statement);
}
}
/**
* Execute the afterQuery event if a EventsManager is available
*/
if (likely(Z_TYPE_P(statement) == IS_OBJECT)) {
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "db:afterQuery", 1);
PHALCON_CALL_METHOD(NULL, events_manager, "fire", event_name, this_ptr, bind_params);
}
object_init_ex(return_value, phalcon_db_result_pdo_ce);
PHALCON_CALL_METHOD(NULL, return_value, "__construct", this_ptr, statement, sql_statement, bind_params, bind_types);
RETURN_MM();
}
RETURN_CTOR(statement);
}
PHP_MALIAS(Phalcon_Session_Bag, __set, set, arginfo___set, ZEND_ACC_PUBLIC)
PHP_MALIAS(Phalcon_Session_Bag, __isset, has, arginfo___isset, ZEND_ACC_PUBLIC)
PHP_MALIAS(Phalcon_Session_Bag, __unset, remove, arginfo___unset, ZEND_ACC_PUBLIC)
PHP_MALIAS(Phalcon_Session_Bag, offsetGet, __get, arginfo_arrayaccess_offsetget, ZEND_ACC_PUBLIC)
PHP_MALIAS(Phalcon_Session_Bag, offsetSet, set, arginfo_arrayaccess_offsetset, ZEND_ACC_PUBLIC)
PHP_MALIAS(Phalcon_Session_Bag, offsetExists, has, arginfo_arrayaccess_offsetexists, ZEND_ACC_PUBLIC)
PHP_MALIAS(Phalcon_Session_Bag, offsetUnset, remove, arginfo_arrayaccess_offsetunset, ZEND_ACC_PUBLIC)
PHP_ME(Phalcon_Session_Bag, count, arginfo_countable_count, ZEND_ACC_PUBLIC)
PHP_FE_END
};
static int phalcon_session_bag_maybe_initialize(zval *this_ptr TSRMLS_DC)
{
zval *initialized;
initialized = phalcon_fetch_nproperty_this(this_ptr, SL("_initialized"), PH_NOISY TSRMLS_CC);
if (PHALCON_IS_FALSE(initialized)) {
return phalcon_call_method(NULL, this_ptr, "initialize", 0, NULL TSRMLS_CC);
}
return SUCCESS;
}
static zend_object_iterator* phalcon_session_bag_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC)
{
zval *iterator;
zval *data;
zval *params[1];
zend_object_iterator *ret;
if (FAILURE == phalcon_session_bag_maybe_initialize(object TSRMLS_CC)) {
/**
* Starts a transaction in the connection
*
* @param boolean $nesting
* @return boolean
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo, begin){
zval *nesting = NULL, *pdo, *transaction_level, *events_manager = NULL;
zval *event_name = NULL, *ntw_savepoint = NULL, *savepoint_name = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 1, &nesting);
if (!nesting) {
nesting = PHALCON_GLOBAL(z_true);
}
pdo = phalcon_fetch_nproperty_this(this_ptr, SL("_pdo"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(pdo) != IS_OBJECT) {
RETURN_MM_FALSE;
}
/**
* Increase the transaction nesting level
*/
phalcon_property_incr(this_ptr, SL("_transactionLevel") TSRMLS_CC);
/**
* Check the transaction nesting level
*/
transaction_level = phalcon_fetch_nproperty_this(this_ptr, SL("_transactionLevel"), PH_NOISY TSRMLS_CC);
if (PHALCON_IS_LONG(transaction_level, 1)) {
events_manager = phalcon_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY TSRMLS_CC);
/**
* Notify the events manager about the started transaction
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_VAR(event_name);
ZVAL_STRING(event_name, "db:beginTransaction", 1);
PHALCON_CALL_METHOD(NULL, events_manager, "fire", event_name, this_ptr);
}
PHALCON_RETURN_CALL_METHOD(pdo, "begintransaction");
RETURN_MM();
}
if (zend_is_true(transaction_level)) {
if (zend_is_true(nesting)) {
PHALCON_CALL_METHOD(&ntw_savepoint, this_ptr, "isnestedtransactionswithsavepoints");
if (zend_is_true(ntw_savepoint)) {
events_manager = phalcon_fetch_nproperty_this(this_ptr, SL("_eventsManager"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(&savepoint_name, this_ptr, "getnestedtransactionsavepointname");
/**
* Notify the events manager about the created savepoint
*/
if (Z_TYPE_P(events_manager) == IS_OBJECT) {
PHALCON_INIT_NVAR(event_name);
ZVAL_STRING(event_name, "db:createSavepoint", 1);
PHALCON_CALL_METHOD(NULL, events_manager, "fire", event_name, this_ptr, savepoint_name);
}
PHALCON_RETURN_CALL_METHOD(this_ptr, "createsavepoint", savepoint_name);
RETURN_MM();
}
}
}
RETURN_MM_FALSE;
}
/**
* Initialize the metadata for certain table
*
* @param Phalcon\Mvc\ModelInterface $model
* @param string $key
* @param string $table
* @param string $schema
*/
PHP_METHOD(Phalcon_Mvc_Model_MetaData, _initialize){
zval *model, *key, *table, *schema, *strategy = NULL, *class_name;
zval *meta_data = NULL, *prefix_key = NULL, *data = NULL, *model_metadata = NULL;
zval *exception_message, *dependency_injector;
zval *key_name, *column_map = NULL, *model_column_map = NULL;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 4, 0, &model, &key, &table, &schema);
dependency_injector = phalcon_fetch_nproperty_this(this_ptr, SL("_dependencyInjector"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(strategy);
PHALCON_INIT_VAR(class_name);
phalcon_get_class(class_name, model, 0 TSRMLS_CC);
if (Z_TYPE_P(key) != IS_NULL) {
PHALCON_OBS_VAR(meta_data);
phalcon_read_property_this(&meta_data, this_ptr, SL("_metaData"), PH_NOISY TSRMLS_CC);
if (!phalcon_array_isset(meta_data, key)) {
PHALCON_INIT_VAR(prefix_key);
PHALCON_CONCAT_SV(prefix_key, "meta-", key);
/**
* The meta-data is read from the adapter always
*/
PHALCON_CALL_METHOD(&data, this_ptr, "read", prefix_key);
if (Z_TYPE_P(data) != IS_NULL) {
if (Z_TYPE_P(meta_data) != IS_ARRAY) {
PHALCON_INIT_NVAR(meta_data);
array_init(meta_data);
}
phalcon_array_update_zval(&meta_data, key, data, PH_COPY | PH_SEPARATE);
phalcon_update_property_this(this_ptr, SL("_metaData"), meta_data TSRMLS_CC);
} else {
/**
* Check if there is a method 'metaData' in the model to retrieve meta-data from it
*/
if (phalcon_method_exists_ex(model, SS("metadata") TSRMLS_CC) == SUCCESS) {
PHALCON_CALL_METHOD(&model_metadata, model, "metadata");
if (Z_TYPE_P(model_metadata) != IS_ARRAY) {
PHALCON_INIT_VAR(exception_message);
PHALCON_CONCAT_SV(exception_message, "Invalid meta-data for model ", class_name);
PHALCON_THROW_EXCEPTION_ZVAL(phalcon_mvc_model_exception_ce, exception_message);
return;
}
} else {
/**
* Get the meta-data extraction strategy
*/
PHALCON_CALL_METHOD(&strategy, this_ptr, "getstrategy");
/**
* Get the meta-data
*/
PHALCON_CALL_METHOD(&model_metadata, strategy, "getmetadata", model, dependency_injector);
}
/**
* Store the meta-data locally
*/
phalcon_update_property_array(this_ptr, SL("_metaData"), key, model_metadata TSRMLS_CC);
/**
* Store the meta-data in the adapter
*/
PHALCON_CALL_METHOD(NULL, this_ptr, "write", prefix_key, model_metadata);
}
}
}
/**
* Check for a column map, store in _columnMap in order and reversed order
*/
if (!PHALCON_GLOBAL(orm).column_renaming) {
RETURN_MM_NULL();
}
PHALCON_INIT_VAR(key_name);
phalcon_fast_strtolower(key_name, class_name);
PHALCON_OBS_VAR(column_map);
phalcon_read_property_this(&column_map, this_ptr, SL("_columnMap"), PH_NOISY TSRMLS_CC);
if (phalcon_array_isset(column_map, key_name)) {
RETURN_MM_NULL();
}
if (Z_TYPE_P(column_map) != IS_ARRAY) {
PHALCON_INIT_NVAR(column_map);
array_init(column_map);
}
/**
* Create the map key name
*/
PHALCON_INIT_NVAR(prefix_key);
PHALCON_CONCAT_SV(prefix_key, "map-", key_name);
/**
* Check if the meta-data is already in the adapter
*/
PHALCON_CALL_METHOD(&data, this_ptr, "read", prefix_key);
if (Z_TYPE_P(data) != IS_NULL) {
phalcon_array_update_zval(&column_map, key_name, data, PH_COPY | PH_SEPARATE);
phalcon_update_property_this(this_ptr, SL("_columnMap"), column_map TSRMLS_CC);
RETURN_MM_NULL();
}
/**
* Get the meta-data extraction strategy
*/
if (Z_TYPE_P(strategy) != IS_OBJECT) {
PHALCON_CALL_METHOD(&strategy, this_ptr, "getstrategy");
}
/**
* Get the meta-data
*/
PHALCON_CALL_METHOD(&model_column_map, strategy, "getcolumnmaps", model, dependency_injector);
/**
* Update the column map locally
*/
phalcon_update_property_array(this_ptr, SL("_columnMap"), key_name, model_column_map TSRMLS_CC);
/**
* Write the data to the adapter
*/
PHALCON_CALL_METHOD(NULL, this_ptr, "write", prefix_key, model_column_map);
PHALCON_MM_RESTORE();
}
return Z_TYPE_PP(tmp) != IS_NULL;
}
if (1 == has_set_exists) {
return zend_is_true(*tmp);
}
return 1;
}
static void phalcon_session_adapter_write_property_internal(zval *object, zval *member, zval *value TSRMLS_DC)
{
zval *unique_id, *_SESSION;
zval key = zval_used_for_init, *pkey = &key;
unique_id = phalcon_fetch_nproperty_this(object, SL("_uniqueId"), PH_NOISY TSRMLS_CC);
_SESSION = phalcon_get_global(SS("_SESSION") TSRMLS_CC);
if (Z_TYPE_P(_SESSION) == IS_ARRAY) {
phalcon_concat_vv(&pkey, unique_id, member, 0 TSRMLS_CC);
Z_ADDREF_P(value);
phalcon_hash_update_or_insert(Z_ARRVAL_P(_SESSION), pkey, value);
zval_dtor(&key);
}
}
static void phalcon_session_adapter_unset_property_internal(zval *object, zval *member TSRMLS_DC)
{
zval *unique_id, *_SESSION;
zval key = zval_used_for_init, *pkey = &key;
/**
* Returns an array of Phalcon\Db\Column objects describing a table
*
* <code>print_r($connection->describeColumns("posts")); ?></code>
*
* @param string $table
* @param string $schema
* @return Phalcon\Db\Column[]
*/
PHP_METHOD(Phalcon_Db_Adapter_Pdo_Postgresql, describeColumns){
zval *table, *schema = NULL, *columns, *dialect, *sql = NULL, *fetch_num;
zval *describe = NULL, *old_column = NULL, *field = NULL, *definition = NULL;
zval *char_size = NULL, *numeric_size = NULL, *numeric_scale = NULL, *column_type = NULL;
zval *attribute = NULL, *column_name = NULL, *column = NULL;
HashTable *ah0;
HashPosition hp0;
zval **hd;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 1, &table, &schema);
if (!schema || !zend_is_true(schema)) {
schema = phalcon_fetch_nproperty_this(this_ptr, SL("_schema"), PH_NOISY TSRMLS_CC);
}
PHALCON_INIT_VAR(columns);
array_init(columns);
PHALCON_OBS_VAR(dialect);
phalcon_read_property_this(&dialect, this_ptr, SL("_dialect"), PH_NOISY TSRMLS_CC);
PHALCON_CALL_METHOD(&sql, dialect, "describecolumns", table, schema);
/**
* We're using FETCH_NUM to fetch the columns
*/
PHALCON_INIT_VAR(fetch_num);
ZVAL_LONG(fetch_num, PDO_FETCH_NUM);
PHALCON_CALL_METHOD(&describe, this_ptr, "fetchall", sql, fetch_num);
/**
* 0:name, 1:type, 2:size, 3:numeric size, 4:numeric scale, 5: null, 6: key, 7: extra, 8: position, 9: element type
*/
PHALCON_INIT_VAR(old_column);
phalcon_is_iterable(describe, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HVALUE(field);
PHALCON_INIT_NVAR(definition);
array_init_size(definition, 1);
add_assoc_long_ex(definition, SS("bindType"), 2);
PHALCON_OBS_NVAR(char_size);
phalcon_array_fetch_long(&char_size, field, 2, PH_NOISY);
if (Z_TYPE_P(char_size) != IS_NULL) {
convert_to_long(char_size);
}
PHALCON_OBS_NVAR(numeric_size);
phalcon_array_fetch_long(&numeric_size, field, 3, PH_NOISY);
if (phalcon_is_numeric(numeric_size)) {
convert_to_long(numeric_size);
}
PHALCON_OBS_NVAR(numeric_scale);
phalcon_array_fetch_long(&numeric_scale, field, 4, PH_NOISY);
if (phalcon_is_numeric(numeric_scale)) {
convert_to_long(numeric_scale);
}
PHALCON_OBS_NVAR(column_type);
phalcon_array_fetch_long(&column_type, field, 1, PH_NOISY);
/**
* Check the column type to get the correct Phalcon type
*/
while (1) {
/**
* Tinyint(1) is boolean
*/
if (phalcon_memnstr_str(column_type, SL("smallint(1)"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_BOOLEAN, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 5, PH_COPY);
break;
}
/**
* Smallint/Bigint/Integers/Int are int
*/
if (phalcon_memnstr_str(column_type, SL("int"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_INTEGER, PH_COPY);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), numeric_size, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 1, PH_COPY);
break;
}
/**
* Varchar
*/
if (phalcon_memnstr_str(column_type, SL("varying"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_VARCHAR, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY);
break;
}
/**
* Special type for datetime
*/
if (phalcon_memnstr_str(column_type, SL("date"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_DATE, PH_COPY);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_COPY);
break;
}
/**
* Numeric
*/
if (phalcon_memnstr_str(column_type, SL("numeric"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_DECIMAL, PH_COPY);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY);
if (phalcon_is_numeric(numeric_size)) {
phalcon_array_update_string(&definition, SL("size"), numeric_size, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bytes"), Z_LVAL_P(numeric_size) * 8, PH_COPY);
} else {
phalcon_array_update_string_long(&definition, SL("size"), 30, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bytes"), 80, PH_COPY);
}
if (phalcon_is_numeric(numeric_scale)) {
phalcon_array_update_string(&definition, SL("scale"), numeric_scale, PH_COPY);
} else {
phalcon_array_update_string_long(&definition, SL("scale"), 6, PH_COPY);
}
phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_COPY);
break;
}
/**
* Chars are chars
*/
if (phalcon_memnstr_str(column_type, SL("char"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_CHAR, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY);
break;
}
/**
* Date
*/
if (phalcon_memnstr_str(column_type, SL("timestamp"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_DATETIME, PH_COPY);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_COPY);
break;
}
/**
* Text are varchars
*/
if (phalcon_memnstr_str(column_type, SL("text"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_TEXT, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY);
break;
}
/**
* Float/Smallfloats/Decimals are float
*/
if (phalcon_memnstr_str(column_type, SL("float"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_FLOAT, PH_COPY);
phalcon_array_update_string_bool(&definition, SL("isNumeric"), 1, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), numeric_size, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 32, PH_COPY);
break;
}
/**
* Boolean
*/
if (phalcon_memnstr_str(column_type, SL("bool"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_BOOLEAN, PH_COPY);
phalcon_array_update_string_long(&definition, SL("size"), 0, PH_COPY);
phalcon_array_update_string_long(&definition, SL("bindType"), 5, PH_COPY);
break;
}
/**
* UUID
*/
if (phalcon_memnstr_str(column_type, SL("uuid"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_CHAR, PH_COPY);
phalcon_array_update_string_long(&definition, SL("size"), 36, PH_COPY);
break;
}
/**
* JSON
*/
if (phalcon_memnstr_str(column_type, SL("json"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_JSON, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY);
break;
}
/**
* ARRAY
*/
if (phalcon_memnstr_str(column_type, SL("ARRAY"))) {
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_ARRAY, PH_COPY);
phalcon_array_update_string(&definition, SL("size"), char_size, PH_COPY);
break;
}
/**
* By default is string
*/
phalcon_array_update_string_long(&definition, SL("type"), PHALCON_DB_COLUMN_TYPE_OTHER, PH_COPY);
break;
}
if (phalcon_memnstr_str(column_type, SL("unsigned"))) {
phalcon_array_update_string_bool(&definition, SL("unsigned"), 1, PH_COPY);
}
if (Z_TYPE_P(old_column) == IS_NULL) {
phalcon_array_update_string_bool(&definition, SL("first"), 1, PH_COPY);
} else {
phalcon_array_update_string(&definition, SL("after"), old_column, PH_COPY);
}
/**
* Check if the field is primary key
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 6, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "PRI")) {
phalcon_array_update_string_bool(&definition, SL("primary"), 1, PH_COPY);
}
/**
* Check if the column allows null values
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 5, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "NO")) {
phalcon_array_update_string_bool(&definition, SL("notNull"), 1, PH_COPY);
}
/**
* Check if the column is auto increment
*/
PHALCON_OBS_NVAR(attribute);
phalcon_array_fetch_long(&attribute, field, 7, PH_NOISY);
if (PHALCON_IS_STRING(attribute, "auto_increment")) {
phalcon_array_update_string_bool(&definition, SL("autoIncrement"), 1, PH_COPY);
} else if (!PHALCON_IS_EMPTY(attribute)) {
phalcon_array_update_string(&definition, SL("default"), attribute, PH_COPY);
}
PHALCON_OBS_NVAR(column_name);
phalcon_array_fetch_long(&column_name, field, 0, PH_NOISY);
/**
* Create a Phalcon\Db\Column to abstract the column
*/
PHALCON_INIT_NVAR(column);
object_init_ex(column, phalcon_db_column_ce);
PHALCON_CALL_METHOD(NULL, column, "__construct", column_name, definition);
phalcon_array_append(&columns, column, PH_COPY);
PHALCON_CPY_WRT(old_column, column_name);
zend_hash_move_forward_ex(ah0, &hp0);
}
RETURN_CTOR(columns);
}
/**
* Deletes a value from the cache by its key
*
* @param int|string $keyName
* @return boolean
*/
PHP_METHOD(Phalcon_Cache_Backend_File, delete){
zval *key_name, *prefixed_key, *cache_file;
zval *options, *prefix, *cache_dir;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 1, 0, &key_name);
options = phalcon_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY TSRMLS_CC);
prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(prefixed_key);
PHALCON_CONCAT_VV(prefixed_key, prefix, key_name);
if (unlikely(!phalcon_array_isset_string_fetch(&cache_dir, options, SS("cacheDir")))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options");
return;
}
PHALCON_INIT_VAR(cache_file);
PHALCON_CONCAT_VV(cache_file, cache_dir, prefixed_key);
if (phalcon_file_exists(cache_file TSRMLS_CC) == SUCCESS) {
phalcon_unlink(return_value, cache_file TSRMLS_CC);
/**
* Resize the image to the given size. Either the width or the height can
* be omitted and the image will be resized proportionally.
*
* @param int $width new width
* @param int $height new height
* @param int $master master dimension, if $master is TENSILE, the width and height must be specified
* @return Phalcon\Image\Adapter
*/
PHP_METHOD(Phalcon_Image_Adapter, resize) {
zval *width = NULL, *height = NULL, *zmaster = NULL;
zval *image_width, *image_height;
long tmp_image_width, tmp_image_height, tmp_width = 0, tmp_height = 0, master;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 3, &width, &height, &zmaster);
if (!zmaster) {
master = PHALCON_IMAGE_AUTO;
} else {
master = phalcon_get_intval(zmaster);
}
if (PHALCON_IMAGE_TENSILE == master) {
if (!width || !height) {
PHALCON_THROW_EXCEPTION_STR(phalcon_image_exception_ce, "width and height parameters must be specified");
return;
}
if (Z_TYPE_P(width) != IS_LONG) {
PHALCON_SEPARATE_PARAM(width);
convert_to_long(width);
}
if (Z_TYPE_P(height) != IS_LONG) {
convert_to_long(height);
}
} else {
if (!width) {
PHALCON_INIT_VAR(width);
} else {
PHALCON_SEPARATE_PARAM(width);
}
if (!height) {
PHALCON_INIT_VAR(height);
} else {
PHALCON_SEPARATE_PARAM(height);
}
image_width = phalcon_fetch_nproperty_this(this_ptr, SL("_width"), PH_NOISY TSRMLS_CC);
image_height = phalcon_fetch_nproperty_this(this_ptr, SL("_height"), PH_NOISY TSRMLS_CC);
tmp_image_width = phalcon_get_intval(image_width);
tmp_image_height = phalcon_get_intval(image_height);
if ((master == PHALCON_IMAGE_WIDTH && Z_TYPE_P(width) == IS_LONG) || (master == PHALCON_IMAGE_HEIGHT && Z_TYPE_P(height) == IS_LONG)) {
master = PHALCON_IMAGE_AUTO;
}
if (Z_TYPE_P(width) != IS_LONG) {
if (master == PHALCON_IMAGE_NONE) {
tmp_width = tmp_image_width;
} else {
master = PHALCON_IMAGE_HEIGHT;
}
} else {
tmp_width = Z_LVAL_P(width);
}
if (Z_TYPE_P(height) != IS_LONG) {
if (master == PHALCON_IMAGE_NONE) {
tmp_height = tmp_image_height;
} else {
master = PHALCON_IMAGE_WIDTH;
}
} else {
tmp_height = Z_LVAL_P(height);
}
if (tmp_width <= 0) {
tmp_width = 1;
}
if (tmp_height <= 0) {
tmp_height = 1;
}
switch (master) {
case PHALCON_IMAGE_AUTO:
if ((tmp_image_width / tmp_width) > (tmp_image_height / tmp_height)) {
master = PHALCON_IMAGE_WIDTH;
} else {
master = PHALCON_IMAGE_HEIGHT;
}
break;
case PHALCON_IMAGE_INVERSE:
if ((tmp_image_width / tmp_width) > (tmp_image_height / tmp_height)) {
master = PHALCON_IMAGE_HEIGHT;
} else {
master = PHALCON_IMAGE_WIDTH;
}
break;
}
if (tmp_image_width <= 0) {
tmp_image_width = 1;
}
if (tmp_image_height <= 0) {
tmp_image_height = 1;
}
switch (master) {
case PHALCON_IMAGE_WIDTH:
tmp_height = (int)((tmp_image_height * tmp_width / tmp_image_width) + 0.5);
break;
case PHALCON_IMAGE_HEIGHT:
tmp_width = (int)((tmp_image_width * tmp_height / tmp_image_height) + 0.5);
break;
case PHALCON_IMAGE_PRECISE:
if ((tmp_width / tmp_height) > (tmp_image_width / tmp_image_height)) {
tmp_height = (int)((tmp_image_height * tmp_width / tmp_image_width) + 0.5);
} else {
tmp_width = (int)((tmp_image_width * tmp_height / tmp_image_height) + 0.5);
}
break;
}
if (tmp_width <= 0) {
tmp_width = 1;
}
if (tmp_height <= 0) {
tmp_height = 1;
}
PHALCON_INIT_NVAR(width);
ZVAL_LONG(width, tmp_width);
PHALCON_INIT_NVAR(height);
ZVAL_LONG(height, tmp_height);
}
PHALCON_CALL_METHOD(NULL, this_ptr, "_resize", width, height);
RETURN_THIS();
}
/**
* 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 *cache_file, *cached_content = NULL, *prepared_content = NULL, *status, *is_buffering = NULL;
zval *last_key, *frontend, *options, *cache_dir;
PHALCON_MM_GROW();
phalcon_fetch_params(1, 0, 4, &key_name, &content, &lifetime, &stop_buffer);
if (!key_name || Z_TYPE_P(key_name) == IS_NULL) {
last_key = phalcon_fetch_nproperty_this(this_ptr, SL("_lastKey"), PH_NOISY TSRMLS_CC);
} else {
zval *prefix = phalcon_fetch_nproperty_this(this_ptr, SL("_prefix"), PH_NOISY TSRMLS_CC);
PHALCON_INIT_VAR(last_key);
PHALCON_CONCAT_VV(last_key, prefix, key_name);
}
if (!zend_is_true(last_key)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "The cache must be started first");
return;
}
frontend = phalcon_fetch_nproperty_this(this_ptr, SL("_frontend"), PH_NOISY TSRMLS_CC);
options = phalcon_fetch_nproperty_this(this_ptr, SL("_options"), PH_NOISY TSRMLS_CC);
if (unlikely(!phalcon_array_isset_string_fetch(&cache_dir, options, SS("cacheDir")))) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Unexpected inconsistency in options");
return;
}
PHALCON_INIT_VAR(cache_file);
PHALCON_CONCAT_VV(cache_file, cache_dir, last_key);
if (!content || !zend_is_true(content)) {
PHALCON_CALL_METHOD(&cached_content, frontend, "getcontent");
} else {
cached_content = content;
}
PHALCON_CALL_METHOD(&prepared_content, frontend, "beforestore", cached_content);
/**
* We use file_put_contents to respect open-base-dir directive
*/
PHALCON_INIT_VAR(status);
if (!phalcon_is_numeric(cached_content)) {
phalcon_file_put_contents(status, cache_file, prepared_content TSRMLS_CC);
} else {
phalcon_file_put_contents(status, cache_file, cached_content TSRMLS_CC);
}
if (PHALCON_IS_FALSE(status)) {
PHALCON_THROW_EXCEPTION_STR(phalcon_cache_exception_ce, "Cache directory is not writable");
return;
}
PHALCON_CALL_METHOD(&is_buffering, frontend, "isbuffering");
if (!stop_buffer || PHALCON_IS_TRUE(stop_buffer)) {
PHALCON_CALL_METHOD(NULL, frontend, "stop");
}
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();
}
/**
* Crop an image to the given size. Either the width or the height can be
* omitted and the current width or height will be used.
*
* @param int $width new width
* @param int $height new height
* @param int $offset_x offset from the left, if it's true then will center
* @param int $offset_y offset from the top, if it's true then will middle
* @return Phalcon\Image\Adapter
*/
PHP_METHOD(Phalcon_Image_Adapter, crop) {
zval **w, **h, **ofs_x = NULL, **ofs_y = NULL;
zval *image_width, *image_height;
zval *width, *height, *offset_x, *offset_y;
long tmp_max_width, tmp_max_height, tmp_width, tmp_height, tmp_image_width, tmp_image_height, tmp_offset_x, tmp_offset_y;
phalcon_fetch_params_ex(2, 2, &w, &h, &ofs_x, &ofs_y);
PHALCON_ENSURE_IS_LONG(w);
PHALCON_ENSURE_IS_LONG(h);
PHALCON_MM_GROW();
image_width = phalcon_fetch_nproperty_this(this_ptr, SL("_width"), PH_NOISY TSRMLS_CC);
image_height = phalcon_fetch_nproperty_this(this_ptr, SL("_height"), PH_NOISY TSRMLS_CC);
SEPARATE_ZVAL_IF_NOT_REF(w);
if (Z_TYPE_PP(w) != IS_LONG) {
convert_to_long(*w);
}
SEPARATE_ZVAL_IF_NOT_REF(h);
if (Z_TYPE_PP(h) != IS_LONG) {
convert_to_long(*h);
}
if (ofs_x && Z_TYPE_PP(ofs_x) != IS_NULL && Z_TYPE_PP(ofs_x) != IS_BOOL && Z_TYPE_PP(ofs_x) != IS_LONG) {
SEPARATE_ZVAL_IF_NOT_REF(ofs_x);
convert_to_long(*ofs_x);
}
if (ofs_y && Z_TYPE_PP(ofs_y) != IS_NULL && Z_TYPE_PP(ofs_y) != IS_BOOL && Z_TYPE_PP(ofs_x) != IS_LONG) {
SEPARATE_ZVAL_IF_NOT_REF(ofs_y);
convert_to_long(*ofs_y);
}
tmp_width = Z_LVAL_PP(w);
tmp_height = Z_LVAL_PP(h);
tmp_image_width = phalcon_get_intval(image_width);
tmp_image_height = phalcon_get_intval(image_height);
if (tmp_width > tmp_image_width) {
tmp_width = tmp_image_width;
}
if (tmp_height > tmp_image_height) {
tmp_height = tmp_image_height;
}
if (!ofs_x) {
tmp_offset_x = (int)(((tmp_image_width - tmp_width) / 2) + 0.5);
} else if (Z_TYPE_PP(ofs_x) == IS_BOOL && PHALCON_IS_TRUE(*ofs_x)) {
tmp_offset_x = tmp_image_width - tmp_width;
} else if (Z_TYPE_PP(ofs_x) == IS_LONG) {
if (Z_LVAL_PP(ofs_x) < 0) {
tmp_offset_x = (int)(tmp_image_width - tmp_width + Z_LVAL_PP(ofs_x) + 0.5);
} else {
tmp_offset_x = Z_LVAL_PP(ofs_x);
}
} else {
tmp_offset_x = (int)(((tmp_image_width - tmp_width) / 2) + 0.5);
}
if (!ofs_y) {
tmp_offset_y = (int)(((tmp_image_height - tmp_height) / 2) + 0.5);
} else if (Z_TYPE_PP(ofs_x) == IS_BOOL && PHALCON_IS_TRUE(*ofs_y)) {
tmp_offset_y = tmp_image_height - tmp_height;
} else if (Z_TYPE_PP(ofs_y) == IS_LONG) {
if (Z_LVAL_PP(ofs_y) < 0) {
tmp_offset_y = tmp_image_height - tmp_height + Z_LVAL_PP(ofs_y);
} else {
tmp_offset_y = Z_LVAL_PP(ofs_y);
}
} else {
tmp_offset_y = (int)(((tmp_image_height - tmp_height) / 2) + 0.5);
}
tmp_max_width = tmp_image_width - tmp_offset_x;
tmp_max_height = tmp_image_height - tmp_offset_y;
if (tmp_width > tmp_max_width) {
tmp_width = tmp_max_width;
}
if (tmp_height > tmp_max_height) {
tmp_height = tmp_max_height;
}
PHALCON_ALLOC_GHOST_ZVAL(width);
PHALCON_ALLOC_GHOST_ZVAL(height);
PHALCON_ALLOC_GHOST_ZVAL(offset_x);
PHALCON_ALLOC_GHOST_ZVAL(offset_y);
ZVAL_LONG(width, tmp_width);
ZVAL_LONG(height, tmp_height);
ZVAL_LONG(offset_x, tmp_offset_x);
ZVAL_LONG(offset_y, tmp_offset_y);
PHALCON_CALL_METHOD(NULL, this_ptr, "_crop", width, height, offset_x, offset_y);
RETURN_THIS();
}
/**
* Check whether internal resource has rows to fetch
*
* @return boolean
*/
PHP_METHOD(Phalcon_Mvc_Model_Resultset_Complex, valid){
zval *type = NULL, *row = NULL, *underscore;
zval *empty_str, *active_row = NULL;
zval *dirty_state, *column = NULL, *alias = NULL, *source = NULL, *attributes = NULL;
zval *column_map = NULL, *row_model = NULL, *attribute = NULL, *column_alias = NULL;
zval *column_value = NULL;
zval *value = NULL, *sql_alias = NULL, *n_alias = NULL;
HashTable *ah0, *ah1;
HashPosition hp0, hp1;
zval **hd;
int i_type, is_partial;
PHALCON_MM_GROW();
type = phalcon_fetch_nproperty_this(this_ptr, SL("_type"), PH_NOISY TSRMLS_CC);
i_type = (Z_TYPE_P(type) == IS_LONG) ? Z_LVAL_P(type) : phalcon_get_intval(type);
is_partial = (i_type == PHALCON_MVC_MODEL_RESULTSET_TYPE_PARTIAL);
type = NULL;
PHALCON_INIT_VAR(row);
if (is_partial) {
/**
* The result is bigger than 32 rows so it's retrieved one by one
*/
zval *result = phalcon_fetch_nproperty_this(this_ptr, SL("_result"), PH_NOISY TSRMLS_CC);
if (PHALCON_IS_NOT_FALSE(result)) {
PHALCON_CALL_METHOD(&row, result, "fetch", result);
} else {
ZVAL_FALSE(row);
}
} else {
/**
* The full rows are dumped in this_ptr->rows
*/
zval *rows = phalcon_fetch_nproperty_this(this_ptr, SL("_rows"), PH_NOISY TSRMLS_CC);
if (Z_TYPE_P(rows) == IS_ARRAY) {
phalcon_array_get_current(row, rows);
if (Z_TYPE_P(row) == IS_OBJECT) {
zend_hash_move_forward(Z_ARRVAL_P(rows));
}
} else {
ZVAL_FALSE(row);
}
}
/**
* Valid records are arrays
*/
if (Z_TYPE_P(row) == IS_ARRAY || Z_TYPE_P(row) == IS_OBJECT) {
/**
* The result type=1 so we need to build every row
*/
if (is_partial) {
/**
* Get current hydration mode
*/
zval *hydrate_mode = phalcon_fetch_nproperty_this(this_ptr, SL("_hydrateMode"), PH_NOISY TSRMLS_CC);
zval *columns_types = phalcon_fetch_nproperty_this(this_ptr, SL("_columnTypes"), PH_NOISY TSRMLS_CC);
int i_hydrate_mode = phalcon_get_intval(hydrate_mode);
PHALCON_INIT_VAR(underscore);
ZVAL_STRING(underscore, "_", 1);
PHALCON_INIT_VAR(empty_str);
ZVAL_EMPTY_STRING(empty_str);
/**
* Each row in a complex result is a Phalcon\Mvc\Model\Row instance
*/
PHALCON_INIT_VAR(active_row);
switch (i_hydrate_mode) {
case 0:
object_init_ex(active_row, phalcon_mvc_model_row_ce);
break;
case 1:
array_init(active_row);
break;
case 2:
default:
object_init(active_row);
break;
}
/**
* Create every record according to the column types
*/
/**
* Set records as dirty state PERSISTENT by default
*/
PHALCON_INIT_VAR(dirty_state);
ZVAL_LONG(dirty_state, 0);
phalcon_is_iterable(columns_types, &ah0, &hp0, 0, 0);
while (zend_hash_get_current_data_ex(ah0, (void**) &hd, &hp0) == SUCCESS) {
PHALCON_GET_HKEY(alias, ah0, hp0);
PHALCON_GET_HVALUE(column);
PHALCON_OBS_NVAR(type);
phalcon_array_fetch_string(&type, column, SL("type"), PH_NOISY);
if (PHALCON_IS_STRING(type, "object")) {
/**
* Object columns are assigned column by column
*/
PHALCON_OBS_NVAR(source);
phalcon_array_fetch_string(&source, column, SL("column"), PH_NOISY);
PHALCON_OBS_NVAR(attributes);
phalcon_array_fetch_string(&attributes, column, SL("attributes"), PH_NOISY);
PHALCON_OBS_NVAR(column_map);
phalcon_array_fetch_string(&column_map, column, SL("columnMap"), PH_NOISY);
/**
* Assign the values from the _source_attribute notation to its real column name
*/
PHALCON_INIT_NVAR(row_model);
array_init(row_model);
phalcon_is_iterable(attributes, &ah1, &hp1, 0, 0);
while (zend_hash_get_current_data_ex(ah1, (void**) &hd, &hp1) == SUCCESS) {
PHALCON_GET_HVALUE(attribute);
/**
* Columns are supposed to be in the form _table_field
*/
PHALCON_INIT_NVAR(column_alias);
PHALCON_CONCAT_VVVV(column_alias, underscore, source, underscore, attribute);
PHALCON_OBS_NVAR(column_value);
phalcon_array_fetch(&column_value, row, column_alias, PH_NOISY);
phalcon_array_update_zval(&row_model, attribute, column_value, PH_COPY | PH_SEPARATE);
zend_hash_move_forward_ex(ah1, &hp1);
}
/**
* Generate the column value according to the hydration type
*/
switch (phalcon_get_intval(hydrate_mode)) {
case 0: {
zval *keep_snapshots, *instance;
/**
* Check if the resultset must keep snapshots
*/
if (!phalcon_array_isset_string_fetch(&keep_snapshots, column, SS("keepSnapshots"))) {
keep_snapshots = PHALCON_GLOBAL(z_false);
}
/**
* Get the base instance
*/
if (!phalcon_array_isset_string_fetch(&instance, column, SS("instance"))) {
php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Undefined index: instance");
instance = PHALCON_GLOBAL(z_null);
}
/**
* Assign the values to the attributes using a column map
*/
PHALCON_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmap", instance, row_model, column_map, dirty_state, keep_snapshots);
break;
}
default:
/**
* Other kinds of hydrations
*/
PHALCON_CALL_CE_STATIC(&value, phalcon_mvc_model_ce, "cloneresultmaphydrate", row_model, column_map, hydrate_mode);
break;
}
/**
* The complete object is assigned to an attribute with the name of the alias or
* the model name
*/
PHALCON_OBS_NVAR(attribute);
if (phalcon_array_isset_string(column, SS("balias"))) {
phalcon_array_fetch_string(&attribute, column, SL("balias"), PH_NOISY);
}
} else {
/**
* Scalar columns are simply assigned to the result object
*/
if (phalcon_array_isset_string(column, SS("sqlAlias"))) {
PHALCON_OBS_NVAR(sql_alias);
phalcon_array_fetch_string(&sql_alias, column, SL("sqlAlias"), PH_NOISY);
PHALCON_OBS_NVAR(value);
phalcon_array_fetch(&value, row, sql_alias, PH_NOISY);
} else {
PHALCON_OBS_NVAR(value);
if (phalcon_array_isset(row, alias)) {
phalcon_array_fetch(&value, row, alias, PH_NOISY);
}
}
/**
* If a 'balias' is defined is not an unnamed scalar
*/
if (phalcon_array_isset_string(column, SS("balias"))) {
PHALCON_CPY_WRT(attribute, alias);
} else {
PHALCON_INIT_NVAR(n_alias);
phalcon_fast_str_replace(n_alias, underscore, empty_str, alias);
PHALCON_CPY_WRT(attribute, n_alias);
}
assert(attribute != NULL);
}
/**
* Assign the instance according to the hydration type
*/
if (unlikely(!attribute)) {
zend_throw_exception_ex(phalcon_mvc_model_exception_ce, 0 TSRMLS_CC, "Unexpected inconsistency: attribute is NULL");
RETURN_MM();
}
switch (phalcon_get_intval(hydrate_mode)) {
case 1:
phalcon_array_update_zval(&active_row, attribute, value, PH_COPY | PH_SEPARATE);
break;
default:
phalcon_update_property_zval_zval(active_row, attribute, value TSRMLS_CC);
break;
}
zend_hash_move_forward_ex(ah0, &hp0);
}
/**
* Store the generated row in this_ptr->activeRow to be retrieved by 'current'
*/
phalcon_update_property_this(this_ptr, SL("_activeRow"), active_row TSRMLS_CC);
} else {
/**
* The row is already built so we just assign it to the activeRow
*/
phalcon_update_property_this(this_ptr, SL("_activeRow"), row TSRMLS_CC);
}
RETURN_MM_TRUE;
}
/**
* There are no results to retrieve so we update this_ptr->activeRow as false
*/
phalcon_update_property_bool(this_ptr, SL("_activeRow"), 0 TSRMLS_CC);
RETURN_MM_FALSE;
}
/**
* Add a watermark to an image with a specified opacity. Alpha transparency
* will be preserved.
*
* @param Phalcon\Image\Adapter $watermark watermark Image instance
* @param int $offset_x offset from the left, If less than 0 offset from the right, If true right the x offset
* @param int $offset_y offset from the top, If less than 0 offset from the bottom, If true bottom the Y offset
* @param int $opacity opacity of watermark: 1-100
* @return Phalcon\Image\AdapterInterface
*/
PHP_METHOD(Phalcon_Image_Adapter, watermark) {
zval **watermark, **ofs_x = NULL, **ofs_y = NULL, **op = NULL;
zval *offset_x, *offset_y, *opacity;
zval *image_width, *image_height, *watermark_width, *watermark_height;
long tmp_image_width, tmp_image_height, tmp_watermark_width, tmp_watermark_height, tmp_offset_x, tmp_offset_y;
phalcon_fetch_params_ex(1, 3, &watermark, &ofs_x, &ofs_y, &op);
PHALCON_VERIFY_INTERFACE_EX(*watermark, phalcon_image_adapterinterface_ce, phalcon_image_exception_ce, 0);
PHALCON_MM_GROW();
image_width = phalcon_fetch_nproperty_this(this_ptr, SL("_width"), PH_NOISY TSRMLS_CC);
image_height = phalcon_fetch_nproperty_this(this_ptr, SL("_height"), PH_NOISY TSRMLS_CC);
watermark_width = phalcon_fetch_nproperty_this(*watermark, SL("_width"), PH_NOISY TSRMLS_CC);
watermark_height = phalcon_fetch_nproperty_this(*watermark, SL("_height"), PH_NOISY TSRMLS_CC);
tmp_image_width = phalcon_get_intval(image_width);
tmp_image_height = phalcon_get_intval(image_height);
tmp_watermark_width = phalcon_get_intval(watermark_width);
tmp_watermark_height = phalcon_get_intval(watermark_height);
if (!ofs_x) {
tmp_offset_x = (int)(((tmp_image_width - tmp_watermark_width) / 2) + 0.5);
} else if (Z_TYPE_PP(ofs_x) == IS_LONG) {
tmp_offset_x = Z_LVAL_PP(ofs_x);
if (tmp_offset_x < 0) {
tmp_offset_x = (int)(tmp_image_width - tmp_watermark_width + tmp_offset_x + 0.5);
}
} else if (zend_is_true(*ofs_x)) {
tmp_offset_x = (int)(tmp_image_width - tmp_watermark_width);
} else {
tmp_offset_x = (int)(((tmp_image_width - tmp_watermark_width) / 2) + 0.5);
}
PHALCON_INIT_VAR(offset_x);
ZVAL_LONG(offset_x, tmp_offset_x);
if (!ofs_y) {
tmp_offset_y = (int)(((tmp_image_height - tmp_watermark_height) / 2) + 0.5);
} else if (Z_TYPE_PP(ofs_y) == IS_LONG) {
tmp_offset_y = Z_LVAL_PP(ofs_y);
if (tmp_offset_y < 0) {
tmp_offset_y = (int)(tmp_image_height - tmp_watermark_height + tmp_offset_y + 0.5);
}
} else if (zend_is_true(*ofs_y)) {
tmp_offset_y = (int)(tmp_image_height - tmp_watermark_height);
} else {
tmp_offset_y = (int)(((tmp_image_height - tmp_watermark_height) / 2) + 0.5);
}
PHALCON_INIT_VAR(offset_y);
ZVAL_LONG(offset_y, tmp_offset_y);
PHALCON_INIT_VAR(opacity);
if (!op) {
ZVAL_LONG(opacity, 100);
} else {
PHALCON_ENSURE_IS_LONG(op);
if (Z_LVAL_PP(op) < 1) {
ZVAL_LONG(opacity, 1);
} else if (Z_LVAL_PP(op) > 100) {
ZVAL_LONG(opacity, 100);
} else {
ZVAL_LONG(opacity, Z_LVAL_PP(op));
}
}
PHALCON_CALL_METHOD(NULL, this_ptr, "_watermark", *watermark, offset_x, offset_y, opacity);
RETURN_THIS();
}
