2008-05-20 14:05:35 +01:00
< ? php
2019-09-11 06:15:16 +01:00
// This file is part of GNU social - https://www.gnu.org/software/social
//
// GNU social is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU social is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with GNU social. If not, see <http://www.gnu.org/licenses/>.
2008-05-20 14:05:35 +01:00
2009-01-13 16:44:09 +00:00
/* XXX: break up into separate modules (HTTP, user, files) */
2008-05-20 14:05:35 +01:00
2019-09-11 06:15:16 +01:00
defined ( 'GNUSOCIAL' ) || die ();
2010-09-12 23:14:36 +01:00
/**
* Show a server error .
*/
2008-12-23 19:33:23 +00:00
function common_server_error ( $msg , $code = 500 )
{
2009-01-23 05:57:08 +00:00
$err = new ServerErrorAction ( $msg , $code );
$err -> showPage ();
2008-05-20 14:05:35 +01:00
}
2010-09-12 23:14:36 +01:00
/**
* Show a user error .
*/
2008-12-23 19:33:23 +00:00
function common_user_error ( $msg , $code = 400 )
{
2009-01-23 05:57:08 +00:00
$err = new ClientErrorAction ( $msg , $code );
$err -> showPage ();
2008-05-20 14:05:35 +01:00
}
2010-05-19 18:10:55 +01:00
/**
* This should only be used at setup ; processes switching languages
* to send text to other users should use common_switch_locale () .
2010-09-06 14:56:45 +01:00
*
2010-05-19 18:10:55 +01:00
* @ param string $language Locale language code ( optional ; empty uses
* current user ' s preference or site default )
* @ return mixed success
*/
2008-12-23 19:33:23 +00:00
function common_init_locale ( $language = null )
{
2019-06-04 18:56:20 +01:00
if ( ! $language ) {
2008-12-04 20:34:33 +00:00
$language = common_language ();
}
putenv ( 'LANGUAGE=' . $language );
putenv ( 'LANG=' . $language );
2019-09-11 06:15:16 +01:00
$ok = setlocale (
LC_ALL ,
$language . '.utf8' ,
$language . '.UTF8' ,
$language . '.utf-8' ,
$language . '.UTF-8' ,
$language
);
2010-04-20 11:06:54 +01:00
return $ok ;
2008-12-04 20:34:33 +00:00
}
2010-05-19 18:10:55 +01:00
/**
* Initialize locale and charset settings and gettext with our message catalog ,
* using the current user ' s language preference or the site default .
2010-09-06 14:56:45 +01:00
*
2010-05-19 18:10:55 +01:00
* This should generally only be run at framework initialization ; code switching
* languages at runtime should call common_switch_language () .
2010-09-06 14:56:45 +01:00
*
2010-05-19 18:10:55 +01:00
* @ access private
*/
2008-12-23 19:33:23 +00:00
function common_init_language ()
{
2008-12-21 00:30:16 +00:00
mb_internal_encoding ( 'UTF-8' );
2009-10-16 18:42:27 +01:00
2009-11-25 19:20:41 +00:00
// Note that this setlocale() call may "fail" but this is harmless;
// gettext will still select the right language.
2008-12-21 00:30:16 +00:00
$language = common_language ();
$locale_set = common_init_locale ( $language );
2010-01-03 02:27:04 +00:00
2010-03-09 16:38:16 +00:00
if ( ! $locale_set ) {
// The requested locale doesn't exist on the system.
//
// gettext seems very picky... We first need to setlocale()
// to a locale which _does_ exist on the system, and _then_
// we can set in another locale that may not be set up
// (say, ga_ES for Galego/Galician) it seems to take it.
//
// For some reason C and POSIX which are guaranteed to work
// don't do the job. en_US.UTF-8 should be there most of the
// time, but not guaranteed.
$ok = common_init_locale ( " en_US " );
2010-07-12 17:56:32 +01:00
if ( ! $ok && strtolower ( substr ( PHP_OS , 0 , 3 )) != 'win' ) {
// Try to find a complete, working locale on Unix/Linux...
2010-03-09 16:38:16 +00:00
// @fixme shelling out feels awfully inefficient
// but I don't think there's a more standard way.
$all = `locale -a` ;
foreach ( explode ( " \n " , $all ) as $locale ) {
if ( preg_match ( '/\.utf[-_]?8$/i' , $locale )) {
$ok = setlocale ( LC_ALL , $locale );
if ( $ok ) {
break ;
}
}
}
2010-07-12 17:56:32 +01:00
}
if ( ! $ok ) {
common_log ( LOG_ERR , " Unable to find a UTF-8 locale on this system; UI translations may not work. " );
2010-03-09 16:38:16 +00:00
}
$locale_set = common_init_locale ( $language );
}
2010-04-20 11:06:54 +01:00
common_init_gettext ();
}
/**
* @ access private
*/
function common_init_gettext ()
{
setlocale ( LC_CTYPE , 'C' );
// So we do not have to make people install the gettext locales
2019-06-04 18:56:20 +01:00
$path = common_config ( 'site' , 'locale_path' );
2010-04-20 11:06:54 +01:00
bindtextdomain ( " statusnet " , $path );
bind_textdomain_codeset ( " statusnet " , " UTF-8 " );
textdomain ( " statusnet " );
}
/**
* Switch locale during runtime , and poke gettext until it cries uncle .
* Otherwise , sometimes it doesn ' t actually switch away from the old language .
*
* @ param string $language code for locale ( 'en' , 'fr' , 'pt_BR' etc )
*/
function common_switch_locale ( $language = null )
{
common_init_locale ( $language );
2009-10-16 18:42:27 +01:00
setlocale ( LC_CTYPE , 'C' );
2009-11-08 22:32:15 +00:00
// So we do not have to make people install the gettext locales
2019-06-04 18:56:20 +01:00
$path = common_config ( 'site' , 'locale_path' );
2009-10-16 18:42:27 +01:00
bindtextdomain ( " statusnet " , $path );
2009-08-25 23:53:24 +01:00
bind_textdomain_codeset ( " statusnet " , " UTF-8 " );
textdomain ( " statusnet " );
2008-08-06 05:04:33 +01:00
}
2008-12-23 19:33:23 +00:00
function common_timezone ()
{
2008-12-21 00:30:16 +00:00
if ( common_logged_in ()) {
$user = common_current_user ();
if ( $user -> timezone ) {
return $user -> timezone ;
}
}
2008-07-20 15:13:25 +01:00
2009-03-10 01:01:35 +00:00
return common_config ( 'site' , 'timezone' );
2008-07-20 15:13:25 +01:00
}
2010-05-06 01:30:42 +01:00
function common_valid_language ( $lang )
{
if ( $lang ) {
// Validate -- we don't want to end up with a bogus code
// left over from some old junk.
foreach ( common_config ( 'site' , 'languages' ) as $code => $info ) {
if ( $info [ 'lang' ] == $lang ) {
return true ;
}
}
}
return false ;
}
2008-12-23 19:33:23 +00:00
function common_language ()
{
2010-05-06 01:30:42 +01:00
// Allow ?uselang=xx override, very useful for debugging
// and helping translators check usage and context.
if ( isset ( $_GET [ 'uselang' ])) {
$uselang = strval ( $_GET [ 'uselang' ]);
if ( common_valid_language ( $uselang )) {
return $uselang ;
}
}
2008-07-19 01:34:17 +01:00
2008-12-21 00:30:16 +00:00
// If there is a user logged in and they've set a language preference
// then return that one...
2009-03-04 14:24:33 +00:00
if ( _have_config () && common_logged_in ()) {
2008-12-21 00:30:16 +00:00
$user = common_current_user ();
2010-05-06 01:30:42 +01:00
if ( common_valid_language ( $user -> language )) {
return $user -> language ;
2009-12-19 19:03:31 +00:00
}
2008-12-21 00:30:16 +00:00
}
2008-07-19 01:34:17 +01:00
2008-12-21 00:30:16 +00:00
// Otherwise, find the best match for the languages requested by the
// user's browser...
2010-03-03 20:08:07 +00:00
if ( common_config ( 'site' , 'langdetect' )) {
$httplang = isset ( $_SERVER [ 'HTTP_ACCEPT_LANGUAGE' ]) ? $_SERVER [ 'HTTP_ACCEPT_LANGUAGE' ] : null ;
if ( ! empty ( $httplang )) {
2019-04-25 22:21:15 +01:00
$language = client_preferred_language ( $httplang );
2019-06-04 18:56:20 +01:00
if ( $language ) {
return $language ;
}
2010-03-03 20:08:07 +00:00
}
2008-12-21 00:30:16 +00:00
}
2008-10-02 19:13:38 +01:00
2008-12-21 00:30:16 +00:00
// Finally, if none of the above worked, use the site's default...
return common_config ( 'site' , 'language' );
2008-07-19 01:34:17 +01:00
}
2008-05-20 14:05:35 +01:00
2010-09-12 23:14:36 +01:00
/**
* Salted , hashed passwords are stored in the DB .
*/
2015-07-17 00:47:43 +01:00
function common_munge_password ( $password , Profile $profile = null )
2008-12-23 19:33:23 +00:00
{
2013-10-17 15:32:53 +01:00
$hashed = null ;
2019-06-04 18:56:20 +01:00
if ( Event :: handle ( 'StartHashPassword' , [ & $hashed , $password , $profile ])) {
Event :: handle ( 'EndHashPassword' , [ & $hashed , $password , $profile ]);
2013-10-17 15:32:53 +01:00
}
if ( empty ( $hashed )) {
throw new PasswordHashException ();
2010-01-10 20:07:49 +00:00
}
2013-10-17 15:32:53 +01:00
return $hashed ;
2008-05-20 14:05:35 +01:00
}
2010-09-12 23:14:36 +01:00
/**
* Check if a username exists and has matching password .
*/
2008-12-23 19:33:23 +00:00
function common_check_user ( $nickname , $password )
{
2010-03-10 03:39:05 +00:00
// empty nickname always unacceptable
if ( empty ( $nickname )) {
return false ;
}
2009-11-10 19:45:19 +00:00
$authenticatedUser = false ;
2019-06-04 18:56:20 +01:00
if ( Event :: handle ( 'StartCheckPassword' , [ $nickname , $password , & $authenticatedUser ])) {
2011-05-02 23:17:08 +01:00
if ( common_is_email ( $nickname )) {
2013-08-18 12:04:58 +01:00
$user = User :: getKV ( 'email' , common_canonical_email ( $nickname ));
2011-05-02 23:17:08 +01:00
} else {
2013-10-16 13:58:22 +01:00
$user = User :: getKV ( 'nickname' , Nickname :: normalize ( $nickname ));
2011-05-02 23:17:08 +01:00
}
2013-10-30 11:21:34 +00:00
if ( $user instanceof User && ! empty ( $password )) {
2015-07-17 00:47:43 +01:00
if ( 0 == strcmp ( common_munge_password ( $password , $user -> getProfile ()), $user -> password )) {
2013-10-30 11:21:34 +00:00
//internal checking passed
$authenticatedUser = $user ;
2009-11-04 18:06:55 +00:00
}
}
2008-12-21 00:30:16 +00:00
}
2019-06-04 18:56:20 +01:00
Event :: handle ( 'EndCheckPassword' , [ $nickname , $password , $authenticatedUser ]);
2009-11-10 19:45:19 +00:00
return $authenticatedUser ;
2008-12-21 00:30:16 +00:00
}
2010-09-12 23:14:36 +01:00
/**
* Is the current user logged in ?
*/
2008-12-23 19:33:23 +00:00
function common_logged_in ()
{
2008-12-21 00:30:16 +00:00
return ( ! is_null ( common_current_user ()));
2008-05-20 14:05:35 +01:00
}
2016-02-22 14:19:10 +00:00
function common_local_referer ()
{
2016-03-31 19:51:50 +01:00
return isset ( $_SERVER [ 'HTTP_REFERER' ])
&& parse_url ( $_SERVER [ 'HTTP_REFERER' ], PHP_URL_HOST ) === common_config ( 'site' , 'server' );
2016-02-22 14:19:10 +00:00
}
2008-12-23 19:33:23 +00:00
function common_have_session ()
{
2008-12-21 00:30:16 +00:00
return ( 0 != strcmp ( session_id (), '' ));
2008-05-20 14:05:35 +01:00
}
2019-06-04 01:02:46 +01:00
/**
* Make sure session is started and handled by
* the correct handler .
*/
2008-12-23 19:33:23 +00:00
function common_ensure_session ()
{
2008-12-21 00:30:16 +00:00
if ( ! common_have_session ()) {
2009-06-27 14:20:24 +01:00
if ( common_config ( 'sessions' , 'handle' )) {
2019-05-14 22:57:45 +01:00
session_set_save_handler ( new InternalSessionHandler (), true );
2009-06-27 14:20:24 +01:00
}
2020-08-06 19:54:49 +01:00
$session_name = session_name ();
$id = null ;
foreach ([ INPUT_COOKIE , INPUT_GET ] as $input_type ) {
// PHP's session handler only accepts symbols from
// "A" to "Z", "a" to "Z", the comma sign and the minus sign.
$id = filter_input (
$input_type ,
$session_name ,
FILTER_VALIDATE_REGEXP ,
[ 'options' => [ 'regexp' => '/^[,\-A-Za-z0-9]+$/D' ]]
);
// Found the session (null is suspicious, so stop at that also)
if ( $id !== false ) {
break ;
}
2019-04-27 00:28:05 +01:00
}
2020-08-06 19:54:49 +01:00
if ( ! is_null ( $id )) {
2019-04-27 00:28:05 +01:00
session_id ( $id );
}
2019-06-04 01:02:46 +01:00
session_start ();
2020-08-06 19:54:49 +01:00
if ( ! array_key_exists ( 'started' , $_SESSION )) {
2009-06-27 13:07:14 +01:00
$_SESSION [ 'started' ] = time ();
2020-08-06 19:54:49 +01:00
if ( ! is_null ( $id )) {
common_debug (
'Session cookie "' . $id . '" is set but without a session'
);
2009-06-27 13:07:14 +01:00
}
}
2008-12-21 00:30:16 +00:00
}
2008-05-20 14:05:35 +01:00
}
2008-12-21 00:30:16 +00:00
// Three kinds of arguments:
// 1) a user object
// 2) a nickname
// 3) null to clear
2008-07-09 06:53:43 +01:00
2008-12-21 00:30:16 +00:00
// Initialize to false; set to null if none found
2008-12-09 17:34:02 +00:00
$_cur = false ;
2008-12-23 19:33:23 +00:00
function common_set_user ( $user )
{
2008-12-09 17:34:02 +00:00
global $_cur ;
2008-12-21 00:30:16 +00:00
if ( is_null ( $user ) && common_have_session ()) {
$_cur = null ;
unset ( $_SESSION [ 'userid' ]);
return true ;
2019-06-04 18:56:20 +01:00
} elseif ( is_string ( $user )) {
2008-12-21 00:30:16 +00:00
$nickname = $user ;
2013-08-18 12:04:58 +01:00
$user = User :: getKV ( 'nickname' , $nickname );
2019-06-04 18:56:20 +01:00
} elseif ( ! $user instanceof User ) {
2008-12-21 00:30:16 +00:00
return false ;
}
if ( $user ) {
2019-06-04 18:56:20 +01:00
if ( Event :: handle ( 'StartSetUser' , [ & $user ])) {
2011-02-21 15:20:42 +00:00
if ( ! empty ( $user )) {
if ( ! $user -> hasRight ( Right :: WEBLOGIN )) {
2011-03-18 17:03:41 +00:00
// TRANS: Authorisation exception thrown when a user a not allowed to login.
2011-02-21 15:20:42 +00:00
throw new AuthorizationException ( _ ( 'Not allowed to log in.' ));
}
2009-11-18 19:19:43 +00:00
common_ensure_session ();
$_SESSION [ 'userid' ] = $user -> id ;
$_cur = $user ;
2019-06-04 18:56:20 +01:00
Event :: handle ( 'EndSetUser' , [ $user ]);
2009-11-18 19:19:43 +00:00
return $_cur ;
}
}
2008-12-21 00:30:16 +00:00
}
return false ;
2008-05-20 14:05:35 +01:00
}
2008-12-23 19:33:23 +00:00
function common_set_cookie ( $key , $value , $expiration = 0 )
{
2008-12-21 00:30:16 +00:00
$path = common_config ( 'site' , 'path' );
$server = common_config ( 'site' , 'server' );
2008-06-24 03:52:34 +01:00
2008-12-21 00:30:16 +00:00
if ( $path && ( $path != '/' )) {
$cookiepath = '/' . $path . '/' ;
} else {
$cookiepath = '/' ;
}
2019-09-11 06:15:16 +01:00
return setcookie (
$key ,
$value ,
$expiration ,
$cookiepath ,
$server ,
GNUsocial :: useHTTPS ()
);
2008-06-24 03:52:34 +01:00
}
define ( 'REMEMBERME' , 'rememberme' );
2008-12-21 00:30:16 +00:00
define ( 'REMEMBERME_EXPIRY' , 30 * 24 * 60 * 60 ); // 30 days
2008-06-24 03:52:34 +01:00
2008-12-23 19:33:23 +00:00
function common_rememberme ( $user = null )
{
2008-12-21 00:30:16 +00:00
if ( ! $user ) {
$user = common_current_user ();
if ( ! $user ) {
return false ;
}
}
2008-12-09 17:54:46 +00:00
2008-12-21 00:30:16 +00:00
$rm = new Remember_me ();
2008-12-09 18:54:24 +00:00
2013-10-21 12:20:30 +01:00
$rm -> code = common_random_hexstr ( 16 );
2008-12-21 00:30:16 +00:00
$rm -> user_id = $user -> id ;
2008-12-09 18:54:24 +00:00
2008-12-21 00:30:16 +00:00
// Wrap the insert in some good ol' fashioned transaction code
2008-12-09 18:54:24 +00:00
2020-06-08 10:25:01 +01:00
$rm -> query ( 'START TRANSACTION' );
2008-12-09 18:54:24 +00:00
2008-12-21 00:30:16 +00:00
$result = $rm -> insert ();
2008-12-09 17:54:46 +00:00
2008-12-21 00:30:16 +00:00
if ( ! $result ) {
common_log_db_error ( $rm , 'INSERT' , __FILE__ );
2015-02-08 10:09:19 +00:00
$rm -> query ( 'ROLLBACK' );
2008-12-21 00:30:16 +00:00
return false ;
2008-12-09 17:54:46 +00:00
}
2008-12-09 18:54:24 +00:00
$rm -> query ( 'COMMIT' );
2008-12-09 17:54:46 +00:00
$cookieval = $rm -> user_id . ':' . $rm -> code ;
2008-12-21 00:30:16 +00:00
common_log ( LOG_INFO , 'adding rememberme cookie "' . $cookieval . '" for ' . $user -> nickname );
2008-12-09 17:54:46 +00:00
2008-12-21 00:30:16 +00:00
common_set_cookie ( REMEMBERME , $cookieval , time () + REMEMBERME_EXPIRY );
2008-12-09 17:54:46 +00:00
2008-12-21 00:30:16 +00:00
return true ;
2008-06-24 03:52:34 +01:00
}
2008-12-23 19:33:23 +00:00
function common_remembered_user ()
{
2008-12-21 00:30:16 +00:00
$user = null ;
2008-12-09 17:04:13 +00:00
2008-12-21 00:30:16 +00:00
$packed = isset ( $_COOKIE [ REMEMBERME ]) ? $_COOKIE [ REMEMBERME ] : null ;
2008-12-09 17:04:13 +00:00
2008-12-21 00:30:16 +00:00
if ( ! $packed ) {
return null ;
2008-12-09 17:04:13 +00:00
}
list ( $id , $code ) = explode ( ':' , $packed );
if ( ! $id || ! $code ) {
2008-12-09 17:42:33 +00:00
common_log ( LOG_WARNING , 'Malformed rememberme cookie: ' . $packed );
2008-12-09 17:04:13 +00:00
common_forgetme ();
2008-12-21 00:30:16 +00:00
return null ;
2008-12-09 17:04:13 +00:00
}
2013-08-18 12:04:58 +01:00
$rm = Remember_me :: getKV ( 'code' , $code );
2008-12-09 17:04:13 +00:00
if ( ! $rm ) {
2008-12-09 17:42:33 +00:00
common_log ( LOG_WARNING , 'No such remember code: ' . $code );
2008-12-09 17:04:13 +00:00
common_forgetme ();
2008-12-21 00:30:16 +00:00
return null ;
2008-12-09 17:04:13 +00:00
}
if ( $rm -> user_id != $id ) {
2008-12-09 17:42:33 +00:00
common_log ( LOG_WARNING , 'Rememberme code for wrong user: ' . $rm -> user_id . ' != ' . $id );
2008-12-09 17:04:13 +00:00
common_forgetme ();
2008-12-21 00:30:16 +00:00
return null ;
2008-12-09 17:04:13 +00:00
}
2013-08-18 12:04:58 +01:00
$user = User :: getKV ( 'id' , $rm -> user_id );
2008-12-09 17:04:13 +00:00
2013-10-29 10:27:26 +00:00
if ( ! $user instanceof User ) {
2008-12-09 17:42:33 +00:00
common_log ( LOG_WARNING , 'No such user for rememberme: ' . $rm -> user_id );
2008-12-09 17:04:13 +00:00
common_forgetme ();
2008-12-21 00:30:16 +00:00
return null ;
2008-12-09 17:04:13 +00:00
}
2008-12-21 00:30:16 +00:00
// successful!
2008-12-09 17:04:13 +00:00
$result = $rm -> delete ();
if ( ! $result ) {
common_log_db_error ( $rm , 'DELETE' , __FILE__ );
2008-12-09 17:42:33 +00:00
common_log ( LOG_WARNING , 'Could not delete rememberme: ' . $code );
2008-12-09 17:04:13 +00:00
common_forgetme ();
2008-12-21 00:30:16 +00:00
return null ;
2008-12-09 17:04:13 +00:00
}
common_log ( LOG_INFO , 'logging in ' . $user -> nickname . ' using rememberme code ' . $rm -> code );
2008-12-09 17:34:02 +00:00
common_set_user ( $user );
2008-12-09 17:04:13 +00:00
common_real_login ( false );
2008-12-21 00:30:16 +00:00
// We issue a new cookie, so they can log in
// automatically again after this session
2008-12-09 17:04:13 +00:00
common_rememberme ( $user );
2008-12-21 00:30:16 +00:00
return $user ;
2008-06-24 03:52:34 +01:00
}
2010-09-12 23:14:36 +01:00
/**
* must be called with a valid user !
*/
2008-12-23 19:33:23 +00:00
function common_forgetme ()
{
2008-12-21 00:30:16 +00:00
common_set_cookie ( REMEMBERME , '' , 0 );
2008-06-24 03:52:34 +01:00
}
2010-09-12 23:14:36 +01:00
/**
* Who is the current user ?
*/
2008-12-23 19:33:23 +00:00
function common_current_user ()
{
2008-12-09 17:34:02 +00:00
global $_cur ;
2009-03-04 14:24:33 +00:00
if ( ! _have_config ()) {
return null ;
}
2008-12-09 17:34:02 +00:00
if ( $_cur === false ) {
2010-02-12 23:24:15 +00:00
if ( isset ( $_COOKIE [ session_name ()]) || isset ( $_GET [ session_name ()])
|| ( isset ( $_SESSION [ 'userid' ]) && $_SESSION [ 'userid' ])) {
2008-12-09 17:34:02 +00:00
common_ensure_session ();
$id = isset ( $_SESSION [ 'userid' ]) ? $_SESSION [ 'userid' ] : false ;
if ( $id ) {
2013-10-29 10:27:26 +00:00
$user = User :: getKV ( 'id' , $id );
if ( $user instanceof User ) {
2019-06-04 18:56:20 +01:00
$_cur = $user ;
return $_cur ;
2009-11-11 18:38:11 +00:00
}
2008-12-09 17:34:02 +00:00
}
}
2008-12-21 00:30:16 +00:00
// that didn't work; try to remember; will init $_cur to null on failure
2008-12-09 17:34:02 +00:00
$_cur = common_remembered_user ();
if ( $_cur ) {
2008-12-21 00:30:16 +00:00
// XXX: Is this necessary?
2008-12-09 17:34:02 +00:00
$_SESSION [ 'userid' ] = $_cur -> id ;
}
}
2008-12-21 00:30:16 +00:00
return $_cur ;
2008-05-20 14:05:35 +01:00
}
2010-09-12 23:14:36 +01:00
/**
* Logins that are 'remembered' aren 't ' real ' -- they' re subject to
* cookie - stealing . So , we don ' t let them do certain things . New reg ,
* OpenID , and password logins _are_ real .
*/
2008-12-23 19:33:23 +00:00
function common_real_login ( $real = true )
{
2008-12-21 00:30:16 +00:00
common_ensure_session ();
$_SESSION [ 'real_login' ] = $real ;
2008-06-24 03:52:34 +01:00
}
2008-12-23 19:33:23 +00:00
function common_is_real_login ()
{
2008-12-21 00:30:16 +00:00
return common_logged_in () && $_SESSION [ 'real_login' ];
2008-06-24 03:52:34 +01:00
}
2010-09-20 21:42:58 +01:00
/**
* Get a hash portion for HTTP caching Etags and such including
* info on the current user ' s session . If login / logout state changes ,
* or we 've changed accounts, or we' ve renamed the current user ,
* we ' ll get a new hash value .
*
* This should not be considered secure information .
*
* @ param User $user ( optional ; uses common_current_user () if left out )
* @ return string
*/
function common_user_cache_hash ( $user = false )
{
if ( $user === false ) {
$user = common_current_user ();
}
if ( $user ) {
return crc32 ( $user -> id . ':' . $user -> nickname );
} else {
return '0' ;
}
}
2010-11-29 19:31:10 +00:00
/**
* get canonical version of nickname for comparison
*
* @ param string $nickname
* @ return string
2010-11-29 22:15:25 +00:00
*
* @ throws NicknameException on invalid input
* @ deprecated call Nickname :: normalize () directly .
2010-11-29 19:31:10 +00:00
*/
2008-12-23 19:33:23 +00:00
function common_canonical_nickname ( $nickname )
{
2010-11-29 22:15:25 +00:00
return Nickname :: normalize ( $nickname );
2008-05-20 14:05:35 +01:00
}
2010-11-29 19:31:10 +00:00
/**
* get canonical version of email for comparison
*
* @ fixme actually normalize
* @ fixme reject invalid input
*
* @ param string $email
* @ return string
*/
2008-12-23 19:33:23 +00:00
function common_canonical_email ( $email )
{
2008-12-21 00:30:16 +00:00
// XXX: canonicalize UTF-8
// XXX: lcase the domain part
return $email ;
2008-05-20 14:05:35 +01:00
}
2016-09-01 23:08:17 +01:00
function common_to_alphanumeric ( $str )
{
$filtered = preg_replace ( '/[^A-Za-z0-9]\s*/' , '' , $str );
if ( strlen ( $filtered ) < 1 ) {
throw new Exception ( 'Filtered string was zero-length.' );
}
return $filtered ;
}
2019-06-04 18:56:20 +01:00
function common_purify ( $html , array $args = [])
2015-02-17 23:10:31 +00:00
{
2018-03-12 03:23:55 +00:00
$cfg = \HTMLPurifier_Config :: createDefault ();
2016-02-28 12:16:52 +00:00
/**
* rel values that should be avoided since they can be used to infer
* information about the _current_ page , not the h - entry :
*
* directory , home , license , payment
*
* Source : http :// microformats . org / wiki / rel
*/
2016-06-09 10:56:36 +01:00
$cfg -> set ( 'Attr.AllowedRel' , [ 'bookmark' , 'enclosure' , 'nofollow' , 'tag' , 'noreferrer' ]);
2019-06-04 18:56:20 +01:00
$cfg -> set ( 'HTML.ForbiddenAttributes' , [ 'style' ]); // id, on* etc. are already filtered by default
2016-02-03 13:31:16 +00:00
$cfg -> set ( 'URI.AllowedSchemes' , array_fill_keys ( common_url_schemes (), true ));
2016-02-26 13:46:26 +00:00
if ( isset ( $args [ 'URI.Base' ])) {
$cfg -> set ( 'URI.Base' , $args [ 'URI.Base' ]); // if null this is like unsetting it I presume
$cfg -> set ( 'URI.MakeAbsolute' , ! is_null ( $args [ 'URI.Base' ])); // if we have a URI base, convert relative URLs to absolute ones.
}
2017-12-06 00:50:22 +00:00
if ( common_config ( 'cache' , 'dir' )) {
$cfg -> set ( 'Cache.SerializerPath' , common_config ( 'cache' , 'dir' ));
}
2017-12-17 17:32:23 +00:00
// if you don't want to use the default cache dir for htmlpurifier, set it specifically as $config['htmlpurifier']['Cache.SerializerPath'] = '/tmp'; or something.
2016-02-28 12:30:47 +00:00
foreach ( common_config ( 'htmlpurifier' ) as $key => $val ) {
$cfg -> set ( $key , $val );
}
2015-02-17 23:10:31 +00:00
2016-01-28 17:57:36 +00:00
// Remove more elements than what the default filter removes, default in GNU social are remotely
// linked resources such as img, video, audio
2019-06-04 18:56:20 +01:00
$forbiddenElements = [];
2015-03-15 13:35:29 +00:00
foreach ( common_config ( 'htmlfilter' ) as $tag => $filter ) {
if ( $filter === true ) {
2016-01-28 17:57:36 +00:00
$forbiddenElements [] = $tag ;
2015-03-15 13:35:29 +00:00
}
}
2016-01-28 17:57:36 +00:00
$cfg -> set ( 'HTML.ForbiddenElements' , $forbiddenElements );
2015-03-15 13:35:29 +00:00
2015-02-17 23:10:31 +00:00
$html = common_remove_unicode_formatting ( $html );
2016-01-28 17:57:36 +00:00
$purifier = new HTMLPurifier ( $cfg );
$purified = $purifier -> purify ( $html );
2019-06-04 18:56:20 +01:00
Event :: handle ( 'EndCommonPurify' , [ & $purified , $html ]);
2019-06-25 22:59:10 +01:00
2016-01-11 20:54:19 +00:00
return $purified ;
2015-02-17 23:10:31 +00:00
}
function common_remove_unicode_formatting ( $text )
{
// Strip Unicode text formatting/direction codes
// this is pretty dangerous for visualisation of text and can be used for mischief
return preg_replace ( '/[\\x{200b}-\\x{200f}\\x{202a}-\\x{202e}]/u' , '' , $text );
}
2010-11-29 19:31:10 +00:00
/**
* Partial notice markup rendering step : build links to ! group references .
*
2016-01-01 17:40:11 +00:00
* @ param string $text partially rendered HTML
* @ param Profile $author the Profile that is composing the current notice
* @ param Notice $parent the Notice this is sent in reply to , if any
2010-11-29 19:31:10 +00:00
* @ return string partially rendered HTML
*/
2016-01-01 17:40:11 +00:00
function common_render_content ( $text , Profile $author , Notice $parent = null )
2008-12-23 19:33:23 +00:00
{
2015-02-17 23:10:31 +00:00
$text = common_render_text ( $text );
2016-01-01 17:40:11 +00:00
$text = common_linkify_mentions ( $text , $author , $parent );
2015-02-17 23:10:31 +00:00
return $text ;
2008-09-17 12:27:30 +01:00
}
2010-11-29 23:04:21 +00:00
/**
* Finds @- mentions within the partially - rendered text section and
* turns them into live links .
*
* Should generally not be called except from common_render_content () .
*
2016-01-01 17:20:42 +00:00
* @ param string $text partially - rendered HTML
* @ param Profile $author the Profile that is composing the current notice
* @ param Notice $parent the Notice this is sent in reply to , if any
2010-11-29 23:04:21 +00:00
* @ return string partially - rendered HTML
*/
2016-01-01 17:20:42 +00:00
function common_linkify_mentions ( $text , Profile $author , Notice $parent = null )
2010-02-21 21:20:30 +00:00
{
2016-01-01 17:20:42 +00:00
$mentions = common_find_mentions ( $text , $author , $parent );
2010-02-21 21:20:30 +00:00
// We need to go through in reverse order by position,
// so our positions stay valid despite our fudging with the
// string!
2019-06-04 18:56:20 +01:00
$points = [];
2010-02-21 21:20:30 +00:00
2019-06-04 18:56:20 +01:00
foreach ( $mentions as $mention ) {
2010-02-21 21:20:30 +00:00
$points [ $mention [ 'position' ]] = $mention ;
}
krsort ( $points );
foreach ( $points as $position => $mention ) {
$linkText = common_linkify_mention ( $mention );
2015-10-23 22:15:40 +01:00
$text = substr_replace ( $text , $linkText , $position , $mention [ 'length' ]);
2010-02-21 21:20:30 +00:00
}
return $text ;
}
2015-06-02 12:17:51 +01:00
function common_linkify_mention ( array $mention )
2010-02-21 21:20:30 +00:00
{
$output = null ;
2019-06-04 18:56:20 +01:00
if ( Event :: handle ( 'StartLinkifyMention' , [ $mention , & $output ])) {
2010-02-21 21:20:30 +00:00
$xs = new XMLStringer ( false );
2019-06-04 18:56:20 +01:00
$attrs = [ 'href' => $mention [ 'url' ],
'class' => 'h-card u-url p-nickname ' . $mention [ 'type' ]];
2010-02-21 21:20:30 +00:00
if ( ! empty ( $mention [ 'title' ])) {
$attrs [ 'title' ] = $mention [ 'title' ];
}
2014-06-21 20:01:17 +01:00
$xs -> element ( 'a' , $attrs , $mention [ 'text' ]);
2010-02-21 21:20:30 +00:00
$output = $xs -> getString ();
2019-06-04 18:56:20 +01:00
Event :: handle ( 'EndLinkifyMention' , [ $mention , & $output ]);
2010-02-21 21:20:30 +00:00
}
return $output ;
}
2016-01-08 01:58:31 +00:00
function common_get_attentions ( $text , Profile $sender , Notice $parent = null )
2016-01-07 22:23:37 +00:00
{
$mentions = common_find_mentions ( $text , $sender , $parent );
2019-06-04 18:56:20 +01:00
$atts = [];
2016-01-07 22:23:37 +00:00
foreach ( $mentions as $mention ) {
foreach ( $mention [ 'mentioned' ] as $mentioned ) {
2016-01-09 14:06:44 +00:00
$atts [ $mentioned -> getUri ()] = $mentioned -> getObjectType ();
2016-01-07 22:23:37 +00:00
}
}
2016-01-08 01:58:31 +00:00
if ( $parent instanceof Notice ) {
$parentAuthor = $parent -> getProfile ();
// afaik groups can't be authors
$atts [ $parentAuthor -> getUri ()] = ActivityObject :: PERSON ;
}
2016-01-07 22:23:37 +00:00
return $atts ;
}
2010-11-29 19:31:10 +00:00
/**
2010-11-29 22:15:25 +00:00
* Find @- mentions in the given text , using the given notice object as context .
* References will be resolved with common_relative_profile () against the user
* who posted the notice .
*
* Note the return data format is internal , to be used for building links and
* such . Should not be used directly ; rather , call common_linkify_mentions () .
2010-11-29 19:31:10 +00:00
*
2016-01-01 17:20:42 +00:00
* @ param string $text
* @ param Profile $sender the Profile that is sending the current text
* @ param Notice $parent the Notice this text is in reply to , if any
2010-11-29 22:15:25 +00:00
*
2010-11-29 19:31:10 +00:00
* @ return array
2010-11-29 22:15:25 +00:00
*
* @ access private
2010-11-29 19:31:10 +00:00
*/
2016-01-01 17:20:42 +00:00
function common_find_mentions ( $text , Profile $sender , Notice $parent = null )
2010-02-21 21:20:30 +00:00
{
2019-06-04 18:56:20 +01:00
$mentions = [];
2013-10-29 10:27:26 +00:00
2019-06-04 18:56:20 +01:00
if ( Event :: handle ( 'StartFindMentions' , [ $sender , $text , & $mentions ])) {
Use notice for context when deciding who @nickname refers to
In a federated system, "@nickname" is insufficient to uniquely
identify a user. However, it's a very convenient idiom. We need to
guess from context who 'nickname' refers to.
Previously, we were using the sender's profile (or what we knew about
them) as the only context. So, we assumed that they'd be mentioning to
someone they followed, or someone who followed them, or someone on
their own server.
Now, we include the notice information for context. We check to see if
the notice is a reply to another notice, and if the author of the
original notice has the nickname 'nickname', then the mention is
probably for them. Alternately, if the original notice mentions someone
with nickname 'nickname', then this notice is probably referring to
_them_.
Doing this kind of context sleuthing means we have to render the
content very late in the notice-saving process.
2010-02-27 21:06:46 +00:00
// Get the context of the original notice, if any
2019-06-04 18:56:20 +01:00
$origMentions = [];
2016-01-01 17:20:42 +00:00
// Does it have a parent notice for context?
if ( $parent instanceof Notice ) {
2016-01-13 17:35:25 +00:00
foreach ( $parent -> getAttentionProfiles () as $repliedTo ) {
if ( ! $repliedTo -> isPerson ()) {
continue ;
2015-07-16 11:53:10 +01:00
}
2016-01-19 13:41:25 +00:00
$origMentions [ $repliedTo -> id ] = $repliedTo ;
Use notice for context when deciding who @nickname refers to
In a federated system, "@nickname" is insufficient to uniquely
identify a user. However, it's a very convenient idiom. We need to
guess from context who 'nickname' refers to.
Previously, we were using the sender's profile (or what we knew about
them) as the only context. So, we assumed that they'd be mentioning to
someone they followed, or someone who followed them, or someone on
their own server.
Now, we include the notice information for context. We check to see if
the notice is a reply to another notice, and if the author of the
original notice has the nickname 'nickname', then the mention is
probably for them. Alternately, if the original notice mentions someone
with nickname 'nickname', then this notice is probably referring to
_them_.
Doing this kind of context sleuthing means we have to render the
content very late in the notice-saving process.
2010-02-27 21:06:46 +00:00
}
}
2017-08-10 10:06:52 +01:00
$matches = common_find_mentions_raw ( $text , '@' );
2010-02-21 21:20:30 +00:00
foreach ( $matches as $match ) {
2010-11-29 22:15:25 +00:00
try {
$nickname = Nickname :: normalize ( $match [ 0 ]);
} catch ( NicknameException $e ) {
// Bogus match? Drop it.
continue ;
}
Use notice for context when deciding who @nickname refers to
In a federated system, "@nickname" is insufficient to uniquely
identify a user. However, it's a very convenient idiom. We need to
guess from context who 'nickname' refers to.
Previously, we were using the sender's profile (or what we knew about
them) as the only context. So, we assumed that they'd be mentioning to
someone they followed, or someone who followed them, or someone on
their own server.
Now, we include the notice information for context. We check to see if
the notice is a reply to another notice, and if the author of the
original notice has the nickname 'nickname', then the mention is
probably for them. Alternately, if the original notice mentions someone
with nickname 'nickname', then this notice is probably referring to
_them_.
Doing this kind of context sleuthing means we have to render the
content very late in the notice-saving process.
2010-02-27 21:06:46 +00:00
2019-06-04 18:56:20 +01:00
// primarily mention the profiles mentioned in the parent
2016-01-19 13:41:25 +00:00
$mention_found_in_origMentions = false ;
2019-06-04 18:56:20 +01:00
foreach ( $origMentions as $origMentionsId => $origMention ) {
if ( $origMention -> getNickname () == $nickname ) {
2016-01-19 13:41:25 +00:00
$mention_found_in_origMentions = $origMention ;
2019-06-04 18:56:20 +01:00
// don't mention same twice! the parent might have mentioned
2016-01-19 13:41:25 +00:00
// two users with same nickname on different instances
unset ( $origMentions [ $origMentionsId ]);
break ;
}
}
Use notice for context when deciding who @nickname refers to
In a federated system, "@nickname" is insufficient to uniquely
identify a user. However, it's a very convenient idiom. We need to
guess from context who 'nickname' refers to.
Previously, we were using the sender's profile (or what we knew about
them) as the only context. So, we assumed that they'd be mentioning to
someone they followed, or someone who followed them, or someone on
their own server.
Now, we include the notice information for context. We check to see if
the notice is a reply to another notice, and if the author of the
original notice has the nickname 'nickname', then the mention is
probably for them. Alternately, if the original notice mentions someone
with nickname 'nickname', then this notice is probably referring to
_them_.
Doing this kind of context sleuthing means we have to render the
content very late in the notice-saving process.
2010-02-27 21:06:46 +00:00
2016-01-19 13:41:25 +00:00
// Try to get a profile for this nickname.
// Start with parents mentions, then go to parents sender context
if ( $mention_found_in_origMentions ) {
2019-06-04 18:56:20 +01:00
$mentioned = $mention_found_in_origMentions ;
} elseif ( $parent instanceof Notice && $parent -> getProfile () -> getNickname () === $nickname ) {
2016-01-01 17:20:42 +00:00
$mentioned = $parent -> getProfile ();
Use notice for context when deciding who @nickname refers to
In a federated system, "@nickname" is insufficient to uniquely
identify a user. However, it's a very convenient idiom. We need to
guess from context who 'nickname' refers to.
Previously, we were using the sender's profile (or what we knew about
them) as the only context. So, we assumed that they'd be mentioning to
someone they followed, or someone who followed them, or someone on
their own server.
Now, we include the notice information for context. We check to see if
the notice is a reply to another notice, and if the author of the
original notice has the nickname 'nickname', then the mention is
probably for them. Alternately, if the original notice mentions someone
with nickname 'nickname', then this notice is probably referring to
_them_.
Doing this kind of context sleuthing means we have to render the
content very late in the notice-saving process.
2010-02-27 21:06:46 +00:00
} else {
2016-01-01 17:20:42 +00:00
// sets to null if no match
Use notice for context when deciding who @nickname refers to
In a federated system, "@nickname" is insufficient to uniquely
identify a user. However, it's a very convenient idiom. We need to
guess from context who 'nickname' refers to.
Previously, we were using the sender's profile (or what we knew about
them) as the only context. So, we assumed that they'd be mentioning to
someone they followed, or someone who followed them, or someone on
their own server.
Now, we include the notice information for context. We check to see if
the notice is a reply to another notice, and if the author of the
original notice has the nickname 'nickname', then the mention is
probably for them. Alternately, if the original notice mentions someone
with nickname 'nickname', then this notice is probably referring to
_them_.
Doing this kind of context sleuthing means we have to render the
content very late in the notice-saving process.
2010-02-27 21:06:46 +00:00
$mentioned = common_relative_profile ( $sender , $nickname );
}
2010-02-21 21:20:30 +00:00
2013-10-29 10:27:26 +00:00
if ( $mentioned instanceof Profile ) {
2016-01-01 17:20:42 +00:00
try {
2016-01-29 14:21:01 +00:00
$url = $mentioned -> getUri (); // prefer the URI as URL, if it is one.
if ( ! common_valid_http_url ( $url )) {
$url = $mentioned -> getUrl ();
}
2016-01-01 17:20:42 +00:00
} catch ( InvalidUrlException $e ) {
2019-06-04 18:56:20 +01:00
$url = common_local_url ( 'userbyid' , [ 'id' => $mentioned -> getID ()]);
2010-02-21 21:20:30 +00:00
}
2019-06-04 18:56:20 +01:00
$mention = [ 'mentioned' => [ $mentioned ],
'type' => 'mention' ,
'text' => $match [ 0 ],
'position' => $match [ 1 ],
'length' => mb_strlen ( $match [ 0 ]),
'title' => $mentioned -> getFullname (),
'url' => $url ];
2010-02-21 21:20:30 +00:00
$mentions [] = $mention ;
}
}
// @#tag => mention of all subscriptions tagged 'tag'
2019-06-04 18:56:20 +01:00
preg_match_all (
'/' . Nickname :: BEFORE_MENTIONS . '@#([\pL\pN_\-\.]{1,64})/' ,
$text ,
$hmatches ,
PREG_OFFSET_CAPTURE
);
2010-02-21 21:20:30 +00:00
foreach ( $hmatches [ 1 ] as $hmatch ) {
$tag = common_canonical_tag ( $hmatch [ 0 ]);
2016-01-01 17:20:42 +00:00
$plist = Profile_list :: getByTaggerAndTag ( $sender -> getID (), $tag );
2013-10-29 10:27:26 +00:00
if ( ! $plist instanceof Profile_list || $plist -> private ) {
continue ;
}
$tagged = $sender -> getTaggedSubscribers ( $tag );
2011-03-06 18:03:39 +00:00
2019-09-11 06:15:16 +01:00
$url = common_local_url (
'showprofiletag' ,
[ 'nickname' => $sender -> getNickname (), 'tag' => $tag ]
);
2019-06-04 18:56:20 +01:00
$mentions [] = [ 'mentioned' => $tagged ,
'type' => 'list' ,
'text' => $hmatch [ 0 ],
'position' => $hmatch [ 1 ],
'length' => mb_strlen ( $hmatch [ 0 ]),
'url' => $url ];
2013-10-29 10:27:26 +00:00
}
2011-03-06 18:03:39 +00:00
2017-08-10 10:33:18 +01:00
$hmatches = common_find_mentions_raw ( $text , '!' );
foreach ( $hmatches as $hmatch ) {
2013-10-29 10:27:26 +00:00
$nickname = Nickname :: normalize ( $hmatch [ 0 ]);
$group = User_group :: getForNickname ( $nickname , $sender );
if ( ! $group instanceof User_group || ! $sender -> isMember ( $group )) {
continue ;
2011-03-06 18:03:39 +00:00
}
2013-10-29 10:27:26 +00:00
$profile = $group -> getProfile ();
2019-06-04 18:56:20 +01:00
$mentions [] = [ 'mentioned' => [ $profile ],
'type' => 'group' ,
'text' => $hmatch [ 0 ],
'position' => $hmatch [ 1 ],
'length' => mb_strlen ( $hmatch [ 0 ]),
'url' => $group -> permalink (),
'title' => $group -> getFancyName ()];
2010-02-21 21:20:30 +00:00
}
2019-06-04 18:56:20 +01:00
Event :: handle ( 'EndFindMentions' , [ $sender , $text , & $mentions ]);
2010-02-21 21:20:30 +00:00
}
return $mentions ;
}
2010-11-29 23:04:21 +00:00
/**
* Does the actual regex pulls to find @- mentions in text .
* Should generally not be called directly ; for use in common_find_mentions .
*
* @ param string $text
2017-08-10 10:06:52 +01:00
* @ param string $preMention Character ( s ) that signals a mention ( '@' , '!' ... )
2010-11-29 23:04:21 +00:00
* @ return array of PCRE match arrays
*/
2017-08-10 10:06:52 +01:00
function common_find_mentions_raw ( $text , $preMention = '@' )
2010-11-29 23:04:21 +00:00
{
2019-06-04 18:56:20 +01:00
$tmatches = [];
2019-09-11 06:15:16 +01:00
preg_match_all (
'/^T (' . Nickname :: DISPLAY_FMT . ') /' ,
$text ,
$tmatches ,
PREG_OFFSET_CAPTURE
);
2010-11-29 23:04:21 +00:00
2019-06-04 18:56:20 +01:00
$atmatches = [];
2016-01-29 14:53:58 +00:00
// the regexp's "(?!\@)" makes sure it doesn't matches the single "@remote" in "@remote@server.com"
2019-09-11 06:15:16 +01:00
preg_match_all (
'/' . Nickname :: BEFORE_MENTIONS . preg_quote ( $preMention , '/' ) . '(' . Nickname :: DISPLAY_FMT . ')\b(?!\@)/' ,
$text ,
$atmatches ,
PREG_OFFSET_CAPTURE
);
2010-11-29 23:04:21 +00:00
$matches = array_merge ( $tmatches [ 1 ], $atmatches [ 1 ]);
return $matches ;
}
2008-12-23 19:33:23 +00:00
function common_render_text ( $text )
{
2015-02-17 23:10:31 +00:00
$text = common_remove_unicode_formatting ( $text );
$text = nl2br ( htmlspecialchars ( $text ));
2008-07-20 13:28:32 +01:00
2015-02-17 23:10:31 +00:00
$text = preg_replace ( '/[\x{0}-\x{8}\x{b}-\x{c}\x{e}-\x{19}]/' , '' , $text );
$text = common_replace_urls_callback ( $text , 'common_linkify' );
2019-06-04 18:56:20 +01:00
$text = preg_replace_callback (
'/(^|\"\;|\'|\(|\[|\{|\s+)#([\pL\pN_\-\.]{1,64})/u' ,
function ( $m ) {
return " { $m [ 1 ] } # " . common_tag_link ( $m [ 2 ]);
},
$text
);
2008-12-21 00:30:16 +00:00
// XXX: machine tags
2015-02-17 23:10:31 +00:00
return $text ;
2008-05-29 18:08:01 +01:00
}
2016-02-02 23:18:37 +00:00
define ( '_URL_SCHEME_COLON_DOUBLE_SLASH' , 1 );
define ( '_URL_SCHEME_SINGLE_COLON' , 2 );
define ( '_URL_SCHEME_NO_DOMAIN' , 4 );
2016-02-03 13:19:08 +00:00
define ( '_URL_SCHEME_COLON_COORDINATES' , 8 );
2016-02-02 23:18:37 +00:00
2019-06-25 10:35:31 +01:00
function common_url_schemes ( $filter = null )
2016-02-02 23:18:37 +00:00
{
// TODO: move these to $config
2019-06-04 18:56:20 +01:00
$schemes = [ 'http' => _URL_SCHEME_COLON_DOUBLE_SLASH ,
2016-02-02 23:18:37 +00:00
'https' => _URL_SCHEME_COLON_DOUBLE_SLASH ,
'ftp' => _URL_SCHEME_COLON_DOUBLE_SLASH ,
'ftps' => _URL_SCHEME_COLON_DOUBLE_SLASH ,
'mms' => _URL_SCHEME_COLON_DOUBLE_SLASH ,
'rtsp' => _URL_SCHEME_COLON_DOUBLE_SLASH ,
'gopher' => _URL_SCHEME_COLON_DOUBLE_SLASH ,
'news' => _URL_SCHEME_COLON_DOUBLE_SLASH ,
'nntp' => _URL_SCHEME_COLON_DOUBLE_SLASH ,
'telnet' => _URL_SCHEME_COLON_DOUBLE_SLASH ,
'wais' => _URL_SCHEME_COLON_DOUBLE_SLASH ,
'file' => _URL_SCHEME_COLON_DOUBLE_SLASH ,
'prospero' => _URL_SCHEME_COLON_DOUBLE_SLASH ,
'webcal' => _URL_SCHEME_COLON_DOUBLE_SLASH ,
'irc' => _URL_SCHEME_COLON_DOUBLE_SLASH ,
'ircs' => _URL_SCHEME_COLON_DOUBLE_SLASH ,
'aim' => _URL_SCHEME_SINGLE_COLON ,
'bitcoin' => _URL_SCHEME_SINGLE_COLON ,
'fax' => _URL_SCHEME_SINGLE_COLON ,
'jabber' => _URL_SCHEME_SINGLE_COLON ,
'mailto' => _URL_SCHEME_SINGLE_COLON ,
'tel' => _URL_SCHEME_SINGLE_COLON ,
'xmpp' => _URL_SCHEME_SINGLE_COLON ,
'magnet' => _URL_SCHEME_NO_DOMAIN ,
2019-06-04 18:56:20 +01:00
'geo' => _URL_SCHEME_COLON_COORDINATES ,];
2016-02-02 23:18:37 +00:00
return array_keys (
2019-06-04 18:56:20 +01:00
array_filter (
$schemes ,
function ( $scheme ) use ( $filter ) {
return is_null ( $filter ) || ( $scheme & $filter );
2019-09-11 06:15:16 +01:00
}
)
2019-06-04 18:56:20 +01:00
);
2016-02-02 23:18:37 +00:00
}
2010-12-02 18:56:44 +00:00
/**
* Find links in the given text and pass them to the given callback function .
*
* @ param string $text
* @ param function ( $text , $arg ) $callback : return replacement text
* @ param mixed $arg : optional argument will be passed on to the callback
*/
2019-06-04 18:56:20 +01:00
function common_replace_urls_callback ( $text , $callback , $arg = null )
{
2016-02-03 13:19:08 +00:00
$geouri_labeltext_regex = '\pN\pL\-' ;
$geouri_mark_regex = '\-\_\.\!\~\*\\\'\(\)' ; // the \\\' is really pretty
$geouri_unreserved_regex = '\pN\pL' . $geouri_mark_regex ;
$geouri_punreserved_regex = '\[\]\:\&\+\$' ;
$geouri_pctencoded_regex = '(?:\%[0-9a-fA-F][0-9a-fA-F])' ;
$geouri_paramchar_regex = $geouri_unreserved_regex . $geouri_punreserved_regex ; //FIXME: add $geouri_pctencoded_regex here so it works
2009-02-05 04:11:40 +00:00
// Start off with a regex
2009-02-12 12:58:36 +00:00
$regex = '#' .
2009-11-02 17:57:51 +00:00
'(?:^|[\s\<\>\(\)\[\]\{\}\\\'\\\";]+)(?![\@\!\#])' .
2009-08-27 17:06:45 +01:00
'(' .
2009-02-12 12:58:36 +00:00
'(?:' .
2009-08-22 02:11:23 +01:00
'(?:' . //Known protocols
'(?:' .
2016-02-02 23:18:37 +00:00
'(?:(?:' . implode ( '|' , common_url_schemes ( _URL_SCHEME_COLON_DOUBLE_SLASH )) . ')://)' .
2009-08-22 02:11:23 +01:00
'|' .
2016-02-02 23:18:37 +00:00
'(?:(?:' . implode ( '|' , common_url_schemes ( _URL_SCHEME_SINGLE_COLON )) . '):)' .
2009-08-25 19:12:31 +01:00
')' .
2009-08-28 21:18:05 +01:00
'(?:[\pN\pL\-\_\+\%\~]+(?::[\pN\pL\-\_\+\%\~]+)?\@)?' . //user:pass@
2009-08-25 19:12:31 +01:00
'(?:' .
'(?:' .
'\[[\pN\pL\-\_\:\.]+(?<![\.\:])\]' . //[dns]
')|(?:' .
'[\pN\pL\-\_\:\.]+(?<![\.\:])' . //dns
')' .
2009-08-25 16:21:45 +01:00
')' .
2009-08-22 02:11:23 +01:00
')' .
2016-02-03 13:19:08 +00:00
'|(?:' .
'(?:' . implode ( '|' , common_url_schemes ( _URL_SCHEME_COLON_COORDINATES )) . '):' .
// There's an order that must be followed here too, if ;crs= is used, it must precede ;u=
// Also 'crsp' (;crs=$crsp) must match $geouri_labeltext_regex
// Also 'uval' (;u=$uval) must be a pnum: \-?[0-9]+
'(?:' .
'(?:[0-9]+(?:\.[0-9]+)?(?:\,[0-9]+(?:\.[0-9]+)?){1,2})' . // 1(.23)?(,4(.56)){1,2}
'(?:\;(?:[' . $geouri_labeltext_regex . ']+)(?:\=[' . $geouri_paramchar_regex . ']+)*)*' .
')' .
')' .
2016-02-02 23:18:37 +00:00
// URLs without domain name, like magnet:?xt=...
2016-02-03 14:26:19 +00:00
'|(?:(?:' . implode ( '|' , common_url_schemes ( _URL_SCHEME_NO_DOMAIN )) . '):(?=\?))' . // zero-length lookahead requires ? after :
2016-02-03 11:55:00 +00:00
( common_config ( 'linkify' , 'bare_ipv4' ) // Convert IPv4 addresses to hyperlinks
? '|(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)'
: '' ) .
( common_config ( 'linkify' , 'bare_ipv6' ) // Convert IPv6 addresses to hyperlinks
? '|(?:' . //IPv6
'\[?(?:(?:(?:[0-9A-Fa-f]{1,4}:){7}(?:(?:[0-9A-Fa-f]{1,4})|:))|(?:(?:[0-9A-Fa-f]{1,4}:){6}(?::|(?:(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})(?:\.(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})|(?::[0-9A-Fa-f]{1,4})))|(?:(?:[0-9A-Fa-f]{1,4}:){5}(?:(?::(?:(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})(?:\.(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|(?:(?::[0-9A-Fa-f]{1,4}){1,2})))|(?:(?:[0-9A-Fa-f]{1,4}:){4}(?::[0-9A-Fa-f]{1,4}){0,1}(?:(?::(?:(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})(?:\.(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|(?:(?::[0-9A-Fa-f]{1,4}){1,2})))|(?:(?:[0-9A-Fa-f]{1,4}:){3}(?::[0-9A-Fa-f]{1,4}){0,2}(?:(?::(?:(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})(?:\.(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|(?:(?::[0-9A-Fa-f]{1,4}){1,2})))|(?:(?:[0-9A-Fa-f]{1,4}:){2}(?::[0-9A-Fa-f]{1,4}){0,3}(?:(?::(?:(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})(?:\.(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|(?:(?::[0-9A-Fa-f]{1,4}){1,2})))|(?:(?:[0-9A-Fa-f]{1,4}:)(?::[0-9A-Fa-f]{1,4}){0,4}(?:(?::(?:(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})(?:\.(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|(?:(?::[0-9A-Fa-f]{1,4}){1,2})))|(?::(?::[0-9A-Fa-f]{1,4}){0,5}(?:(?::(?:(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})(?:\.(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})?)|(?:(?::[0-9A-Fa-f]{1,4}){1,2})))|(?:(?:(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})(?:\.(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})){3})))\]?(?<!:)' .
')'
: '' ) .
2015-02-17 19:54:32 +00:00
( common_config ( 'linkify' , 'bare_domains' )
? '|(?:' . //DNS
'(?:[\pN\pL\-\_\+\%\~]+(?:\:[\pN\pL\-\_\+\%\~]+)?\@)?' . //user:pass@
'[\pN\pL\-\_]+(?:\.[\pN\pL\-\_]+)*\.' .
//tld list from http://data.iana.org/TLD/tlds-alpha-by-domain.txt, also added local, loc, and onion
'(?:AC|AD|AE|AERO|AF|AG|AI|AL|AM|AN|AO|AQ|AR|ARPA|AS|ASIA|AT|AU|AW|AX|AZ|BA|BB|BD|BE|BF|BG|BH|BI|BIZ|BJ|BM|BN|BO|BR|BS|BT|BV|BW|BY|BZ|CA|CAT|CC|CD|CF|CG|CH|CI|CK|CL|CM|CN|CO|COM|COOP|CR|CU|CV|CX|CY|CZ|DE|DJ|DK|DM|DO|DZ|EC|EDU|EE|EG|ER|ES|ET|EU|FI|FJ|FK|FM|FO|FR|GA|GB|GD|GE|GF|GG|GH|GI|GL|GM|GN|GOV|GP|GQ|GR|GS|GT|GU|GW|GY|HK|HM|HN|HR|HT|HU|ID|IE|IL|IM|IN|INFO|INT|IO|IQ|IR|IS|IT|JE|JM|JO|JOBS|JP|KE|KG|KH|KI|KM|KN|KP|KR|KW|KY|KZ|LA|LB|LC|LI|LK|LR|LS|LT|LU|LV|LY|MA|MC|MD|ME|MG|MH|MIL|MK|ML|MM|MN|MO|MOBI|MP|MQ|MR|MS|MT|MU|MUSEUM|MV|MW|MX|MY|MZ|NA|NAME|NC|NE|NET|NF|NG|NI|NL|NO|NP|NR|NU|NZ|OM|ORG|PA|PE|PF|PG|PH|PK|PL|PM|PN|PR|PRO|PS|PT|PW|PY|QA|RE|RO|RS|RU|RW|SA|SB|SC|SD|SE|SG|SH|SI|SJ|SK|SL|SM|SN|SO|SR|ST|SU|SV|SY|SZ|TC|TD|TEL|TF|TG|TH|TJ|TK|TL|TM|TN|TO|TP|TR|TRAVEL|TT|TV|TW|TZ|UA|UG|UK|US|UY|UZ|VA|VC|VE|VG|VI|VN|VU|WF|WS|XN--0ZWM56D|测试|XN--11B5BS3A9AJ6G|परीक्षा|XN--80AKHBYKNJ4F|испытание|XN--9T4B11YI5A|테스트|XN--DEBA0AD|טעסט|XN--G6W251D|測試|XN--HGBK6AJ7F53BBA|آزمایشی|XN--HLCJ6AYA9ESC7A|பரிட்சை|XN--JXALPDLP|δοκιμή|XN--KGBECHTV|إختبار|XN--ZCKZAH|テスト|YE|YT|YU|ZA|ZM|ZONE|ZW|local|loc|onion)' .
')(?![\pN\pL\-\_])'
: '' ) . // if common_config('linkify', 'bare_domains') is false, don't add anything here
2009-02-12 12:58:36 +00:00
')' .
2009-08-22 02:11:23 +01:00
'(?:' .
2009-08-25 16:21:45 +01:00
'(?:\:\d+)?' . //:port
2016-03-09 13:51:52 +00:00
'(?:/[' . URL_REGEX_VALID_PATH_CHARS . ']*)?' . // path
'(?:\?[' . URL_REGEX_VALID_QSTRING_CHARS . ']*)?' . // ?query string
'(?:\#[' . URL_REGEX_VALID_FRAGMENT_CHARS . ']*)?' . // #fragment
2016-03-09 14:16:47 +00:00
')(?<![' . URL_REGEX_EXCLUDED_END_CHARS . '])' .
2009-02-12 12:58:36 +00:00
')' .
2009-08-25 16:21:45 +01:00
'#ixu' ;
2009-09-09 21:57:11 +01:00
//preg_match_all($regex,$text,$matches);
2009-08-25 19:12:31 +01:00
//print_r($matches);
2019-07-12 16:31:14 +01:00
return preg_replace_callback ( $regex , callableLeftCurry ( 'callback_helper' , $callback , $arg ), $text );
2009-08-21 17:47:01 +01:00
}
2009-02-06 08:13:08 +00:00
2010-12-02 18:56:44 +00:00
/**
* Intermediate callback for common_replace_links (), helps resolve some
* ambiguous link forms before passing on to the final callback .
*
* @ param array $matches
* @ param callable $callback
* @ param mixed $arg optional argument to pass on as second param to callback
* @ return string
2011-03-18 17:03:41 +00:00
*
2010-12-02 18:56:44 +00:00
* @ access private
*/
2019-06-25 10:35:31 +01:00
function callback_helper ( $matches , $callback , $arg = null )
2019-06-04 18:56:20 +01:00
{
2019-06-25 10:35:31 +01:00
$url = $matches [ 1 ];
2019-06-04 18:56:20 +01:00
$left = strpos ( $matches [ 0 ], $url );
2019-06-25 10:35:31 +01:00
$right = $left + strlen ( $url );
2009-08-28 04:06:03 +01:00
2019-06-04 18:56:20 +01:00
$groupSymbolSets = [
[
2009-08-25 21:41:44 +01:00
'left' => '(' ,
'right' => ')'
2019-06-04 18:56:20 +01:00
],
[
2009-08-25 21:41:44 +01:00
'left' => '[' ,
'right' => ']'
2019-06-04 18:56:20 +01:00
],
[
2009-08-25 21:41:44 +01:00
'left' => '{' ,
'right' => '}'
2019-06-04 18:56:20 +01:00
],
[
2009-11-02 17:57:51 +00:00
'left' => '<' ,
'right' => '>'
2019-06-04 18:56:20 +01:00
]
];
2019-06-25 10:35:31 +01:00
$cannotEndWith = [ '.' , '?' , ',' , '#' ];
2019-06-04 18:56:20 +01:00
do {
2019-06-25 10:35:31 +01:00
$original_url = $url ;
2019-06-04 18:56:20 +01:00
foreach ( $groupSymbolSets as $groupSymbolSet ) {
2019-06-25 10:35:31 +01:00
if ( substr ( $url , - 1 ) == $groupSymbolSet [ 'right' ]) {
2019-06-04 18:56:20 +01:00
$group_left_count = substr_count ( $url , $groupSymbolSet [ 'left' ]);
$group_right_count = substr_count ( $url , $groupSymbolSet [ 'right' ]);
2019-06-25 10:35:31 +01:00
if ( $group_left_count < $group_right_count ) {
$right -= 1 ;
$url = substr ( $url , 0 , - 1 );
2009-08-25 21:41:44 +01:00
}
}
}
2019-06-04 18:56:20 +01:00
if ( in_array ( substr ( $url , - 1 ), $cannotEndWith )) {
2019-06-25 10:35:31 +01:00
$right -= 1 ;
2019-06-04 18:56:20 +01:00
$url = substr ( $url , 0 , - 1 );
2009-08-25 21:41:44 +01:00
}
2019-06-25 10:35:31 +01:00
} while ( $original_url != $url );
2009-08-28 04:06:03 +01:00
2019-06-04 18:56:20 +01:00
$result = call_user_func_array ( $callback , [ $url , $arg ]);
return substr ( $matches [ 0 ], 0 , $left ) . $result . substr ( $matches [ 0 ], $right );
2009-08-21 17:47:01 +01:00
}
2009-02-06 08:13:08 +00:00
2019-08-23 13:36:02 +01:00
require_once INSTALLDIR . '/lib/util/callableleftcurry.php' ;
2009-02-05 04:11:40 +00:00
2019-06-04 18:56:20 +01:00
function common_linkify ( $url )
{
2009-02-12 14:22:45 +00:00
// It comes in special'd, so we unspecial it before passing to the stringifying
// functions
$url = htmlspecialchars_decode ( $url );
2009-06-28 20:21:15 +01:00
2011-02-25 23:46:35 +00:00
if ( strpos ( $url , '@' ) !== false && strpos ( $url , ':' ) === false && Validate :: email ( $url )) {
//url is an email address without the mailto: protocol
$canon = " mailto: $url " ;
$longurl = " mailto: $url " ;
} else {
2009-09-27 21:52:15 +01:00
$canon = File_redirection :: _canonUrl ( $url );
2010-11-17 21:03:59 +00:00
$longurl_data = File_redirection :: where ( $canon , common_config ( 'attachments' , 'process_links' ));
2019-06-25 22:59:10 +01:00
2019-06-04 18:56:20 +01:00
if ( isset ( $longurl_data -> redir_url )) {
$longurl = $longurl_data -> redir_url ;
2016-01-05 23:14:51 +00:00
} else {
// e.g. local files
2019-06-04 18:56:20 +01:00
$longurl = $longurl_data -> url ;
2016-01-05 23:14:51 +00:00
}
2009-05-13 19:27:32 +01:00
}
2019-06-25 22:59:10 +01:00
2019-06-04 18:56:20 +01:00
$attrs = [ 'href' => $longurl , 'title' => $longurl ];
2009-05-25 02:13:42 +01:00
2009-06-25 20:52:10 +01:00
$is_attachment = false ;
$attachment_id = null ;
$has_thumb = false ;
2009-08-28 04:09:07 +01:00
// Check to see whether this is a known "attachment" URL.
2009-06-25 20:52:10 +01:00
2016-01-07 17:13:10 +00:00
try {
$f = File :: getByUrl ( $longurl );
} catch ( NoResultException $e ) {
2010-11-17 21:03:59 +00:00
if ( common_config ( 'attachments' , 'process_links' )) {
// XXX: this writes to the database. :<
2014-06-02 01:08:48 +01:00
try {
$f = File :: processNew ( $longurl );
} catch ( ServerException $e ) {
$f = null ;
}
2010-11-17 21:03:59 +00:00
}
2009-06-25 20:52:10 +01:00
}
2014-06-02 00:26:23 +01:00
if ( $f instanceof File ) {
try {
$enclosure = $f -> getEnclosure ();
2009-06-25 20:52:10 +01:00
$is_attachment = true ;
2009-08-28 04:23:31 +01:00
$attachment_id = $f -> id ;
2010-01-22 15:12:26 +00:00
2013-08-18 12:04:58 +01:00
$thumb = File_thumbnail :: getKV ( 'file_id' , $f -> id );
2014-06-02 00:26:23 +01:00
$has_thumb = ( $thumb instanceof File_thumbnail );
} catch ( ServerException $e ) {
// There was not enough metadata available
2009-06-25 20:52:10 +01:00
}
}
2010-10-18 16:29:52 +01:00
// Whether to nofollow
$nf = common_config ( 'nofollow' , 'external' );
if ( $nf == 'never' ) {
$attrs [ 'rel' ] = 'external' ;
} else {
$attrs [ 'rel' ] = 'nofollow external' ;
}
2016-06-09 10:56:36 +01:00
// Add clippy
if ( $is_attachment ) {
$attrs [ 'class' ] = 'attachment' ;
if ( $has_thumb ) {
$attrs [ 'class' ] = 'attachment thumbnail' ;
}
$attrs [ 'id' ] = " attachment- { $attachment_id } " ;
$attrs [ 'rel' ] .= ' noreferrer' ;
}
2009-06-28 20:21:15 +01:00
return XMLStringer :: estring ( 'a' , $attrs , $url );
2008-11-02 09:02:41 +00:00
}
2010-12-02 18:56:44 +00:00
/**
* Find and shorten links in a given chunk of text if it ' s longer than the
* configured notice content limit ( or unconditionally ) .
*
* Side effects : may save file and file_redirection records for referenced URLs .
*
* Pass the $user option or call $user -> shortenLinks ( $text ) to ensure the proper
* user 's options are used; otherwise the current web session user' s setitngs
* will be used or ur1 . ca if there is no active web login .
*
* @ param string $text
* @ param boolean $always ( optional )
* @ param User $user ( optional )
*
* @ return string
*/
function common_shorten_links ( $text , $always = false , User $user = null )
2008-12-23 19:33:23 +00:00
{
2012-08-13 19:33:19 +01:00
if ( $user === null ) {
$user = common_current_user ();
}
2010-04-26 07:40:36 +01:00
$maxLength = User_urlshortener_prefs :: maxNoticeLength ( $user );
2013-09-25 21:48:32 +01:00
if ( $always || ( $maxLength != - 1 && mb_strlen ( $text ) > $maxLength )) {
2019-06-04 18:56:20 +01:00
return common_replace_urls_callback ( $text , [ 'File_redirection' , 'forceShort' ], $user );
2010-04-26 07:40:36 +01:00
} else {
2019-06-04 18:56:20 +01:00
return common_replace_urls_callback ( $text , [ 'File_redirection' , 'makeShort' ], $user );
2010-04-26 07:40:36 +01:00
}
2008-11-06 20:59:26 +00:00
}
2010-10-06 21:00:30 +01:00
/**
* Very basic stripping of invalid UTF - 8 input text .
*
* @ param string $str
* @ return mixed string or null if invalid input
*
* @ todo ideally we should drop bad chars , and maybe do some of the checks
* from common_xml_safe_str . But we can ' t strip newlines , etc .
* @ todo Unicode normalization might also be useful , but not needed now .
*/
function common_validate_utf8 ( $str )
{
// preg_replace will return NULL on invalid UTF-8 input.
2010-10-07 20:32:10 +01:00
//
// Note: empty regex //u also caused NULL return on some
// production machines, but none of our test machines.
//
// This should be replaced with a more reliable check.
return preg_replace ( '/\x00/u' , '' , $str );
2010-10-06 21:00:30 +01:00
}
/**
* Make sure an arbitrary string is safe for output in XML as a single line .
*
* @ param string $str
* @ return string
*/
2008-12-23 19:33:23 +00:00
function common_xml_safe_str ( $str )
{
2010-03-01 22:58:06 +00:00
// Replace common eol and extra whitespace input chars
2019-06-04 18:56:20 +01:00
$unWelcome = [ " \t " , // tab
" \n " , // newline
" \r " , // cr
" \0 " , // null byte eos
" \x0B " ]; // vertical tab
$replacement = [ ' ' , // single space
' ' ,
'' , // nothing
'' ,
' ' ];
2010-03-01 22:58:06 +00:00
$str = str_replace ( $unWelcome , $replacement , $str );
// Neutralize any additional control codes and UTF-16 surrogates
// (Twitter uses '*')
return preg_replace ( '/[\p{Cc}\p{Cs}]/u' , '*' , $str );
2008-11-04 08:40:27 +00:00
}
2015-02-17 19:11:35 +00:00
function common_slugify ( $str )
{
2015-02-26 21:58:36 +00:00
// php5-intl is highly recommended...
if ( ! function_exists ( 'transliterator_transliterate' )) {
$str = preg_replace ( '/[^\pL\pN]/u' , '' , $str );
$str = mb_convert_case ( $str , MB_CASE_LOWER , 'UTF-8' );
$str = substr ( $str , 0 , 64 );
return $str ;
}
2019-06-04 18:56:20 +01:00
$str = transliterator_transliterate ( 'Any-Latin;' . // any charset to latin compatible
'NFD;' . // decompose
'[:Nonspacing Mark:] Remove;' . // remove nonspacing marks (accents etc.)
'NFC;' . // composite again
'[:Punctuation:] Remove;' . // remove punctuation (.,¿? etc.)
'Lower();' . // turn into lowercase
'Latin-ASCII;' , // get ASCII equivalents (ð to d for example)
$str );
2015-02-17 19:11:35 +00:00
return preg_replace ( '/[^\pL\pN]/' , '' , $str );
}
2008-12-23 19:33:23 +00:00
function common_tag_link ( $tag )
{
2008-12-21 00:30:16 +00:00
$canonical = common_canonical_tag ( $tag );
2010-04-09 01:04:10 +01:00
if ( common_config ( 'singleuser' , 'enabled' )) {
// regular TagAction isn't set up in 1user mode
2010-12-06 20:39:09 +00:00
$nickname = User :: singleUserNickname ();
2019-06-04 18:56:20 +01:00
$url = common_local_url ( 'showstream' , [ 'nickname' => $nickname , 'tag' => $canonical ]);
2010-04-09 01:04:10 +01:00
} else {
2019-06-04 18:56:20 +01:00
$url = common_local_url ( 'tag' , [ 'tag' => $canonical ]);
2010-04-09 01:04:10 +01:00
}
2009-02-12 13:38:43 +00:00
$xs = new XMLStringer ();
$xs -> elementStart ( 'span' , 'tag' );
2019-06-04 18:56:20 +01:00
$xs -> element ( 'a' , [ 'href' => $url , 'rel' => 'tag' ], $tag );
2009-02-16 23:02:04 +00:00
$xs -> elementEnd ( 'span' );
2009-02-12 13:38:43 +00:00
return $xs -> getString ();
2008-09-17 12:22:34 +01:00
}
2008-12-23 19:33:23 +00:00
function common_canonical_tag ( $tag )
{
2015-02-17 19:11:35 +00:00
$tag = common_slugify ( $tag );
$tag = substr ( $tag , 0 , 64 );
return $tag ;
2008-07-20 06:57:02 +01:00
}
2008-12-23 19:33:23 +00:00
function common_valid_profile_tag ( $str )
{
2008-12-21 00:30:16 +00:00
return preg_match ( '/^[A-Za-z0-9_\-\.]{1,64}$/' , $str );
2008-11-20 21:48:21 +00:00
}
2010-11-29 19:31:10 +00:00
/**
* Resolve an ambiguous profile nickname reference , checking in following order :
* - profiles that $sender subscribes to
* - profiles that subscribe to $sender
* - local user profiles
*
* WARNING : does not validate or normalize $nickname -- MUST BE PRE - VALIDATED
* OR THERE MAY BE A RISK OF SQL INJECTION ATTACKS . THIS FUNCTION DOES NOT
* ESCAPE SQL .
*
* @ fixme validate input
* @ fixme escape SQL
* @ fixme fix or remove mystery third parameter
* @ fixme is $sender a User or Profile ?
*
* @ param < type > $sender the user or profile in whose context we ' re looking
* @ param string $nickname validated nickname of
2010-11-30 00:44:01 +00:00
* @ param < type > $dt unused mystery parameter ; in Notice reply - to handling a timestamp is passed .
2010-11-29 19:31:10 +00:00
*
* @ return Profile or null
*/
2008-12-23 19:33:23 +00:00
function common_relative_profile ( $sender , $nickname , $dt = null )
{
2010-11-30 00:44:01 +00:00
// Will throw exception on invalid input.
$nickname = Nickname :: normalize ( $nickname );
2008-12-21 00:30:16 +00:00
// Try to find profiles this profile is subscribed to that have this nickname
$recipient = new Profile ();
2019-09-11 06:15:16 +01:00
$recipient -> whereAdd (
sprintf ( 'id IN (SELECT subscribed FROM subscription WHERE subscriber = %d)' , $sender -> id ),
'AND'
);
2010-11-30 00:44:01 +00:00
$recipient -> whereAdd ( " nickname = ' " . $recipient -> escape ( $nickname ) . " ' " , 'AND' );
2008-12-23 19:44:28 +00:00
if ( $recipient -> find ( true )) {
2008-12-21 00:30:16 +00:00
// XXX: should probably differentiate between profiles with
// the same name by date of most recent update
return $recipient ;
}
// Try to find profiles that listen to this profile and that have this nickname
$recipient = new Profile ();
2019-09-11 06:15:16 +01:00
$recipient -> whereAdd (
sprintf ( 'id IN (SELECT subscriber FROM subscription WHERE subscribed = %d)' , $sender -> id ),
'AND'
);
2010-11-30 00:44:01 +00:00
$recipient -> whereAdd ( " nickname = ' " . $recipient -> escape ( $nickname ) . " ' " , 'AND' );
2008-12-23 19:44:28 +00:00
if ( $recipient -> find ( true )) {
2008-12-21 00:30:16 +00:00
// XXX: should probably differentiate between profiles with
// the same name by date of most recent update
return $recipient ;
}
// If this is a local user, try to find a local user with that nickname.
2013-10-29 10:27:26 +00:00
$sender = User :: getKV ( 'id' , $sender -> id );
2013-10-28 21:18:00 +00:00
if ( $sender instanceof User ) {
2013-08-18 12:04:58 +01:00
$recipient_user = User :: getKV ( 'nickname' , $nickname );
2013-10-28 21:18:00 +00:00
if ( $recipient_user instanceof User ) {
2008-12-21 00:30:16 +00:00
return $recipient_user -> getProfile ();
}
}
// Otherwise, no links. @messages from local users to remote users,
// or from remote users to other remote users, are just
// outside our ability to make intelligent guesses about
return null ;
2008-05-20 14:05:35 +01:00
}
2019-10-26 16:10:44 +01:00
function common_local_url ( $action , $args = null , $params = null , $fragment = null , $addSession = true , $defancy = false )
2008-12-23 19:33:23 +00:00
{
2019-06-04 18:56:20 +01:00
if ( Event :: handle ( 'StartLocalURL' , [ & $action , & $params , & $fragment , & $addSession , & $url ])) {
2011-04-13 05:08:02 +01:00
$r = Router :: get ();
$path = $r -> build ( $action , $args , $params , $fragment );
2009-03-07 01:18:21 +00:00
2016-02-09 23:57:39 +00:00
$ssl = GNUsocial :: useHTTPS ();
2009-03-26 19:03:59 +00:00
2019-10-26 16:10:44 +01:00
if ( common_config ( 'site' , 'fancy' ) && ! $defancy ) {
2011-09-14 17:15:56 +01:00
$url = common_path ( $path , $ssl , $addSession );
2009-03-07 01:18:21 +00:00
} else {
2011-04-13 05:08:02 +01:00
if ( mb_strpos ( $path , '/index.php' ) === 0 ) {
2011-09-14 17:15:56 +01:00
$url = common_path ( $path , $ssl , $addSession );
2011-04-13 05:08:02 +01:00
} else {
2011-09-14 17:15:56 +01:00
$url = common_path ( 'index.php/' . $path , $ssl , $addSession );
2011-04-13 05:08:02 +01:00
}
2009-03-07 01:18:21 +00:00
}
2019-06-04 18:56:20 +01:00
Event :: handle ( 'EndLocalURL' , [ & $action , & $params , & $fragment , & $addSession , & $url ]);
2008-12-21 00:30:16 +00:00
}
return $url ;
}
2010-02-26 22:28:44 +00:00
function common_path ( $relative , $ssl = false , $addSession = true )
2008-12-23 19:33:23 +00:00
{
2009-03-10 01:01:35 +00:00
$pathpart = ( common_config ( 'site' , 'path' )) ? common_config ( 'site' , 'path' ) . " / " : '' ;
2009-03-26 19:03:59 +00:00
2016-02-09 23:57:39 +00:00
if ( $ssl && GNUsocial :: useHTTPS ()) {
2009-03-26 19:03:59 +00:00
$proto = 'https' ;
if ( is_string ( common_config ( 'site' , 'sslserver' )) &&
mb_strlen ( common_config ( 'site' , 'sslserver' )) > 0 ) {
$serverpart = common_config ( 'site' , 'sslserver' );
2019-06-04 18:56:20 +01:00
} elseif ( common_config ( 'site' , 'server' )) {
2009-03-26 19:03:59 +00:00
$serverpart = common_config ( 'site' , 'server' );
2009-10-20 01:08:20 +01:00
} else {
2019-09-13 10:11:43 +01:00
throw new ServerException ( 'Site server not configured, unable to determine site name.' );
2009-03-26 19:03:59 +00:00
}
} else {
$proto = 'http' ;
2009-10-20 01:08:20 +01:00
if ( common_config ( 'site' , 'server' )) {
$serverpart = common_config ( 'site' , 'server' );
} else {
2019-09-13 10:11:43 +01:00
throw new ServerException ( 'Site server not configured, unable to determine site name.' );
2009-10-20 01:08:20 +01:00
}
2009-03-26 19:03:59 +00:00
}
2010-02-26 22:28:44 +00:00
if ( $addSession ) {
$relative = common_inject_session ( $relative , $serverpart );
}
2010-01-11 23:09:46 +00:00
2009-03-26 19:03:59 +00:00
return $proto . '://' . $serverpart . '/' . $pathpart . $relative ;
2008-05-20 14:05:35 +01:00
}
2016-02-21 18:01:37 +00:00
// FIXME: Maybe this should also be able to handle non-fancy URLs with index.php?p=...
2016-02-21 17:48:18 +00:00
function common_fake_local_fancy_url ( $url )
{
/**
* This is a hacky fix to make URIs generated with " index.php/ " match against
* locally stored URIs without that . So for example if the remote site is looking
* up the webfinger for some user and for some reason knows about https :// some . example / user / 1
* but we locally store and report only https :// some . example / index . php / user / 1 then they would
* dismiss the profile for not having an identified alias .
*
* There are various live instances where these issues occur , for various reasons .
* Most of them being users fiddling with configuration while already having
* started federating ( distributing the URI to other servers ) or maybe manually
* editing the local database .
*/
if ( ! preg_match (
// [1] protocol part, we can only rewrite http/https anyway.
'/^(https?:\/\/)' .
// [2] site name.
// FIXME: Dunno how this acts if we're aliasing ourselves with a .onion domain etc.
'(' . preg_quote ( common_config ( 'site' , 'server' ), '/' ) . ')' .
// [3] site path, or if that is empty just '/' (to retain the /)
'(' . preg_quote ( common_config ( 'site' , 'path' ) ? : '/' , '/' ) . ')' .
// [4] + [5] extract index.php (+ possible leading double /) and the rest of the URL separately.
2019-06-04 18:56:20 +01:00
'(\/?index\.php\/)(.*)$/' ,
$url ,
$matches
)) {
2016-02-21 17:48:18 +00:00
// if preg_match failed to match
2016-02-21 18:01:37 +00:00
throw new Exception ( 'No known change could be made to the URL.' );
2016-02-21 17:48:18 +00:00
}
// now reconstruct the URL with everything except the "index.php/" part
$fancy_url = '' ;
foreach ([ 1 , 2 , 3 , 5 ] as $idx ) {
$fancy_url .= $matches [ $idx ];
}
return $fancy_url ;
}
2016-02-21 19:00:07 +00:00
// FIXME: Maybe this should also be able to handle non-fancy URLs with index.php?p=...
function common_fake_local_nonfancy_url ( $url )
{
/**
* This is a hacky fix to make URIs NOT generated with " index.php/ " match against
* locally stored URIs WITH that . The reverse from the above .
*
* It will also " repair " index . php URLs with multiple / prepended . Like https :// some . example ///index.php/user/1
*/
if ( ! preg_match (
// [1] protocol part, we can only rewrite http/https anyway.
'/^(https?:\/\/)' .
// [2] site name.
// FIXME: Dunno how this acts if we're aliasing ourselves with a .onion domain etc.
'(' . preg_quote ( common_config ( 'site' , 'server' ), '/' ) . ')' .
// [3] site path, or if that is empty just '/' (to retain the /)
'(' . preg_quote ( common_config ( 'site' , 'path' ) ? : '/' , '/' ) . ')' .
// [4] should be empty (might contain one or more / and then maybe also index.php). Will be overwritten.
// [5] will have the extracted actual URL part (besides site path)
2019-06-04 18:56:20 +01:00
'((?!index.php\/)\/*(?:index.php\/)?)(.*)$/' ,
$url ,
$matches
)) {
2016-02-21 19:00:07 +00:00
// if preg_match failed to match
throw new Exception ( 'No known change could be made to the URL.' );
}
$matches [ 4 ] = 'index.php/' ; // inject the index.php/ rewritethingy
// remove the first element, which is the full matching string
array_shift ( $matches );
return implode ( $matches );
}
2010-01-11 08:39:02 +00:00
function common_inject_session ( $url , $serverpart = null )
{
2013-10-30 11:21:34 +00:00
if ( ! common_have_session ()) {
return $url ;
}
2010-01-11 07:51:57 +00:00
2013-10-30 11:21:34 +00:00
if ( empty ( $serverpart )) {
$serverpart = parse_url ( $url , PHP_URL_HOST );
}
2010-01-11 23:09:46 +00:00
2013-10-30 11:21:34 +00:00
$currentServer = ( array_key_exists ( 'HTTP_HOST' , $_SERVER )) ? $_SERVER [ 'HTTP_HOST' ] : null ;
2010-01-11 07:51:57 +00:00
2013-10-30 11:21:34 +00:00
// Are we pointing to another server (like an SSL server?)
2010-01-11 07:51:57 +00:00
2013-10-30 11:21:34 +00:00
if ( ! empty ( $currentServer ) && 0 != strcasecmp ( $currentServer , $serverpart )) {
// Pass the session ID as a GET parameter
$sesspart = session_name () . '=' . session_id ();
$i = strpos ( $url , '?' );
if ( $i === false ) { // no GET params, just append
$url .= '?' . $sesspart ;
} else {
$url = substr ( $url , 0 , $i + 1 ) . $sesspart . '&' . substr ( $url , $i + 1 );
2010-01-11 07:51:57 +00:00
}
}
2010-01-11 23:09:46 +00:00
2010-01-11 08:39:02 +00:00
return $url ;
2008-05-20 14:05:35 +01:00
}
2008-12-23 19:33:23 +00:00
function common_date_string ( $dt )
{
2008-12-21 00:30:16 +00:00
// XXX: do some sexy date formatting
// return date(DATE_RFC822, $dt);
$t = strtotime ( $dt );
$now = time ();
$diff = $now - $t ;
if ( $now < $t ) { // that shouldn't happen!
return common_exact_date ( $dt );
2019-06-04 18:56:20 +01:00
} elseif ( $diff < 60 ) {
2010-04-11 21:15:41 +01:00
// TRANS: Used in notices to indicate when the notice was made compared to now.
2008-12-21 00:30:16 +00:00
return _ ( 'a few seconds ago' );
2019-06-04 18:56:20 +01:00
} elseif ( $diff < 92 ) {
2010-04-11 21:15:41 +01:00
// TRANS: Used in notices to indicate when the notice was made compared to now.
2008-12-21 00:30:16 +00:00
return _ ( 'about a minute ago' );
2019-06-04 18:56:20 +01:00
} elseif ( $diff < 3300 ) {
2010-09-15 23:07:47 +01:00
$minutes = round ( $diff / 60 );
2010-04-11 21:15:41 +01:00
// TRANS: Used in notices to indicate when the notice was made compared to now.
2019-06-04 18:56:20 +01:00
return sprintf ( _m ( 'about one minute ago' , 'about %d minutes ago' , $minutes ), $minutes );
} elseif ( $diff < 5400 ) {
2010-04-11 21:15:41 +01:00
// TRANS: Used in notices to indicate when the notice was made compared to now.
2008-12-21 00:30:16 +00:00
return _ ( 'about an hour ago' );
2019-06-04 18:56:20 +01:00
} elseif ( $diff < 22 * 3600 ) {
2010-09-15 23:07:47 +01:00
$hours = round ( $diff / 3600 );
2010-04-11 21:15:41 +01:00
// TRANS: Used in notices to indicate when the notice was made compared to now.
2019-06-04 18:56:20 +01:00
return sprintf ( _m ( 'about one hour ago' , 'about %d hours ago' , $hours ), $hours );
} elseif ( $diff < 37 * 3600 ) {
2010-04-11 21:15:41 +01:00
// TRANS: Used in notices to indicate when the notice was made compared to now.
2008-12-21 00:30:16 +00:00
return _ ( 'about a day ago' );
2019-06-04 18:56:20 +01:00
} elseif ( $diff < 24 * 24 * 3600 ) {
2010-09-15 23:07:47 +01:00
$days = round ( $diff / ( 24 * 3600 ));
2010-04-11 21:15:41 +01:00
// TRANS: Used in notices to indicate when the notice was made compared to now.
2019-06-04 18:56:20 +01:00
return sprintf ( _m ( 'about one day ago' , 'about %d days ago' , $days ), $days );
} elseif ( $diff < 46 * 24 * 3600 ) {
2010-04-11 21:15:41 +01:00
// TRANS: Used in notices to indicate when the notice was made compared to now.
2008-12-21 00:30:16 +00:00
return _ ( 'about a month ago' );
2019-06-04 18:56:20 +01:00
} elseif ( $diff < 330 * 24 * 3600 ) {
2010-09-15 23:07:47 +01:00
$months = round ( $diff / ( 30 * 24 * 3600 ));
2010-04-11 21:15:41 +01:00
// TRANS: Used in notices to indicate when the notice was made compared to now.
2019-06-04 18:56:20 +01:00
return sprintf ( _m ( 'about one month ago' , 'about %d months ago' , $months ), $months );
} elseif ( $diff < 480 * 24 * 3600 ) {
2010-04-11 21:15:41 +01:00
// TRANS: Used in notices to indicate when the notice was made compared to now.
2008-12-21 00:30:16 +00:00
return _ ( 'about a year ago' );
} else {
return common_exact_date ( $dt );
}
2008-06-27 23:25:22 +01:00
}
2008-12-23 19:33:23 +00:00
function common_exact_date ( $dt )
{
2008-07-25 00:46:19 +01:00
static $_utc ;
static $_siteTz ;
if ( ! $_utc ) {
$_utc = new DateTimeZone ( 'UTC' );
$_siteTz = new DateTimeZone ( common_timezone ());
}
2008-12-21 00:30:16 +00:00
$dateStr = date ( 'd F Y H:i:s' , strtotime ( $dt ));
$d = new DateTime ( $dateStr , $_utc );
$d -> setTimezone ( $_siteTz );
2014-04-28 16:45:21 +01:00
// TRANS: Human-readable full date-time specification (formatting on http://php.net/date)
return $d -> format ( _ ( 'l, d-M-Y H:i:s T' ));
2008-05-20 14:05:35 +01:00
}
2008-12-23 19:33:23 +00:00
function common_date_w3dtf ( $dt )
{
2008-12-21 00:30:16 +00:00
$dateStr = date ( 'd F Y H:i:s' , strtotime ( $dt ));
$d = new DateTime ( $dateStr , new DateTimeZone ( 'UTC' ));
$d -> setTimezone ( new DateTimeZone ( common_timezone ()));
return $d -> format ( DATE_W3C );
2008-05-21 15:59:16 +01:00
}
2008-12-23 19:33:23 +00:00
function common_date_rfc2822 ( $dt )
{
2008-12-21 00:30:16 +00:00
$dateStr = date ( 'd F Y H:i:s' , strtotime ( $dt ));
$d = new DateTime ( $dateStr , new DateTimeZone ( 'UTC' ));
$d -> setTimezone ( new DateTimeZone ( common_timezone ()));
return $d -> format ( 'r' );
2008-07-16 23:02:23 +01:00
}
2008-12-23 19:33:23 +00:00
function common_date_iso8601 ( $dt )
{
2008-12-21 00:30:16 +00:00
$dateStr = date ( 'd F Y H:i:s' , strtotime ( $dt ));
$d = new DateTime ( $dateStr , new DateTimeZone ( 'UTC' ));
$d -> setTimezone ( new DateTimeZone ( common_timezone ()));
return $d -> format ( 'c' );
2008-07-16 23:02:23 +01:00
}
2008-12-23 19:33:23 +00:00
function common_sql_now ()
{
2009-06-27 13:48:22 +01:00
return common_sql_date ( time ());
}
function common_sql_date ( $datetime )
{
return strftime ( '%Y-%m-%d %H:%M:%S' , $datetime );
2008-08-25 19:23:38 +01:00
}
2010-01-04 19:55:27 +00:00
/**
* Return an SQL fragment to calculate an age - based weight from a given
* timestamp or datetime column .
*
* @ param string $column name of field we ' re comparing against current time
* @ param integer $dropoff divisor for age in seconds before exponentiation
* @ return string SQL fragment
*/
function common_sql_weight ( $column , $dropoff )
{
2020-06-10 14:52:00 +01:00
if ( common_config ( 'db' , 'type' ) !== 'mysql' ) {
$expr = sprintf (
'(((EXTRACT(DAY %1$s) * 24 + EXTRACT(HOUR %1$s)) * 60 + '
. 'EXTRACT(MINUTE %1$s)) * 60 + EXTRACT(SECOND %1$s))' ,
" FROM ( { $column } - CURRENT_TIMESTAMP) "
);
2010-01-04 19:55:27 +00:00
} else {
2020-06-10 14:52:00 +01:00
$expr = " timestampdiff(SECOND, CURRENT_TIMESTAMP, { $column } ) " ;
2010-01-04 19:55:27 +00:00
}
2020-06-10 14:52:00 +01:00
return " SUM(EXP( { $expr } / { $dropoff } )) " ;
2010-01-04 19:55:27 +00:00
}
2020-08-04 12:12:17 +01:00
function common_redirect ( string $url , int $code = 307 ) : void
2008-12-23 19:33:23 +00:00
{
2020-08-04 12:12:17 +01:00
assert ( in_array ( $code , [ 301 , 302 , 303 , 307 ]));
http_response_code ( $code );
header ( " Location: { $url } " );
2011-09-08 10:45:34 +01:00
header ( " Connection: close " );
2008-12-21 00:30:16 +00:00
2009-01-21 07:45:08 +00:00
$xo = new XMLOutputter ();
2019-06-04 18:56:20 +01:00
$xo -> startXML (
'a' ,
'-//W3C//DTD XHTML 1.0 Strict//EN' ,
'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'
);
$xo -> element ( 'a' , [ 'href' => $url ], $url );
2009-01-21 07:45:08 +00:00
$xo -> endXML ();
2020-08-04 12:12:17 +01:00
die ();
2008-05-20 14:05:35 +01:00
}
2008-12-21 00:30:16 +00:00
// Stick the notice on the queue
2008-07-04 06:04:25 +01:00
2008-12-23 19:33:23 +00:00
function common_enqueue_notice ( $notice )
{
2019-06-04 18:56:20 +01:00
static $localTransports = [ 'ping' ];
2009-09-21 19:39:22 +01:00
2019-06-04 18:56:20 +01:00
$transports = [];
2010-02-01 18:16:19 +00:00
if ( common_config ( 'sms' , 'enabled' )) {
$transports [] = 'sms' ;
}
if ( Event :: hasHandler ( 'HandleQueuedNotice' )) {
2019-08-12 15:03:18 +01:00
$transports [] = 'Module' ;
2010-02-01 18:16:19 +00:00
}
2009-06-25 03:17:41 +01:00
2010-06-04 00:58:45 +01:00
// We can skip these for gatewayed notices.
if ( $notice -> isLocal ()) {
2009-07-01 16:34:12 +01:00
$transports = array_merge ( $transports , $localTransports );
2009-02-20 18:57:20 +00:00
}
2008-07-08 10:45:31 +01:00
2019-06-04 18:56:20 +01:00
if ( Event :: handle ( 'StartEnqueueNotice' , [ $notice , & $transports ])) {
2009-09-21 19:14:55 +01:00
$qm = QueueManager :: get ();
2019-06-04 18:56:20 +01:00
foreach ( $transports as $transport ) {
2009-09-21 19:14:55 +01:00
$qm -> enqueue ( $notice , $transport );
}
2019-06-04 18:56:20 +01:00
Event :: handle ( 'EndEnqueueNotice' , [ $notice , $transports ]);
2009-02-12 01:46:53 +00:00
}
2009-02-13 15:47:22 +00:00
2009-07-01 16:34:12 +01:00
return true ;
2008-05-20 14:05:35 +01:00
}
2008-12-23 19:33:23 +00:00
function common_profile_url ( $nickname )
{
2019-09-11 06:15:16 +01:00
return common_local_url (
'showstream' ,
[ 'nickname' => $nickname ],
null ,
null ,
false
);
2008-05-20 14:05:35 +01:00
}
2010-09-12 23:14:36 +01:00
/**
* Should make up a reasonable root URL
2016-03-10 13:20:21 +00:00
*
* @ param bool $tls true or false to force TLS scheme , null to use server configuration
2010-09-12 23:14:36 +01:00
*/
2016-03-10 13:20:21 +00:00
function common_root_url ( $tls = null )
2008-12-23 19:33:23 +00:00
{
2016-03-10 13:20:21 +00:00
if ( is_null ( $tls )) {
$tls = GNUsocial :: useHTTPS ();
}
$url = common_path ( '' , $tls , false );
2010-01-11 23:09:46 +00:00
$i = strpos ( $url , '?' );
if ( $i !== false ) {
$url = substr ( $url , 0 , $i );
}
return $url ;
2008-05-27 12:42:19 +01:00
}
2010-09-12 23:14:36 +01:00
/**
2015-10-04 11:06:48 +01:00
* returns $bytes bytes of raw random data
2010-09-12 23:14:36 +01:00
*/
2015-10-04 11:06:48 +01:00
function common_random_rawstr ( $bytes )
2013-10-21 12:09:40 +01:00
{
2015-10-04 11:06:48 +01:00
$rawstr = @ file_exists ( '/dev/urandom' )
2013-10-21 12:09:40 +01:00
? common_urandom ( $bytes )
: common_mtrand ( $bytes );
2015-10-04 11:06:48 +01:00
return $rawstr ;
}
/**
* returns $bytes bytes of random data as a hexadecimal string
*/
function common_random_hexstr ( $bytes )
{
2019-06-22 18:57:43 +01:00
return bin2hex ( random_bytes ( $bytes ));
2008-05-27 21:07:21 +01:00
}
2008-12-23 19:33:23 +00:00
function common_urandom ( $bytes )
{
2008-12-21 00:30:16 +00:00
$h = fopen ( '/dev/urandom' , 'rb' );
// should not block
$src = fread ( $h , $bytes );
fclose ( $h );
2013-10-21 12:09:40 +01:00
return $src ;
2008-05-27 21:07:21 +01:00
}
2008-12-23 19:33:23 +00:00
function common_mtrand ( $bytes )
{
2013-10-21 12:09:40 +01:00
$str = '' ;
2008-12-21 00:30:16 +00:00
for ( $i = 0 ; $i < $bytes ; $i ++ ) {
2013-10-21 12:09:40 +01:00
$str .= chr ( mt_rand ( 0 , 255 ));
2008-12-21 00:30:16 +00:00
}
2013-10-21 12:09:40 +01:00
return $str ;
2008-05-27 21:07:21 +01:00
}
2010-04-09 03:06:55 +01:00
/**
* Record the given URL as the return destination for a future
* form submission , to be read by common_get_returnto () .
2010-09-06 14:56:45 +01:00
*
2010-04-09 03:06:55 +01:00
* @ param string $url
2010-09-06 14:56:45 +01:00
*
2010-04-09 03:06:55 +01:00
* @ fixme as a session - global setting , this can allow multiple forms
* to conflict and overwrite each others ' returnto destinations if
* the user has multiple tabs or windows open .
2010-09-06 14:56:45 +01:00
*
2010-04-09 03:06:55 +01:00
* Should refactor to index with a token or otherwise only pass the
* data along its intended path .
*/
2008-12-23 19:33:23 +00:00
function common_set_returnto ( $url )
{
2008-12-21 00:30:16 +00:00
common_ensure_session ();
$_SESSION [ 'returnto' ] = $url ;
2008-05-30 15:23:24 +01:00
}
2010-04-09 03:06:55 +01:00
/**
* Fetch a return - destination URL previously recorded by
* common_set_returnto () .
2010-09-06 14:56:45 +01:00
*
2010-04-09 03:06:55 +01:00
* @ return mixed URL string or null
2010-09-06 14:56:45 +01:00
*
2010-04-09 03:06:55 +01:00
* @ fixme as a session - global setting , this can allow multiple forms
* to conflict and overwrite each others ' returnto destinations if
* the user has multiple tabs or windows open .
2010-09-06 14:56:45 +01:00
*
2010-04-09 03:06:55 +01:00
* Should refactor to index with a token or otherwise only pass the
* data along its intended path .
*/
2008-12-23 19:33:23 +00:00
function common_get_returnto ()
{
2008-12-21 00:30:16 +00:00
common_ensure_session ();
2009-10-07 10:09:00 +01:00
return ( array_key_exists ( 'returnto' , $_SESSION )) ? $_SESSION [ 'returnto' ] : null ;
2008-05-30 15:23:24 +01:00
}
2008-12-23 19:33:23 +00:00
function common_timestamp ()
{
2008-12-21 00:30:16 +00:00
return date ( 'YmdHis' );
2008-05-28 15:03:21 +01:00
}
2008-06-06 17:04:37 +01:00
2008-12-23 19:33:23 +00:00
function common_ensure_syslog ()
{
2008-12-21 00:30:16 +00:00
static $initialized = false ;
if ( ! $initialized ) {
2019-06-04 18:56:20 +01:00
openlog (
common_config ( 'syslog' , 'appname' ),
0 ,
common_config ( 'syslog' , 'facility' )
);
2008-12-21 00:30:16 +00:00
$initialized = true ;
}
}
2009-06-28 21:38:27 +01:00
function common_log_line ( $priority , $msg )
{
2019-06-04 18:56:20 +01:00
static $syslog_priorities = [ 'LOG_EMERG' , 'LOG_ALERT' , 'LOG_CRIT' , 'LOG_ERR' ,
'LOG_WARNING' , 'LOG_NOTICE' , 'LOG_INFO' , 'LOG_DEBUG' ];
2010-05-11 20:22:14 +01:00
return date ( 'Y-m-d H:i:s' ) . ' ' . $syslog_priorities [ $priority ] . ': ' . $msg . PHP_EOL ;
2009-06-28 21:38:27 +01:00
}
2009-11-27 20:28:15 +00:00
function common_request_id ()
{
$pid = getmypid ();
2010-01-13 03:57:15 +00:00
$server = common_config ( 'site' , 'server' );
2009-11-27 20:28:15 +00:00
if ( php_sapi_name () == 'cli' ) {
2010-01-22 00:42:50 +00:00
$script = basename ( $_SERVER [ 'PHP_SELF' ]);
return " $server : $script : $pid " ;
2009-11-27 20:28:15 +00:00
} else {
static $req_id = null ;
if ( ! isset ( $req_id )) {
$req_id = substr ( md5 ( mt_rand ()), 0 , 8 );
}
if ( isset ( $_SERVER [ 'REQUEST_URI' ])) {
$url = $_SERVER [ 'REQUEST_URI' ];
}
$method = $_SERVER [ 'REQUEST_METHOD' ];
2010-01-13 03:57:15 +00:00
return " $server : $pid . $req_id $method $url " ;
2009-11-27 20:28:15 +00:00
}
}
2008-12-23 19:33:23 +00:00
function common_log ( $priority , $msg , $filename = null )
{
2019-06-25 22:59:10 +01:00
// Don't write LOG_DEBUG if that's not wanted
if ( $priority === LOG_DEBUG && ! common_config ( 'site' , 'logdebug' )) {
return ;
}
2019-06-04 18:56:20 +01:00
if ( Event :: handle ( 'StartLog' , [ & $priority , & $msg , & $filename ])) {
$msg = ( empty ( $filename )) ? $msg : basename ( $filename ) . ' - ' . $msg ;
2009-12-05 07:11:27 +00:00
$msg = '[' . common_request_id () . '] ' . $msg ;
$logfile = common_config ( 'site' , 'logfile' );
if ( $logfile ) {
$log = fopen ( $logfile , " a " );
if ( $log ) {
$output = common_log_line ( $priority , $msg );
fwrite ( $log , $output );
fclose ( $log );
}
} else {
common_ensure_syslog ();
syslog ( $priority , $msg );
2008-12-21 00:30:16 +00:00
}
2019-06-04 18:56:20 +01:00
Event :: handle ( 'EndLog' , [ $priority , $msg , $filename ]);
2008-12-21 00:30:16 +00:00
}
}
2008-12-23 19:33:23 +00:00
function common_debug ( $msg , $filename = null )
{
2008-12-21 00:30:16 +00:00
if ( $filename ) {
common_log ( LOG_DEBUG , basename ( $filename ) . ' - ' . $msg );
} else {
common_log ( LOG_DEBUG , $msg );
}
}
2008-12-23 19:33:23 +00:00
function common_log_db_error ( & $object , $verb , $filename = null )
{
2013-10-28 18:03:09 +00:00
global $_PEAR ;
2008-12-21 00:30:16 +00:00
$objstr = common_log_objstring ( $object );
2019-06-04 18:56:20 +01:00
$last_error = & $_PEAR -> getStaticProperty ( 'DB_DataObject' , 'lastError' );
2010-09-21 00:52:22 +01:00
if ( is_object ( $last_error )) {
$msg = $last_error -> message ;
} else {
$msg = 'Unknown error (' . var_export ( $last_error , true ) . ')' ;
}
common_log ( LOG_ERR , $msg . '(' . $verb . ' on ' . $objstr . ')' , $filename );
2008-06-22 15:09:41 +01:00
}
2008-12-23 19:33:23 +00:00
function common_log_objstring ( & $object )
{
2008-12-21 00:30:16 +00:00
if ( is_null ( $object )) {
return " null " ;
}
2009-07-04 06:17:37 +01:00
if ( ! ( $object instanceof DB_DataObject )) {
return " (unknown) " ;
}
2008-12-21 00:30:16 +00:00
$arr = $object -> toArray ();
2019-06-04 18:56:20 +01:00
$fields = [];
2008-12-21 00:30:16 +00:00
foreach ( $arr as $k => $v ) {
2009-11-10 19:06:30 +00:00
if ( is_object ( $v )) {
$fields [] = " $k =' " . get_class ( $v ) . " ' " ;
} else {
$fields [] = " $k =' $v ' " ;
}
2008-12-21 00:30:16 +00:00
}
$objstring = $object -> tableName () . '[' . implode ( ',' , $fields ) . ']' ;
return $objstring ;
2008-06-22 15:09:41 +01:00
}
2013-10-07 13:46:09 +01:00
function common_valid_http_url ( $url , $secure = false )
2008-12-23 19:33:23 +00:00
{
2017-05-06 11:25:27 +01:00
if ( empty ( $url )) {
return false ;
}
2013-10-07 13:46:09 +01:00
// If $secure is true, only allow https URLs to pass
// (if false, we use '?' in 'https?' to say the 's' is optional)
$regex = $secure ? '/^https$/' : '/^https?$/' ;
return filter_var ( $url , FILTER_VALIDATE_URL )
&& preg_match ( $regex , parse_url ( $url , PHP_URL_SCHEME ));
2008-06-04 19:51:31 +01:00
}
2008-06-05 05:01:53 +01:00
2008-12-23 19:33:23 +00:00
function common_valid_tag ( $tag )
{
2008-12-21 00:30:16 +00:00
if ( preg_match ( '/^tag:(.*?),(\d{4}(-\d{2}(-\d{2})?)?):(.*)$/' , $tag , $matches )) {
return ( Validate :: email ( $matches [ 1 ]) ||
preg_match ( '/^([\w-\.]+)$/' , $matches [ 1 ]));
}
return false ;
2008-06-05 05:01:53 +01:00
}
2008-06-10 20:21:01 +01:00
2010-03-31 01:35:27 +01:00
/**
* Determine if given domain or address literal is valid
* eg for use in JIDs and URLs . Does not check if the domain
* exists !
2010-04-26 07:40:36 +01:00
*
2010-03-31 01:35:27 +01:00
* @ param string $domain
* @ return boolean valid or not
*/
function common_valid_domain ( $domain )
{
$octet = " (?:25[0-5]|2[0-4][0-9]|1[0-9] { 2}|[1-9][0-9]|[0-9]) " ;
$ipv4 = " (?: $octet (?: \ . $octet ) { 3}) " ;
2019-06-04 18:56:20 +01:00
if ( preg_match ( " /^ $ipv4 $ /u " , $domain )) {
return true ;
}
2010-03-31 01:35:27 +01:00
$group = " (?:[0-9a-f] { 1,4}) " ;
$ipv6 = " (?: \ [( $group (?:: $group ) { 0,7})?(::)?( $group (?:: $group ) { 0,7})? \ ]) " ; // http://tools.ietf.org/html/rfc3513#section-2.2
if ( preg_match ( " /^ $ipv6 $ /ui " , $domain , $matches )) {
$before = explode ( " : " , $matches [ 1 ]);
$zeroes = $matches [ 2 ];
$after = explode ( " : " , $matches [ 3 ]);
if ( $zeroes ) {
$min = 0 ;
$max = 7 ;
} else {
$min = 1 ;
$max = 8 ;
}
$explicit = count ( $before ) + count ( $after );
if ( $explicit < $min || $explicit > $max ) {
return false ;
}
return true ;
}
try {
2019-07-07 23:34:41 +01:00
require_once " Net/IDNA2.php " ;
$idn = Net_IDNA2 :: getInstance ();
2010-03-31 01:35:27 +01:00
$domain = $idn -> encode ( $domain );
} catch ( Exception $e ) {
return false ;
}
$subdomain = " (?:[a-z0-9][a-z0-9-]*) " ; // @fixme
$fqdn = " (?: $subdomain (?: \ . $subdomain )* \ .?) " ;
return preg_match ( " /^ $fqdn $ /ui " , $domain );
}
2008-06-13 15:49:13 +01:00
/* Following functions are copied from MediaWiki GlobalFunctions . php
* and written by Evan Prodromou . */
2008-12-23 19:33:23 +00:00
function common_accept_to_prefs ( $accept , $def = '*/*' )
{
2008-12-21 00:30:16 +00:00
// No arg means accept anything (per HTTP spec)
2019-06-04 18:56:20 +01:00
if ( ! $accept ) {
return [ $def => 1 ];
2008-12-21 00:30:16 +00:00
}
2008-06-13 15:49:13 +01:00
2019-06-04 18:56:20 +01:00
$prefs = [];
2008-06-13 15:49:13 +01:00
2008-12-21 00:30:16 +00:00
$parts = explode ( ',' , $accept );
2008-06-13 15:49:13 +01:00
2019-06-04 18:56:20 +01:00
foreach ( $parts as $part ) {
2009-11-09 19:01:46 +00:00
// FIXME: doesn't deal with params like 'text/html; level=1'
2009-04-10 18:40:45 +01:00
@ list ( $value , $qpart ) = explode ( ';' , trim ( $part ));
2019-06-04 18:56:20 +01:00
$match = [];
if ( ! isset ( $qpart )) {
2008-12-21 00:30:16 +00:00
$prefs [ $value ] = 1 ;
2019-06-04 18:56:20 +01:00
} elseif ( preg_match ( '/q\s*=\s*(\d*\.\d+)/' , $qpart , $match )) {
2008-12-21 00:30:16 +00:00
$prefs [ $value ] = $match [ 1 ];
}
}
2008-06-13 15:49:13 +01:00
2008-12-21 00:30:16 +00:00
return $prefs ;
2008-06-13 15:49:13 +01:00
}
2014-03-08 02:03:04 +00:00
// Match by our supported file extensions
2016-07-06 08:34:09 +01:00
function common_supported_filename_to_mime ( $filename )
2014-03-08 02:03:04 +00:00
{
// Accept a filename and take out the extension
2016-07-06 08:34:09 +01:00
if ( strpos ( $filename , '.' ) === false ) {
throw new ServerException ( sprintf ( 'No extension on filename: %1$s' , _ve ( $filename )));
2014-03-08 02:03:04 +00:00
}
2016-07-06 08:34:09 +01:00
$fileext = substr ( strrchr ( $filename , '.' ), 1 );
return common_supported_ext_to_mime ( $fileext );
}
function common_supported_ext_to_mime ( $fileext )
{
2014-03-08 02:03:04 +00:00
$supported = common_config ( 'attachments' , 'supported' );
2016-01-12 12:08:54 +00:00
if ( $supported === true ) {
2016-07-06 08:34:09 +01:00
// FIXME: Should we just accept the extension straight off when supported === true?
2016-07-06 08:14:59 +01:00
throw new UnknownExtensionMimeException ( $fileext );
2016-01-12 12:08:54 +00:00
}
2019-06-04 18:56:20 +01:00
foreach ( $supported as $type => $ext ) {
2014-03-08 02:03:04 +00:00
if ( $ext === $fileext ) {
return $type ;
}
}
2014-03-08 02:51:47 +00:00
throw new ServerException ( 'Unsupported file extension' );
}
// Match by our supported mime types
function common_supported_mime_to_ext ( $mimetype )
{
$supported = common_config ( 'attachments' , 'supported' );
2016-07-06 08:34:09 +01:00
if ( is_array ( $supported )) {
2019-06-04 18:56:20 +01:00
foreach ( $supported as $type => $ext ) {
2016-07-06 08:34:09 +01:00
if ( $mimetype === $type ) {
return $ext ;
}
2014-03-08 02:51:47 +00:00
}
}
2016-07-06 08:34:09 +01:00
throw new UnknownMimeExtensionException ( $mimetype );
2014-03-08 02:03:04 +00:00
}
// The MIME "media" is the part before the slash (video in video/webm)
function common_get_mime_media ( $type )
{
$tmp = explode ( '/' , $type );
return strtolower ( $tmp [ 0 ]);
}
2015-10-01 21:14:49 +01:00
// Get only the mimetype and not additional info (separated from bare mime with semi-colon)
2014-08-05 09:54:00 +01:00
function common_bare_mime ( $mimetype )
{
$mimetype = mb_strtolower ( $mimetype );
if ( $semicolon = mb_strpos ( $mimetype , ';' )) {
$mimetype = mb_substr ( $mimetype , 0 , $semicolon );
}
2017-08-05 08:46:14 +01:00
return trim ( $mimetype );
2014-08-05 09:54:00 +01:00
}
2008-12-23 19:33:23 +00:00
function common_mime_type_match ( $type , $avail )
{
2019-06-04 18:56:20 +01:00
if ( array_key_exists ( $type , $avail )) {
2008-12-21 00:30:16 +00:00
return $type ;
} else {
$parts = explode ( '/' , $type );
2019-06-04 18:56:20 +01:00
if ( array_key_exists ( $parts [ 0 ] . '/*' , $avail )) {
2008-12-21 00:30:16 +00:00
return $parts [ 0 ] . '/*' ;
2019-06-04 18:56:20 +01:00
} elseif ( array_key_exists ( '*/*' , $avail )) {
2008-12-21 00:30:16 +00:00
return '*/*' ;
} else {
return null ;
}
}
2008-06-13 15:49:13 +01:00
}
2008-12-23 19:33:23 +00:00
function common_negotiate_type ( $cprefs , $sprefs )
{
2019-06-04 18:56:20 +01:00
$combine = [];
2008-12-21 00:30:16 +00:00
2019-06-04 18:56:20 +01:00
foreach ( array_keys ( $sprefs ) as $type ) {
2008-12-21 00:30:16 +00:00
$parts = explode ( '/' , $type );
2019-09-01 21:33:11 +01:00
if ( isset ( $parts [ 1 ]) && $parts [ 1 ] != '*' ) {
2008-12-21 00:30:16 +00:00
$ckey = common_mime_type_match ( $type , $cprefs );
2019-06-04 18:56:20 +01:00
if ( $ckey ) {
2008-12-21 00:30:16 +00:00
$combine [ $type ] = $sprefs [ $type ] * $cprefs [ $ckey ];
}
}
}
2019-06-04 18:56:20 +01:00
foreach ( array_keys ( $cprefs ) as $type ) {
2008-12-21 00:30:16 +00:00
$parts = explode ( '/' , $type );
2019-09-01 21:33:11 +01:00
if ( isset ( $parts [ 1 ]) && $parts [ 1 ] != '*' && ! array_key_exists ( $type , $sprefs )) {
2008-12-21 00:30:16 +00:00
$skey = common_mime_type_match ( $type , $sprefs );
2019-06-04 18:56:20 +01:00
if ( $skey ) {
2008-12-21 00:30:16 +00:00
$combine [ $type ] = $sprefs [ $skey ] * $cprefs [ $type ];
}
}
}
$bestq = 0 ;
2009-02-02 21:08:33 +00:00
$besttype = 'text/html' ;
2008-12-21 00:30:16 +00:00
2019-06-04 18:56:20 +01:00
foreach ( array_keys ( $combine ) as $type ) {
if ( $combine [ $type ] > $bestq ) {
2008-12-21 00:30:16 +00:00
$besttype = $type ;
$bestq = $combine [ $type ];
}
}
2009-02-02 21:08:33 +00:00
if ( 'text/html' === $besttype ) {
2009-10-01 11:07:09 +01:00
return " text/html; charset=utf-8 " ;
2009-02-02 21:08:33 +00:00
}
2008-12-21 00:30:16 +00:00
return $besttype ;
2008-06-13 15:49:13 +01:00
}
2008-06-13 18:53:44 +01:00
2015-03-15 13:35:29 +00:00
function common_config ( $main , $sub = null )
2008-12-23 19:33:23 +00:00
{
2008-12-21 00:30:16 +00:00
global $config ;
2019-09-13 10:11:43 +01:00
if ( is_null ( $config )) {
throw new ServerException ( 'common_config was invoked before config.php was read' );
}
2015-03-15 13:35:29 +00:00
if ( is_null ( $sub )) {
// Return the config category array
2019-06-04 18:56:20 +01:00
return array_key_exists ( $main , $config ) ? $config [ $main ] : [];
2015-03-15 13:35:29 +00:00
}
// Return the config value
2009-08-21 11:33:12 +01:00
return ( array_key_exists ( $main , $config ) &&
array_key_exists ( $sub , $config [ $main ])) ? $config [ $main ][ $sub ] : false ;
2008-06-13 18:53:44 +01:00
}
2008-06-19 15:11:07 +01:00
2011-04-26 21:50:42 +01:00
function common_config_set ( $main , $sub , $value )
{
global $config ;
if ( ! array_key_exists ( $main , $config )) {
2019-06-04 18:56:20 +01:00
$config [ $main ] = [];
2011-04-26 21:50:42 +01:00
}
$config [ $main ][ $sub ] = $value ;
}
function common_config_append ( $main , $sub , $value )
{
global $config ;
if ( ! array_key_exists ( $main , $config )) {
2019-06-04 18:56:20 +01:00
$config [ $main ] = [];
2011-04-26 21:50:42 +01:00
}
if ( ! array_key_exists ( $sub , $config [ $main ])) {
2019-06-04 18:56:20 +01:00
$config [ $main ][ $sub ] = [];
2011-04-26 21:50:42 +01:00
}
if ( ! is_array ( $config [ $main ][ $sub ])) {
2019-06-04 18:56:20 +01:00
$config [ $main ][ $sub ] = [ $config [ $main ][ $sub ]];
2011-04-26 21:50:42 +01:00
}
array_push ( $config [ $main ][ $sub ], $value );
}
2010-10-06 21:00:30 +01:00
/**
* Pull arguments from a GET / POST / REQUEST array with first - level input checks :
* strips " magic quotes " slashes if necessary , and kills invalid UTF - 8 strings .
*
* @ param array $from
* @ return array
*/
2008-12-23 19:33:23 +00:00
function common_copy_args ( $from )
{
2019-06-04 18:56:20 +01:00
$to = [];
2008-12-21 00:30:16 +00:00
$strip = get_magic_quotes_gpc ();
foreach ( $from as $k => $v ) {
2019-06-04 18:56:20 +01:00
if ( is_array ( $v )) {
2010-10-06 21:00:30 +01:00
$to [ $k ] = common_copy_args ( $v );
2010-03-09 02:42:17 +00:00
} else {
2010-10-06 21:00:30 +01:00
if ( $strip ) {
$v = stripslashes ( $v );
}
$to [ $k ] = strval ( common_validate_utf8 ( $v ));
2010-03-09 02:42:17 +00:00
}
2008-12-21 00:30:16 +00:00
}
return $to ;
2008-06-20 07:54:55 +01:00
}
2008-06-20 08:17:00 +01:00
2009-12-15 23:55:18 +00:00
/**
* Neutralise the evil effects of magic_quotes_gpc in the current request .
* This is used before handing a request off to OAuthRequest :: from_request .
* @ fixme Doesn ' t consider vars other than _POST and _GET ?
* @ fixme Can ' t be undone and could corrupt data if run twice .
*/
2008-12-23 19:33:23 +00:00
function common_remove_magic_from_request ()
{
2019-06-04 18:56:20 +01:00
if ( get_magic_quotes_gpc ()) {
$_POST = array_map ( 'stripslashes' , $_POST );
$_GET = array_map ( 'stripslashes' , $_GET );
2008-12-21 00:30:16 +00:00
}
2008-09-04 07:55:04 +01:00
}
2008-12-23 19:33:23 +00:00
function common_user_uri ( & $user )
{
2019-09-11 06:15:16 +01:00
return common_local_url (
'userbyid' ,
[ 'id' => $user -> id ],
null ,
null ,
2019-10-28 15:03:28 +00:00
false ,
true
2019-09-11 06:15:16 +01:00
);
2008-06-20 08:17:00 +01:00
}
2019-06-22 18:57:43 +01:00
/**
* Generates cryptographically secure pseudo - random strings out of a allowed chars string
*
* @ param $bits int strength of the confirmation code
* @ param $codechars allowed characters to be used in the confirmation code , by default we use 36 upper case
* alphanums and remove lookalikes ( 0 , O , 1 , I ) = 32 chars = 5 bits to make it easy for the user to type in
* @ return string confirmation_code of length $bits / 5
*/
2019-09-11 06:15:16 +01:00
function common_confirmation_code ( $bits , $codechars = '23456789ABCDEFGHJKLMNPQRSTUVWXYZ' )
{
2008-12-21 00:30:16 +00:00
$chars = ceil ( $bits / 5 );
2019-06-22 18:57:43 +01:00
$codechars_length = strlen ( $codechars ) - 1 ;
2008-12-21 00:30:16 +00:00
$code = '' ;
2019-09-11 06:15:16 +01:00
for ( $i = 0 ; $i < $chars ; ++ $i ) {
2019-06-22 18:57:43 +01:00
$random_char = $codechars [ random_int ( 0 , $codechars_length )];
$code .= $random_char ;
2008-12-21 00:30:16 +00:00
}
return $code ;
}
// convert markup to HTML
2011-04-18 14:03:43 +01:00
function common_markup_to_html ( $c , $args = null )
2008-12-23 19:33:23 +00:00
{
2013-10-30 11:21:34 +00:00
if ( $c === null ) {
return '' ;
}
2011-04-18 14:47:08 +01:00
if ( is_null ( $args )) {
2019-06-04 18:56:20 +01:00
$args = [];
2011-04-18 14:47:08 +01:00
}
2011-04-18 14:51:26 +01:00
// XXX: not very efficient
foreach ( $args as $name => $value ) {
$c = preg_replace ( '/%%arg.' . $name . '%%/' , $value , $c );
}
2019-06-04 18:56:20 +01:00
$c = preg_replace_callback ( '/%%user.(\w+)%%/' , function ( $m ) {
return common_user_property ( $m [ 1 ]);
}, $c );
$c = preg_replace_callback ( '/%%action.(\w+)%%/' , function ( $m ) {
return common_local_url ( $m [ 1 ]);
}, $c );
$c = preg_replace_callback ( '/%%doc.(\w+)%%/' , function ( $m ) {
return common_local_url ( 'doc' , [ 'title' => $m [ 1 ]]);
}, $c );
$c = preg_replace_callback ( '/%%(\w+).(\w+)%%/' , function ( $m ) {
return common_config ( $m [ 1 ], $m [ 2 ]);
}, $c );
2014-03-18 09:46:24 +00:00
return \Michelf\Markdown :: defaultTransform ( $c );
2008-06-30 18:03:42 +01:00
}
2008-07-14 04:44:43 +01:00
2011-04-18 11:17:28 +01:00
function common_user_property ( $property )
{
$profile = Profile :: current ();
if ( empty ( $profile )) {
return null ;
}
switch ( $property ) {
case 'profileurl' :
case 'nickname' :
case 'fullname' :
case 'location' :
case 'bio' :
return $profile -> $property ;
break ;
case 'avatar' :
2013-10-01 10:37:59 +01:00
try {
return $profile -> getAvatar ( AVATAR_STREAM_SIZE );
} catch ( Exception $e ) {
return null ;
}
2011-04-18 11:17:28 +01:00
break ;
case 'bestname' :
return $profile -> getBestName ();
break ;
default :
return null ;
}
}
2008-12-23 19:33:23 +00:00
function common_profile_uri ( $profile )
{
2011-07-15 20:13:57 +01:00
$uri = null ;
2008-12-21 00:30:16 +00:00
2011-07-15 20:13:57 +01:00
if ( ! empty ( $profile )) {
2019-06-04 18:56:20 +01:00
if ( Event :: handle ( 'StartCommonProfileURI' , [ $profile , & $uri ])) {
2013-10-29 10:27:26 +00:00
$user = User :: getKV ( 'id' , $profile -> id );
if ( $user instanceof User ) {
2014-04-28 13:08:42 +01:00
$uri = $user -> getUri ();
2019-12-10 22:27:32 +00:00
} // FIXME: might be a remote profile, by this function name, I would guess it would be fine to call this
2020-01-07 16:48:13 +00:00
// On the other hand, there's Profile->getUri
2019-06-04 18:56:20 +01:00
Event :: handle ( 'EndCommonProfileURI' , [ $profile , & $uri ]);
2011-07-15 20:13:57 +01:00
}
2008-12-21 00:30:16 +00:00
}
2011-07-15 20:13:57 +01:00
2008-12-21 00:30:16 +00:00
// XXX: this is a very bad profile!
2011-07-15 20:13:57 +01:00
return $uri ;
2008-07-20 20:30:05 +01:00
}
2008-12-23 19:33:23 +00:00
function common_canonical_sms ( $sms )
{
2008-12-21 00:30:16 +00:00
// strip non-digits
preg_replace ( '/\D/' , '' , $sms );
return $sms ;
2008-07-29 09:06:41 +01:00
}
2008-08-29 18:40:12 +01:00
2008-12-23 19:33:23 +00:00
function common_error_handler ( $errno , $errstr , $errfile , $errline , $errcontext )
{
2008-08-29 18:40:12 +01:00
switch ( $errno ) {
2009-06-29 00:24:14 +01:00
case E_ERROR :
case E_COMPILE_ERROR :
case E_CORE_ERROR :
2008-08-29 18:40:12 +01:00
case E_USER_ERROR :
2009-06-29 00:24:14 +01:00
case E_PARSE :
case E_RECOVERABLE_ERROR :
common_log ( LOG_ERR , " [ $errno ] $errstr ( $errfile : $errline ) [ABORT] " );
die ();
2008-12-21 00:30:16 +00:00
break ;
2008-08-29 18:40:12 +01:00
2009-06-29 00:24:14 +01:00
case E_WARNING :
case E_COMPILE_WARNING :
case E_CORE_WARNING :
2008-12-21 00:30:16 +00:00
case E_USER_WARNING :
common_log ( LOG_WARNING , " [ $errno ] $errstr ( $errfile : $errline ) " );
break ;
2008-08-29 18:40:12 +01:00
2009-06-29 00:24:14 +01:00
case E_NOTICE :
2008-08-29 18:40:12 +01:00
case E_USER_NOTICE :
2008-12-21 00:30:16 +00:00
common_log ( LOG_NOTICE , " [ $errno ] $errstr ( $errfile : $errline ) " );
break ;
2009-06-29 00:24:14 +01:00
case E_STRICT :
case E_DEPRECATED :
case E_USER_DEPRECATED :
// XXX: config variable to log this stuff, too
break ;
default :
common_log ( LOG_ERR , " [ $errno ] $errstr ( $errfile : $errline ) [UNKNOWN LEVEL, die()'ing] " );
die ();
break ;
2008-08-29 18:40:12 +01:00
}
2008-12-21 00:30:16 +00:00
// FIXME: show error page if we're on the Web
2009-11-09 19:01:46 +00:00
/* Don't execute PHP internal error handler */
2008-08-29 18:40:12 +01:00
return true ;
}
2008-12-23 19:33:23 +00:00
function common_session_token ()
{
2008-12-21 00:30:16 +00:00
common_ensure_session ();
if ( ! array_key_exists ( 'token' , $_SESSION )) {
2013-10-21 12:20:30 +01:00
$_SESSION [ 'token' ] = common_random_hexstr ( 64 );
2008-12-21 00:30:16 +00:00
}
return $_SESSION [ 'token' ];
2008-08-29 18:40:12 +01:00
}
2008-09-15 07:56:16 +01:00
2009-04-16 15:57:35 +01:00
function common_license_terms ( $uri )
{
2019-06-04 18:56:20 +01:00
if ( preg_match ( '/creativecommons.org\/licenses\/([^\/]+)/' , $uri , $matches )) {
return explode ( '-' , $matches [ 1 ]);
2009-04-16 15:57:35 +01:00
}
2019-06-04 18:56:20 +01:00
return [ $uri ];
2009-04-16 15:57:35 +01:00
}
2008-12-23 19:33:23 +00:00
function common_compatible_license ( $from , $to )
{
2009-04-16 15:57:35 +01:00
$from_terms = common_license_terms ( $from );
// public domain and cc-by are compatible with everything
2019-06-04 18:56:20 +01:00
if ( count ( $from_terms ) == 1 && ( $from_terms [ 0 ] == 'publicdomain' || $from_terms [ 0 ] == 'by' )) {
2009-04-16 15:57:35 +01:00
return true ;
}
$to_terms = common_license_terms ( $to );
// sa is compatible across versions. IANAL
2019-06-04 18:56:20 +01:00
if ( in_array ( 'sa' , $from_terms ) || in_array ( 'sa' , $to_terms )) {
2009-04-16 15:57:35 +01:00
return count ( array_diff ( $from_terms , $to_terms )) == 0 ;
}
2008-12-21 00:30:16 +00:00
// XXX: better compatibility check needed here!
2009-04-16 15:57:35 +01:00
// Should at least normalise URIs
2008-12-21 00:30:16 +00:00
return ( $from == $to );
2008-12-04 18:02:33 +00:00
}
2009-03-16 21:36:12 +00:00
/**
2019-09-11 06:15:16 +01:00
* returns a quoted table name
2009-03-16 21:36:12 +00:00
*/
function common_database_tablename ( $tablename )
{
2019-09-11 06:15:16 +01:00
$schema = Schema :: get ();
// table prefixes could be added here later
return $schema -> quoteIdentifier ( $tablename );
2009-04-10 18:40:45 +01:00
}
2009-06-23 15:29:43 +01:00
2009-12-15 23:55:18 +00:00
/**
* Shorten a URL with the current user ' s configured shortening service ,
* or ur1 . ca if configured , or not at all if no shortening is set up .
*
2010-04-26 07:40:36 +01:00
* @ param string $long_url original URL
2010-12-02 18:56:44 +00:00
* @ param User $user to specify a particular user ' s options
2010-04-26 07:40:36 +01:00
* @ param boolean $force Force shortening ( used when notice is too long )
2009-12-15 23:55:18 +00:00
* @ return string may return the original URL if shortening failed
*
* @ fixme provide a way to specify a particular shortener
*/
2010-12-07 18:50:05 +00:00
function common_shorten_url ( $long_url , User $user = null , $force = false )
2009-06-23 15:29:43 +01:00
{
2010-02-25 18:30:37 +00:00
$long_url = trim ( $long_url );
2010-04-26 07:40:36 +01:00
2009-06-23 15:29:43 +01:00
$user = common_current_user ();
2010-04-26 07:40:36 +01:00
$maxUrlLength = User_urlshortener_prefs :: maxUrlLength ( $user );
// $force forces shortening even if it's not strictly needed
2011-01-23 21:49:12 +00:00
// I doubt URL shortening is ever 'strictly' needed. - ESP
2010-04-26 07:40:36 +01:00
2013-10-06 21:35:26 +01:00
if (( $maxUrlLength == - 1 || mb_strlen ( $long_url ) < $maxUrlLength ) && ! $force ) {
2010-04-26 07:40:36 +01:00
return $long_url ;
2009-06-23 15:29:43 +01:00
}
2010-04-26 07:40:36 +01:00
$shortenerName = User_urlshortener_prefs :: urlShorteningService ( $user );
2019-06-04 18:56:20 +01:00
if ( Event :: handle (
'StartShortenUrl' ,
[ $long_url , $shortenerName , & $shortenedUrl ]
)) {
2011-01-23 21:49:12 +00:00
if ( $shortenerName == 'internal' ) {
2014-06-02 01:08:48 +01:00
try {
$f = File :: processNew ( $long_url );
2019-06-04 18:56:20 +01:00
$shortenedUrl = common_local_url ( 'redirecturl' , [ 'id' => $f -> id ]);
2011-09-26 22:05:35 +01:00
if (( mb_strlen ( $shortenedUrl ) < mb_strlen ( $long_url )) || $force ) {
return $shortenedUrl ;
} else {
return $long_url ;
}
2014-06-02 01:08:48 +01:00
} catch ( ServerException $e ) {
return $long_url ;
2011-01-23 21:49:12 +00:00
}
} else {
return $long_url ;
}
2010-04-26 07:40:36 +01:00
} else {
2009-11-11 19:02:57 +00:00
//URL was shortened, so return the result
2010-02-25 18:30:37 +00:00
return trim ( $shortenedUrl );
2009-11-11 19:02:57 +00:00
}
2009-06-27 15:37:58 +01:00
}
2009-12-15 23:55:18 +00:00
/**
* @ return mixed array ( $proxy , $ip ) for web requests ; proxy may be null
* null if not a web request
*
* @ fixme X - Forwarded - For can be chained by multiple proxies ;
we should parse the list and provide a cleaner array
* @ fixme X - Forwarded - For can be forged by clients ; only use them if trusted
* @ fixme X_Forwarded_For headers will override X - Forwarded - For read through $_SERVER ;
* use function to get exact request headers from Apache if possible .
*/
2009-06-27 15:37:58 +01:00
function common_client_ip ()
{
if ( ! isset ( $_SERVER ) || ! array_key_exists ( 'REQUEST_METHOD' , $_SERVER )) {
return null ;
}
2009-08-02 13:10:31 +01:00
if ( array_key_exists ( 'HTTP_X_FORWARDED_FOR' , $_SERVER )) {
if ( array_key_exists ( 'HTTP_CLIENT_IP' , $_SERVER )) {
2009-06-27 15:37:58 +01:00
$proxy = $_SERVER [ 'HTTP_CLIENT_IP' ];
} else {
$proxy = $_SERVER [ 'REMOTE_ADDR' ];
}
$ip = $_SERVER [ 'HTTP_X_FORWARDED_FOR' ];
} else {
2009-08-02 13:10:31 +01:00
$proxy = null ;
if ( array_key_exists ( 'HTTP_CLIENT_IP' , $_SERVER )) {
2009-06-27 15:37:58 +01:00
$ip = $_SERVER [ 'HTTP_CLIENT_IP' ];
} else {
$ip = $_SERVER [ 'REMOTE_ADDR' ];
}
}
2019-06-04 18:56:20 +01:00
return [ $proxy , $ip ];
2009-06-27 15:37:58 +01:00
}
2010-02-16 16:06:10 +00:00
function common_url_to_nickname ( $url )
{
2019-06-04 18:56:20 +01:00
static $bad = [ 'query' , 'user' , 'password' , 'port' , 'fragment' ];
2010-02-16 16:06:10 +00:00
$parts = parse_url ( $url );
2011-03-22 15:54:23 +00:00
// If any of these parts exist, this won't work
2010-02-16 16:06:10 +00:00
foreach ( $bad as $badpart ) {
if ( array_key_exists ( $badpart , $parts )) {
return null ;
}
}
2011-03-22 15:54:23 +00:00
// We just have host and/or path
2010-02-16 16:06:10 +00:00
2011-03-22 15:54:23 +00:00
// If it's just a host...
2010-02-16 16:06:10 +00:00
if ( array_key_exists ( 'host' , $parts ) &&
2019-06-04 18:56:20 +01:00
( ! array_key_exists ( 'path' , $parts ) || strcmp ( $parts [ 'path' ], '/' ) == 0 )) {
2010-02-16 16:06:10 +00:00
$hostparts = explode ( '.' , $parts [ 'host' ]);
2011-03-22 15:54:23 +00:00
// Try to catch common idiom of nickname.service.tld
2010-02-16 16:06:10 +00:00
if (( count ( $hostparts ) > 2 ) &&
( strlen ( $hostparts [ count ( $hostparts ) - 2 ]) > 3 ) && # try to skip .co.uk, .com.au
2019-06-04 18:56:20 +01:00
( strcmp ( $hostparts [ 0 ], 'www' ) != 0 )) {
2010-02-16 16:06:10 +00:00
return common_nicknamize ( $hostparts [ 0 ]);
} else {
2011-03-22 15:54:23 +00:00
// Do the whole hostname
2010-02-16 16:06:10 +00:00
return common_nicknamize ( $parts [ 'host' ]);
}
} else {
if ( array_key_exists ( 'path' , $parts )) {
2011-03-22 15:54:23 +00:00
// Strip starting, ending slashes
2010-02-16 16:06:10 +00:00
$path = preg_replace ( '@/$@' , '' , $parts [ 'path' ]);
$path = preg_replace ( '@^/@' , '' , $path );
2010-02-25 23:52:34 +00:00
$path = basename ( $path );
2010-05-20 00:19:06 +01:00
// Hack for MediaWiki user pages, in the form:
// http://example.com/wiki/User:Myname
// ('User' may be localized.)
if ( strpos ( $path , ':' )) {
$parts = array_filter ( explode ( ':' , $path ));
$path = $parts [ count ( $parts ) - 1 ];
}
2010-02-25 23:52:34 +00:00
if ( $path ) {
2010-02-16 16:06:10 +00:00
return common_nicknamize ( $path );
}
}
}
return null ;
}
function common_nicknamize ( $str )
{
2013-10-16 13:58:22 +01:00
try {
return Nickname :: normalize ( $str );
} catch ( NicknameException $e ) {
return null ;
}
2010-02-16 16:06:10 +00:00
}
2011-01-31 21:12:56 +00:00
function common_perf_counter ( $key , $val = null )
{
global $_perfCounters ;
if ( isset ( $_perfCounters )) {
if ( common_config ( 'site' , 'logperf' )) {
if ( array_key_exists ( $key , $_perfCounters )) {
$_perfCounters [ $key ][] = $val ;
} else {
2019-06-04 18:56:20 +01:00
$_perfCounters [ $key ] = [ $val ];
2011-01-31 21:12:56 +00:00
}
if ( common_config ( 'site' , 'logperf_detail' )) {
common_log ( LOG_DEBUG , " PERF COUNTER HIT: $key $val " );
}
}
}
}
function common_log_perf_counters ()
{
if ( common_config ( 'site' , 'logperf' )) {
2020-01-07 16:48:13 +00:00
global $_startCpuTime , $_perfCounters ;
2011-01-31 21:12:56 +00:00
2020-01-07 16:48:13 +00:00
if ( isset ( $_startCpuTime )) {
$end_cpu_time = hrtime ( true );
$diff = round (( $end_cpu_time - $_startCpuTime ) / 1000000 );
2011-01-31 21:12:56 +00:00
common_log ( LOG_DEBUG , " PERF runtime: ${ diff } ms " );
}
$counters = $_perfCounters ;
ksort ( $counters );
foreach ( $counters as $key => $values ) {
$count = count ( $values );
$unique = count ( array_unique ( $values ));
common_log ( LOG_DEBUG , " PERF COUNTER: $key $count ( $unique unique) " );
}
}
}
2011-05-02 23:17:08 +01:00
function common_is_email ( $str )
{
return ( strpos ( $str , '@' ) !== false );
}
2011-09-14 17:19:29 +01:00
function common_init_stats ()
{
global $_mem , $_ts ;
$_mem = memory_get_usage ( true );
$_ts = microtime ( true );
}
function common_log_delta ( $comment = null )
{
global $_mem , $_ts ;
$mold = $_mem ;
$told = $_ts ;
$_mem = memory_get_usage ( true );
$_ts = microtime ( true );
$mtotal = $_mem - $mold ;
$ttotal = $_ts - $told ;
if ( empty ( $comment )) {
$comment = 'Delta' ;
}
common_debug ( sprintf ( " %s: %d %d " , $comment , $mtotal , round ( $ttotal * 1000000 )));
}
2014-07-14 12:52:23 +01:00
function common_strip_html ( $html , $trim = true , $save_whitespace = false )
{
2017-07-11 20:58:24 +01:00
// first replace <br /> with \n
2019-06-04 18:56:20 +01:00
$html = preg_replace ( '/\<(\s*)?br(\s*)?\/?(\s*)?\>/i' , " \n " , $html );
2017-07-11 20:58:24 +01:00
// then, unless explicitly avoided, remove excessive whitespace
2014-07-14 12:52:23 +01:00
if ( ! $save_whitespace ) {
$html = preg_replace ( '/\s+/' , ' ' , $html );
}
$text = html_entity_decode ( strip_tags ( $html ), ENT_QUOTES , 'UTF-8' );
return $trim ? trim ( $text ) : $text ;
}
2015-09-06 00:53:11 +01:00
2019-06-15 15:21:05 +01:00
/**
* An internal helper function that converts a $size from php . ini for
* file size limit from the 'human-readable' shorthand into a int . If
* $size is empty ( the value is not set in php . ini ), returns a default
* value ( 5000000 )
*
* @ param string | bool $size
* @ return int the php . ini upload limit in machine - readable format
*/
2019-08-12 04:45:25 +01:00
function _common_size_str_to_int ( $size ) : int
2019-06-15 15:21:05 +01:00
{
2019-06-18 20:57:30 +01:00
// `memory_limit` can be -1 and `post_max_size` can be 0
// for unlimited. Consistency.
if ( empty ( $size ) || $size === '-1' || $size === '0' ) {
2019-06-15 15:21:05 +01:00
return 5000000 ;
}
$suffix = substr ( $size , - 1 );
$size = substr ( $size , 0 , - 1 );
switch ( strtoupper ( $suffix )) {
case 'P' :
$size *= 1024 ;
// no break
case 'T' :
$size *= 1024 ;
// no break
case 'G' :
$size *= 1024 ;
// no break
case 'M' :
$size *= 1024 ;
// no break
case 'K' :
$size *= 1024 ;
break ;
}
return $size ;
}
/**
* Uses `_common_size_str_to_int()` to find the smallest value for uploads in php . ini
*
2019-06-18 20:57:30 +01:00
* @ return int
2019-06-15 15:21:05 +01:00
*/
2019-09-11 06:15:16 +01:00
function common_get_preferred_php_upload_limit () : int
{
return min (
_common_size_str_to_int ( ini_get ( 'post_max_size' )),
_common_size_str_to_int ( ini_get ( 'upload_max_filesize' )),
_common_size_str_to_int ( ini_get ( 'memory_limit' ))
);
2019-06-15 15:21:05 +01:00
}
2020-06-27 23:59:08 +01:00
/**
2020-07-22 16:07:25 +01:00
* Send a file to the client .
2020-06-27 23:59:08 +01:00
*
2020-07-22 16:07:25 +01:00
* @ param string $filepath
* @ param string $mimetype
* @ param string $filename
* @ param string $disposition
* @ param int $expires header browser cache expires in milliseconds ( defaults to 30 days )
2020-06-27 23:59:08 +01:00
* @ throws ServerException
*/
2020-07-22 16:07:25 +01:00
function common_send_file ( string $filepath , string $mimetype , string $filename , string $disposition = 'inline' , int $expires = 30 * 24 * 3600 ) : void
2020-06-27 23:59:08 +01:00
{
2020-07-22 16:07:25 +01:00
header ( " Content-Type: { $mimetype } " );
header ( " Content-Disposition: { $disposition } ; filename= \" { $filename } \" " );
header ( 'Expires: ' . gmdate ( 'D, d M Y H:i:s' , time () + $expires ) . ' GMT' );
2020-06-27 23:59:08 +01:00
if ( is_string ( common_config ( 'site' , 'x-static-delivery' ))) {
$tmp = explode ( INSTALLDIR , $filepath );
$relative_path = end ( $tmp );
common_debug ( " Using Static Delivery with header: ' " .
common_config ( 'site' , 'x-static-delivery' ) . " : { $relative_path } ' " );
header ( common_config ( 'site' , 'x-static-delivery' ) . " : { $relative_path } " );
} else {
header ( " Content-Description: File Transfer " );
header ( 'Content-Transfer-Encoding: binary' );
$filesize = filesize ( $filepath );
if ( file_exists ( $filepath )) {
http_response_code ( 200 );
header ( " Content-Length: { $filesize } " );
// header('Cache-Control: private, no-transform, no-store, must-revalidate');
$ret = @ readfile ( $filepath );
2020-07-22 16:07:25 +01:00
if ( $ret === false ) {
http_response_code ( 404 );
common_log ( LOG_ERR , " Couldn't read file at { $filepath } . " );
} elseif ( $ret !== $filesize ) {
http_response_code ( 500 );
common_log ( LOG_ERR , " The lengths of the file as recorded on the DB (or on disk) for the file " .
" { $filepath } differ from what was sent to the user ( { $filesize } vs { $ret } ). " );
}
} else {
2020-06-27 23:59:08 +01:00
http_response_code ( 404 );
2020-07-22 16:07:25 +01:00
common_log ( LOG_ERR , " File doesn't exist at { $filepath } . " );
2020-06-27 23:59:08 +01:00
}
}
}
2015-09-06 00:53:11 +01:00
function html_sprintf ()
{
$args = func_get_args ();
for ( $i = 1 ; $i < count ( $args ); $i ++ ) {
$args [ $i ] = htmlspecialchars ( $args [ $i ]);
}
return call_user_func_array ( 'sprintf' , $args );
2016-01-07 17:13:10 +00:00
}
2016-01-11 18:52:54 +00:00
function _ve ( $var )
{
return var_export ( $var , true );
2016-01-12 12:08:54 +00:00
}