/* XXX: break up into separate modules (HTTP, user, files) */
-// Show a server error
-
+/**
+ * Show a server error.
+ */
function common_server_error($msg, $code=500)
{
$err = new ServerErrorAction($msg, $code);
$err->showPage();
}
-// Show a user error
+/**
+ * Show a user error.
+ */
function common_user_error($msg, $code=400)
{
$err = new ClientErrorAction($msg, $code);
/**
* This should only be used at setup; processes switching languages
* to send text to other users should use common_switch_locale().
- *
+ *
* @param string $language Locale language code (optional; empty uses
* current user's preference or site default)
* @return mixed success
/**
* Initialize locale and charset settings and gettext with our message catalog,
* using the current user's language preference or the site default.
- *
+ *
* This should generally only be run at framework initialization; code switching
* languages at runtime should call common_switch_language().
- *
+ *
* @access private
*/
function common_init_language()
textdomain("statusnet");
}
-
function common_timezone()
{
if (common_logged_in()) {
// Finally, if none of the above worked, use the site's default...
return common_config('site', 'language');
}
-// salted, hashed passwords are stored in the DB
+/**
+ * Salted, hashed passwords are stored in the DB.
+ */
function common_munge_password($password, $id)
{
if (is_object($id) || is_object($password)) {
return md5($password . $id);
}
-// check if a username exists and has matching password
-
+/**
+ * Check if a username exists and has matching password.
+ */
function common_check_user($nickname, $password)
{
// empty nickname always unacceptable
return $authenticatedUser;
}
-// is the current user logged in?
+/**
+ * Is the current user logged in?
+ */
function common_logged_in()
{
return (!is_null(common_current_user()));
// 3) null to clear
// Initialize to false; set to null if none found
-
$_cur = false;
function common_set_user($user)
{
-
global $_cur;
if (is_null($user) && common_have_session()) {
if ($user) {
if (Event::handle('StartSetUser', array(&$user))) {
- if($user){
+ if (!empty($user)) {
+ if (!$user->hasRight(Right::WEBLOGIN)) {
+ // TRANS: Authorisation exception thrown when a user a not allowed to login.
+ throw new AuthorizationException(_('Not allowed to log in.'));
+ }
common_ensure_session();
$_SESSION['userid'] = $user->id;
$_cur = $user;
$value,
$expiration,
$cookiepath,
- $server);
+ $server,
+ common_config('site', 'ssl')=='always');
}
define('REMEMBERME', 'rememberme');
function common_remembered_user()
{
-
$user = null;
$packed = isset($_COOKIE[REMEMBERME]) ? $_COOKIE[REMEMBERME] : null;
return $user;
}
-// must be called with a valid user!
-
+/**
+ * must be called with a valid user!
+ */
function common_forgetme()
{
common_set_cookie(REMEMBERME, '', 0);
}
-// who is the current user?
+/**
+ * Who is the current user?
+ */
function common_current_user()
{
global $_cur;
return $_cur;
}
-// 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.
-
+/**
+ * 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.
+ */
function common_real_login($real=true)
{
common_ensure_session();
return common_logged_in() && $_SESSION['real_login'];
}
-// get canonical version of nickname for comparison
+/**
+ * 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';
+ }
+}
+
+/**
+ * get canonical version of nickname for comparison
+ *
+ * @param string $nickname
+ * @return string
+ *
+ * @throws NicknameException on invalid input
+ * @deprecated call Nickname::normalize() directly.
+ */
function common_canonical_nickname($nickname)
{
- // XXX: UTF-8 canonicalization (like combining chars)
- return strtolower($nickname);
+ return Nickname::normalize($nickname);
}
-// get canonical version of email for comparison
+/**
+ * get canonical version of email for comparison
+ *
+ * @fixme actually normalize
+ * @fixme reject invalid input
+ *
+ * @param string $email
+ * @return string
+ */
function common_canonical_email($email)
{
// XXX: canonicalize UTF-8
return $email;
}
+/**
+ * Partial notice markup rendering step: build links to !group references.
+ *
+ * @param string $text partially rendered HTML
+ * @param Notice $notice in whose context we're working
+ * @return string partially rendered HTML
+ */
function common_render_content($text, $notice)
{
$r = common_render_text($text);
$id = $notice->profile_id;
$r = common_linkify_mentions($r, $notice);
- $r = preg_replace('/(^|[\s\.\,\:\;]+)!([A-Za-z0-9]{1,64})/e', "'\\1!'.common_group_link($id, '\\2')", $r);
+ $r = preg_replace('/(^|[\s\.\,\:\;]+)!(' . Nickname::DISPLAY_FMT . ')/e',
+ "'\\1!'.common_group_link($id, '\\2')", $r);
return $r;
}
+/**
+ * Finds @-mentions within the partially-rendered text section and
+ * turns them into live links.
+ *
+ * Should generally not be called except from common_render_content().
+ *
+ * @param string $text partially-rendered HTML
+ * @param Notice $notice in-progress or complete Notice object for context
+ * @return string partially-rendered HTML
+ */
function common_linkify_mentions($text, $notice)
{
$mentions = common_find_mentions($text, $notice);
$xs->elementStart('span', 'vcard');
$xs->elementStart('a', $attrs);
- $xs->element('span', 'fn nickname', $mention['text']);
+ $xs->element('span', 'fn nickname mention', $mention['text']);
$xs->elementEnd('a');
$xs->elementEnd('span');
return $output;
}
+/**
+ * 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().
+ *
+ * @param string $text
+ * @param Notice $notice notice in whose context we're building links
+ *
+ * @return array
+ *
+ * @access private
+ */
function common_find_mentions($text, $notice)
{
$mentions = array();
}
if (Event::handle('StartFindMentions', array($sender, $text, &$mentions))) {
-
// Get the context of the original notice, if any
-
$originalAuthor = null;
$originalNotice = null;
$originalMentions = array();
}
}
- 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]);
+ $matches = common_find_mentions_raw($text);
foreach ($matches as $match) {
-
- $nickname = common_canonical_nickname($match[0]);
+ try {
+ $nickname = Nickname::normalize($match[0]);
+ } catch (NicknameException $e) {
+ // Bogus match? Drop it.
+ continue;
+ }
// 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)) {
-
$mentioned = $originalMentions[$nickname];
} else {
$mentioned = common_relative_profile($sender, $nickname);
}
if (!empty($mentioned)) {
-
$user = User::staticGet('id', $mentioned->id);
if ($user) {
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);
+ $plist = Profile_list::getByTaggerAndTag($sender->id, $tag);
+ if (!empty($plist) && !$plist->private) {
+ $tagged = $sender->getTaggedSubscribers($tag);
+
+ $url = common_local_url('showprofiletag',
+ array('tagger' => $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;
}
+/**
+ * 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
+ * @return array of PCRE match arrays
+ */
+function common_find_mentions_raw($text)
+{
+ $tmatches = array();
+ preg_match_all('/^T (' . Nickname::DISPLAY_FMT . ') /',
+ $text,
+ $tmatches,
+ PREG_OFFSET_CAPTURE);
+
+ $atmatches = array();
+ preg_match_all('/(?:^|\s+)@(' . Nickname::DISPLAY_FMT . ')\b/',
+ $text,
+ $atmatches,
+ PREG_OFFSET_CAPTURE);
+
+ $matches = array_merge($tmatches[1], $atmatches[1]);
+ return $matches;
+}
+
function common_render_text($text)
{
$r = htmlspecialchars($text);
$r = preg_replace('/[\x{0}-\x{8}\x{b}-\x{c}\x{e}-\x{19}]/', '', $r);
$r = common_replace_urls_callback($r, 'common_linkify');
- $r = preg_replace('/(^|\"\;|\'|\(|\[|\{|\s+)#([\pL\pN_\-\.]{1,64})/e', "'\\1#'.common_tag_link('\\2')", $r);
+ $r = preg_replace('/(^|\"\;|\'|\(|\[|\{|\s+)#([\pL\pN_\-\.]{1,64})/ue', "'\\1#'.common_tag_link('\\2')", $r);
// XXX: machine tags
return $r;
}
-function common_replace_urls_callback($text, $callback, $notice_id = null) {
+/**
+ * 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
+ */
+function common_replace_urls_callback($text, $callback, $arg = null) {
// Start off with a regex
$regex = '#'.
'(?:^|[\s\<\>\(\)\[\]\{\}\\\'\\\";]+)(?![\@\!\#])'.
'#ixu';
//preg_match_all($regex,$text,$matches);
//print_r($matches);
- return preg_replace_callback($regex, curry('callback_helper',$callback,$notice_id) ,$text);
+ return preg_replace_callback($regex, curry('callback_helper',$callback,$arg) ,$text);
}
-function callback_helper($matches, $callback, $notice_id) {
+/**
+ * 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
+ *
+ * @access private
+ */
+function callback_helper($matches, $callback, $arg=null) {
$url=$matches[1];
$left = strpos($matches[0],$url);
$right = $left+strlen($url);
}
}while($original_url!=$url);
- if(empty($notice_id)){
- $result = call_user_func_array($callback, array($url));
- }else{
- $result = call_user_func_array($callback, array(array($url,$notice_id)) );
- }
+ $result = call_user_func_array($callback, array($url, $arg));
return substr($matches[0],0,$left) . $result . substr($matches[0],$right);
}
// functions
$url = htmlspecialchars_decode($url);
- if(strpos($url, '@') !== false && strpos($url, ':') === false) {
- //url is an email address without the mailto: protocol
- $canon = "mailto:$url";
- $longurl = "mailto:$url";
- }else{
+ 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 {
$canon = File_redirection::_canonUrl($url);
- $longurl_data = File_redirection::where($canon);
+ $longurl_data = File_redirection::where($canon, common_config('attachments', 'process_links'));
if (is_array($longurl_data)) {
$longurl = $longurl_data['url'];
} elseif (is_string($longurl_data)) {
$longurl = $longurl_data;
} else {
- throw new ServerException("Can't linkify url '$url'");
+ // Unable to reach the server to verify contents, etc
+ // Just pass the link on through for now.
+ common_log(LOG_ERR, "Can't linkify url '$url'");
+ $longurl = $url;
}
}
- $attrs = array('href' => $canon, 'title' => $longurl, 'rel' => 'external');
+
+ $attrs = array('href' => $canon, 'title' => $longurl);
$is_attachment = false;
$attachment_id = null;
$f = File::staticGet('url', $longurl);
if (empty($f)) {
- // XXX: this writes to the database. :<
- $f = File::processNew($longurl);
+ if (common_config('attachments', 'process_links')) {
+ // XXX: this writes to the database. :<
+ $f = File::processNew($longurl);
+ }
}
if (!empty($f)) {
- if ($f->getEnclosure() || File_oembed::staticGet('file_id',$f->id)) {
+ if ($f->getEnclosure()) {
$is_attachment = true;
$attachment_id = $f->id;
$attrs['id'] = "attachment-{$attachment_id}";
}
+ // Whether to nofollow
+
+ $nf = common_config('nofollow', 'external');
+
+ if ($nf == 'never') {
+ $attrs['rel'] = 'external';
+ } else {
+ $attrs['rel'] = 'nofollow external';
+ }
+
return XMLStringer::estring('a', $attrs, $url);
}
-function common_shorten_links($text, $always = false)
+/**
+ * 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)
{
- common_debug("common_shorten_links() called");
-
$user = common_current_user();
$maxLength = User_urlshortener_prefs::maxNoticeLength($user);
- common_debug("maxLength = $maxLength");
-
if ($always || mb_strlen($text) > $maxLength) {
- common_debug("Forcing shortening");
- return common_replace_urls_callback($text, array('File_redirection', 'forceShort'));
+ return common_replace_urls_callback($text, array('File_redirection', 'forceShort'), $user);
} else {
- common_debug("Not forcing shortening");
- return common_replace_urls_callback($text, array('File_redirection', 'makeShort'));
+ return common_replace_urls_callback($text, array('File_redirection', 'makeShort'), $user);
}
}
+/**
+ * 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.
+ //
+ // 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);
+}
+
+/**
+ * Make sure an arbitrary string is safe for output in XML as a single line.
+ *
+ * @param string $str
+ * @return string
+ */
function common_xml_safe_str($str)
{
// Replace common eol and extra whitespace input chars
$canonical = common_canonical_tag($tag);
if (common_config('singleuser', 'enabled')) {
// regular TagAction isn't set up in 1user mode
+ $nickname = User::singleUserNickname();
$url = common_local_url('showstream',
- array('nickname' => common_config('singleuser', 'nickname'),
+ array('nickname' => $nickname,
'tag' => $canonical));
} else {
$url = common_local_url('tag', array('tag' => $canonical));
return preg_match('/^[A-Za-z0-9_\-\.]{1,64}$/', $str);
}
+/**
+ *
+ * @param <type> $sender_id
+ * @param <type> $nickname
+ * @return <type>
+ * @access private
+ */
function common_group_link($sender_id, $nickname)
{
$sender = Profile::staticGet($sender_id);
$attrs = array('href' => $group->permalink(),
'class' => 'url');
if (!empty($group->fullname)) {
- $attrs['title'] = $group->fullname . ' (' . $group->nickname . ')';
+ $attrs['title'] = $group->getFancyName();
}
$xs = new XMLStringer();
$xs->elementStart('span', 'vcard');
$xs->elementStart('a', $attrs);
- $xs->element('span', 'fn nickname', $nickname);
+ $xs->element('span', 'fn nickname group', $nickname);
$xs->elementEnd('a');
$xs->elementEnd('span');
return $xs->getString();
}
}
+/**
+ * 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
+ * @param <type> $dt unused mystery parameter; in Notice reply-to handling a timestamp is passed.
+ *
+ * @return Profile or null
+ */
function common_relative_profile($sender, $nickname, $dt=null)
{
+ // Will throw exception on invalid input.
+ $nickname = Nickname::normalize($nickname);
+
// 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');
- $recipient->whereAdd("nickname = '" . trim($nickname) . "'", 'AND');
+ $recipient->whereAdd('EXISTS (SELECT subscribed from subscription where subscriber = '.intval($sender->id).' and subscribed = id)', 'AND');
+ $recipient->whereAdd("nickname = '" . $recipient->escape($nickname) . "'", 'AND');
if ($recipient->find(true)) {
// XXX: should probably differentiate between profiles with
// the same name by date of most recent update
// 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');
- $recipient->whereAdd("nickname = '" . trim($nickname) . "'", 'AND');
+ $recipient->whereAdd('EXISTS (SELECT subscriber from subscription where subscribed = '.intval($sender->id).' and subscriber = id)', 'AND');
+ $recipient->whereAdd("nickname = '" . $recipient->escape($nickname) . "'", 'AND');
if ($recipient->find(true)) {
// XXX: should probably differentiate between profiles with
// the same name by date of most recent update
function common_local_url($action, $args=null, $params=null, $fragment=null, $addSession=true)
{
- $r = Router::get();
- $path = $r->build($action, $args, $params, $fragment);
+ if (Event::handle('StartLocalURL', array(&$action, &$params, &$fragment, &$addSession, &$url))) {
+ $r = Router::get();
+ $path = $r->build($action, $args, $params, $fragment);
- $ssl = common_is_sensitive($action);
+ $ssl = common_is_sensitive($action);
- if (common_config('site','fancy')) {
- $url = common_path(mb_substr($path, 1), $ssl, $addSession);
- } else {
- if (mb_strpos($path, '/index.php') === 0) {
+ if (common_config('site','fancy')) {
$url = common_path(mb_substr($path, 1), $ssl, $addSession);
} else {
- $url = common_path('index.php'.$path, $ssl, $addSession);
+ if (mb_strpos($path, '/index.php') === 0) {
+ $url = common_path(mb_substr($path, 1), $ssl, $addSession);
+ } else {
+ $url = common_path('index.php'.$path, $ssl, $addSession);
+ }
}
+ Event::handle('EndLocalURL', array(&$action, &$params, &$fragment, &$addSession, &$url));
}
return $url;
}
function common_is_sensitive($action)
{
- static $sensitive = array('login', 'register', 'passwordsettings',
- 'twittersettings', 'api');
+ static $sensitive = array(
+ 'login',
+ 'register',
+ 'passwordsettings',
+ 'api',
+ 'ApiOauthRequestToken',
+ 'ApiOauthAccessToken',
+ 'ApiOauthAuthorize',
+ 'ApiOauthPin',
+ 'showapplication'
+ );
$ssl = null;
if (Event::handle('SensitiveAction', array($action, &$ssl))) {
// TRANS: Used in notices to indicate when the notice was made compared to now.
return _('about a minute ago');
} else if ($diff < 3300) {
- // XXX: should support plural.
+ $minutes = round($diff/60);
// TRANS: Used in notices to indicate when the notice was made compared to now.
- return sprintf(_('about %d minutes ago'), round($diff/60));
+ return sprintf( _m('about one minute ago', 'about %d minutes ago', $minutes), $minutes);
} else if ($diff < 5400) {
// TRANS: Used in notices to indicate when the notice was made compared to now.
return _('about an hour ago');
} else if ($diff < 22 * 3600) {
- // XXX: should support plural.
+ $hours = round($diff/3600);
// TRANS: Used in notices to indicate when the notice was made compared to now.
- return sprintf(_('about %d hours ago'), round($diff/3600));
+ return sprintf( _m('about one hour ago', 'about %d hours ago', $hours), $hours);
} else if ($diff < 37 * 3600) {
// TRANS: Used in notices to indicate when the notice was made compared to now.
return _('about a day ago');
} else if ($diff < 24 * 24 * 3600) {
- // XXX: should support plural.
+ $days = round($diff/(24*3600));
// TRANS: Used in notices to indicate when the notice was made compared to now.
- return sprintf(_('about %d days ago'), round($diff/(24*3600)));
+ return sprintf( _m('about one day ago', 'about %d days ago', $days), $days);
} else if ($diff < 46 * 24 * 3600) {
// TRANS: Used in notices to indicate when the notice was made compared to now.
return _('about a month ago');
} else if ($diff < 330 * 24 * 3600) {
- // XXX: should support plural.
+ $months = round($diff/(30*24*3600));
// TRANS: Used in notices to indicate when the notice was made compared to now.
- return sprintf(_('about %d months ago'), round($diff/(30*24*3600)));
+ return sprintf( _m('about one month ago', 'about %d months ago',$months), $months);
} else if ($diff < 480 * 24 * 3600) {
// TRANS: Used in notices to indicate when the notice was made compared to now.
return _('about a year ago');
exit;
}
-function common_broadcast_notice($notice, $remote=false)
-{
- // DO NOTHING!
-}
-
// Stick the notice on the queue
function common_enqueue_notice($notice)
null, null, false);
}
-// Should make up a reasonable root URL
-
+/**
+ * Should make up a reasonable root URL
+ */
function common_root_url($ssl=false)
{
$url = common_path('', $ssl, false);
return $url;
}
-// returns $bytes bytes of random data as a hexadecimal string
-// "good" here is a goal and not a guarantee
-
+/**
+ * returns $bytes bytes of random data as a hexadecimal string
+ * "good" here is a goal and not a guarantee
+ */
function common_good_rand($bytes)
{
// XXX: use random.org...?
/**
* Record the given URL as the return destination for a future
* form submission, to be read by common_get_returnto().
- *
+ *
* @param string $url
- *
+ *
* @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.
- *
+ *
* Should refactor to index with a token or otherwise only pass the
* data along its intended path.
*/
/**
* Fetch a return-destination URL previously recorded by
* common_set_returnto().
- *
+ *
* @return mixed URL string or null
- *
+ *
* @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.
- *
+ *
* Should refactor to index with a token or otherwise only pass the
* data along its intended path.
*/
function common_log($priority, $msg, $filename=null)
{
if(Event::handle('StartLog', array(&$priority, &$msg, &$filename))){
+ $msg = (empty($filename)) ? $msg : basename($filename) . ' - ' . $msg;
$msg = '[' . common_request_id() . '] ' . $msg;
$logfile = common_config('site', 'logfile');
if ($logfile) {
{
$objstr = common_log_objstring($object);
$last_error = &PEAR::getStaticProperty('DB_DataObject','lastError');
- common_log(LOG_ERR, $last_error->message . '(' . $verb . ' on ' . $objstr . ')', $filename);
+ 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);
}
function common_log_objstring(&$object)
array_key_exists($sub, $config[$main])) ? $config[$main][$sub] : false;
}
+/**
+ * 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
+ */
function common_copy_args($from)
{
$to = array();
$strip = get_magic_quotes_gpc();
foreach ($from as $k => $v) {
- if($strip) {
- if(is_array($v)) {
- $to[$k] = common_copy_args($v);
- } else {
- $to[$k] = stripslashes($v);
- }
+ if(is_array($v)) {
+ $to[$k] = common_copy_args($v);
} else {
- $to[$k] = $v;
+ if ($strip) {
+ $v = stripslashes($v);
+ }
+ $to[$k] = strval(common_validate_utf8($v));
}
}
return $to;
return $_SESSION['token'];
}
-function common_cache_key($extra)
-{
- return Cache::key($extra);
-}
-
-function common_keyize($str)
-{
- return Cache::keyize($str);
-}
-
-function common_memcache()
-{
- return Cache::instance();
-}
-
function common_license_terms($uri)
{
if(preg_match('/creativecommons.org\/licenses\/([^\/]+)/', $uri, $matches)) {
*/
function common_database_tablename($tablename)
{
-
if(common_config('db','quote_identifiers')) {
$tablename = '"'. $tablename .'"';
}
* or ur1.ca if configured, or not at all if no shortening is set up.
*
* @param string $long_url original URL
+ * @param User $user to specify a particular user's options
* @param boolean $force Force shortening (used when notice is too long)
- *
* @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
*/
-
-function common_shorten_url($long_url, $force = false)
+function common_shorten_url($long_url, User $user=null, $force = false)
{
- common_debug("Shortening URL '$long_url' (force = $force)");
-
$long_url = trim($long_url);
$user = common_current_user();
$maxUrlLength = User_urlshortener_prefs::maxUrlLength($user);
- common_debug("maxUrlLength = $maxUrlLength");
// $force forces shortening even if it's not strictly needed
+ // I doubt URL shortening is ever 'strictly' needed. - ESP
if (mb_strlen($long_url) < $maxUrlLength && !$force) {
- common_debug("Skipped shortening URL.");
return $long_url;
}
$shortenerName = User_urlshortener_prefs::urlShorteningService($user);
- common_debug("Shortener name = '$shortenerName'");
-
- if (Event::handle('StartShortenUrl', array($long_url, $shortenerName, &$shortenedUrl))) {
- //URL wasn't shortened, so return the long url
- return $long_url;
+ if (Event::handle('StartShortenUrl',
+ array($long_url, $shortenerName, &$shortenedUrl))) {
+ if ($shortenerName == 'internal') {
+ $f = File::processNew($long_url);
+ if (empty($f)) {
+ return $long_url;
+ } else {
+ $shortenedUrl = common_local_url('redirecturl',
+ array('id' => $f->id));
+ return $shortenedUrl;
+ }
+ } else {
+ return $long_url;
+ }
} else {
//URL was shortened, so return the result
return trim($shortenedUrl);
$parts = parse_url($url);
- # If any of these parts exist, this won't work
+ // If any of these parts exist, this won't work
foreach ($bad as $badpart) {
if (array_key_exists($badpart, $parts)) {
}
}
- # We just have host and/or path
+ // We just have host and/or path
- # If it's just a host...
+ // 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
+ // 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
{
return common_nicknamize($hostparts[0]);
} else {
- # Do the whole hostname
+ // Do the whole hostname
return common_nicknamize($parts['host']);
}
} else {
if (array_key_exists('path', $parts)) {
- # Strip starting, ending slashes
+ // Strip starting, ending slashes
$path = preg_replace('@/$@', '', $parts['path']);
$path = preg_replace('@^/@', '', $path);
$path = basename($path);
$str = preg_replace('/\W/', '', $str);
return strtolower($str);
}
+
+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 {
+ $_perfCounters[$key] = array($val);
+ }
+ 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')) {
+ global $_startTime, $_perfCounters;
+
+ if (isset($_startTime)) {
+ $endTime = microtime(true);
+ $diff = round(($endTime - $_startTime) * 1000);
+ 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)");
+ }
+ }
+}
projects / quix0rs-gnu-social.git / blobdiff