/**
* Returns the current version of pLog, determined by the value of the $version
* variable in the version.php file.
* If the file is not available, the result is unknown.
* @static
* @return The version identifier.
*/
function getVersion()
{
$versionFile = PLOG_CLASS_PATH . "version.php";
if (File::isReadable($versionFile)) {
include_once $versionFile;
} else {
$version = "UNKNOWN";
}
return $version;
}
function validate($data)
{
// check the rules created in the constructor
if (!parent::validate($data)) {
return false;
}
// and if they succeeded, check if the file exists. If not, return false
// and go to the main page...
$filePath = "templates/summary/{$data}.template";
return File::isReadable($filePath);
}
function LoggerConfigLoader($defaultFilePath = LOGGER_DEFAULT_CONFIG_FILE_PATH)
{
// load the config file if it is readable
if (File::isReadable($defaultFilePath)) {
include_once $defaultFilePath;
$this->_keys = $config;
} else {
throw new Exception("There was an error loading logger config file: {$defaultFilePath}");
die;
}
}
/**
* Construct the iterator with a file instance
* @param File $file Instance of a file object.
* @throws \InvalidArgumentException
*/
public function __construct(File $file)
{
if (!$file->exists()) {
throw new \InvalidArgumentException('The file "' . $file->getPath() . '" does not exist');
}
if (!$file->isReadable()) {
throw new \InvalidArgumentException('The file "' . $file->getPath() . '" is not readable.');
}
$this->file = $file;
$this->file->open('r');
}
/**
* Reloads the contents from the configuration file.
*
* @return Returns true if successul or false otherwise
*/
function reload()
{
if (File::isReadable($this->_configFile)) {
include $this->_configFile;
$this->_props = new Properties($config);
$result = true;
} else {
$this->_props = new Properties();
$result = false;
}
return $result;
}
/**
* Loads a plugin locale file from disk
*
* @private
*/
function _loadLocaleFile()
{
$fileName = PLOG_CLASS_PATH . "plugins/" . $this->_pluginId . "/locale/locale_" . $this->_code . ".php";
if (File::isReadable($fileName)) {
include $fileName;
}
// The following is just to handle the case where a plugin doesn't
// have a valid local file.
if (!isset($messages) || !is_array($messages)) {
$messages = array();
}
$this->_messages = $messages;
}
/**
* Returns true if the template is a valid template set
*/
function validate()
{
// first of all, check that the folder exists
if (!File::isDir($this->_fullName)) {
return ERROR_TEMPLATE_NOT_INSIDE_FOLDER;
}
// now check that all the basic files are available
foreach ($this->_basicFiles as $basicFile) {
if (!File::isReadable($this->_fullName . $basicFile)) {
return ERROR_MISSING_BASE_FILES;
}
}
return true;
}
function findBinary($binary, $searchFolders)
{
if ($searchFolders == null) {
$searchFolders = array($this->_folder);
}
$found = false;
$i = 0;
while (!$found && $i < count($searchFolders)) {
// get the current folder
$currentFolder = $searchFolders[$i];
// see if the file's there
$fullPath = $currentFolder . $binary;
if (File::isReadable($fullPath)) {
$found = true;
} else {
$i++;
}
}
if ($found) {
return $fullPath;
} else {
return "";
}
}
/**
* Sets the folder where sessions should be saved, in case we'd like to save
* them somewhere else. This class will check the config parameter <b>session_save_path</b>: if
* it's not empty, it will use its value as the name of the folder where sessions should be saved, and it
* will also take care of creating the folder if it does not exist. If the folder exists but it cannot
* be read, it will throw an exception and quit (because this is a big issue)
* If the value of this parameter is empty, it will not do anything and use PHP's default settings for this.
*
* @static
*/
function setSessionSavePath()
{
$config =& Config::getConfig();
$sessionFolder = $config->getValue("session_save_path");
// do we need to do anything if we are using the default
// session path? PHP defaults to /tmp/, so there isn't
// anything to do
if (isset($sessionFolder)) {
if (!File::exists($sessionFolder)) {
// create folder with only user permissions
// since we want to protect the session data
if (!File::createDir($sessionFolder, 0700)) {
throw new Exception("Sessions should be " . "saved in {$sessionFolder} but it " . "doesn't exist and I can't create it!");
die;
}
}
// check if the folder is accessible
if (!File::isReadable($sessionFolder) || !File::isWritable($sessionFolder)) {
if (!File::chMod($sessionFolder, 0700)) {
throw new Exception("Sessions should be " . "saved in {$sessionFolder} but it is " . "not accessible!");
die;
}
}
// if everything ok, we can continue...
session_save_path($sessionFolder);
}
return true;
}
/**
* Makes sure that the file is a valid template set. The file can be packed
* in any of the formats supported by the Unpacker class (.tar.gz, .tar.bz2
* and .zip as of the time of writing these lines)
* Returns true if the template is valid or a negative value carrying an
* error code.
*
* @param file The file that contains the template set
* @return Returns true (positive value) if template set is ok or a negative
* value otherwise.
*/
function checkTemplateSet($file, $filePath)
{
// get the temporary folder
$config =& Config::getConfig();
$tmpFolder = $config->getValue('temp_folder');
if ($tmpFolder[strlen($tmpFolder) - 1] != '/') {
$tmpFolder .= '/';
}
// get the name of the file, which we will use in many places
$fileNameParts = explode('.', $file);
$fileNameNoExt = $fileNameParts[0];
// create our working folder
$workFolder = $tmpFolder . File::getTempName() . '/';
if (!File::createDir($workFolder, 0777)) {
return TEMPLATE_SANDBOX_ERROR_CREATING_WORKING_FOLDER;
}
// now we can unpack the file to the temporary folder
$unpacker = new Unpacker();
if (!$unpacker->unpack($filePath . $file, $workFolder)) {
$this->cleanUp($workFolder . $fileNameNoExt);
if (File::exists($workFolder)) {
File::delete($workFolder);
}
return TEMPLATE_SANDBOX_ERROR_UNPACKING;
}
// if the file was correctly unpacked, now we will need the TemplateValidator
// class to do some work for us
$fileNameParts = explode('.', $file);
$fileNameNoExt = $fileNameParts[0];
// we can use the checkTenmplateFolder which will do all the rest of
// the work for us...
$res = $this->checkTemplateFolder($fileNameNoExt, $workFolder);
if ($res < 0) {
//$this->cleanUp( $workFolder.$fileNameNoExt );
$this->cleanUp($workFolder);
if (File::isReadable($workFolder) && File::isDir($workFolder)) {
File::delete($workFolder);
}
return $res;
}
$this->cleanUp($workFolder . $fileNameNoExt);
File::delete($workFolder);
return true;
}
/**
* dynamically loads a layout formatter
*
* @param appenderName
* @return a qLayout class
*/
function createAppenderInstance($appender, $layout, $properties)
{
$appenderClassName = $appender . "appender";
$appenderClassFile = PLOG_CLASS_PATH . "class/logger/appender/" . $appenderClassName . ".class.php";
// load the class but first check if it exists...
if (!File::isReadable($appenderClassFile)) {
throw new Exception("Cannot find an appender suitable for appender type '{$appender}'");
die;
}
// if so, load the class and create an object
include_once $appenderClassFile;
$appender = new $appenderClassName($layout, $properties);
return $appender;
}
/**
* Loads classes from disk using the list of folders that has been provided
* via ResourceClassLoader::addSearchFolder() The class will go through all the folders where
* classes can be located and if it can be found, it will proceed to load it.
* If not, an exception will be thrown
*
* @param actionClassName name of the class that we are going to load, <b>without the class suffix</b>
* @return True if successful
*/
function load($actionClassName)
{
//foreach( $this->_paths as $path ) {
$i = 0;
$loaded = false;
while ($i < count($this->_paths) && !$loaded) {
// get the current folder
$path = $this->_paths[$i];
// build up the file name
$fileName = $path . strtolower($actionClassName) . $this->_classFileSuffix;
// and see if it exists and can be loaded
if (File::exists($fileName) && File::isReadable($fileName)) {
include_once $fileName;
$loaded = true;
}
// increase the counter
$i++;
}
// did we load anything??
if (!$loaded) {
throw new Exception("Could not load {$actionClassName}!");
die;
}
// otherwise return everything ok!
return true;
}
/**
* returns true if the template set has a screenshot available in disk
*
* @param templateName The name of the template
* @param blogId If the template is blog specific, then the blog id and if it is global, then
* '0' or no parameeter
*/
function isScreenshotAvailable($templateName, $blogId = 0)
{
// build up the path to the screenshot file
$templatePath = $this->getTemplateFolder($templateName, $blogId);
// and return whether it is available or not
$screenshotPath = $templatePath . "/screenshot.jpg";
return File::isReadable($screenshotPath);
}
/**
* returns an stream of data with the contents of the file. This method is used by
* getData(), getPreviewData and getMediumSizePreviewData()
*
* @return The contents of the given file or nothing if empty or if it can't be read
* @private
*/
function _getData($file)
{
if (File::isReadable($file)) {
$file = new File($file);
$file->open("rb");
$size = $file->getSize();
return $file->read($size);
} else {
return false;
}
}
/**
* adds a resource to the gallery when the resource is already stored on disk, instead of
* it coming from an upload as it usually happens. This method is better than
* GalleryResources::addResource() when instead of dealing with uploaded files, the file
* is already in disk and all that is left to do is to add it to the database.
*
* @param ownerId
* @param albumId
* @param description
* @param fullFilePath The real path where the file is stored. This is expected to be
* its final and permanent destination
* @return It will return one of the following constants:
* - GALLERY_ERROR_RESOURCE_TOO_BIG
* - GALLERY_ERROR_RESOURCE_FORBIDDEN_EXTENSION
* - GALLERY_ERROR_QUOTA_EXCEEDED
* - GALLERY_ERROR_ADDING_RESOURCE
* - GALLERY_ERROR_UPLOADS_NOT_ENABLED
* or the identifier of the resource that was just added if the operation succeeded.
*/
function addResourceFromDisk($ownerId, $albumId, $description, $fullFilePath)
{
// check if quotas are enabled, and if this file would make us go
// over the quota
if (GalleryResourceQuotas::isBlogOverResourceQuota($ownerId, File::getSize($fullFilePath))) {
return GALLERY_ERROR_QUOTA_EXCEEDED;
}
$fileName = basename($fullFilePath);
$filePath = dirname($fullFilePath);
// get the metadata
$getId3 = new GetID3();
$metadata = $getId3->analyze($fullFilePath);
// nifty helper method from the getid3 package
getid3_lib::CopyTagsToComments($metadata);
$resourceType = $this->_getResourceType($fullFilePath, $metadata);
$info = $this->_filterMetadata($metadata, $resourceType);
// set the flags
$flags = 0;
if ($resourceType == GALLERY_RESOURCE_IMAGE) {
$flags = $flags | GALLERY_RESOURCE_PREVIEW_AVAILABLE;
}
// add the record to the database
$resourceId = $this->addResourceToDatabase($ownerId, $albumId, $description, $flags, $resourceType, $filePath, $fileName, $metadata);
if (!$resourceId) {
return false;
}
// and finally move the file to the right place in disk
// move the file to disk
$storage = new GalleryResourceStorage();
$resFile = $storage->storeFile($resourceId, $ownerId, $fullFilePath, RESOURCE_STORAGE_STORE_MOVE);
// if the file cannot be read, we will also remove the record from the
// database so that we don't screw up
$fileReadable = File::isReadable($resFile);
if (!$resFile || $resFile < 0 || !$fileReadable) {
// if something went wrong, we should not keep the record in the db
$query = "DELETE FROM " . $this->getPrefix() . "gallery_resources\n WHERE id = {$resourceId}";
$this->Execute($query);
return $resFile;
}
// and finally, we can generate the thumbnail only if the file is an image, of course :)
if ($resourceType == GALLERY_RESOURCE_IMAGE) {
$this->generateResourceThumbnail($resFile, $resourceId, $ownerId);
}
// return the id of the resource we just added
return $resourceId;
}
/**
* Adds a new locale to the list of available/supported locale. It checks to make
* sure that the file exists and that has proper access permissions.
*
* @param localeCode the code of the locale we'd like to add.
* @return Returns true if the file was successfully added or false otherwise.
*/
function addLocale($localeCode)
{
$config =& Config::getConfig();
// if the locale is already there, there is no need to add it,
// since the user is *maybe* just updating the file.
if ($this->isValidLocale($localeCode)) {
return true;
}
$fileName = $this->getLocaleFilename($localeCode);
// make sure that the file exists and can be read and
// give up if not so
if (!File::isReadable($fileName)) {
return false;
}
// otherwise, we can happily add it to the list of supported locales
$availableLocales = $this->getAvailableLocales();
array_push($availableLocales, $localeCode);
$config->saveValue("locales", $availableLocales);
return true;
}
//ini_set('memory_limit', "16M");
if (!defined("PLOG_CLASS_PATH")) {
define("PLOG_CLASS_PATH", dirname(__FILE__) . "/");
}
include_once PLOG_CLASS_PATH . "class/controller/blogcontroller.class.php";
include_once PLOG_CLASS_PATH . "class/net/http/session/sessionmanager.class.php";
include_once PLOG_CLASS_PATH . "class/dao/userinfo.class.php";
include_once PLOG_CLASS_PATH . "class/dao/bloginfo.class.php";
include_once PLOG_CLASS_PATH . "class/plugin/pluginmanager.class.php";
// just to make php use & as the separator when adding the PHPSESSID
// variable to our requests
ini_set("arg_seperator.output", "&");
ini_set("magic_quotes_runtime", 0);
//
// a security check, or else people might forget to remove the wizard.php script
//
if (File::isReadable("wizard.php")) {
print "<span style=\"color:red\">The wizard.php script has to be removed after the installation process.</span><br/><br/>\n Please remove it first to continue.";
die;
}
// initialize the session
SessionManager::init();
$controller = new BlogController();
// load the plugins, this needs to be done *before* we call the
// Controller::process() method, as some of the plugins _might_
// add new actions to the controller
$pluginManager =& PluginManager::getPluginManager();
$pluginManager->loadPlugins();
// give control to the, ehem, controller :)
$controller->process(HttpVars::getRequest(), "op");
//xdebug_dump_function_profile(4);
/**
* returns true if the plugin provides the requested locale
*
* @param pluginId The plugin identifier that we're like to check
* @param localeCode the locale code
* @return True if the plugin has this locale or false otherwise
* @static
*/
function pluginHasLocale($pluginId, $localeCode)
{
return File::isReadable("plugins/{$pluginId}/locale/locale_{$localeCode}.php");
}
/**
* removes a directory, optinally in a recursive fashion
*
* @param dirName
* @param recursive Whether to recurse through all subdirectories that
* are within the given one and remove them.
* @param onlyFiles If the recursive mode is enabled, setting this to 'true' will
* force the method to only remove files but not folders. The directory will not be
* removed but all the files included it in (and all subdirectories) will be.
* @return True if successful or false otherwise
* @static
*/
function deleteDir($dirName, $recursive = false, $onlyFiles = false)
{
// if the directory can't be read, then quit with an error
if (!File::isReadable($dirName) || !File::exists($dirName)) {
return false;
}
// if it's not a file, let's get out of here and transfer flow
// to the right place...
if (!File::isDir($dirName)) {
return File::delete($dirName);
}
// Glob::myGlob is easier to use than Glob::glob, specially when
// we're relying on the native version... This improved version
// will automatically ignore things like "." and ".." for us,
// making it much easier!
$files = Glob::myGlob($dirName, "*");
foreach ($files as $file) {
if (File::isDir($file)) {
// perform a recursive call if we were allowed to do so
if ($recursive) {
File::deleteDir($file, $recursive, $onlyFiles);
}
}
// File::delete can remove empty folders as well as files
if (File::isReadable($file)) {
File::delete($file);
}
}
// finally, remove the top-level folder but only in case we
// are supposed to!
if (!$onlyFiles) {
File::delete($dirName);
}
return true;
}
/**
* removes a file from disk
*
* @param resource A GalleryResource object, representing the resource
* we'd like to delete.
* @return Returns ok if file was successfully deleted ok or false otherwise.
*/
function remove($resource)
{
if ($resource) {
// first of all, remove the resource file itself
$fileParts = explode(".", $resource->getFileName());
$fileExt = $fileParts[count($fileParts) - 1];
$fileName = $resource->getOwnerId() . "-" . $resource->getId() . "." . $fileExt;
$filePath = $this->getUserFolder($resource->getOwnerId());
$fullName = $filePath . $fileName;
if (File::isReadable($fullName)) {
$result = File::delete($fullName);
}
// and now if preview images are available, remove them too!
if ($resource->hasPreview()) {
// delete the small thumbnail
$previewFile = $resource->getPreviewFileName();
if (File::isReadable($previewFile)) {
File::delete($previewFile);
}
// and the medium-sized thumbnail
$medPreviewFile = $resource->getMediumSizePreviewFileName();
if (File::isReadable($medPreviewFile)) {
File::delete($medPreviewFile);
}
}
} else {
$result = false;
}
return $result;
}
/**
* @private
*/
function _loadLocaleFile()
{
$fileName = $this->_defaultFolder . "/locale_" . $this->_code . ".php";
if (File::isReadable($fileName)) {
include $fileName;
}
// The following is just to handle the case where there isn't
// a valid local file.
if (!isset($messages) || !is_array($messages)) {
$messages = array();
}
$this->_messages = $messages;
unset($messages);
/*if( function_exists('memory_get_usage'))
$this->log->debug('Memory used after loading locale ' . $this->_code . ': ' . memory_get_usage());*/
}
/** @ignore */
public static function __test()
{
$file = new File(__FILE__);
assert($file->exists());
assert($file->isFile());
assert(!$file->isDir());
assert($file->isReadable());
}
