/** * Phalcon\Cache\Backend\Memcache constructor * * @param Phalcon\Cache\FrontendInterface $frontend * @param array $options */ PHP_METHOD(Phalcon_Cache_Backend_Memcache, __construct){ zval *frontend, *opts = NULL, options = {}; phalcon_fetch_params(0, 1, 1, &frontend, &opts); if (opts) { PHALCON_CPY_WRT(&options, opts); } if (Z_TYPE(options) != IS_ARRAY) { array_init_size(&options, 4); } if (!phalcon_array_isset_str(&options, SL("host"))) { phalcon_array_update_str_str(&options, SL("host"), SL("127.0.0.1"), PH_COPY); } if (!phalcon_array_isset_str(&options, SL("port"))) { phalcon_array_update_str_long(&options, SL("port"), 11211, 0); } if (!phalcon_array_isset_str(&options, SL("persistent"))) { phalcon_array_update_str_bool(&options, SL("persistent"), 0, 0); } if (!phalcon_array_isset_str(&options, SL("statsKey"))) { phalcon_array_update_str_str(&options, SL("statsKey"), SL("_PHCM"), PH_COPY); } PHALCON_CALL_PARENTW(NULL, phalcon_cache_backend_memcache_ce, getThis(), "__construct", frontend, &options); }
/** * Phalcon\Cache\Backend\Libmemcached constructor * * @param Phalcon\Cache\FrontendInterface $frontend * @param array $options */ PHP_METHOD(Phalcon_Cache_Backend_Libmemcached, __construct){ zval *frontend, *options = NULL, *server, *servers; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 1, &frontend, &options); if (!options) { PHALCON_INIT_VAR(options); } else { PHALCON_SEPARATE_PARAM(options); } if (Z_TYPE_P(options) != IS_ARRAY) { PHALCON_INIT_NVAR(options); array_init(options); } if (!phalcon_array_isset_str(options, SL("servers"))) { PHALCON_INIT_VAR(servers); array_init_size(servers, 1); PHALCON_INIT_VAR(server); array_init_size(server, 3); phalcon_array_update_str_str(server, SL("host"), SL("127.0.0.1"), PH_COPY); phalcon_array_update_str_long(server, SL("port"), 11211, PH_COPY); phalcon_array_update_str_long(server, SL("weight"), 1, PH_COPY); phalcon_array_append(servers, server, PH_COPY); phalcon_array_update_str(options, SL("servers"), servers, PH_COPY); } if (!phalcon_array_isset_str(options, SL("statsKey"))) { phalcon_array_update_str_str(options, SL("statsKey"), SL("_PHCM"), PH_COPY); } PHALCON_CALL_PARENT(NULL, phalcon_cache_backend_libmemcached_ce, getThis(), "__construct", frontend, options); PHALCON_MM_RESTORE(); }
/** * Returns a slice of the resultset to show in the pagination * * @return stdClass */ PHP_METHOD(Phalcon_Paginator_Adapter_Sql, getPaginate){ zval db = {}, sql = {}, total_sql = {}, bind = {}, limit = {}, number_page = {}, number = {}, fetch_mode = {}, items = {}, row = {}, rowcount = {}; long int i_limit, i_number_page, i_number, i_before, i_rowcount; long int i_total_pages, i_next; ldiv_t tp; phalcon_return_property(&db, getThis(), SL("_db")); phalcon_return_property(&sql, getThis(), SL("_sql")); phalcon_return_property(&total_sql, getThis(), SL("_total_sql")); phalcon_return_property(&bind, getThis(), SL("_bind")); phalcon_return_property(&limit, getThis(), SL("_limitRows")); phalcon_return_property(&number_page, getThis(), SL("_page")); phalcon_return_property(&fetch_mode, getThis(), SL("_fetchMode")); i_limit = phalcon_get_intval(&limit); i_number_page = phalcon_get_intval(&number_page); if (i_limit < 1) { /* This should never happen unless someone deliberately modified the properties of the object */ i_limit = 10; } if (!i_number_page) { i_number_page = 1; } i_number = (i_number_page - 1) * i_limit; i_before = (i_number_page == 1) ? 1 : (i_number_page - 1); PHALCON_CALL_METHODW(&row, &db, "fetchone", &total_sql, &fetch_mode, &bind); phalcon_return_property(&rowcount, &row, SL("rowcount")); PHALCON_SEPARATE(&bind); /* Set the limit clause avoiding negative offsets */ if (i_number < i_limit) { phalcon_array_update_str(&bind, SL("limit"), &limit, PH_COPY); phalcon_array_update_str_long(&bind, SL("offset"), 0, 0); } else { ZVAL_LONG(&number, i_number); phalcon_array_update_str(&bind, SL("limit"), &limit, PH_COPY); phalcon_array_update_str(&bind, SL("offset"), &number, PH_COPY); } PHALCON_CALL_METHODW(&items, &db, "fetchall", &sql, &fetch_mode, &bind); i_rowcount = phalcon_get_intval(&rowcount); tp = ldiv(i_rowcount, i_limit); i_total_pages = tp.quot + (tp.rem ? 1 : 0); i_next = (i_number_page < i_total_pages) ? (i_number_page + 1) : i_total_pages; object_init(return_value); phalcon_update_property_zval(return_value, SL("items"), &items); phalcon_update_property_long(return_value, SL("before"), i_before); phalcon_update_property_long(return_value, SL("first"), 1); phalcon_update_property_long(return_value, SL("next"), i_next); phalcon_update_property_long(return_value, SL("last"), i_total_pages); phalcon_update_property_long(return_value, SL("current"), i_number_page); phalcon_update_property_long(return_value, SL("total_pages"), i_total_pages); phalcon_update_property_long(return_value, SL("total_items"), i_rowcount); }
/** * Handles a MVC request * * @param string $uri * @return Phalcon\Http\ResponseInterface */ PHP_METHOD(Phalcon_Mvc_JsonRpc, handle){ zval *uri = NULL, *dependency_injector, *events_manager; zval *status = NULL, *service = NULL, *request = NULL, *response = NULL; zval *json = NULL, *data = NULL, *jsonrpc_message, *jsonrpc_error, *jsonrpc_result = NULL; zval *jsonrpc_method, *jsonrpc_params, *jsonrpc_id; zval *url = NULL, *router = NULL, *module_name = NULL; zval *module_object = NULL, *modules; zval *module, *class_name = NULL, *module_params; zval *namespace_name = NULL; zval *controller_name = NULL, *action_name = NULL, *params = NULL, *exact = NULL; zval *dispatcher = NULL, *controller = NULL, *returned_response = NULL; zval *path; PHALCON_MM_GROW(); dependency_injector = phalcon_read_property(getThis(), SL("_dependencyInjector"), PH_NOISY); if (Z_TYPE_P(dependency_injector) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_jsonrpc_exception_ce, "A dependency injection object is required to access internal services"); return; } events_manager = phalcon_read_property(getThis(), SL("_eventsManager"), PH_NOISY); if (Z_TYPE_P(events_manager) != IS_OBJECT) { events_manager = NULL; } else { PHALCON_VERIFY_INTERFACE_EX(events_manager, phalcon_events_managerinterface_ce, phalcon_mvc_jsonrpc_exception_ce, 1); } /* Call boot event, this allows the developer to perform initialization actions */ if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:boot", getThis(), NULL)) { RETURN_MM_FALSE; } /* Deserializer Json */ PHALCON_INIT_NVAR(service); ZVAL_STR(service, IS(request)); PHALCON_CALL_METHOD(&request, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(request, phalcon_http_requestinterface_ce); PHALCON_CALL_METHOD(&json, request, "getrawbody"); PHALCON_CALL_FUNCTION(&data, "json_decode", json, &PHALCON_GLOBAL(z_true)); PHALCON_INIT_NVAR(service); ZVAL_STR(service, IS(response)); PHALCON_CALL_METHOD(&response, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(response, phalcon_http_responseinterface_ce); PHALCON_INIT_VAR(jsonrpc_message); array_init(jsonrpc_message); PHALCON_INIT_VAR(jsonrpc_error); array_init(jsonrpc_error); if (PHALCON_IS_EMPTY(data)) { phalcon_array_update_str_long(jsonrpc_error, SL("code"), __LINE__, 0); phalcon_array_update_str_str(jsonrpc_error, SL("message"), SL("Parse error"), PH_COPY); } else if (Z_TYPE_P(data) != IS_ARRAY) { phalcon_array_update_str_long(jsonrpc_error, SL("code"), __LINE__, 0); phalcon_array_update_str_str(jsonrpc_error, SL("message"), SL("Parse error"), PH_COPY); } else if (!phalcon_array_isset_str(data, SL("jsonrpc"))) { phalcon_array_update_str_long(jsonrpc_error, SL("code"), __LINE__, 0); phalcon_array_update_str_str(jsonrpc_error, SL("message"), SL("Invalid Request"), PH_COPY); } else if (!phalcon_array_isset_str(data, SL("method"))) { phalcon_array_update_str_long(jsonrpc_error, SL("code"), __LINE__, 0); phalcon_array_update_str_str(jsonrpc_error, SL("message"), SL("Invalid Request"), PH_COPY); } else { PHALCON_OBS_VAR(jsonrpc_method); phalcon_array_fetch_str(&jsonrpc_method, data, SL("method"), PH_NOISY); if (phalcon_array_isset_str(data, SL("params"))) { PHALCON_OBS_VAR(jsonrpc_params); phalcon_array_fetch_str(&jsonrpc_params, data, SL("params"), PH_NOISY); } else { PHALCON_INIT_VAR(jsonrpc_params); array_init(jsonrpc_params); } PHALCON_INIT_NVAR(service); ZVAL_STR(service, IS(url)); PHALCON_CALL_METHOD(&url, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(url, phalcon_mvc_urlinterface_ce); PHALCON_CALL_METHOD(&uri, url, "get", jsonrpc_method); PHALCON_INIT_NVAR(service); ZVAL_STR(service, IS(router)); PHALCON_CALL_METHOD(&router, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(router, phalcon_mvc_routerinterface_ce); /* Handle the URI pattern (if any) */ PHALCON_CALL_METHOD(NULL, router, "handle", uri); /* Load module config */ PHALCON_CALL_METHOD(&module_name, router, "getmodulename"); /* Load module config */ PHALCON_CALL_METHOD(&module_name, router, "getmodulename"); /* If the router doesn't return a valid module we use the default module */ if (!zend_is_true(module_name)) { module_name = phalcon_read_property(getThis(), SL("_defaultModule"), PH_NOISY); } /** * Process the module definition */ if (zend_is_true(module_name)) { if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:beforeStartModule", getThis(), module_name)) { RETURN_MM_FALSE; } /** * Check if the module passed by the router is registered in the modules container */ modules = phalcon_read_property(getThis(), SL("_modules"), PH_NOISY); if (!phalcon_array_isset_fetch(&module, modules, module_name)) { convert_to_string(module_name); zend_throw_exception_ex(phalcon_mvc_jsonrpc_exception_ce, 0, "Module %s is not registered in the jsonrpc container", Z_STRVAL_P(module_name)); RETURN_MM(); } /** * A module definition must be an array or an object */ if (Z_TYPE_P(module) != IS_ARRAY && Z_TYPE_P(module) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_jsonrpc_exception_ce, "Invalid module definition"); return; } /* An array module definition contains a path to a module definition class */ if (Z_TYPE_P(module) == IS_ARRAY) { /* Class name used to load the module definition */ if (phalcon_array_isset_str(module, SL("className"))) { PHALCON_OBS_VAR(class_name); phalcon_array_fetch_str(&class_name, module, SL("className"), PH_NOISY); } else { PHALCON_INIT_NVAR(class_name); ZVAL_STRING(class_name, "Module"); } /* If the developer has specified a path, try to include the file */ if (phalcon_array_isset_str(module, SL("path"))) { PHALCON_OBS_VAR(path); phalcon_array_fetch_str(&path, module, SL("path"), PH_NOISY); convert_to_string_ex(path); if (Z_TYPE_P(class_name) != IS_STRING || phalcon_class_exists(class_name, 0) == NULL) { if (phalcon_file_exists(path) == SUCCESS) { RETURN_MM_ON_FAILURE(phalcon_require(Z_STRVAL_P(path))); } else { zend_throw_exception_ex(phalcon_mvc_jsonrpc_exception_ce, 0, "Module definition path '%s' does not exist", Z_STRVAL_P(path)); RETURN_MM(); } } } PHALCON_CALL_METHOD(&module_object, dependency_injector, "get", class_name); /** * 'registerAutoloaders' and 'registerServices' are automatically called */ PHALCON_CALL_METHOD(NULL, module_object, "registerautoloaders", dependency_injector); PHALCON_CALL_METHOD(NULL, module_object, "registerservices", dependency_injector); } else if (Z_TYPE_P(module) == IS_OBJECT && instanceof_function(Z_OBJCE_P(module), zend_ce_closure)) { /* A module definition object, can be a Closure instance */ PHALCON_INIT_VAR(module_params); array_init_size(module_params, 1); phalcon_array_append(module_params, dependency_injector, PH_COPY); PHALCON_CALL_USER_FUNC_ARRAY(&status, module, module_params); } else { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_jsonrpc_exception_ce, "Invalid module definition"); return; } /* Calling afterStartModule event */ if (events_manager) { if (!module_object) { module_object = &PHALCON_GLOBAL(z_null); } phalcon_update_property_this(getThis(), SL("_moduleObject"), module_object); if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:afterStartModule", getThis(), module_name)) { RETURN_MM_FALSE; } } } /* We get the parameters from the router and assign them to the dispatcher */ PHALCON_CALL_METHOD(&module_name, router, "getmodulename"); PHALCON_CALL_METHOD(&namespace_name, router, "getnamespacename"); PHALCON_CALL_METHOD(&controller_name, router, "getcontrollername"); PHALCON_CALL_METHOD(&action_name, router, "getactionname"); PHALCON_CALL_METHOD(¶ms, router, "getparams"); PHALCON_CALL_METHOD(&exact, router, "isexactcontrollername"); PHALCON_INIT_NVAR(service); ZVAL_STR(service, IS(dispatcher)); PHALCON_CALL_METHOD(&dispatcher, dependency_injector, "getshared", service); PHALCON_VERIFY_INTERFACE(dispatcher, phalcon_dispatcherinterface_ce); /* Assign the values passed from the router */ PHALCON_CALL_METHOD(NULL, dispatcher, "setmodulename", module_name); PHALCON_CALL_METHOD(NULL, dispatcher, "setnamespacename", namespace_name); PHALCON_CALL_METHOD(NULL, dispatcher, "setcontrollername", controller_name, exact); PHALCON_CALL_METHOD(NULL, dispatcher, "setactionname", action_name); PHALCON_CALL_METHOD(NULL, dispatcher, "setparams", jsonrpc_params); /* Calling beforeHandleRequest */ RETURN_MM_ON_FAILURE(phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:beforeHandleRequest", getThis(), dispatcher)); /* The dispatcher must return an object */ PHALCON_CALL_METHOD(&controller, dispatcher, "dispatch"); PHALCON_INIT_VAR(returned_response); /* Get the latest value returned by an action */ PHALCON_CALL_METHOD(&jsonrpc_result, dispatcher, "getreturnedvalue"); } /* Calling afterHandleRequest */ if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:afterHandleRequest", getThis(), controller) && EG(exception)) { RETURN_MM(); } phalcon_array_update_str_str(jsonrpc_message, SL("jsonrpc"), SL("2.0"), PH_COPY); if (PHALCON_IS_NOT_EMPTY(jsonrpc_error)) { phalcon_array_update_str(jsonrpc_message, SL("error"), jsonrpc_error, PH_COPY); } if (jsonrpc_result != NULL) { phalcon_array_update_str(jsonrpc_message, SL("result"), jsonrpc_result, PH_COPY); } if (phalcon_array_isset_str_fetch(&jsonrpc_id, data, SL("id"))) { phalcon_array_update_str(jsonrpc_message, SL("id"), jsonrpc_id, PH_COPY); } else { phalcon_array_update_str(jsonrpc_message, SL("id"), &PHALCON_GLOBAL(z_null), PH_COPY); } PHALCON_CALL_METHOD(NULL, response, "setjsoncontent", jsonrpc_message); /* Calling beforeSendResponse */ if (FAILURE == phalcon_mvc_jsonrpc_fire_event(events_manager, "jsonrpc:beforeSendResponse", getThis(), response) && EG(exception)) { RETURN_MM(); } /* Headers are automatically sent */ PHALCON_CALL_METHOD(NULL, response, "sendheaders"); /* Cookies are automatically sent */ PHALCON_CALL_METHOD(NULL, response, "sendcookies"); /* Return the response */ RETURN_CCTOR(response); }
PHP_METHOD(Phalcon_Mvc_Collection_GridFS, remove){ zval *sha1 = NULL, *md5 = NULL, *source = NULL, *files_source; zval *connection = NULL, *mongo_collection = NULL; zval *criteria, *operation, *field, *value, *new_object; zval *status = NULL, *ok, *exist, *options, *grid_fs = NULL; PHALCON_MM_GROW(); phalcon_fetch_params(1, 0, 2, &sha1, &md5); if (!sha1) { sha1 = phalcon_read_property(getThis(), SL("sha1"), PH_NOISY); } if (!md5) { md5 = phalcon_read_property(getThis(), SL("md5"), PH_NOISY); } PHALCON_CALL_METHOD(&source, getThis(), "getsource"); PHALCON_INIT_VAR(files_source); PHALCON_CONCAT_VS(files_source, source, ".files"); PHALCON_CALL_METHOD(&connection, getThis(), "getconnection"); PHALCON_CALL_METHOD(&mongo_collection, connection, "selectcollection", files_source); if (Z_TYPE_P(mongo_collection) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_collection_exception_ce, "Couldn't select mongo collection"); return; } PHALCON_INIT_VAR(criteria); array_init_size(criteria, 2); phalcon_array_update_str(criteria, SL("md5"), md5, PH_COPY); phalcon_array_update_str(criteria, SL("sha1"), sha1, PH_COPY); PHALCON_INIT_VAR(operation); ZVAL_STRING(operation, "$inc"); PHALCON_INIT_VAR(field); ZVAL_STRING(field, "use"); PHALCON_INIT_VAR(value); ZVAL_LONG(value, -1) PHALCON_INIT_VAR(new_object); array_init_size(new_object, 1); phalcon_array_update_multi_2(new_object, operation, field, value, PH_COPY); PHALCON_CALL_METHOD(&status, mongo_collection, "update", criteria, new_object); if (phalcon_array_isset_str_fetch(&ok, status, SL("ok"))) { if (zend_is_true(ok)) { if (phalcon_array_isset_str_fetch(&exist, status, SL("updatedExisting"))) { if (!zend_is_true(exist)) { RETURN_MM_FALSE; } } } else { RETURN_MM_FALSE; } } PHALCON_CALL_METHOD(&grid_fs, connection, "getgridfs", source); if (Z_TYPE_P(grid_fs) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_collection_exception_ce, "Couldn't select mongo GridFS"); return; } PHALCON_INIT_NVAR(criteria); array_init_size(criteria, 3); phalcon_array_update_str(criteria, SL("sha1"), sha1, PH_COPY); phalcon_array_update_str(criteria, SL("md5"), md5, PH_COPY); PHALCON_INIT_NVAR(operation); ZVAL_STRING(operation, "$lte"); PHALCON_INIT_NVAR(value); ZVAL_LONG(value, 0) phalcon_array_update_multi_2(criteria, field, operation, value, PH_COPY); PHALCON_INIT_VAR(options); array_init_size(options, 1); phalcon_array_update_str_long(options, SL("w"), 0, PH_COPY); PHALCON_RETURN_CALL_METHOD(grid_fs, "remove", criteria, options); RETURN_MM(); }
PHP_METHOD(Phalcon_Mvc_Collection_GridFS, store){ zval *file, *metadata = NULL, *options = NULL, *isBytes = NULL; zval *mongo_id = NULL, *source = NULL, *files_source; zval *connection = NULL, *mongo_collection = NULL, *grid_fs = NULL; zval *sha1, *md5, *criteria, *operation, *field, *value, *new_object; zval *status = NULL, *ok, *exist; PHALCON_MM_GROW(); phalcon_fetch_params(1, 1, 3, &file, &metadata, &options, &isBytes); if (!metadata) { PHALCON_INIT_VAR(metadata); array_init_size(metadata, 1); } else { PHALCON_SEPARATE_PARAM(metadata); if (Z_TYPE_P(metadata) != IS_ARRAY) { PHALCON_INIT_NVAR(metadata); array_init_size(metadata, 1); } } if (!options) { PHALCON_INIT_NVAR(options); array_init_size(options, 1); } else { PHALCON_SEPARATE_PARAM(options); if (Z_TYPE_P(options) != IS_ARRAY) { PHALCON_INIT_NVAR(options); array_init_size(options, 1); } } if (!isBytes) { isBytes = &PHALCON_GLOBAL(z_false); } phalcon_array_update_str_long(options, SL("w"), 0, 0); PHALCON_CALL_SELF(&mongo_id, "getid"); if (!zend_is_true(mongo_id)) { RETURN_MM_FALSE; } PHALCON_CALL_METHOD(&source, getThis(), "getsource"); PHALCON_INIT_VAR(files_source); PHALCON_CONCAT_VS(files_source, source, ".files"); PHALCON_CALL_METHOD(&connection, getThis(), "getconnection"); PHALCON_CALL_METHOD(&mongo_collection, connection, "selectcollection", files_source); if (Z_TYPE_P(mongo_collection) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_collection_exception_ce, "Couldn't select mongo collection"); return; } sha1 = phalcon_read_property(getThis(), SL("sha1"), PH_NOISY); md5 = phalcon_read_property(getThis(), SL("md5"), PH_NOISY); PHALCON_INIT_VAR(criteria); array_init_size(criteria, 3); phalcon_array_update_str(criteria, SL("md5"), md5, PH_COPY); phalcon_array_update_str(criteria, SL("sha1"), sha1, PH_COPY); PHALCON_INIT_VAR(operation); ZVAL_STRING(operation, "$gte"); PHALCON_INIT_VAR(field); ZVAL_STRING(field, "use"); PHALCON_INIT_VAR(value); ZVAL_LONG(value, 1) phalcon_array_update_multi_2(criteria, field, operation, value, PH_COPY); PHALCON_INIT_NVAR(operation); ZVAL_STRING(operation, "$inc"); PHALCON_INIT_VAR(new_object); array_init_size(new_object, 1); phalcon_array_update_multi_2(new_object, operation, field, value, PH_COPY); PHALCON_CALL_METHOD(&status, mongo_collection, "update", criteria, new_object); if (phalcon_array_isset_str_fetch(&ok, status, SL("ok"))) { if (zend_is_true(ok)) { if (phalcon_array_isset_str_fetch(&exist, status, SL("updatedExisting"))) { if (zend_is_true(exist)) { RETURN_MM_TRUE; } } } else { RETURN_MM_FALSE; } } PHALCON_CALL_METHOD(&grid_fs, connection, "getgridfs", source); if (Z_TYPE_P(grid_fs) != IS_OBJECT) { PHALCON_THROW_EXCEPTION_STR(phalcon_mvc_collection_exception_ce, "Couldn't select mongo GridFS"); return; } phalcon_array_update_str(metadata, SL("sha1"), sha1, PH_COPY); phalcon_array_update_str(metadata, SL("use"), value, PH_COPY); if (zend_is_true(isBytes)) { PHALCON_CALL_METHOD(&status, grid_fs, "storebytes", file, metadata, options); } else { PHALCON_CALL_METHOD(&status, grid_fs, "storefile", file, metadata, options); } if (zend_is_true(status)) { RETURN_MM_TRUE; } RETURN_MM_FALSE; }