2010-07-01 19:48:07 -04:00
< ? php
2018-02-04 18:44:42 -05:00
/**
2018-03-01 00:33:10 -05:00
* @ file boot . php
2015-12-23 19:31:17 -05:00
* This file defines some global constants and includes the central App class .
*/
/**
* Friendica
2016-04-03 07:48:31 -04:00
*
2015-12-23 19:31:17 -05:00
* Friendica is a communications platform for integrated social communications
* utilising decentralised communications and linkage to several indie social
* projects - as well as popular mainstream providers .
2016-04-03 07:48:31 -04:00
*
2015-12-23 19:31:17 -05:00
* Our mission is to free our friends and families from the clutches of
* data - harvesting corporations , and pave the way to a future where social
* communications are free and open and flow between alternate providers as
* easily as email does today .
*/
2010-07-01 19:48:07 -04:00
2017-11-09 11:05:18 -05:00
require_once __DIR__ . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php' ;
2016-04-03 07:48:31 -04:00
2017-04-30 00:07:00 -04:00
use Friendica\App ;
2018-03-07 12:34:47 -05:00
use Friendica\BaseObject ;
2018-01-17 13:42:40 -05:00
use Friendica\Core\Addon ;
2018-03-01 00:33:10 -05:00
use Friendica\Core\Cache ;
2017-04-30 00:01:26 -04:00
use Friendica\Core\Config ;
2018-01-26 21:43:43 -05:00
use Friendica\Core\L10n ;
2017-11-06 21:22:52 -05:00
use Friendica\Core\PConfig ;
2018-02-05 14:09:03 -05:00
use Friendica\Core\Protocol ;
2018-01-24 21:08:45 -05:00
use Friendica\Core\System ;
2017-11-08 08:03:41 -05:00
use Friendica\Core\Worker ;
2018-07-21 08:40:21 -04:00
use Friendica\Database\DBA ;
2017-12-14 16:13:02 -05:00
use Friendica\Database\DBStructure ;
2018-01-24 21:08:45 -05:00
use Friendica\Model\Contact ;
2018-02-05 14:09:03 -05:00
use Friendica\Model\Conversation ;
2018-01-26 21:38:34 -05:00
use Friendica\Util\DateTimeFormat ;
2017-01-17 14:21:46 -05:00
2017-05-02 22:42:29 -04:00
require_once 'include/text.php' ;
2014-09-07 11:28:38 -04:00
2017-11-09 11:05:18 -05:00
define ( 'FRIENDICA_PLATFORM' , 'Friendica' );
2018-03-23 02:14:49 -04:00
define ( 'FRIENDICA_CODENAME' , 'The Tazmans Flax-lily' );
2018-09-23 19:02:11 -04:00
define ( 'FRIENDICA_VERSION' , '2018.12-dev' );
2017-11-09 11:05:18 -05:00
define ( 'DFRN_PROTOCOL_VERSION' , '2.23' );
2017-12-14 16:13:02 -05:00
define ( 'NEW_UPDATE_ROUTINE_VERSION' , 1170 );
/**
* @ brief Constants for the database update check
*/
const DB_UPDATE_NOT_CHECKED = 0 ; // Database check wasn't executed before
const DB_UPDATE_SUCCESSFUL = 1 ; // Database check was successful
const DB_UPDATE_FAILED = 2 ; // Database check failed
2015-12-25 12:36:13 -05:00
/**
* @ brief Constant with a HTML line break .
*
* Contains a HTML line break ( br ) element and a real carriage return with line
* feed for the source .
* This can be used in HTML and JavaScript where needed a line break .
*/
2017-11-09 11:05:18 -05:00
define ( 'EOL' , " <br /> \r \n " );
2011-08-16 23:05:02 -04:00
2011-05-04 05:20:44 -04:00
/**
2015-12-25 14:58:26 -05:00
* @ brief Image storage quality .
2016-10-01 23:29:30 -04:00
*
2015-12-25 14:58:26 -05:00
* Lower numbers save space at cost of image detail .
2018-06-24 20:26:00 -04:00
* For ease of upgrade , please do not change here . Set [ system ] jpegquality = n in config / local . ini . php ,
* where n is between 1 and 100 , and with very poor results below about 50
2011-05-04 05:20:44 -04:00
*/
2017-11-09 11:05:18 -05:00
define ( 'JPEG_QUALITY' , 100 );
2017-05-02 22:42:29 -04:00
2012-06-07 11:42:13 -04:00
/**
2018-06-24 20:26:00 -04:00
* [ system ] png_quality = n where is between 0 ( uncompressed ) to 9
2012-06-07 11:42:13 -04:00
*/
2017-11-09 11:05:18 -05:00
define ( 'PNG_QUALITY' , 8 );
2012-06-07 11:42:13 -04:00
2012-06-28 12:33:21 -04:00
/**
* An alternate way of limiting picture upload sizes . Specify the maximum pixel
* length that pictures are allowed to be ( for non - square pictures , it will apply
* to the longest side ) . Pictures longer than this length will be resized to be
* this length ( on the longest side , the other side will be scaled appropriately ) .
* Modify this value using
*
2018-06-24 20:26:00 -04:00
* [ system ]
* max_image_length = n ;
2012-06-28 12:33:21 -04:00
*
2018-06-24 20:26:00 -04:00
* in config / local . ini . php
2012-06-28 12:33:21 -04:00
*
* If you don ' t want to set a maximum length , set to - 1. The default value is
* defined by 'MAX_IMAGE_LENGTH' below .
*/
2017-11-09 11:05:18 -05:00
define ( 'MAX_IMAGE_LENGTH' , - 1 );
2012-06-28 12:33:21 -04:00
2012-05-09 01:46:40 -04:00
/**
* Not yet used
*/
2017-11-09 11:05:18 -05:00
define ( 'DEFAULT_DB_ENGINE' , 'InnoDB' );
2012-05-09 01:46:40 -04:00
2011-01-30 01:35:11 -05:00
/**
2015-12-25 14:58:26 -05:00
* @ name SSL Policy
2016-10-01 23:29:30 -04:00
*
2011-01-30 01:35:11 -05:00
* SSL redirection policies
2015-12-25 14:58:26 -05:00
* @ {
2011-01-30 01:35:11 -05:00
*/
2017-11-09 11:05:18 -05:00
define ( 'SSL_POLICY_NONE' , 0 );
define ( 'SSL_POLICY_FULL' , 1 );
define ( 'SSL_POLICY_SELFSIGN' , 2 );
2015-12-25 14:58:26 -05:00
/* @}*/
2011-01-30 01:35:11 -05:00
2010-12-10 07:04:35 -05:00
/**
2015-12-25 14:58:26 -05:00
* @ name Register
2016-10-01 23:29:30 -04:00
*
2015-12-25 14:58:26 -05:00
* Registration policies
* @ {
2010-12-10 07:04:35 -05:00
*/
2017-11-09 11:05:18 -05:00
define ( 'REGISTER_CLOSED' , 0 );
define ( 'REGISTER_APPROVE' , 1 );
define ( 'REGISTER_OPEN' , 2 );
/**
* @ }
*/
2010-07-01 19:48:07 -04:00
2012-04-28 20:53:19 -04:00
/**
2015-12-25 14:58:26 -05:00
* @ name Update
2016-10-01 23:29:30 -04:00
*
2012-04-28 20:53:19 -04:00
* DB update return values
2015-12-25 14:58:26 -05:00
* @ {
2012-04-28 20:53:19 -04:00
*/
2017-11-09 11:05:18 -05:00
define ( 'UPDATE_SUCCESS' , 0 );
define ( 'UPDATE_FAILED' , 1 );
/**
* @ }
*/
2012-04-28 20:53:19 -04:00
2015-12-25 12:36:13 -05:00
/**
2015-12-25 14:58:26 -05:00
* @ name CP
2016-10-01 23:29:30 -04:00
*
2015-12-25 12:36:13 -05:00
* Type of the community page
2015-12-25 14:58:26 -05:00
* @ {
2015-12-25 12:36:13 -05:00
*/
2018-04-23 07:14:25 -04:00
define ( 'CP_NO_INTERNAL_COMMUNITY' , - 2 );
define ( 'CP_NO_COMMUNITY_PAGE' , - 1 );
define ( 'CP_USERS_ON_SERVER' , 0 );
define ( 'CP_GLOBAL_COMMUNITY' , 1 );
define ( 'CP_USERS_AND_GLOBAL' , 2 );
2017-11-09 11:05:18 -05:00
/**
* @ }
*/
2015-02-08 14:35:40 -05:00
2012-04-09 10:56:01 -04:00
/**
2012-03-28 22:56:14 -04:00
* These numbers are used in stored permissions
* and existing allocations MUST NEVER BE CHANGED
* OR RE - ASSIGNED ! You may only add to them .
*/
2018-01-15 08:05:12 -05:00
$netgroup_ids = [
2018-08-11 16:40:44 -04:00
Protocol :: DFRN => ( - 1 ),
Protocol :: ZOT => ( - 2 ),
Protocol :: OSTATUS => ( - 3 ),
Protocol :: FEED => ( - 4 ),
Protocol :: DIASPORA => ( - 5 ),
Protocol :: MAIL => ( - 6 ),
Protocol :: FACEBOOK => ( - 8 ),
Protocol :: LINKEDIN => ( - 9 ),
Protocol :: XMPP => ( - 10 ),
Protocol :: MYSPACE => ( - 11 ),
Protocol :: GPLUS => ( - 12 ),
Protocol :: PUMPIO => ( - 13 ),
Protocol :: TWITTER => ( - 14 ),
Protocol :: DIASPORA2 => ( - 15 ),
Protocol :: STATUSNET => ( - 16 ),
Protocol :: NEWS => ( - 18 ),
Protocol :: ICALENDAR => ( - 19 ),
Protocol :: PNUT => ( - 20 ),
Protocol :: PHANTOM => ( - 127 ),
2018-01-15 08:05:12 -05:00
];
2012-03-28 22:56:14 -04:00
2010-12-10 07:04:35 -05:00
/**
* Maximum number of " people who like (or don't like) this " that we will list by name
*/
2017-11-09 11:05:18 -05:00
define ( 'MAX_LIKERS' , 75 );
2010-10-12 20:11:06 -04:00
2010-12-10 07:04:35 -05:00
/**
2015-12-25 14:58:26 -05:00
* @ name Notify
2016-10-01 23:29:30 -04:00
*
2015-12-25 14:58:26 -05:00
* Email notification options
* @ {
2010-12-10 07:04:35 -05:00
*/
2017-11-09 11:05:18 -05:00
define ( 'NOTIFY_INTRO' , 0x0001 );
define ( 'NOTIFY_CONFIRM' , 0x0002 );
define ( 'NOTIFY_WALL' , 0x0004 );
define ( 'NOTIFY_COMMENT' , 0x0008 );
define ( 'NOTIFY_MAIL' , 0x0010 );
define ( 'NOTIFY_SUGGEST' , 0x0020 );
define ( 'NOTIFY_PROFILE' , 0x0040 );
define ( 'NOTIFY_TAGSELF' , 0x0080 );
define ( 'NOTIFY_TAGSHARE' , 0x0100 );
define ( 'NOTIFY_POKE' , 0x0200 );
define ( 'NOTIFY_SHARE' , 0x0400 );
define ( 'SYSTEM_EMAIL' , 0x4000 );
define ( 'NOTIFY_SYSTEM' , 0x8000 );
2015-12-25 14:58:26 -05:00
/* @}*/
2012-03-25 07:37:09 -04:00
2012-07-05 20:59:56 -04:00
/**
2015-12-25 14:58:26 -05:00
* @ name Term
2016-10-01 23:29:30 -04:00
*
2012-07-05 20:59:56 -04:00
* Tag / term types
2015-12-25 14:58:26 -05:00
* @ {
2012-07-05 20:59:56 -04:00
*/
2017-11-09 11:05:18 -05:00
define ( 'TERM_UNKNOWN' , 0 );
define ( 'TERM_HASHTAG' , 1 );
define ( 'TERM_MENTION' , 2 );
define ( 'TERM_CATEGORY' , 3 );
define ( 'TERM_PCATEGORY' , 4 );
define ( 'TERM_FILE' , 5 );
define ( 'TERM_SAVEDSEARCH' , 6 );
define ( 'TERM_CONVERSATION' , 7 );
define ( 'TERM_OBJ_POST' , 1 );
define ( 'TERM_OBJ_PHOTO' , 2 );
2012-07-05 20:59:56 -04:00
2010-12-10 07:04:35 -05:00
/**
2015-12-25 14:58:26 -05:00
* @ name Namespaces
2016-10-01 23:29:30 -04:00
*
2015-12-25 14:58:26 -05:00
* Various namespaces we may need to parse
* @ {
2010-12-10 07:04:35 -05:00
*/
2017-11-09 11:05:18 -05:00
define ( 'NAMESPACE_ZOT' , 'http://purl.org/zot' );
define ( 'NAMESPACE_DFRN' , 'http://purl.org/macgirvin/dfrn/1.0' );
define ( 'NAMESPACE_THREAD' , 'http://purl.org/syndication/thread/1.0' );
define ( 'NAMESPACE_TOMB' , 'http://purl.org/atompub/tombstones/1.0' );
define ( 'NAMESPACE_ACTIVITY' , 'http://activitystrea.ms/spec/1.0/' );
define ( 'NAMESPACE_ACTIVITY_SCHEMA' , 'http://activitystrea.ms/schema/1.0/' );
define ( 'NAMESPACE_MEDIA' , 'http://purl.org/syndication/atommedia' );
define ( 'NAMESPACE_SALMON_ME' , 'http://salmon-protocol.org/ns/magic-env' );
define ( 'NAMESPACE_OSTATUSSUB' , 'http://ostatus.org/schema/1.0/subscribe' );
define ( 'NAMESPACE_GEORSS' , 'http://www.georss.org/georss' );
define ( 'NAMESPACE_POCO' , 'http://portablecontacts.net/spec/1.0' );
define ( 'NAMESPACE_FEED' , 'http://schemas.google.com/g/2010#updates-from' );
define ( 'NAMESPACE_OSTATUS' , 'http://ostatus.org/schema/1.0' );
define ( 'NAMESPACE_STATUSNET' , 'http://status.net/schema/api/1/' );
define ( 'NAMESPACE_ATOM1' , 'http://www.w3.org/2005/Atom' );
define ( 'NAMESPACE_MASTODON' , 'http://mastodon.social/schema/1.0' );
2015-12-25 14:58:26 -05:00
/* @}*/
2010-12-10 07:04:35 -05:00
/**
2015-12-25 14:58:26 -05:00
* @ name Activity
2016-10-01 23:29:30 -04:00
*
2015-12-25 14:58:26 -05:00
* Activity stream defines
* @ {
2010-12-10 07:04:35 -05:00
*/
2017-11-09 11:05:18 -05:00
define ( 'ACTIVITY_LIKE' , NAMESPACE_ACTIVITY_SCHEMA . 'like' );
define ( 'ACTIVITY_DISLIKE' , NAMESPACE_DFRN . '/dislike' );
define ( 'ACTIVITY_ATTEND' , NAMESPACE_ZOT . '/activity/attendyes' );
define ( 'ACTIVITY_ATTENDNO' , NAMESPACE_ZOT . '/activity/attendno' );
define ( 'ACTIVITY_ATTENDMAYBE' , NAMESPACE_ZOT . '/activity/attendmaybe' );
define ( 'ACTIVITY_OBJ_HEART' , NAMESPACE_DFRN . '/heart' );
define ( 'ACTIVITY_FRIEND' , NAMESPACE_ACTIVITY_SCHEMA . 'make-friend' );
define ( 'ACTIVITY_REQ_FRIEND' , NAMESPACE_ACTIVITY_SCHEMA . 'request-friend' );
define ( 'ACTIVITY_UNFRIEND' , NAMESPACE_ACTIVITY_SCHEMA . 'remove-friend' );
define ( 'ACTIVITY_FOLLOW' , NAMESPACE_ACTIVITY_SCHEMA . 'follow' );
define ( 'ACTIVITY_UNFOLLOW' , NAMESPACE_ACTIVITY_SCHEMA . 'stop-following' );
define ( 'ACTIVITY_JOIN' , NAMESPACE_ACTIVITY_SCHEMA . 'join' );
define ( 'ACTIVITY_POST' , NAMESPACE_ACTIVITY_SCHEMA . 'post' );
define ( 'ACTIVITY_UPDATE' , NAMESPACE_ACTIVITY_SCHEMA . 'update' );
define ( 'ACTIVITY_TAG' , NAMESPACE_ACTIVITY_SCHEMA . 'tag' );
define ( 'ACTIVITY_FAVORITE' , NAMESPACE_ACTIVITY_SCHEMA . 'favorite' );
define ( 'ACTIVITY_UNFAVORITE' , NAMESPACE_ACTIVITY_SCHEMA . 'unfavorite' );
define ( 'ACTIVITY_SHARE' , NAMESPACE_ACTIVITY_SCHEMA . 'share' );
define ( 'ACTIVITY_DELETE' , NAMESPACE_ACTIVITY_SCHEMA . 'delete' );
define ( 'ACTIVITY_POKE' , NAMESPACE_ZOT . '/activity/poke' );
define ( 'ACTIVITY_OBJ_BOOKMARK' , NAMESPACE_ACTIVITY_SCHEMA . 'bookmark' );
define ( 'ACTIVITY_OBJ_COMMENT' , NAMESPACE_ACTIVITY_SCHEMA . 'comment' );
define ( 'ACTIVITY_OBJ_NOTE' , NAMESPACE_ACTIVITY_SCHEMA . 'note' );
define ( 'ACTIVITY_OBJ_PERSON' , NAMESPACE_ACTIVITY_SCHEMA . 'person' );
define ( 'ACTIVITY_OBJ_IMAGE' , NAMESPACE_ACTIVITY_SCHEMA . 'image' );
define ( 'ACTIVITY_OBJ_PHOTO' , NAMESPACE_ACTIVITY_SCHEMA . 'photo' );
define ( 'ACTIVITY_OBJ_VIDEO' , NAMESPACE_ACTIVITY_SCHEMA . 'video' );
define ( 'ACTIVITY_OBJ_P_PHOTO' , NAMESPACE_ACTIVITY_SCHEMA . 'profile-photo' );
define ( 'ACTIVITY_OBJ_ALBUM' , NAMESPACE_ACTIVITY_SCHEMA . 'photo-album' );
define ( 'ACTIVITY_OBJ_EVENT' , NAMESPACE_ACTIVITY_SCHEMA . 'event' );
define ( 'ACTIVITY_OBJ_GROUP' , NAMESPACE_ACTIVITY_SCHEMA . 'group' );
define ( 'ACTIVITY_OBJ_TAGTERM' , NAMESPACE_DFRN . '/tagterm' );
define ( 'ACTIVITY_OBJ_PROFILE' , NAMESPACE_DFRN . '/profile' );
define ( 'ACTIVITY_OBJ_QUESTION' , 'http://activityschema.org/object/question' );
2015-12-25 14:58:26 -05:00
/* @}*/
2010-09-08 23:14:17 -04:00
2010-12-10 07:04:35 -05:00
/**
2015-12-25 14:58:26 -05:00
* @ name Gravity
2016-10-01 23:29:30 -04:00
*
2015-12-25 14:58:26 -05:00
* Item weight for query ordering
* @ {
2010-12-10 07:04:35 -05:00
*/
2017-11-09 11:05:18 -05:00
define ( 'GRAVITY_PARENT' , 0 );
2018-06-27 14:09:33 -04:00
define ( 'GRAVITY_ACTIVITY' , 3 );
2017-11-09 11:05:18 -05:00
define ( 'GRAVITY_COMMENT' , 6 );
2018-06-27 14:09:33 -04:00
define ( 'GRAVITY_UNKNOWN' , 9 );
2015-12-25 14:58:26 -05:00
/* @}*/
2016-08-01 01:48:43 -04:00
/**
* @ name Priority
*
* Process priority for the worker
* @ {
*/
2017-11-09 11:05:18 -05:00
define ( 'PRIORITY_UNDEFINED' , 0 );
define ( 'PRIORITY_CRITICAL' , 10 );
define ( 'PRIORITY_HIGH' , 20 );
define ( 'PRIORITY_MEDIUM' , 30 );
define ( 'PRIORITY_LOW' , 40 );
define ( 'PRIORITY_NEGLIGIBLE' , 50 );
2016-08-01 01:48:43 -04:00
/* @}*/
2017-02-10 15:45:22 -05:00
/**
* @ name Social Relay settings
*
* See here : https :// github . com / jaywink / social - relay
* and here : https :// wiki . diasporafoundation . org / Relay_servers_for_public_posts
* @ {
*/
define ( 'SR_SCOPE_NONE' , '' );
define ( 'SR_SCOPE_ALL' , 'all' );
define ( 'SR_SCOPE_TAGS' , 'tags' );
/* @}*/
2010-09-08 23:14:17 -04:00
2016-05-22 06:31:32 -04:00
// Normally this constant is defined - but not if "pcntl" isn't installed
2017-03-19 04:04:04 -04:00
if ( ! defined ( " SIGTERM " )) {
2016-05-22 06:31:32 -04:00
define ( " SIGTERM " , 15 );
2017-03-19 04:04:04 -04:00
}
2017-05-02 22:42:29 -04:00
2017-06-03 15:46:19 -04:00
/**
* Depending on the PHP version this constant does exist - or not .
* See here : http :// php . net / manual / en / curl . constants . php #117928
*/
if ( ! defined ( 'CURLE_OPERATION_TIMEDOUT' )) {
2017-11-09 11:05:18 -05:00
define ( 'CURLE_OPERATION_TIMEDOUT' , CURLE_OPERATION_TIMEOUTED );
2017-06-03 15:46:19 -04:00
}
2010-11-24 02:42:45 -05:00
2015-12-23 19:31:17 -05:00
/**
* @ brief Retrieve the App structure
2016-10-01 23:29:30 -04:00
*
2015-12-23 19:31:17 -05:00
* Useful in functions which require it but don ' t get it passed to them
2017-12-17 15:27:50 -05:00
*
* @ return App
2015-12-23 19:31:17 -05:00
*/
2017-11-09 11:05:18 -05:00
function get_app ()
{
2018-06-25 20:44:35 -04:00
return BaseObject :: getApp ();
2012-04-09 08:04:49 -04:00
}
2010-07-01 19:48:07 -04:00
2015-12-23 19:31:17 -05:00
/**
* @ brief Multi - purpose function to check variable state .
*
* Usage : x ( $var ) or $x ( $array , 'key' )
*
* returns false if variable / key is not set
* if variable is set , returns 1 if has 'non-zero' value , otherwise returns 0.
* e . g . x ( '' ) or x ( 0 ) returns 0 ;
*
* @ param string | array $s variable to check
2017-11-09 11:05:18 -05:00
* @ param string $k key inside the array to check
2015-12-23 19:31:17 -05:00
*
* @ return bool | int
*/
2017-11-09 11:05:18 -05:00
function x ( $s , $k = null )
{
if ( $k != null ) {
2017-04-01 15:46:57 -04:00
if (( is_array ( $s )) && ( array_key_exists ( $k , $s ))) {
2017-01-26 08:28:43 -05:00
if ( $s [ $k ]) {
2015-12-23 19:31:17 -05:00
return ( int ) 1 ;
2017-01-26 08:28:43 -05:00
}
2015-12-23 19:31:17 -05:00
return ( int ) 0 ;
2017-01-26 08:28:43 -05:00
}
2015-12-23 19:31:17 -05:00
return false ;
2017-01-26 08:28:43 -05:00
} else {
if ( isset ( $s )) {
if ( $s ) {
2015-12-23 19:31:17 -05:00
return ( int ) 1 ;
2010-07-01 19:48:07 -04:00
}
2015-12-23 19:31:17 -05:00
return ( int ) 0 ;
2010-07-01 19:48:07 -04:00
}
2015-12-23 19:31:17 -05:00
return false ;
2010-07-01 19:48:07 -04:00
}
2012-04-09 08:04:49 -04:00
}
2010-07-01 19:48:07 -04:00
2018-01-01 14:50:47 -05:00
/**
* Return the provided variable value if it exists and is truthy or the provided
* default value instead .
*
* Works with initialized variables and potentially uninitialized array keys
*
* Usages :
* - defaults ( $var , $default )
* - defaults ( $array , 'key' , $default )
*
* @ brief Returns a defaut value if the provided variable or array key is falsy
* @ see x ()
* @ return mixed
*/
function defaults () {
$args = func_get_args ();
if ( count ( $args ) < 2 ) {
throw new BadFunctionCallException ( 'defaults() requires at least 2 parameters' );
}
if ( count ( $args ) > 3 ) {
throw new BadFunctionCallException ( 'defaults() cannot use more than 3 parameters' );
}
if ( count ( $args ) === 3 && is_null ( $args [ 1 ])) {
throw new BadFunctionCallException ( 'defaults($arr, $key, $def) $key is null' );
}
$default = array_pop ( $args );
if ( call_user_func_array ( 'x' , $args )) {
if ( count ( $args ) === 1 ) {
$return = $args [ 0 ];
} else {
$return = $args [ 0 ][ $args [ 1 ]];
}
} else {
$return = $default ;
}
return $return ;
}
2017-09-30 13:42:03 -04:00
/**
* @ brief Function to check if request was an AJAX ( xmlhttprequest ) request .
*
2017-11-19 16:47:21 -05:00
* @ param boolean $via_worker boolean Is the check run via the worker ?
2017-09-30 13:42:03 -04:00
*/
2017-11-09 11:05:18 -05:00
function check_db ( $via_worker )
{
2017-11-06 21:22:52 -05:00
$build = Config :: get ( 'system' , 'build' );
2017-12-22 09:48:29 -05:00
if ( empty ( $build )) {
2018-01-10 17:44:38 -05:00
Config :: set ( 'system' , 'build' , DB_UPDATE_VERSION - 1 );
2018-02-20 23:06:17 -05:00
$build = DB_UPDATE_VERSION - 1 ;
2013-01-18 20:37:45 -05:00
}
2017-12-22 09:48:29 -05:00
// We don't support upgrading from very old versions anymore
if ( $build < NEW_UPDATE_ROUTINE_VERSION ) {
die ( 'You try to update from a version prior to database version 1170. The direct upgrade path is not supported. Please update to version 3.5.4 before updating to this version.' );
}
2018-02-20 23:06:17 -05:00
if ( $build < DB_UPDATE_VERSION ) {
2017-09-30 12:45:35 -04:00
// When we cannot execute the database update via the worker, we will do it directly
2017-11-18 02:31:33 -05:00
if ( ! Worker :: add ( PRIORITY_CRITICAL , 'DBUpdate' ) && $via_worker ) {
2018-01-04 09:51:05 -05:00
update_db ();
2017-09-30 12:45:35 -04:00
}
2017-01-26 08:28:43 -05:00
}
2013-01-18 20:37:45 -05:00
}
2015-12-23 19:31:17 -05:00
/**
* @ brief Automatic database updates
2017-11-09 11:05:18 -05:00
* @ param object $a App
2015-12-23 19:31:17 -05:00
*/
2018-01-03 21:12:19 -05:00
function update_db ()
2017-11-09 11:05:18 -05:00
{
2017-11-06 21:22:52 -05:00
$build = Config :: get ( 'system' , 'build' );
2017-12-22 09:48:29 -05:00
2018-01-10 17:44:38 -05:00
if ( empty ( $build ) || ( $build > DB_UPDATE_VERSION )) {
$build = DB_UPDATE_VERSION - 1 ;
Config :: set ( 'system' , 'build' , $build );
2017-01-26 08:28:43 -05:00
}
2012-08-13 19:46:24 -04:00
2017-01-26 08:28:43 -05:00
if ( $build != DB_UPDATE_VERSION ) {
2017-12-22 09:56:40 -05:00
require_once 'update.php' ;
2015-12-23 19:31:17 -05:00
$stored = intval ( $build );
$current = intval ( DB_UPDATE_VERSION );
2017-01-26 08:28:43 -05:00
if ( $stored < $current ) {
2017-01-18 16:45:32 -05:00
Config :: load ( 'database' );
2015-12-23 19:31:17 -05:00
2017-12-22 09:48:29 -05:00
// Compare the current structure with the defined structure
$t = Config :: get ( 'database' , 'dbupdate_' . DB_UPDATE_VERSION );
if ( ! is_null ( $t )) {
return ;
}
2013-01-19 01:38:49 -05:00
2018-07-20 15:47:16 -04:00
// run the pre_update_nnnn functions in update.php
for ( $x = $stored + 1 ; $x <= $current ; $x ++ ) {
$r = run_update_function ( $x , 'pre_update' );
if ( ! $r ) {
break ;
}
}
2017-12-22 09:48:29 -05:00
Config :: set ( 'database' , 'dbupdate_' . DB_UPDATE_VERSION , time ());
2018-07-20 15:47:16 -04:00
// update the structure in one call
2017-12-22 09:48:29 -05:00
$retval = DBStructure :: update ( false , true );
if ( $retval ) {
DBStructure :: updateFail (
DB_UPDATE_VERSION ,
$retval
);
return ;
} else {
Config :: set ( 'database' , 'dbupdate_' . DB_UPDATE_VERSION , 'success' );
}
2015-12-23 19:31:17 -05:00
2018-07-20 15:47:16 -04:00
// run the update_nnnn functions in update.php
2017-12-22 16:31:32 -05:00
for ( $x = $stored + 1 ; $x <= $current ; $x ++ ) {
2018-07-20 15:47:16 -04:00
$r = run_update_function ( $x , 'update' );
2017-12-22 09:48:29 -05:00
if ( ! $r ) {
break ;
2010-08-14 22:31:10 -04:00
}
}
}
2013-01-14 22:31:32 -05:00
}
2015-12-23 19:31:17 -05:00
return ;
2013-01-14 22:31:32 -05:00
}
2015-12-23 19:31:17 -05:00
2018-07-20 15:47:16 -04:00
function run_update_function ( $x , $prefix )
2017-11-09 11:05:18 -05:00
{
2018-07-20 15:47:16 -04:00
$funcname = $prefix . '_' . $x ;
if ( function_exists ( $funcname )) {
2015-12-23 19:31:17 -05:00
// There could be a lot of processes running or about to run.
// We want exactly one process to run the update command.
// So store the fact that we're taking responsibility
// after first checking to see if somebody else already has.
// If the update fails or times-out completely you may need to
// delete the config entry to try again.
2018-07-20 15:47:16 -04:00
$t = Config :: get ( 'database' , $funcname );
2017-12-06 14:57:06 -05:00
if ( ! is_null ( $t )) {
2015-12-23 19:31:17 -05:00
return false ;
2017-01-26 08:28:43 -05:00
}
2018-07-20 15:47:16 -04:00
Config :: set ( 'database' , $funcname , time ());
2015-12-23 19:31:17 -05:00
// call the specific update
2018-07-20 15:47:16 -04:00
$retval = $funcname ();
2015-12-23 19:31:17 -05:00
2017-01-26 08:28:43 -05:00
if ( $retval ) {
2015-12-23 19:31:17 -05:00
//send the administrator an e-mail
2017-12-14 16:13:02 -05:00
DBStructure :: updateFail (
2015-12-23 19:31:17 -05:00
$x ,
2018-01-23 12:47:30 -05:00
L10n :: t ( 'Update %s failed. See error logs.' , $x )
2015-12-23 19:31:17 -05:00
);
return false ;
2014-09-07 11:28:38 -04:00
} else {
2018-07-20 15:47:16 -04:00
Config :: set ( 'database' , $funcname , 'success' );
2018-07-22 12:53:46 -04:00
if ( $prefix == 'update' ) {
2018-07-20 15:47:16 -04:00
Config :: set ( 'system' , 'build' , $x );
}
2018-07-22 12:53:46 -04:00
2014-09-07 11:28:38 -04:00
return true ;
}
2015-12-23 19:31:17 -05:00
} else {
2018-07-20 15:47:16 -04:00
Config :: set ( 'database' , $funcname , 'success' );
2018-07-22 12:53:46 -04:00
if ( $prefix == 'update' ) {
2018-07-20 15:47:16 -04:00
Config :: set ( 'system' , 'build' , $x );
}
2018-07-22 12:53:46 -04:00
2014-09-07 11:28:38 -04:00
return true ;
}
}
2013-01-14 22:31:32 -05:00
2015-12-23 19:31:17 -05:00
/**
* @ brief Used to end the current process , after saving session state .
2018-02-03 00:46:05 -05:00
* @ deprecated
2015-12-23 19:31:17 -05:00
*/
2017-11-09 11:05:18 -05:00
function killme ()
{
2017-03-24 16:17:00 -04:00
exit ();
2012-04-09 08:04:49 -04:00
}
2010-07-01 19:48:07 -04:00
2015-12-23 19:31:17 -05:00
/**
* @ brief Returns the user id of locally logged in user or false .
2016-10-01 23:29:30 -04:00
*
2015-12-23 19:31:17 -05:00
* @ return int | bool user id or false
*/
2017-11-09 11:05:18 -05:00
function local_user ()
{
2018-07-10 08:27:56 -04:00
if ( ! empty ( $_SESSION [ 'authenticated' ]) && ! empty ( $_SESSION [ 'uid' ])) {
2015-12-23 19:31:17 -05:00
return intval ( $_SESSION [ 'uid' ]);
2017-03-06 05:06:05 -05:00
}
2015-12-23 19:31:17 -05:00
return false ;
2012-04-09 08:04:49 -04:00
}
2010-07-01 19:48:07 -04:00
2017-03-06 05:06:05 -05:00
/**
* @ brief Returns the public contact id of logged in user or false .
*
* @ return int | bool public contact id or false
*/
2017-11-09 11:05:18 -05:00
function public_contact ()
{
2017-03-06 05:06:05 -05:00
static $public_contact_id = false ;
if ( ! $public_contact_id && x ( $_SESSION , 'authenticated' )) {
if ( x ( $_SESSION , 'my_address' )) {
// Local user
2018-03-01 19:54:45 -05:00
$public_contact_id = intval ( Contact :: getIdForURL ( $_SESSION [ 'my_address' ], 0 , true ));
2017-03-23 15:48:48 -04:00
} elseif ( x ( $_SESSION , 'visitor_home' )) {
2017-03-06 05:06:05 -05:00
// Remote user
2018-03-01 19:54:45 -05:00
$public_contact_id = intval ( Contact :: getIdForURL ( $_SESSION [ 'visitor_home' ], 0 , true ));
2017-03-06 05:06:05 -05:00
}
2017-03-23 15:48:48 -04:00
} elseif ( ! x ( $_SESSION , 'authenticated' )) {
2017-03-06 05:06:05 -05:00
$public_contact_id = false ;
}
return $public_contact_id ;
}
2015-12-23 19:31:17 -05:00
/**
2015-12-24 05:58:42 -05:00
* @ brief Returns contact id of authenticated site visitor or false
2016-10-01 23:29:30 -04:00
*
2015-12-23 19:31:17 -05:00
* @ return int | bool visitor_id or false
*/
2017-11-09 11:05:18 -05:00
function remote_user ()
{
2018-04-12 11:10:48 -04:00
// You cannot be both local and remote.
// Unncommented by rabuzarus because remote authentication to local
// profiles wasn't possible anymore (2018-04-12).
// if (local_user()) {
// return false;
// }
2018-07-10 08:27:56 -04:00
if ( empty ( $_SESSION )) {
return false ;
}
2017-12-22 09:48:29 -05:00
if ( x ( $_SESSION , 'authenticated' ) && x ( $_SESSION , 'visitor_id' )) {
2015-12-23 19:31:17 -05:00
return intval ( $_SESSION [ 'visitor_id' ]);
2017-01-26 08:28:43 -05:00
}
2015-12-23 19:31:17 -05:00
return false ;
2012-04-09 08:04:49 -04:00
}
2010-07-01 19:48:07 -04:00
2015-12-23 19:31:17 -05:00
/**
* @ brief Show an error message to user .
*
* This function save text in session , to be shown to the user at next page load
*
* @ param string $s - Text of notice
*/
2017-11-09 11:05:18 -05:00
function notice ( $s )
{
2018-07-15 14:36:20 -04:00
if ( empty ( $_SESSION )) {
return ;
}
2015-12-23 19:31:17 -05:00
$a = get_app ();
2017-05-02 22:42:29 -04:00
if ( ! x ( $_SESSION , 'sysmsg' )) {
2018-01-15 08:05:12 -05:00
$_SESSION [ 'sysmsg' ] = [];
2017-01-26 08:28:43 -05:00
}
if ( $a -> interactive ) {
2015-12-23 19:31:17 -05:00
$_SESSION [ 'sysmsg' ][] = $s ;
2017-01-26 08:28:43 -05:00
}
2012-04-09 08:04:49 -04:00
}
2014-04-25 20:22:30 -04:00
2015-12-23 19:31:17 -05:00
/**
* @ brief Show an info message to user .
*
* This function save text in session , to be shown to the user at next page load
*
* @ param string $s - Text of notice
*/
2017-11-09 11:05:18 -05:00
function info ( $s )
{
2015-12-23 19:31:17 -05:00
$a = get_app ();
2014-04-25 20:22:30 -04:00
2017-11-06 21:22:52 -05:00
if ( local_user () && PConfig :: get ( local_user (), 'system' , 'ignore_info' )) {
2015-12-23 19:31:17 -05:00
return ;
2017-01-26 08:28:43 -05:00
}
2011-05-23 05:39:57 -04:00
2017-05-02 22:42:29 -04:00
if ( ! x ( $_SESSION , 'sysmsg_info' )) {
2018-01-15 08:05:12 -05:00
$_SESSION [ 'sysmsg_info' ] = [];
2017-01-26 08:28:43 -05:00
}
if ( $a -> interactive ) {
2015-12-23 19:31:17 -05:00
$_SESSION [ 'sysmsg_info' ][] = $s ;
2017-01-26 08:28:43 -05:00
}
2015-12-23 19:31:17 -05:00
}
2010-07-08 10:03:25 -04:00
2017-11-09 11:05:18 -05:00
function feed_birthday ( $uid , $tz )
{
2015-12-23 19:31:17 -05:00
/**
* Determine the next birthday , but only if the birthday is published
* in the default profile . We _could_ also look for a private profile that the
* recipient can see , but somebody could get mad at us if they start getting
* public birthday greetings when they haven ' t made this info public .
*
* Assuming we are able to publish this info , we are then going to convert
* the start time from the owner ' s timezone to UTC .
*
* This will potentially solve the problem found with some social networks
* where birthdays are converted to the viewer ' s timezone and salutations from
* elsewhere in the world show up on the wrong day . We will convert it to the
* viewer ' s timezone also , but first we are going to convert it from the birthday
* person ' s timezone to GMT - so the viewer may find the birthday starting at
* 6 : 00 PM the day before , but that will correspond to midnight to the birthday person .
*/
$birthday = '' ;
2012-04-09 08:04:49 -04:00
2017-05-02 22:42:29 -04:00
if ( ! strlen ( $tz )) {
2015-12-23 19:31:17 -05:00
$tz = 'UTC' ;
2017-01-26 08:28:43 -05:00
}
2012-04-09 08:04:49 -04:00
2018-08-19 08:46:11 -04:00
$profile = DBA :: selectFirst ( 'profile' , [ 'dob' ], [ 'is-default' => true , 'uid' => $uid ]);
if ( DBA :: isResult ( $profile )) {
$tmp_dob = substr ( $profile [ 'dob' ], 5 );
2017-01-26 08:28:43 -05:00
if ( intval ( $tmp_dob )) {
2018-01-26 21:38:34 -05:00
$y = DateTimeFormat :: timezoneNow ( $tz , 'Y' );
2015-12-23 19:31:17 -05:00
$bd = $y . '-' . $tmp_dob . ' 00:00' ;
$t_dob = strtotime ( $bd );
2018-01-26 21:38:34 -05:00
$now = strtotime ( DateTimeFormat :: timezoneNow ( $tz ));
2017-01-26 08:28:43 -05:00
if ( $t_dob < $now ) {
2015-12-23 19:31:17 -05:00
$bd = $y + 1 . '-' . $tmp_dob . ' 00:00' ;
2017-01-26 08:28:43 -05:00
}
2018-01-26 21:38:34 -05:00
$birthday = DateTimeFormat :: convert ( $bd , 'UTC' , $tz , DateTimeFormat :: ATOM );
2011-02-07 01:41:07 -05:00
}
2012-04-09 08:04:49 -04:00
}
2015-12-23 19:31:17 -05:00
return $birthday ;
2012-04-09 08:04:49 -04:00
}
2011-02-07 20:06:04 -05:00
2015-12-23 19:31:17 -05:00
/**
* @ brief Check if current user has admin role .
*
* @ return bool true if user is an admin
*/
2017-11-09 11:05:18 -05:00
function is_site_admin ()
{
2015-12-23 19:31:17 -05:00
$a = get_app ();
2013-12-01 18:11:31 -05:00
2018-07-07 17:46:30 -04:00
$admin_email = Config :: get ( 'config' , 'admin_email' );
2013-12-01 18:11:31 -05:00
2018-07-07 17:46:30 -04:00
$adminlist = explode ( ',' , str_replace ( ' ' , '' , $admin_email ));
return local_user () && $admin_email && in_array ( defaults ( $a -> user , 'email' , '' ), $adminlist );
2012-04-09 08:04:49 -04:00
}
2011-05-23 20:18:36 -04:00
2012-06-14 10:04:13 -04:00
/**
2015-12-23 19:31:17 -05:00
* @ brief Returns querystring as string from a mapped array .
*
2017-11-09 11:05:18 -05:00
* @ param array $params mapped array with query parameters
* @ param string $name of parameter , default null
2015-12-23 19:31:17 -05:00
*
* @ return string
*/
2017-11-09 11:05:18 -05:00
function build_querystring ( $params , $name = null )
{
2015-08-11 17:26:00 -04:00
$ret = " " ;
2017-03-23 15:48:48 -04:00
foreach ( $params as $key => $val ) {
2017-01-26 08:28:43 -05:00
if ( is_array ( $val )) {
2017-03-23 15:48:48 -04:00
/// @TODO maybe not compare against null, use is_null()
if ( $name == null ) {
2015-08-11 17:26:00 -04:00
$ret .= build_querystring ( $val , $key );
} else {
2017-05-02 22:42:29 -04:00
$ret .= build_querystring ( $val , $name . " [ $key ] " );
2015-08-11 17:26:00 -04:00
}
} else {
$val = urlencode ( $val );
2017-03-23 15:48:48 -04:00
/// @TODO maybe not compare against null, use is_null()
if ( $name != null ) {
/// @TODO two string concated, can be merged to one
$ret .= $name . " [ $key ] " . " = $val & " ;
2015-08-11 17:26:00 -04:00
} else {
2017-03-23 15:48:48 -04:00
$ret .= " $key = $val & " ;
2015-08-11 17:26:00 -04:00
}
}
}
return $ret ;
2012-06-14 10:04:13 -04:00
}
2012-09-12 23:35:51 -04:00
2017-11-09 11:05:18 -05:00
function explode_querystring ( $query )
{
2013-01-26 14:52:21 -05:00
$arg_st = strpos ( $query , '?' );
2017-01-26 08:28:43 -05:00
if ( $arg_st !== false ) {
2013-01-26 14:52:21 -05:00
$base = substr ( $query , 0 , $arg_st );
$arg_st += 1 ;
2015-08-11 17:26:00 -04:00
} else {
2013-01-26 14:52:21 -05:00
$base = '' ;
$arg_st = 0 ;
}
$args = explode ( '&' , substr ( $query , $arg_st ));
2017-03-23 15:48:48 -04:00
foreach ( $args as $k => $arg ) {
/// @TODO really compare type-safe here?
2017-01-26 08:28:43 -05:00
if ( $arg === '' ) {
2013-01-26 14:52:21 -05:00
unset ( $args [ $k ]);
2017-01-26 08:28:43 -05:00
}
2013-01-26 14:52:21 -05:00
}
$args = array_values ( $args );
2017-01-26 08:28:43 -05:00
if ( ! $base ) {
2013-01-26 14:52:21 -05:00
$base = $args [ 0 ];
unset ( $args [ 0 ]);
$args = array_values ( $args );
}
2018-01-15 08:05:12 -05:00
return [
2013-01-26 14:52:21 -05:00
'base' => $base ,
'args' => $args ,
2018-01-15 08:05:12 -05:00
];
2013-01-26 14:52:21 -05:00
}
2012-09-12 23:35:51 -04:00
/**
2017-05-02 22:42:29 -04:00
* Returns the complete URL of the current page , e . g .: http ( s ) :// something . com / network
*
* Taken from http :// webcheatsheet . com / php / get_current_page_url . php
*/
2017-11-09 11:05:18 -05:00
function curPageURL ()
{
2012-09-12 23:35:51 -04:00
$pageURL = 'http' ;
2018-07-23 07:43:18 -04:00
if ( ! empty ( $_SERVER [ " HTTPS " ]) && ( $_SERVER [ " HTTPS " ] == " on " )) {
2017-01-26 08:28:43 -05:00
$pageURL .= " s " ;
}
2017-03-23 15:48:48 -04:00
2012-09-12 23:35:51 -04:00
$pageURL .= " :// " ;
2017-03-23 15:48:48 -04:00
2012-09-12 23:35:51 -04:00
if ( $_SERVER [ " SERVER_PORT " ] != " 80 " && $_SERVER [ " SERVER_PORT " ] != " 443 " ) {
2017-05-02 22:42:29 -04:00
$pageURL .= $_SERVER [ " SERVER_NAME " ] . " : " . $_SERVER [ " SERVER_PORT " ] . $_SERVER [ " REQUEST_URI " ];
2012-09-12 23:35:51 -04:00
} else {
2017-05-02 22:42:29 -04:00
$pageURL .= $_SERVER [ " SERVER_NAME " ] . $_SERVER [ " REQUEST_URI " ];
2012-09-12 23:35:51 -04:00
}
return $pageURL ;
}
2012-10-15 19:28:43 -04:00
2017-11-09 11:05:18 -05:00
function random_digits ( $digits )
{
2012-11-01 19:14:42 -04:00
$rn = '' ;
2017-01-26 08:28:43 -05:00
for ( $i = 0 ; $i < $digits ; $i ++ ) {
2017-03-23 15:48:48 -04:00
/// @TODO Avoid rand/mt_rand, when it comes to cryptography, they are generating predictable (seedable) numbers.
2017-05-02 22:42:29 -04:00
$rn .= rand ( 0 , 9 );
2012-11-01 19:14:42 -04:00
}
return $rn ;
}
2012-11-16 18:50:39 -05:00
2017-11-09 11:05:18 -05:00
function get_server ()
{
2017-11-06 21:22:52 -05:00
$server = Config :: get ( " system " , " directory " );
2015-08-23 05:05:10 -04:00
2017-01-26 08:28:43 -05:00
if ( $server == " " ) {
2018-04-27 20:56:34 -04:00
$server = " https://dir.friendica.social " ;
2017-01-26 08:28:43 -05:00
}
2015-08-23 05:05:10 -04:00
2017-03-23 15:48:48 -04:00
return $server ;
2015-08-23 05:05:10 -04:00
}
2017-11-09 11:05:18 -05:00
function get_temppath ()
{
2017-07-08 11:25:13 -04:00
$a = get_app ();
2017-11-06 21:22:52 -05:00
$temppath = Config :: get ( " system " , " temppath " );
2017-07-08 11:25:13 -04:00
2018-10-09 13:58:58 -04:00
if (( $temppath != " " ) && App :: isDirectoryUsable ( $temppath )) {
2017-07-08 11:25:13 -04:00
// We have a temp path and it is usable
2018-10-09 13:58:58 -04:00
return App :: getRealPath ( $temppath );
2017-07-08 11:25:13 -04:00
}
// We don't have a working preconfigured temp path, so we take the system path.
$temppath = sys_get_temp_dir ();
// Check if it is usable
2018-10-09 13:58:58 -04:00
if (( $temppath != " " ) && App :: isDirectoryUsable ( $temppath )) {
2017-07-22 01:50:25 -04:00
// Always store the real path, not the path through symlinks
2018-10-09 13:58:58 -04:00
$temppath = App :: getRealPath ( $temppath );
2017-07-22 01:50:25 -04:00
2017-07-08 11:25:13 -04:00
// To avoid any interferences with other systems we create our own directory
2018-10-09 13:58:58 -04:00
$new_temppath = $temppath . " / " . $a -> getHostName ();
2017-07-08 11:25:13 -04:00
if ( ! is_dir ( $new_temppath )) {
/// @TODO There is a mkdir()+chmod() upwards, maybe generalize this (+ configurable) into a function/method?
mkdir ( $new_temppath );
}
2018-10-09 13:58:58 -04:00
if ( App :: isDirectoryUsable ( $new_temppath )) {
2017-07-08 11:25:13 -04:00
// The new path is usable, we are happy
2017-11-06 21:22:52 -05:00
Config :: set ( " system " , " temppath " , $new_temppath );
2017-07-08 11:25:13 -04:00
return $new_temppath ;
} else {
// We can't create a subdirectory, strange.
// But the directory seems to work, so we use it but don't store it.
return $temppath ;
}
}
// Reaching this point means that the operating system is configured badly.
return '' ;
}
2017-11-09 11:05:18 -05:00
function get_cachefile ( $file , $writemode = true )
{
2014-06-22 19:24:39 -04:00
$cache = get_itemcachepath ();
2012-11-16 18:50:39 -05:00
2017-05-02 22:42:29 -04:00
if (( ! $cache ) || ( ! is_dir ( $cache ))) {
2017-03-23 15:48:48 -04:00
return " " ;
2017-01-26 08:28:43 -05:00
}
2012-11-16 18:50:39 -05:00
2017-03-23 15:48:48 -04:00
$subfolder = $cache . " / " . substr ( $file , 0 , 2 );
2012-11-16 18:50:39 -05:00
2017-03-23 15:48:48 -04:00
$cachepath = $subfolder . " / " . $file ;
2012-11-16 18:50:39 -05:00
if ( $writemode ) {
if ( ! is_dir ( $subfolder )) {
mkdir ( $subfolder );
chmod ( $subfolder , 0777 );
}
}
2017-03-24 16:05:08 -04:00
return $cachepath ;
2012-11-16 18:50:39 -05:00
}
2017-11-09 11:05:18 -05:00
function clear_cache ( $basepath = " " , $path = " " )
{
2012-11-16 18:50:39 -05:00
if ( $path == " " ) {
2014-06-22 19:24:39 -04:00
$basepath = get_itemcachepath ();
2012-11-16 18:50:39 -05:00
$path = $basepath ;
}
2017-06-07 22:00:59 -04:00
if (( $path == " " ) || ( ! is_dir ( $path ))) {
2012-11-16 18:50:39 -05:00
return ;
2017-01-26 08:28:43 -05:00
}
2012-11-16 18:50:39 -05:00
2017-01-26 08:28:43 -05:00
if ( substr ( realpath ( $path ), 0 , strlen ( $basepath )) != $basepath ) {
2012-11-16 18:50:39 -05:00
return ;
2017-01-26 08:28:43 -05:00
}
2012-11-16 18:50:39 -05:00
2017-11-06 21:22:52 -05:00
$cachetime = ( int ) Config :: get ( 'system' , 'itemcache_duration' );
2017-01-26 08:28:43 -05:00
if ( $cachetime == 0 ) {
2012-11-16 18:50:39 -05:00
$cachetime = 86400 ;
2017-01-26 08:28:43 -05:00
}
2012-11-16 18:50:39 -05:00
2017-05-02 22:42:29 -04:00
if ( is_writable ( $path )) {
2015-08-11 17:26:00 -04:00
if ( $dh = opendir ( $path )) {
while (( $file = readdir ( $dh )) !== false ) {
2017-05-02 22:42:29 -04:00
$fullpath = $path . " / " . $file ;
2017-06-08 21:03:44 -04:00
if (( filetype ( $fullpath ) == " dir " ) && ( $file != " . " ) && ( $file != " .. " )) {
2015-08-11 17:26:00 -04:00
clear_cache ( $basepath , $fullpath );
2017-01-26 08:28:43 -05:00
}
2017-06-08 21:03:44 -04:00
if (( filetype ( $fullpath ) == " file " ) && ( filectime ( $fullpath ) < ( time () - $cachetime ))) {
2015-08-11 17:26:00 -04:00
unlink ( $fullpath );
2017-01-26 08:28:43 -05:00
}
2015-08-11 17:26:00 -04:00
}
closedir ( $dh );
2012-11-16 18:50:39 -05:00
}
2013-10-21 14:03:01 -04:00
}
2012-11-16 18:50:39 -05:00
}
2012-12-23 08:16:35 -05:00
2017-11-09 11:05:18 -05:00
function get_itemcachepath ()
{
2014-06-22 19:24:39 -04:00
// Checking, if the cache is deactivated
2017-11-06 21:22:52 -05:00
$cachetime = ( int ) Config :: get ( 'system' , 'itemcache_duration' );
2017-01-26 08:28:43 -05:00
if ( $cachetime < 0 ) {
2014-06-22 19:24:39 -04:00
return " " ;
2017-01-26 08:28:43 -05:00
}
2014-06-22 19:24:39 -04:00
2017-11-06 21:22:52 -05:00
$itemcache = Config :: get ( 'system' , 'itemcache' );
2018-10-09 13:58:58 -04:00
if (( $itemcache != " " ) && App :: isDirectoryUsable ( $itemcache )) {
return App :: getRealPath ( $itemcache );
2017-02-15 16:46:29 -05:00
}
2014-06-22 19:24:39 -04:00
$temppath = get_temppath ();
if ( $temppath != " " ) {
2017-05-02 22:42:29 -04:00
$itemcache = $temppath . " /itemcache " ;
2017-01-26 08:28:43 -05:00
if ( ! file_exists ( $itemcache ) && ! is_dir ( $itemcache )) {
2015-03-29 07:56:26 -04:00
mkdir ( $itemcache );
}
2014-06-22 19:24:39 -04:00
2018-10-09 13:58:58 -04:00
if ( App :: isDirectoryUsable ( $itemcache )) {
2017-11-06 21:22:52 -05:00
Config :: set ( " system " , " itemcache " , $itemcache );
2017-02-19 03:23:21 -05:00
return $itemcache ;
2014-06-22 19:24:39 -04:00
}
}
return " " ;
}
2016-12-01 17:50:07 -05:00
/**
* @ brief Returns the path where spool files are stored
*
* @ return string Spool path
*/
2017-11-09 11:05:18 -05:00
function get_spoolpath ()
{
2017-11-06 21:22:52 -05:00
$spoolpath = Config :: get ( 'system' , 'spoolpath' );
2018-10-09 13:58:58 -04:00
if (( $spoolpath != " " ) && App :: isDirectoryUsable ( $spoolpath )) {
2017-02-19 03:23:21 -05:00
// We have a spool path and it is usable
return $spoolpath ;
2016-12-01 17:50:07 -05:00
}
2016-12-01 08:50:26 -05:00
2017-02-19 03:23:21 -05:00
// We don't have a working preconfigured spool path, so we take the temp path.
2016-12-01 08:50:26 -05:00
$temppath = get_temppath ();
if ( $temppath != " " ) {
2017-02-19 03:23:21 -05:00
// To avoid any interferences with other systems we create our own directory
2017-05-02 22:42:29 -04:00
$spoolpath = $temppath . " /spool " ;
2016-12-01 17:50:07 -05:00
if ( ! is_dir ( $spoolpath )) {
2016-12-01 08:50:26 -05:00
mkdir ( $spoolpath );
2016-12-01 17:50:07 -05:00
}
2016-12-01 08:50:26 -05:00
2018-10-09 13:58:58 -04:00
if ( App :: isDirectoryUsable ( $spoolpath )) {
2017-02-19 03:23:21 -05:00
// The new path is usable, we are happy
2017-11-06 21:22:52 -05:00
Config :: set ( " system " , " spoolpath " , $spoolpath );
2017-02-19 03:23:21 -05:00
return $spoolpath ;
} else {
// We can't create a subdirectory, strange.
// But the directory seems to work, so we use it but don't store it.
return $temppath ;
2016-12-01 08:50:26 -05:00
}
}
2017-02-19 03:23:21 -05:00
// Reaching this point means that the operating system is configured badly.
2016-12-01 08:50:26 -05:00
return " " ;
}
2017-01-26 08:28:43 -05:00
if ( ! function_exists ( 'exif_imagetype' )) {
2017-11-09 11:05:18 -05:00
function exif_imagetype ( $file )
{
2015-06-26 12:57:20 -04:00
$size = getimagesize ( $file );
2017-03-24 16:05:08 -04:00
return $size [ 2 ];
2015-06-26 12:57:20 -04:00
}
2013-10-22 10:08:29 -04:00
}
2015-09-13 12:47:10 -04:00
2017-11-09 11:05:18 -05:00
function validate_include ( & $file )
{
2015-09-13 12:47:10 -04:00
$orig_file = $file ;
$file = realpath ( $file );
2017-01-26 08:28:43 -05:00
if ( strpos ( $file , getcwd ()) !== 0 ) {
2015-09-13 12:47:10 -04:00
return false ;
2017-01-26 08:28:43 -05:00
}
2015-09-13 12:47:10 -04:00
2017-05-02 22:42:29 -04:00
$file = str_replace ( getcwd () . " / " , " " , $file , $count );
2017-01-26 08:28:43 -05:00
if ( $count != 1 ) {
2015-09-13 12:47:10 -04:00
return false ;
2017-01-26 08:28:43 -05:00
}
2015-09-13 12:47:10 -04:00
2017-01-26 08:28:43 -05:00
if ( $orig_file !== $file ) {
2015-09-13 12:47:10 -04:00
return false ;
2017-01-26 08:28:43 -05:00
}
2015-09-13 12:47:10 -04:00
$valid = false ;
2017-01-26 08:28:43 -05:00
if ( strpos ( $file , " include/ " ) === 0 ) {
2015-09-13 12:47:10 -04:00
$valid = true ;
2017-01-26 08:28:43 -05:00
}
2015-09-13 12:47:10 -04:00
2017-01-26 08:28:43 -05:00
if ( strpos ( $file , " addon/ " ) === 0 ) {
2015-09-13 12:47:10 -04:00
$valid = true ;
2017-01-26 08:28:43 -05:00
}
2015-09-13 12:47:10 -04:00
2017-01-26 08:28:43 -05:00
// Simply return flag
2017-03-23 15:48:48 -04:00
return $valid ;
2015-09-13 12:47:10 -04:00
}