2008-05-20 14:05:35 +01:00
|
|
|
<?php
|
2008-05-20 20:14:12 +01:00
|
|
|
/*
|
2009-08-25 23:14:12 +01:00
|
|
|
* StatusNet - the distributed open-source microblogging tool
|
2009-08-25 23:12:20 +01:00
|
|
|
* Copyright (C) 2008, 2009, StatusNet, Inc.
|
2008-05-20 20:14:12 +01:00
|
|
|
*
|
2008-05-20 14:05:35 +01:00
|
|
|
* This program 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.
|
2008-05-20 20:14:12 +01:00
|
|
|
*
|
2008-05-20 14:05:35 +01:00
|
|
|
* This program 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.
|
2008-05-20 20:14:12 +01:00
|
|
|
*
|
2008-05-20 14:05:35 +01:00
|
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
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
|
|
|
|
2008-12-21 00:30:16 +00:00
|
|
|
// Show a server error
|
2008-05-20 14:05:35 +01:00
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2008-12-21 00:30:16 +00: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
|
|
|
}
|
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_init_locale($language=null)
|
|
|
|
{
|
2008-12-04 20:34:33 +00:00
|
|
|
if(!$language) {
|
|
|
|
$language = common_language();
|
|
|
|
}
|
|
|
|
putenv('LANGUAGE='.$language);
|
|
|
|
putenv('LANG='.$language);
|
|
|
|
return setlocale(LC_ALL, $language . ".utf8",
|
2008-12-21 00:30:16 +00:00
|
|
|
$language . ".UTF8",
|
|
|
|
$language . ".utf-8",
|
|
|
|
$language . ".UTF-8",
|
|
|
|
$language);
|
2008-12-04 20:34:33 +00:00
|
|
|
}
|
|
|
|
|
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
|
|
|
|
|
|
|
// 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.
|
|
|
|
common_init_locale("en_US");
|
2009-11-10 19:06:30 +00: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
|
|
|
|
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
|
2009-10-16 18:42:27 +01:00
|
|
|
$path = common_config('site','locale_path');
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_language()
|
|
|
|
{
|
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();
|
|
|
|
$user_language = $user->language;
|
2009-12-19 19:03:31 +00:00
|
|
|
|
|
|
|
if ($user->language) {
|
|
|
|
// 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'] == $user_language) {
|
|
|
|
return $user_language;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
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...
|
|
|
|
$httplang = isset($_SERVER['HTTP_ACCEPT_LANGUAGE']) ? $_SERVER['HTTP_ACCEPT_LANGUAGE'] : null;
|
|
|
|
if (!empty($httplang)) {
|
|
|
|
$language = client_prefered_language($httplang);
|
|
|
|
if ($language)
|
|
|
|
return $language;
|
|
|
|
}
|
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-12-21 00:30:16 +00:00
|
|
|
// salted, hashed passwords are stored in the DB
|
2008-05-20 14:05:35 +01:00
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_munge_password($password, $id)
|
|
|
|
{
|
2010-01-10 20:07:49 +00:00
|
|
|
if (is_object($id) || is_object($password)) {
|
|
|
|
$e = new Exception();
|
|
|
|
common_log(LOG_ERR, __METHOD__ . ' object in param to common_munge_password ' .
|
|
|
|
str_replace("\n", " ", $e->getTraceAsString()));
|
|
|
|
}
|
2008-12-21 00:30:16 +00:00
|
|
|
return md5($password . $id);
|
2008-05-20 14:05:35 +01:00
|
|
|
}
|
|
|
|
|
2008-12-21 00:30:16 +00:00
|
|
|
// check if a username exists and has matching password
|
2009-11-10 19:45:19 +00:00
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_check_user($nickname, $password)
|
|
|
|
{
|
2009-11-10 19:45:19 +00:00
|
|
|
$authenticatedUser = false;
|
|
|
|
|
|
|
|
if (Event::handle('StartCheckPassword', array($nickname, $password, &$authenticatedUser))) {
|
2010-02-25 19:53:39 +00:00
|
|
|
$user = User::staticGet('nickname', common_canonical_nickname($nickname));
|
2009-11-10 19:45:19 +00:00
|
|
|
if (!empty($user)) {
|
|
|
|
if (!empty($password)) { // never allow login with blank password
|
2009-11-05 21:39:57 +00:00
|
|
|
if (0 == strcmp(common_munge_password($password, $user->id),
|
|
|
|
$user->password)) {
|
|
|
|
//internal checking passed
|
2009-12-02 17:47:02 +00:00
|
|
|
$authenticatedUser = $user;
|
2009-11-05 21:39:57 +00:00
|
|
|
}
|
2009-11-04 18:06:55 +00:00
|
|
|
}
|
|
|
|
}
|
2009-11-10 19:45:19 +00:00
|
|
|
Event::handle('EndCheckPassword', array($nickname, $password, $authenticatedUser));
|
2008-12-21 00:30:16 +00:00
|
|
|
}
|
2009-11-10 19:45:19 +00:00
|
|
|
|
|
|
|
return $authenticatedUser;
|
2008-12-21 00:30:16 +00: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
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_ensure_session()
|
|
|
|
{
|
2009-06-27 13:07:14 +01:00
|
|
|
$c = null;
|
2009-08-02 12:36:09 +01:00
|
|
|
if (array_key_exists(session_name(), $_COOKIE)) {
|
2009-06-27 13:07:14 +01:00
|
|
|
$c = $_COOKIE[session_name()];
|
|
|
|
}
|
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')) {
|
|
|
|
Session::setSaveHandler();
|
|
|
|
}
|
2010-01-11 08:39:02 +00:00
|
|
|
if (array_key_exists(session_name(), $_GET)) {
|
|
|
|
$id = $_GET[session_name()];
|
|
|
|
} else if (array_key_exists(session_name(), $_COOKIE)) {
|
|
|
|
$id = $_COOKIE[session_name()];
|
|
|
|
}
|
|
|
|
if (isset($id)) {
|
|
|
|
session_id($id);
|
|
|
|
}
|
2008-12-21 00:30:16 +00:00
|
|
|
@session_start();
|
2009-06-27 13:07:14 +01:00
|
|
|
if (!isset($_SESSION['started'])) {
|
|
|
|
$_SESSION['started'] = time();
|
2010-01-11 08:39:02 +00:00
|
|
|
if (!empty($id)) {
|
2009-06-27 13:07:14 +01:00
|
|
|
common_log(LOG_WARNING, 'Session cookie "' . $_COOKIE[session_name()] . '" ' .
|
|
|
|
' is set but started value is null');
|
|
|
|
}
|
|
|
|
}
|
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;
|
|
|
|
} else if (is_string($user)) {
|
|
|
|
$nickname = $user;
|
|
|
|
$user = User::staticGet('nickname', $nickname);
|
|
|
|
} else if (!($user instanceof User)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ($user) {
|
2009-11-18 19:19:43 +00:00
|
|
|
if (Event::handle('StartSetUser', array(&$user))) {
|
|
|
|
if($user){
|
|
|
|
common_ensure_session();
|
|
|
|
$_SESSION['userid'] = $user->id;
|
|
|
|
$_cur = $user;
|
|
|
|
Event::handle('EndSetUser', array($user));
|
|
|
|
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 = '/';
|
|
|
|
}
|
|
|
|
return setcookie($key,
|
|
|
|
$value,
|
|
|
|
$expiration,
|
|
|
|
$cookiepath,
|
|
|
|
$server);
|
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
|
|
|
|
2008-12-21 00:30:16 +00:00
|
|
|
$rm->code = common_good_rand(16);
|
|
|
|
$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
|
|
|
|
|
|
|
$rm->query('BEGIN');
|
|
|
|
|
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__);
|
|
|
|
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-09 17:04:13 +00:00
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
$rm = Remember_me::staticGet($code);
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
$user = User::staticGet($rm->user_id);
|
|
|
|
|
|
|
|
if (!$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
|
|
|
}
|
|
|
|
|
2008-12-21 00:30:16 +00:00
|
|
|
// must be called with a valid user!
|
2008-06-24 03:52:34 +01:00
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2008-12-21 00:30:16 +00: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) {
|
2009-11-11 18:38:11 +00:00
|
|
|
$user = User::staticGet($id);
|
|
|
|
if ($user) {
|
|
|
|
$_cur = $user;
|
|
|
|
return $_cur;
|
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
2008-12-21 00:30:16 +00:00
|
|
|
// Logins that are 'remembered' aren't 'real' -- they're subject to
|
2009-11-09 19:01:46 +00:00
|
|
|
// cookie-stealing. So, we don't let them do certain things. New reg,
|
2008-12-21 00:30:16 +00:00
|
|
|
// OpenID, and password logins _are_ real.
|
2008-06-24 03:52:34 +01:00
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2008-12-21 00:30:16 +00:00
|
|
|
// get canonical version of nickname for comparison
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_canonical_nickname($nickname)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
// XXX: UTF-8 canonicalization (like combining chars)
|
|
|
|
return strtolower($nickname);
|
2008-05-20 14:05:35 +01:00
|
|
|
}
|
|
|
|
|
2008-12-21 00:30:16 +00:00
|
|
|
// get canonical version of email for comparison
|
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
|
|
|
}
|
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_render_content($text, $notice)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
$r = common_render_text($text);
|
|
|
|
$id = $notice->profile_id;
|
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
|
|
|
$r = common_linkify_mentions($r, $notice);
|
2009-09-23 00:34:10 +01:00
|
|
|
$r = preg_replace('/(^|[\s\.\,\:\;]+)!([A-Za-z0-9]{1,64})/e', "'\\1!'.common_group_link($id, '\\2')", $r);
|
2008-12-21 00:30:16 +00:00
|
|
|
return $r;
|
2008-09-17 12:27:30 +01:00
|
|
|
}
|
|
|
|
|
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
|
|
|
function common_linkify_mentions($text, $notice)
|
2010-02-21 21:20:30 +00:00
|
|
|
{
|
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
|
|
|
$mentions = common_find_mentions($text, $notice);
|
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!
|
|
|
|
|
|
|
|
$points = array();
|
|
|
|
|
|
|
|
foreach ($mentions as $mention)
|
|
|
|
{
|
|
|
|
$points[$mention['position']] = $mention;
|
|
|
|
}
|
|
|
|
|
|
|
|
krsort($points);
|
|
|
|
|
|
|
|
foreach ($points as $position => $mention) {
|
|
|
|
|
|
|
|
$linkText = common_linkify_mention($mention);
|
|
|
|
|
|
|
|
$text = substr_replace($text, $linkText, $position, mb_strlen($mention['text']));
|
|
|
|
}
|
|
|
|
|
|
|
|
return $text;
|
|
|
|
}
|
|
|
|
|
|
|
|
function common_linkify_mention($mention)
|
|
|
|
{
|
|
|
|
$output = null;
|
|
|
|
|
|
|
|
if (Event::handle('StartLinkifyMention', array($mention, &$output))) {
|
|
|
|
|
|
|
|
$xs = new XMLStringer(false);
|
|
|
|
|
|
|
|
$attrs = array('href' => $mention['url'],
|
|
|
|
'class' => 'url');
|
|
|
|
|
|
|
|
if (!empty($mention['title'])) {
|
|
|
|
$attrs['title'] = $mention['title'];
|
|
|
|
}
|
|
|
|
|
|
|
|
$xs->elementStart('span', 'vcard');
|
|
|
|
$xs->elementStart('a', $attrs);
|
|
|
|
$xs->element('span', 'fn nickname', $mention['text']);
|
|
|
|
$xs->elementEnd('a');
|
|
|
|
$xs->elementEnd('span');
|
|
|
|
|
|
|
|
$output = $xs->getString();
|
|
|
|
|
|
|
|
Event::handle('EndLinkifyMention', array($mention, &$output));
|
|
|
|
}
|
|
|
|
|
|
|
|
return $output;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
function common_find_mentions($text, $notice)
|
2010-02-21 21:20:30 +00:00
|
|
|
{
|
|
|
|
$mentions = array();
|
|
|
|
|
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
|
|
|
$sender = Profile::staticGet('id', $notice->profile_id);
|
2010-02-21 21:20:30 +00:00
|
|
|
|
|
|
|
if (empty($sender)) {
|
|
|
|
return $mentions;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Event::handle('StartFindMentions', array($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
|
|
|
|
|
|
|
|
$originalAuthor = null;
|
|
|
|
$originalNotice = null;
|
|
|
|
$originalMentions = array();
|
|
|
|
|
|
|
|
// Is it a reply?
|
|
|
|
|
|
|
|
if (!empty($notice) && !empty($notice->reply_to)) {
|
|
|
|
$originalNotice = Notice::staticGet('id', $notice->reply_to);
|
|
|
|
if (!empty($originalNotice)) {
|
|
|
|
$originalAuthor = Profile::staticGet('id', $originalNotice->profile_id);
|
|
|
|
|
|
|
|
$ids = $originalNotice->getReplies();
|
|
|
|
|
|
|
|
foreach ($ids as $id) {
|
|
|
|
$repliedTo = Profile::staticGet('id', $id);
|
|
|
|
if (!empty($repliedTo)) {
|
|
|
|
$originalMentions[$repliedTo->nickname] = $repliedTo;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-21 21:20:30 +00:00
|
|
|
preg_match_all('/^T ([A-Z0-9]{1,64}) /',
|
|
|
|
$text,
|
|
|
|
$tmatches,
|
|
|
|
PREG_OFFSET_CAPTURE);
|
|
|
|
|
|
|
|
preg_match_all('/(?:^|\s+)@(['.NICKNAME_FMT.']{1,64})/',
|
|
|
|
$text,
|
|
|
|
$atmatches,
|
|
|
|
PREG_OFFSET_CAPTURE);
|
|
|
|
|
|
|
|
$matches = array_merge($tmatches[1], $atmatches[1]);
|
|
|
|
|
|
|
|
foreach ($matches as $match) {
|
|
|
|
|
|
|
|
$nickname = common_canonical_nickname($match[0]);
|
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
|
|
|
|
|
|
|
// Try to get a profile for this nickname.
|
|
|
|
// Start with conversation context, then go to
|
|
|
|
// sender context.
|
|
|
|
|
|
|
|
if (!empty($originalAuthor) && $originalAuthor->nickname == $nickname) {
|
|
|
|
|
|
|
|
$mentioned = $originalAuthor;
|
|
|
|
|
|
|
|
} else if (!empty($originalMentions) &&
|
|
|
|
array_key_exists($nickname, $originalMentions)) {
|
|
|
|
|
|
|
|
$mention = $originalMentions[$nickname];
|
|
|
|
} else {
|
|
|
|
$mentioned = common_relative_profile($sender, $nickname);
|
|
|
|
}
|
2010-02-21 21:20:30 +00:00
|
|
|
|
|
|
|
if (!empty($mentioned)) {
|
|
|
|
|
|
|
|
$user = User::staticGet('id', $mentioned->id);
|
|
|
|
|
|
|
|
if ($user) {
|
|
|
|
$url = common_local_url('userbyid', array('id' => $user->id));
|
|
|
|
} else {
|
|
|
|
$url = $mentioned->profileurl;
|
|
|
|
}
|
|
|
|
|
|
|
|
$mention = array('mentioned' => array($mentioned),
|
|
|
|
'text' => $match[0],
|
|
|
|
'position' => $match[1],
|
|
|
|
'url' => $url);
|
|
|
|
|
|
|
|
if (!empty($mentioned->fullname)) {
|
|
|
|
$mention['title'] = $mentioned->fullname;
|
|
|
|
}
|
|
|
|
|
|
|
|
$mentions[] = $mention;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// @#tag => mention of all subscriptions tagged 'tag'
|
|
|
|
|
|
|
|
preg_match_all('/(?:^|[\s\.\,\:\;]+)@#([\pL\pN_\-\.]{1,64})/',
|
|
|
|
$text,
|
|
|
|
$hmatches,
|
|
|
|
PREG_OFFSET_CAPTURE);
|
|
|
|
|
|
|
|
foreach ($hmatches[1] as $hmatch) {
|
|
|
|
|
|
|
|
$tag = common_canonical_tag($hmatch[0]);
|
|
|
|
|
|
|
|
$tagged = Profile_tag::getTagged($sender->id, $tag);
|
|
|
|
|
|
|
|
$url = common_local_url('subscriptions',
|
|
|
|
array('nickname' => $sender->nickname,
|
|
|
|
'tag' => $tag));
|
|
|
|
|
|
|
|
$mentions[] = array('mentioned' => $tagged,
|
|
|
|
'text' => $hmatch[0],
|
|
|
|
'position' => $hmatch[1],
|
|
|
|
'url' => $url);
|
|
|
|
}
|
|
|
|
|
|
|
|
Event::handle('EndFindMentions', array($sender, $text, &$mentions));
|
|
|
|
}
|
|
|
|
|
|
|
|
return $mentions;
|
|
|
|
}
|
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_render_text($text)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
$r = htmlspecialchars($text);
|
2008-07-20 13:28:32 +01:00
|
|
|
|
2008-12-21 00:30:16 +00:00
|
|
|
$r = preg_replace('/[\x{0}-\x{8}\x{b}-\x{c}\x{e}-\x{19}]/', '', $r);
|
2009-02-05 04:11:40 +00:00
|
|
|
$r = common_replace_urls_callback($r, 'common_linkify');
|
2009-08-25 22:52:16 +01:00
|
|
|
$r = preg_replace('/(^|\"\;|\'|\(|\[|\{|\s+)#([\pL\pN_\-\.]{1,64})/e', "'\\1#'.common_tag_link('\\2')", $r);
|
2008-12-21 00:30:16 +00:00
|
|
|
// XXX: machine tags
|
|
|
|
return $r;
|
2008-05-29 18:08:01 +01:00
|
|
|
}
|
|
|
|
|
2009-05-11 18:45:00 +01:00
|
|
|
function common_replace_urls_callback($text, $callback, $notice_id = null) {
|
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
|
|
|
|
'(?:'.
|
2009-08-25 19:12:31 +01:00
|
|
|
'(?:(?:https?|ftps?|mms|rtsp|gopher|news|nntp|telnet|wais|file|prospero|webcal|irc)://)'.
|
2009-08-22 02:11:23 +01:00
|
|
|
'|'.
|
2009-08-25 19:12:31 +01:00
|
|
|
'(?:(?:mailto|aim|tel|xmpp):)'.
|
|
|
|
')'.
|
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
|
|
|
')'.
|
|
|
|
'|(?:(?: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]?)'. //IPv4
|
2009-08-22 03:58:43 +01:00
|
|
|
'|(?:'. //IPv6
|
2009-09-09 21:57:11 +01:00
|
|
|
'\[?(?:(?:(?:[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})))\]?(?<!:)'.
|
2009-08-22 02:11:23 +01:00
|
|
|
')|(?:'. //DNS
|
2009-08-28 21:18:05 +01:00
|
|
|
'(?:[\pN\pL\-\_\+\%\~]+(?:\:[\pN\pL\-\_\+\%\~]+)?\@)?'. //user:pass@
|
2009-08-25 19:12:31 +01:00
|
|
|
'[\pN\pL\-\_]+(?:\.[\pN\pL\-\_]+)*\.'.
|
|
|
|
//tld list from http://data.iana.org/TLD/tlds-alpha-by-domain.txt, also added local, loc, and onion
|
2009-08-25 19:19:05 +01:00
|
|
|
'(?: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|ZW|local|loc|onion)'.
|
2009-08-25 16:21:45 +01:00
|
|
|
')(?![\pN\pL\-\_])'.
|
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
|
2009-11-02 15:38:58 +00:00
|
|
|
'(?:/[\pN\pL$\,\!\(\)\.\:\-\_\+\/\=\&\;\%\~\*\$\+\'@]*)?'. // /path
|
|
|
|
'(?:\?[\pN\pL\$\,\!\(\)\.\:\-\_\+\/\=\&\;\%\~\*\$\+\'@\/]*)?'. // ?query string
|
|
|
|
'(?:\#[\pN\pL$\,\!\(\)\.\:\-\_\+\/\=\&\;\%\~\*\$\+\'\@/\?\#]*)?'. // #fragment
|
2009-08-25 21:41:44 +01:00
|
|
|
')(?<![\?\.\,\#\,])'.
|
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);
|
2009-08-28 16:43:28 +01:00
|
|
|
return preg_replace_callback($regex, curry('callback_helper',$callback,$notice_id) ,$text);
|
2009-08-21 17:47:01 +01:00
|
|
|
}
|
2009-02-06 08:13:08 +00:00
|
|
|
|
2009-08-21 20:56:15 +01:00
|
|
|
function callback_helper($matches, $callback, $notice_id) {
|
2009-08-27 17:06:45 +01:00
|
|
|
$url=$matches[1];
|
2009-08-25 21:41:44 +01:00
|
|
|
$left = strpos($matches[0],$url);
|
|
|
|
$right = $left+strlen($url);
|
2009-08-28 04:06:03 +01:00
|
|
|
|
2009-08-25 21:41:44 +01:00
|
|
|
$groupSymbolSets=array(
|
|
|
|
array(
|
|
|
|
'left'=>'(',
|
|
|
|
'right'=>')'
|
|
|
|
),
|
|
|
|
array(
|
|
|
|
'left'=>'[',
|
|
|
|
'right'=>']'
|
|
|
|
),
|
|
|
|
array(
|
|
|
|
'left'=>'{',
|
|
|
|
'right'=>'}'
|
2009-11-02 17:57:51 +00:00
|
|
|
),
|
|
|
|
array(
|
|
|
|
'left'=>'<',
|
|
|
|
'right'=>'>'
|
2009-08-25 21:41:44 +01:00
|
|
|
)
|
|
|
|
);
|
|
|
|
$cannotEndWith=array('.','?',',','#');
|
|
|
|
$original_url=$url;
|
|
|
|
do{
|
|
|
|
$original_url=$url;
|
|
|
|
foreach($groupSymbolSets as $groupSymbolSet){
|
|
|
|
if(substr($url,-1)==$groupSymbolSet['right']){
|
|
|
|
$group_left_count = substr_count($url,$groupSymbolSet['left']);
|
|
|
|
$group_right_count = substr_count($url,$groupSymbolSet['right']);
|
|
|
|
if($group_left_count<$group_right_count){
|
|
|
|
$right-=1;
|
|
|
|
$url=substr($url,0,-1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(in_array(substr($url,-1),$cannotEndWith)){
|
|
|
|
$right-=1;
|
|
|
|
$url=substr($url,0,-1);
|
|
|
|
}
|
|
|
|
}while($original_url!=$url);
|
2009-08-28 04:06:03 +01:00
|
|
|
|
2009-08-21 17:47:01 +01:00
|
|
|
if(empty($notice_id)){
|
2009-09-21 06:30:10 +01:00
|
|
|
$result = call_user_func_array($callback, array($url));
|
2009-08-21 17:47:01 +01:00
|
|
|
}else{
|
2009-08-31 20:33:23 +01:00
|
|
|
$result = call_user_func_array($callback, array(array($url,$notice_id)) );
|
2008-12-21 00:30:16 +00:00
|
|
|
}
|
2009-08-25 21:41:44 +01:00
|
|
|
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
|
|
|
|
2009-12-15 21:53:19 +00:00
|
|
|
if (version_compare(PHP_VERSION, '5.3.0', 'ge')) {
|
|
|
|
// lambda implementation in a separate file; PHP 5.2 won't parse it.
|
|
|
|
require_once INSTALLDIR . "/lib/curry.php";
|
|
|
|
} else {
|
|
|
|
function curry($fn) {
|
|
|
|
$args = func_get_args();
|
|
|
|
array_shift($args);
|
|
|
|
$id = uniqid('_partial');
|
|
|
|
$GLOBALS[$id] = array($fn, $args);
|
|
|
|
return create_function('',
|
|
|
|
'$args = func_get_args(); '.
|
|
|
|
'return call_user_func_array('.
|
|
|
|
'$GLOBALS["'.$id.'"][0],'.
|
|
|
|
'array_merge('.
|
|
|
|
'$args,'.
|
|
|
|
'$GLOBALS["'.$id.'"][1]));');
|
|
|
|
}
|
2009-02-05 04:11:40 +00: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
|
|
|
|
2009-08-28 04:23:31 +01:00
|
|
|
if(strpos($url, '@') !== false && strpos($url, ':') === false) {
|
2009-08-21 20:56:15 +01:00
|
|
|
//url is an email address without the mailto: protocol
|
2009-09-27 21:52:15 +01:00
|
|
|
$canon = "mailto:$url";
|
|
|
|
$longurl = "mailto:$url";
|
|
|
|
}else{
|
2009-08-21 20:56:15 +01:00
|
|
|
|
2009-09-27 21:52:15 +01:00
|
|
|
$canon = File_redirection::_canonUrl($url);
|
2009-06-28 20:21:15 +01:00
|
|
|
|
2009-09-27 21:52:15 +01:00
|
|
|
$longurl_data = File_redirection::where($canon);
|
|
|
|
if (is_array($longurl_data)) {
|
|
|
|
$longurl = $longurl_data['url'];
|
|
|
|
} elseif (is_string($longurl_data)) {
|
|
|
|
$longurl = $longurl_data;
|
|
|
|
} else {
|
2009-11-08 22:28:51 +00:00
|
|
|
throw new ServerException("Can't linkify url '$url'");
|
2009-09-27 21:52:15 +01:00
|
|
|
}
|
2009-05-13 19:27:32 +01:00
|
|
|
}
|
2009-09-22 16:12:55 +01:00
|
|
|
$attrs = array('href' => $canon, 'title' => $longurl, 'rel' => 'external');
|
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
|
|
|
|
2009-08-28 04:23:31 +01:00
|
|
|
$f = File::staticGet('url', $longurl);
|
2009-06-25 20:52:10 +01:00
|
|
|
|
2009-08-28 04:23:31 +01:00
|
|
|
if (empty($f)) {
|
|
|
|
// XXX: this writes to the database. :<
|
|
|
|
$f = File::processNew($longurl);
|
2009-06-25 20:52:10 +01:00
|
|
|
}
|
|
|
|
|
2009-08-28 04:23:31 +01:00
|
|
|
if (!empty($f)) {
|
2009-09-11 02:13:30 +01:00
|
|
|
if ($f->isEnclosure()) {
|
2009-06-25 20:52:10 +01:00
|
|
|
$is_attachment = true;
|
2009-08-28 04:23:31 +01:00
|
|
|
$attachment_id = $f->id;
|
2009-09-11 02:13:30 +01:00
|
|
|
} else {
|
2009-08-28 04:23:31 +01:00
|
|
|
$foe = File_oembed::staticGet('file_id', $f->id);
|
2009-08-28 04:09:07 +01:00
|
|
|
if (!empty($foe)) {
|
2009-09-11 02:13:30 +01:00
|
|
|
// if it has OEmbed info, it's an attachment, too
|
2009-08-28 04:09:07 +01:00
|
|
|
$is_attachment = true;
|
2009-08-28 04:23:31 +01:00
|
|
|
$attachment_id = $f->id;
|
2009-08-28 04:09:07 +01:00
|
|
|
|
2009-08-28 04:23:31 +01:00
|
|
|
$thumb = File_thumbnail::staticGet('file_id', $f->id);
|
2009-08-28 04:09:07 +01:00
|
|
|
if (!empty($thumb)) {
|
|
|
|
$has_thumb = true;
|
|
|
|
}
|
|
|
|
}
|
2009-06-25 20:52:10 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add clippy
|
|
|
|
if ($is_attachment) {
|
|
|
|
$attrs['class'] = 'attachment';
|
|
|
|
if ($has_thumb) {
|
2009-05-25 16:13:13 +01:00
|
|
|
$attrs['class'] = 'attachment thumbnail';
|
|
|
|
}
|
2009-06-25 20:52:10 +01:00
|
|
|
$attrs['id'] = "attachment-{$attachment_id}";
|
2009-05-25 02:13:42 +01:00
|
|
|
}
|
2009-06-25 20:52:10 +01:00
|
|
|
|
2009-06-28 20:21:15 +01:00
|
|
|
return XMLStringer::estring('a', $attrs, $url);
|
2008-11-02 09:02:41 +00:00
|
|
|
}
|
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_shorten_links($text)
|
|
|
|
{
|
2009-08-21 13:16:08 +01:00
|
|
|
$maxLength = Notice::maxContent();
|
|
|
|
if ($maxLength == 0 || mb_strlen($text) <= $maxLength) return $text;
|
2009-05-13 19:27:32 +01:00
|
|
|
return common_replace_urls_callback($text, array('File_redirection', 'makeShort'));
|
2008-11-06 20:59:26 +00:00
|
|
|
}
|
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_xml_safe_str($str)
|
|
|
|
{
|
2009-04-03 21:19:33 +01:00
|
|
|
// Neutralize control codes and surrogates
|
|
|
|
return preg_replace('/[\p{Cc}\p{Cs}]/u', '*', $str);
|
2008-11-04 08:40:27 +00:00
|
|
|
}
|
|
|
|
|
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);
|
|
|
|
$url = common_local_url('tag', array('tag' => $canonical));
|
2009-02-12 13:38:43 +00:00
|
|
|
$xs = new XMLStringer();
|
|
|
|
$xs->elementStart('span', 'tag');
|
|
|
|
$xs->element('a', array('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)
|
|
|
|
{
|
2009-07-26 05:34:27 +01:00
|
|
|
$tag = mb_convert_case($tag, MB_CASE_LOWER, "UTF-8");
|
|
|
|
return str_replace(array('-', '_', '.'), '', $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
|
|
|
}
|
|
|
|
|
2009-01-22 02:53:02 +00:00
|
|
|
function common_group_link($sender_id, $nickname)
|
|
|
|
{
|
|
|
|
$sender = Profile::staticGet($sender_id);
|
2009-06-15 07:43:47 +01:00
|
|
|
$group = User_group::getForNickname($nickname);
|
2010-02-10 02:32:52 +00:00
|
|
|
if ($sender && $group && $sender->isMember($group)) {
|
2009-03-30 15:26:36 +01:00
|
|
|
$attrs = array('href' => $group->permalink(),
|
|
|
|
'class' => 'url');
|
|
|
|
if (!empty($group->fullname)) {
|
|
|
|
$attrs['title'] = $group->fullname . ' (' . $group->nickname . ')';
|
|
|
|
}
|
2009-02-12 13:38:43 +00:00
|
|
|
$xs = new XMLStringer();
|
|
|
|
$xs->elementStart('span', 'vcard');
|
2009-03-30 15:26:36 +01:00
|
|
|
$xs->elementStart('a', $attrs);
|
2009-02-12 13:38:43 +00:00
|
|
|
$xs->element('span', 'fn nickname', $nickname);
|
|
|
|
$xs->elementEnd('a');
|
|
|
|
$xs->elementEnd('span');
|
|
|
|
return $xs->getString();
|
2009-01-22 02:53:02 +00:00
|
|
|
} else {
|
|
|
|
return $nickname;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_relative_profile($sender, $nickname, $dt=null)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
// Try to find profiles this profile is subscribed to that have this nickname
|
|
|
|
$recipient = new Profile();
|
|
|
|
// XXX: use a join instead of a subquery
|
|
|
|
$recipient->whereAdd('EXISTS (SELECT subscribed from subscription where subscriber = '.$sender->id.' and subscribed = id)', 'AND');
|
2009-03-08 16:16:10 +00:00
|
|
|
$recipient->whereAdd("nickname = '" . trim($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();
|
|
|
|
// XXX: use a join instead of a subquery
|
|
|
|
$recipient->whereAdd('EXISTS (SELECT subscriber from subscription where subscribed = '.$sender->id.' and subscriber = id)', 'AND');
|
2009-03-08 16:16:10 +00:00
|
|
|
$recipient->whereAdd("nickname = '" . trim($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.
|
|
|
|
$sender = User::staticGet($sender->id);
|
|
|
|
if ($sender) {
|
|
|
|
$recipient_user = User::staticGet('nickname', $nickname);
|
|
|
|
if ($recipient_user) {
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2010-02-26 22:28:44 +00:00
|
|
|
function common_local_url($action, $args=null, $params=null, $fragment=null, $addSession=true)
|
2008-12-23 19:33:23 +00:00
|
|
|
{
|
2009-02-11 05:45:11 +00:00
|
|
|
$r = Router::get();
|
2009-02-20 22:30:09 +00:00
|
|
|
$path = $r->build($action, $args, $params, $fragment);
|
2009-03-07 01:18:21 +00:00
|
|
|
|
2009-08-04 13:58:24 +01:00
|
|
|
$ssl = common_is_sensitive($action);
|
2009-03-26 19:03:59 +00:00
|
|
|
|
2008-12-21 00:30:16 +00:00
|
|
|
if (common_config('site','fancy')) {
|
2010-02-26 22:28:44 +00:00
|
|
|
$url = common_path(mb_substr($path, 1), $ssl, $addSession);
|
2008-12-21 00:30:16 +00:00
|
|
|
} else {
|
2009-03-07 01:18:21 +00:00
|
|
|
if (mb_strpos($path, '/index.php') === 0) {
|
2010-02-26 22:28:44 +00:00
|
|
|
$url = common_path(mb_substr($path, 1), $ssl, $addSession);
|
2009-03-07 01:18:21 +00:00
|
|
|
} else {
|
2010-02-26 22:28:44 +00:00
|
|
|
$url = common_path('index.php'.$path, $ssl, $addSession);
|
2009-03-07 01:18:21 +00:00
|
|
|
}
|
2008-12-21 00:30:16 +00:00
|
|
|
}
|
|
|
|
return $url;
|
|
|
|
}
|
|
|
|
|
2009-08-04 13:58:24 +01:00
|
|
|
function common_is_sensitive($action)
|
|
|
|
{
|
|
|
|
static $sensitive = array('login', 'register', 'passwordsettings',
|
2009-08-04 14:00:58 +01:00
|
|
|
'twittersettings', 'api');
|
2009-08-04 13:58:24 +01:00
|
|
|
$ssl = null;
|
|
|
|
|
|
|
|
if (Event::handle('SensitiveAction', array($action, &$ssl))) {
|
|
|
|
$ssl = in_array($action, $sensitive);
|
|
|
|
}
|
|
|
|
|
|
|
|
return $ssl;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
|
|
|
if (($ssl && (common_config('site', 'ssl') === 'sometimes'))
|
|
|
|
|| common_config('site', 'ssl') === 'always') {
|
|
|
|
$proto = 'https';
|
|
|
|
if (is_string(common_config('site', 'sslserver')) &&
|
|
|
|
mb_strlen(common_config('site', 'sslserver')) > 0) {
|
|
|
|
$serverpart = common_config('site', 'sslserver');
|
2009-10-20 01:08:20 +01:00
|
|
|
} else if (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 {
|
2010-01-11 06:59:32 +00:00
|
|
|
common_log(LOG_ERR, '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 {
|
2010-01-11 06:59:32 +00:00
|
|
|
common_log(LOG_ERR, '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
|
|
|
}
|
|
|
|
|
2010-01-11 08:39:02 +00:00
|
|
|
function common_inject_session($url, $serverpart = null)
|
|
|
|
{
|
2010-01-11 07:51:57 +00:00
|
|
|
if (common_have_session()) {
|
|
|
|
|
2010-01-11 08:39:02 +00:00
|
|
|
if (empty($serverpart)) {
|
|
|
|
$serverpart = parse_url($url, PHP_URL_HOST);
|
|
|
|
}
|
2010-01-11 23:09:46 +00:00
|
|
|
|
2010-01-11 07:51:57 +00:00
|
|
|
$currentServer = $_SERVER['HTTP_HOST'];
|
|
|
|
|
|
|
|
// Are we pointing to another server (like an SSL server?)
|
|
|
|
|
|
|
|
if (!empty($currentServer) &&
|
|
|
|
0 != strcasecmp($currentServer, $serverpart)) {
|
|
|
|
// Pass the session ID as a GET parameter
|
|
|
|
$sesspart = session_name() . '=' . session_id();
|
2010-01-11 08:39:02 +00:00
|
|
|
$i = strpos($url, '?');
|
2010-01-11 07:51:57 +00:00
|
|
|
if ($i === false) { // no GET params, just append
|
2010-01-11 08:39:02 +00:00
|
|
|
$url .= '?' . $sesspart;
|
2010-01-11 07:51:57 +00:00
|
|
|
} else {
|
2010-01-11 08:39:02 +00:00
|
|
|
$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);
|
|
|
|
} else if ($diff < 60) {
|
|
|
|
return _('a few seconds ago');
|
|
|
|
} else if ($diff < 92) {
|
|
|
|
return _('about a minute ago');
|
|
|
|
} else if ($diff < 3300) {
|
|
|
|
return sprintf(_('about %d minutes ago'), round($diff/60));
|
|
|
|
} else if ($diff < 5400) {
|
|
|
|
return _('about an hour ago');
|
|
|
|
} else if ($diff < 22 * 3600) {
|
|
|
|
return sprintf(_('about %d hours ago'), round($diff/3600));
|
|
|
|
} else if ($diff < 37 * 3600) {
|
|
|
|
return _('about a day ago');
|
|
|
|
} else if ($diff < 24 * 24 * 3600) {
|
|
|
|
return sprintf(_('about %d days ago'), round($diff/(24*3600)));
|
|
|
|
} else if ($diff < 46 * 24 * 3600) {
|
|
|
|
return _('about a month ago');
|
|
|
|
} else if ($diff < 330 * 24 * 3600) {
|
|
|
|
return sprintf(_('about %d months ago'), round($diff/(30*24*3600)));
|
|
|
|
} else if ($diff < 480 * 24 * 3600) {
|
|
|
|
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);
|
|
|
|
return $d->format(DATE_RFC850);
|
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)
|
|
|
|
{
|
|
|
|
if (common_config('db', 'type') == 'pgsql') {
|
|
|
|
// PostgreSQL doesn't support timestampdiff function.
|
|
|
|
// @fixme will this use the right time zone?
|
|
|
|
// @fixme does this handle cross-year subtraction correctly?
|
|
|
|
return "sum(exp(-extract(epoch from (now() - $column)) / $dropoff))";
|
|
|
|
} else {
|
|
|
|
return "sum(exp(timestampdiff(second, utc_timestamp(), $column) / $dropoff))";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_redirect($url, $code=307)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
static $status = array(301 => "Moved Permanently",
|
|
|
|
302 => "Found",
|
|
|
|
303 => "See Other",
|
|
|
|
307 => "Temporary Redirect");
|
2009-01-21 07:45:08 +00:00
|
|
|
|
2009-04-01 18:11:02 +01:00
|
|
|
header('HTTP/1.1 '.$code.' '.$status[$code]);
|
2008-12-21 00:30:16 +00:00
|
|
|
header("Location: $url");
|
|
|
|
|
2009-01-21 07:45:08 +00:00
|
|
|
$xo = new XMLOutputter();
|
|
|
|
$xo->startXML('a',
|
|
|
|
'-//W3C//DTD XHTML 1.0 Strict//EN',
|
|
|
|
'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd');
|
2009-01-22 02:53:02 +00:00
|
|
|
$xo->element('a', array('href' => $url), $url);
|
2009-01-21 07:45:08 +00:00
|
|
|
$xo->endXML();
|
2008-07-10 06:57:26 +01:00
|
|
|
exit;
|
2008-05-20 14:05:35 +01:00
|
|
|
}
|
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_broadcast_notice($notice, $remote=false)
|
|
|
|
{
|
2010-01-25 23:08:21 +00:00
|
|
|
// DO NOTHING!
|
2008-07-04 06:04:25 +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)
|
|
|
|
{
|
2009-07-01 16:34:12 +01:00
|
|
|
static $localTransports = array('omb',
|
|
|
|
'ping');
|
2009-09-21 19:39:22 +01:00
|
|
|
|
2010-02-01 18:16:19 +00:00
|
|
|
$transports = array();
|
|
|
|
if (common_config('sms', 'enabled')) {
|
|
|
|
$transports[] = 'sms';
|
|
|
|
}
|
|
|
|
if (Event::hasHandler('HandleQueuedNotice')) {
|
|
|
|
$transports[] = 'plugin';
|
|
|
|
}
|
2009-06-25 03:17:41 +01:00
|
|
|
|
2009-07-01 17:09:41 +01:00
|
|
|
$xmpp = common_config('xmpp', 'enabled');
|
|
|
|
|
|
|
|
if ($xmpp) {
|
|
|
|
$transports[] = 'jabber';
|
|
|
|
}
|
|
|
|
|
2010-02-01 18:16:19 +00:00
|
|
|
// @fixme move these checks into QueueManager and/or individual handlers
|
2009-08-19 07:34:17 +01:00
|
|
|
if ($notice->is_local == Notice::LOCAL_PUBLIC ||
|
|
|
|
$notice->is_local == Notice::LOCAL_NONPUBLIC) {
|
2009-07-01 16:34:12 +01:00
|
|
|
$transports = array_merge($transports, $localTransports);
|
2009-07-01 17:09:41 +01:00
|
|
|
if ($xmpp) {
|
|
|
|
$transports[] = 'public';
|
|
|
|
}
|
2009-02-20 18:57:20 +00:00
|
|
|
}
|
2008-07-08 10:45:31 +01:00
|
|
|
|
2009-09-21 19:14:55 +01:00
|
|
|
if (Event::handle('StartEnqueueNotice', array($notice, &$transports))) {
|
2008-07-08 10:45:31 +01:00
|
|
|
|
2009-09-21 19:14:55 +01:00
|
|
|
$qm = QueueManager::get();
|
|
|
|
|
|
|
|
foreach ($transports as $transport)
|
|
|
|
{
|
|
|
|
$qm->enqueue($notice, $transport);
|
|
|
|
}
|
|
|
|
|
|
|
|
Event::handle('EndEnqueueNotice', array($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
|
|
|
}
|
|
|
|
|
2010-02-24 20:36:36 +00:00
|
|
|
/**
|
|
|
|
* Broadcast profile updates to OMB and other remote subscribers.
|
|
|
|
*
|
|
|
|
* Since this may be slow with a lot of subscribers or bad remote sites,
|
|
|
|
* this is run through the background queues if possible.
|
|
|
|
*/
|
|
|
|
function common_broadcast_profile(Profile $profile)
|
2008-12-23 19:33:23 +00:00
|
|
|
{
|
2010-02-24 20:36:36 +00:00
|
|
|
$qm = QueueManager::get();
|
|
|
|
$qm->enqueue($profile, "profile");
|
2008-12-21 00:30:16 +00:00
|
|
|
return true;
|
2008-06-12 19:40:28 +01:00
|
|
|
}
|
2008-06-06 17:04:37 +01:00
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_profile_url($nickname)
|
|
|
|
{
|
2010-02-26 22:28:44 +00:00
|
|
|
return common_local_url('showstream', array('nickname' => $nickname),
|
|
|
|
null, null, false);
|
2008-05-20 14:05:35 +01:00
|
|
|
}
|
|
|
|
|
2008-12-21 00:30:16 +00:00
|
|
|
// Should make up a reasonable root URL
|
2008-05-27 12:42:19 +01:00
|
|
|
|
2009-03-31 15:09:11 +01:00
|
|
|
function common_root_url($ssl=false)
|
2008-12-23 19:33:23 +00:00
|
|
|
{
|
2010-02-26 22:28:44 +00:00
|
|
|
$url = common_path('', $ssl, 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
|
|
|
}
|
|
|
|
|
2008-12-21 00:30:16 +00:00
|
|
|
// returns $bytes bytes of random data as a hexadecimal string
|
|
|
|
// "good" here is a goal and not a guarantee
|
2008-05-27 21:07:21 +01:00
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_good_rand($bytes)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
// XXX: use random.org...?
|
2009-04-21 23:36:15 +01:00
|
|
|
if (@file_exists('/dev/urandom')) {
|
2008-12-21 00:30:16 +00:00
|
|
|
return common_urandom($bytes);
|
|
|
|
} else { // FIXME: this is probably not good enough
|
|
|
|
return common_mtrand($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);
|
|
|
|
$enc = '';
|
|
|
|
for ($i = 0; $i < $bytes; $i++) {
|
|
|
|
$enc .= sprintf("%02x", (ord($src[$i])));
|
|
|
|
}
|
|
|
|
return $enc;
|
2008-05-27 21:07:21 +01:00
|
|
|
}
|
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_mtrand($bytes)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
$enc = '';
|
|
|
|
for ($i = 0; $i < $bytes; $i++) {
|
|
|
|
$enc .= sprintf("%02x", mt_rand(0, 255));
|
|
|
|
}
|
|
|
|
return $enc;
|
2008-05-27 21:07:21 +01:00
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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) {
|
2009-07-03 00:06:13 +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)
|
|
|
|
{
|
|
|
|
static $syslog_priorities = array('LOG_EMERG', 'LOG_ALERT', 'LOG_CRIT', 'LOG_ERR',
|
|
|
|
'LOG_WARNING', 'LOG_NOTICE', 'LOG_INFO', 'LOG_DEBUG');
|
|
|
|
return date('Y-m-d H:i:s') . ' ' . $syslog_priorities[$priority] . ': ' . $msg . "\n";
|
|
|
|
}
|
|
|
|
|
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 20:52:36 +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)
|
|
|
|
{
|
2009-12-05 07:11:27 +00:00
|
|
|
if(Event::handle('StartLog', array(&$priority, &$msg, &$filename))){
|
|
|
|
$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
|
|
|
}
|
2009-12-05 07:11:27 +00:00
|
|
|
Event::handle('EndLog', array($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)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
$objstr = common_log_objstring($object);
|
|
|
|
$last_error = &PEAR::getStaticProperty('DB_DataObject','lastError');
|
|
|
|
common_log(LOG_ERR, $last_error->message . '(' . $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();
|
|
|
|
$fields = array();
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_valid_http_url($url)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
return Validate::uri($url, array('allowed_schemes' => array('http', 'https')));
|
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
|
|
|
|
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)
|
|
|
|
if(!$accept) {
|
|
|
|
return array($def => 1);
|
|
|
|
}
|
2008-06-13 15:49:13 +01:00
|
|
|
|
2008-12-21 00:30:16 +00:00
|
|
|
$prefs = array();
|
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
|
|
|
|
2008-12-21 00:30:16 +00: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));
|
2008-12-21 00:30:16 +00:00
|
|
|
$match = array();
|
|
|
|
if(!isset($qpart)) {
|
|
|
|
$prefs[$value] = 1;
|
|
|
|
} elseif(preg_match('/q\s*=\s*(\d*\.\d+)/', $qpart, $match)) {
|
|
|
|
$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
|
|
|
}
|
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_mime_type_match($type, $avail)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
if(array_key_exists($type, $avail)) {
|
|
|
|
return $type;
|
|
|
|
} else {
|
|
|
|
$parts = explode('/', $type);
|
|
|
|
if(array_key_exists($parts[0] . '/*', $avail)) {
|
|
|
|
return $parts[0] . '/*';
|
|
|
|
} elseif(array_key_exists('*/*', $avail)) {
|
|
|
|
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)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
$combine = array();
|
|
|
|
|
|
|
|
foreach(array_keys($sprefs) as $type) {
|
|
|
|
$parts = explode('/', $type);
|
|
|
|
if($parts[1] != '*') {
|
|
|
|
$ckey = common_mime_type_match($type, $cprefs);
|
|
|
|
if($ckey) {
|
|
|
|
$combine[$type] = $sprefs[$type] * $cprefs[$ckey];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
foreach(array_keys($cprefs) as $type) {
|
|
|
|
$parts = explode('/', $type);
|
|
|
|
if($parts[1] != '*' && !array_key_exists($type, $sprefs)) {
|
|
|
|
$skey = common_mime_type_match($type, $sprefs);
|
|
|
|
if($skey) {
|
|
|
|
$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
|
|
|
|
|
|
|
foreach(array_keys($combine) as $type) {
|
|
|
|
if($combine[$type] > $bestq) {
|
|
|
|
$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
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_config($main, $sub)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
global $config;
|
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
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_copy_args($from)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
$to = array();
|
|
|
|
$strip = get_magic_quotes_gpc();
|
|
|
|
foreach ($from as $k => $v) {
|
|
|
|
$to[$k] = ($strip) ? stripslashes($v) : $v;
|
|
|
|
}
|
|
|
|
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()
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
if(get_magic_quotes_gpc()) {
|
|
|
|
$_POST=array_map('stripslashes',$_POST);
|
|
|
|
$_GET=array_map('stripslashes',$_GET);
|
|
|
|
}
|
2008-09-04 07:55:04 +01:00
|
|
|
}
|
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_user_uri(&$user)
|
|
|
|
{
|
2010-02-26 22:28:44 +00:00
|
|
|
return common_local_url('userbyid', array('id' => $user->id),
|
|
|
|
null, null, false);
|
2008-06-20 08:17:00 +01:00
|
|
|
}
|
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_notice_uri(&$notice)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
return common_local_url('shownotice',
|
|
|
|
array('notice' => $notice->id));
|
2008-06-20 08:17:00 +01:00
|
|
|
}
|
2008-06-22 17:32:41 +01:00
|
|
|
|
2008-12-21 00:30:16 +00:00
|
|
|
// 36 alphanums - lookalikes (0, O, 1, I) = 32 chars = 5 bits
|
2008-06-22 17:32:41 +01:00
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_confirmation_code($bits)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
// 36 alphanums - lookalikes (0, O, 1, I) = 32 chars = 5 bits
|
|
|
|
static $codechars = '23456789ABCDEFGHJKLMNPQRSTUVWXYZ';
|
|
|
|
$chars = ceil($bits/5);
|
|
|
|
$code = '';
|
|
|
|
for ($i = 0; $i < $chars; $i++) {
|
|
|
|
// XXX: convert to string and back
|
|
|
|
$num = hexdec(common_good_rand(1));
|
|
|
|
// XXX: randomness is too precious to throw away almost
|
|
|
|
// 40% of the bits we get!
|
|
|
|
$code .= $codechars[$num%32];
|
|
|
|
}
|
|
|
|
return $code;
|
|
|
|
}
|
|
|
|
|
|
|
|
// convert markup to HTML
|
2008-06-30 18:03:42 +01:00
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_markup_to_html($c)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
$c = preg_replace('/%%action.(\w+)%%/e', "common_local_url('\\1')", $c);
|
|
|
|
$c = preg_replace('/%%doc.(\w+)%%/e', "common_local_url('doc', array('title'=>'\\1'))", $c);
|
|
|
|
$c = preg_replace('/%%(\w+).(\w+)%%/e', 'common_config(\'\\1\', \'\\2\')', $c);
|
|
|
|
return Markdown($c);
|
2008-06-30 18:03:42 +01:00
|
|
|
}
|
2008-07-14 04:44:43 +01:00
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_profile_uri($profile)
|
|
|
|
{
|
2008-12-21 00:30:16 +00:00
|
|
|
if (!$profile) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
$user = User::staticGet($profile->id);
|
|
|
|
if ($user) {
|
|
|
|
return $user->uri;
|
|
|
|
}
|
|
|
|
|
|
|
|
$remote = Remote_profile::staticGet($profile->id);
|
|
|
|
if ($remote) {
|
|
|
|
return $remote->uri;
|
|
|
|
}
|
|
|
|
// XXX: this is a very bad profile!
|
|
|
|
return null;
|
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)) {
|
|
|
|
$_SESSION['token'] = common_good_rand(64);
|
|
|
|
}
|
|
|
|
return $_SESSION['token'];
|
2008-08-29 18:40:12 +01:00
|
|
|
}
|
2008-09-15 07:56:16 +01:00
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_cache_key($extra)
|
|
|
|
{
|
2010-01-03 06:26:33 +00:00
|
|
|
return Cache::key($extra);
|
2008-09-15 07:56:16 +01:00
|
|
|
}
|
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_keyize($str)
|
|
|
|
{
|
2010-01-03 06:26:33 +00:00
|
|
|
return Cache::keyize($str);
|
2008-09-15 07:56:16 +01:00
|
|
|
}
|
2008-09-24 21:41:31 +01:00
|
|
|
|
2008-12-23 19:33:23 +00:00
|
|
|
function common_memcache()
|
|
|
|
{
|
2010-01-03 06:26:33 +00:00
|
|
|
return Cache::instance();
|
2008-09-26 21:01:02 +01:00
|
|
|
}
|
2008-12-03 03:27:05 +00:00
|
|
|
|
2009-04-16 15:57:35 +01:00
|
|
|
function common_license_terms($uri)
|
|
|
|
{
|
|
|
|
if(preg_match('/creativecommons.org\/licenses\/([^\/]+)/', $uri, $matches)) {
|
|
|
|
return explode('-',$matches[1]);
|
|
|
|
}
|
|
|
|
return array($uri);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
if(count($from_terms) == 1 && ($from_terms[0] == 'publicdomain' || $from_terms[0] == 'by')) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
$to_terms = common_license_terms($to);
|
|
|
|
// sa is compatible across versions. IANAL
|
|
|
|
if(in_array('sa',$from_terms) || in_array('sa',$to_terms)) {
|
|
|
|
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
|
|
|
|
|
|
|
/**
|
|
|
|
* returns a quoted table name, if required according to config
|
|
|
|
*/
|
|
|
|
function common_database_tablename($tablename)
|
|
|
|
{
|
2009-04-23 10:03:19 +01:00
|
|
|
|
2009-03-16 21:36:12 +00:00
|
|
|
if(common_config('db','quote_identifiers')) {
|
|
|
|
$tablename = '"'. $tablename .'"';
|
|
|
|
}
|
|
|
|
//table prefixes could be added here later
|
|
|
|
return $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.
|
|
|
|
* Length is not considered.
|
|
|
|
*
|
|
|
|
* @param string $long_url
|
|
|
|
* @return string may return the original URL if shortening failed
|
|
|
|
*
|
|
|
|
* @fixme provide a way to specify a particular shortener
|
|
|
|
* @fixme provide a way to specify to use a given user's shortening preferences
|
|
|
|
*/
|
2009-06-23 15:29:43 +01:00
|
|
|
function common_shorten_url($long_url)
|
|
|
|
{
|
2010-02-25 18:30:37 +00:00
|
|
|
$long_url = trim($long_url);
|
2009-06-23 15:29:43 +01:00
|
|
|
$user = common_current_user();
|
|
|
|
if (empty($user)) {
|
|
|
|
// common current user does not find a user when called from the XMPP daemon
|
|
|
|
// therefore we'll set one here fix, so that XMPP given URLs may be shortened
|
2009-11-11 19:02:57 +00:00
|
|
|
$shortenerName = 'ur1.ca';
|
2009-06-23 15:29:43 +01:00
|
|
|
} else {
|
2009-11-11 19:02:57 +00:00
|
|
|
$shortenerName = $user->urlshorteningservice;
|
2009-06-23 15:29:43 +01:00
|
|
|
}
|
|
|
|
|
2009-11-11 19:02:57 +00:00
|
|
|
if(Event::handle('StartShortenUrl', array($long_url,$shortenerName,&$shortenedUrl))){
|
|
|
|
//URL wasn't shortened, so return the long url
|
|
|
|
return $long_url;
|
|
|
|
}else{
|
|
|
|
//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'];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-02 13:10:31 +01:00
|
|
|
return array($proxy, $ip);
|
2009-06-27 15:37:58 +01:00
|
|
|
}
|
2010-02-16 16:06:10 +00:00
|
|
|
|
|
|
|
function common_url_to_nickname($url)
|
|
|
|
{
|
|
|
|
static $bad = array('query', 'user', 'password', 'port', 'fragment');
|
|
|
|
|
|
|
|
$parts = parse_url($url);
|
|
|
|
|
|
|
|
# If any of these parts exist, this won't work
|
|
|
|
|
|
|
|
foreach ($bad as $badpart) {
|
|
|
|
if (array_key_exists($badpart, $parts)) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
# We just have host and/or path
|
|
|
|
|
|
|
|
# If it's just a host...
|
|
|
|
if (array_key_exists('host', $parts) &&
|
|
|
|
(!array_key_exists('path', $parts) || strcmp($parts['path'], '/') == 0))
|
|
|
|
{
|
|
|
|
$hostparts = explode('.', $parts['host']);
|
|
|
|
|
|
|
|
# Try to catch common idiom of nickname.service.tld
|
|
|
|
|
|
|
|
if ((count($hostparts) > 2) &&
|
|
|
|
(strlen($hostparts[count($hostparts) - 2]) > 3) && # try to skip .co.uk, .com.au
|
|
|
|
(strcmp($hostparts[0], 'www') != 0))
|
|
|
|
{
|
|
|
|
return common_nicknamize($hostparts[0]);
|
|
|
|
} else {
|
|
|
|
# Do the whole hostname
|
|
|
|
return common_nicknamize($parts['host']);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (array_key_exists('path', $parts)) {
|
|
|
|
# Strip starting, ending slashes
|
|
|
|
$path = preg_replace('@/$@', '', $parts['path']);
|
|
|
|
$path = preg_replace('@^/@', '', $path);
|
2010-02-25 23:52:34 +00:00
|
|
|
$path = basename($path);
|
|
|
|
if ($path) {
|
2010-02-16 16:06:10 +00:00
|
|
|
return common_nicknamize($path);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
function common_nicknamize($str)
|
|
|
|
{
|
|
|
|
$str = preg_replace('/\W/', '', $str);
|
|
|
|
return strtolower($str);
|
|
|
|
}
|