lib/util.php

   1 <?php
   2 /*
   3  * StatusNet - the distributed open-source microblogging tool
   4  * Copyright (C) 2008-2011, StatusNet, Inc.
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU Affero General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU Affero General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Affero General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 /* XXX: break up into separate modules (HTTP, user, files) */
  21
  22 /**
  23  * Show a server error.
  24  */
  25 function common_server_error($msg, $code=500)
  26 {
  27     $err = new ServerErrorAction($msg, $code);
  28     $err->showPage();
  29 }
  30
  31 /**
  32  * Show a user error.
  33  */
  34 function common_user_error($msg, $code=400)
  35 {
  36     $err = new ClientErrorAction($msg, $code);
  37     $err->showPage();
  38 }
  39
  40 /**
  41  * This should only be used at setup; processes switching languages
  42  * to send text to other users should use common_switch_locale().
  43  *
  44  * @param string $language Locale language code (optional; empty uses
  45  *                         current user's preference or site default)
  46  * @return mixed success
  47  */
  48 function common_init_locale($language=null)
  49 {
  50     if(!$language) {
  51         $language = common_language();
  52     }
  53     putenv('LANGUAGE='.$language);
  54     putenv('LANG='.$language);
  55     $ok =  setlocale(LC_ALL, $language . ".utf8",
  56                      $language . ".UTF8",
  57                      $language . ".utf-8",
  58                      $language . ".UTF-8",
  59                      $language);
  60
  61     return $ok;
  62 }
  63
  64 /**
  65  * Initialize locale and charset settings and gettext with our message catalog,
  66  * using the current user's language preference or the site default.
  67  *
  68  * This should generally only be run at framework initialization; code switching
  69  * languages at runtime should call common_switch_language().
  70  *
  71  * @access private
  72  */
  73 function common_init_language()
  74 {
  75     mb_internal_encoding('UTF-8');
  76
  77     // Note that this setlocale() call may "fail" but this is harmless;
  78     // gettext will still select the right language.
  79     $language = common_language();
  80     $locale_set = common_init_locale($language);
  81
  82     if (!$locale_set) {
  83         // The requested locale doesn't exist on the system.
  84         //
  85         // gettext seems very picky... We first need to setlocale()
  86         // to a locale which _does_ exist on the system, and _then_
  87         // we can set in another locale that may not be set up
  88         // (say, ga_ES for Galego/Galician) it seems to take it.
  89         //
  90         // For some reason C and POSIX which are guaranteed to work
  91         // don't do the job. en_US.UTF-8 should be there most of the
  92         // time, but not guaranteed.
  93         $ok = common_init_locale("en_US");
  94         if (!$ok && strtolower(substr(PHP_OS, 0, 3)) != 'win') {
  95             // Try to find a complete, working locale on Unix/Linux...
  96             // @fixme shelling out feels awfully inefficient
  97             // but I don't think there's a more standard way.
  98             $all = `locale -a`;
  99             foreach (explode("\n", $all) as $locale) {
 100                 if (preg_match('/\.utf[-_]?8$/i', $locale)) {
 101                     $ok = setlocale(LC_ALL, $locale);
 102                     if ($ok) {
 103                         break;
 104                     }
 105                 }
 106             }
 107         }
 108         if (!$ok) {
 109             common_log(LOG_ERR, "Unable to find a UTF-8 locale on this system; UI translations may not work.");
 110         }
 111         $locale_set = common_init_locale($language);
 112     }
 113
 114     common_init_gettext();
 115 }
 116
 117 /**
 118  * @access private
 119  */
 120 function common_init_gettext()
 121 {
 122     setlocale(LC_CTYPE, 'C');
 123     // So we do not have to make people install the gettext locales
 124     $path = common_config('site','locale_path');
 125     bindtextdomain("statusnet", $path);
 126     bind_textdomain_codeset("statusnet", "UTF-8");
 127     textdomain("statusnet");
 128 }
 129
 130 /**
 131  * Switch locale during runtime, and poke gettext until it cries uncle.
 132  * Otherwise, sometimes it doesn't actually switch away from the old language.
 133  *
 134  * @param string $language code for locale ('en', 'fr', 'pt_BR' etc)
 135  */
 136 function common_switch_locale($language=null)
 137 {
 138     common_init_locale($language);
 139
 140     setlocale(LC_CTYPE, 'C');
 141     // So we do not have to make people install the gettext locales
 142     $path = common_config('site','locale_path');
 143     bindtextdomain("statusnet", $path);
 144     bind_textdomain_codeset("statusnet", "UTF-8");
 145     textdomain("statusnet");
 146 }
 147
 148 function common_timezone()
 149 {
 150     if (common_logged_in()) {
 151         $user = common_current_user();
 152         if ($user->timezone) {
 153             return $user->timezone;
 154         }
 155     }
 156
 157     return common_config('site', 'timezone');
 158 }
 159
 160 function common_valid_language($lang)
 161 {
 162     if ($lang) {
 163         // Validate -- we don't want to end up with a bogus code
 164         // left over from some old junk.
 165         foreach (common_config('site', 'languages') as $code => $info) {
 166             if ($info['lang'] == $lang) {
 167                 return true;
 168             }
 169         }
 170     }
 171     return false;
 172 }
 173
 174 function common_language()
 175 {
 176     // Allow ?uselang=xx override, very useful for debugging
 177     // and helping translators check usage and context.
 178     if (isset($_GET['uselang'])) {
 179         $uselang = strval($_GET['uselang']);
 180         if (common_valid_language($uselang)) {
 181             return $uselang;
 182         }
 183     }
 184
 185     // If there is a user logged in and they've set a language preference
 186     // then return that one...
 187     if (_have_config() && common_logged_in()) {
 188         $user = common_current_user();
 189
 190         if (common_valid_language($user->language)) {
 191             return $user->language;
 192         }
 193     }
 194
 195     // Otherwise, find the best match for the languages requested by the
 196     // user's browser...
 197     if (common_config('site', 'langdetect')) {
 198         $httplang = isset($_SERVER['HTTP_ACCEPT_LANGUAGE']) ? $_SERVER['HTTP_ACCEPT_LANGUAGE'] : null;
 199         if (!empty($httplang)) {
 200             $language = client_prefered_language($httplang);
 201             if ($language)
 202               return $language;
 203         }
 204     }
 205
 206     // Finally, if none of the above worked, use the site's default...
 207     return common_config('site', 'language');
 208 }
 209
 210 /**
 211  * Salted, hashed passwords are stored in the DB.
 212  */
 213 function common_munge_password($password, $id, Profile $profile=null)
 214 {
 215     $hashed = null;
 216
 217     if (Event::handle('StartHashPassword', array(&$hashed, $password, $profile))) {
 218         Event::handle('EndHashPassword', array(&$hashed, $password, $profile));
 219     }
 220     if (empty($hashed)) {
 221         throw new PasswordHashException();
 222     }
 223
 224     return $hashed;
 225 }
 226
 227 /**
 228  * Check if a username exists and has matching password.
 229  */
 230 function common_check_user($nickname, $password)
 231 {
 232     // empty nickname always unacceptable
 233     if (empty($nickname)) {
 234         return false;
 235     }
 236
 237     $authenticatedUser = false;
 238
 239     if (Event::handle('StartCheckPassword', array($nickname, $password, &$authenticatedUser))) {
 240
 241         if (common_is_email($nickname)) {
 242             $user = User::getKV('email', common_canonical_email($nickname));
 243         } else {
 244             $user = User::getKV('nickname', Nickname::normalize($nickname));
 245         }
 246
 247         if (!empty($user)) {
 248             if (!empty($password)) { // never allow login with blank password
 249                 if (0 == strcmp(common_munge_password($password, $user->id),
 250                                 $user->password)) {
 251                     //internal checking passed
 252                     $authenticatedUser = $user;
 253                 }
 254             }
 255         }
 256         Event::handle('EndCheckPassword', array($nickname, $password, $authenticatedUser));
 257     }
 258
 259     return $authenticatedUser;
 260 }
 261
 262 /**
 263  * Is the current user logged in?
 264  */
 265 function common_logged_in()
 266 {
 267     return (!is_null(common_current_user()));
 268 }
 269
 270 function common_have_session()
 271 {
 272     return (0 != strcmp(session_id(), ''));
 273 }
 274
 275 function common_ensure_session()
 276 {
 277     $c = null;
 278     if (array_key_exists(session_name(), $_COOKIE)) {
 279         $c = $_COOKIE[session_name()];
 280     }
 281     if (!common_have_session()) {
 282         if (common_config('sessions', 'handle')) {
 283             Session::setSaveHandler();
 284         }
 285         if (array_key_exists(session_name(), $_GET)) {
 286             $id = $_GET[session_name()];
 287         } else if (array_key_exists(session_name(), $_COOKIE)) {
 288             $id = $_COOKIE[session_name()];
 289         }
 290         if (isset($id)) {
 291             session_id($id);
 292         }
 293         @session_start();
 294         if (!isset($_SESSION['started'])) {
 295             $_SESSION['started'] = time();
 296             if (!empty($id)) {
 297                 common_log(LOG_WARNING, 'Session cookie "' . $_COOKIE[session_name()] . '" ' .
 298                            ' is set but started value is null');
 299             }
 300         }
 301     }
 302 }
 303
 304 // Three kinds of arguments:
 305 // 1) a user object
 306 // 2) a nickname
 307 // 3) null to clear
 308
 309 // Initialize to false; set to null if none found
 310 $_cur = false;
 311
 312 function common_set_user($user)
 313 {
 314     global $_cur;
 315
 316     if (is_null($user) && common_have_session()) {
 317         $_cur = null;
 318         unset($_SESSION['userid']);
 319         return true;
 320     } else if (is_string($user)) {
 321         $nickname = $user;
 322         $user = User::getKV('nickname', $nickname);
 323     } else if (!($user instanceof User)) {
 324         return false;
 325     }
 326
 327     if ($user) {
 328         if (Event::handle('StartSetUser', array(&$user))) {
 329             if (!empty($user)) {
 330                 if (!$user->hasRight(Right::WEBLOGIN)) {
 331                     // TRANS: Authorisation exception thrown when a user a not allowed to login.
 332                     throw new AuthorizationException(_('Not allowed to log in.'));
 333                 }
 334                 common_ensure_session();
 335                 $_SESSION['userid'] = $user->id;
 336                 $_cur = $user;
 337                 Event::handle('EndSetUser', array($user));
 338                 return $_cur;
 339             }
 340         }
 341     }
 342     return false;
 343 }
 344
 345 function common_set_cookie($key, $value, $expiration=0)
 346 {
 347     $path = common_config('site', 'path');
 348     $server = common_config('site', 'server');
 349
 350     if ($path && ($path != '/')) {
 351         $cookiepath = '/' . $path . '/';
 352     } else {
 353         $cookiepath = '/';
 354     }
 355     return setcookie($key,
 356                      $value,
 357                      $expiration,
 358                      $cookiepath,
 359                      $server,
 360                      common_config('site', 'ssl')=='always');
 361 }
 362
 363 define('REMEMBERME', 'rememberme');
 364 define('REMEMBERME_EXPIRY', 30 * 24 * 60 * 60); // 30 days
 365
 366 function common_rememberme($user=null)
 367 {
 368     if (!$user) {
 369         $user = common_current_user();
 370         if (!$user) {
 371             return false;
 372         }
 373     }
 374
 375     $rm = new Remember_me();
 376
 377     $rm->code = common_good_rand(16);
 378     $rm->user_id = $user->id;
 379
 380     // Wrap the insert in some good ol' fashioned transaction code
 381
 382     $rm->query('BEGIN');
 383
 384     $result = $rm->insert();
 385
 386     if (!$result) {
 387         common_log_db_error($rm, 'INSERT', __FILE__);
 388         return false;
 389     }
 390
 391     $rm->query('COMMIT');
 392
 393     $cookieval = $rm->user_id . ':' . $rm->code;
 394
 395     common_log(LOG_INFO, 'adding rememberme cookie "' . $cookieval . '" for ' . $user->nickname);
 396
 397     common_set_cookie(REMEMBERME, $cookieval, time() + REMEMBERME_EXPIRY);
 398
 399     return true;
 400 }
 401
 402 function common_remembered_user()
 403 {
 404     $user = null;
 405
 406     $packed = isset($_COOKIE[REMEMBERME]) ? $_COOKIE[REMEMBERME] : null;
 407
 408     if (!$packed) {
 409         return null;
 410     }
 411
 412     list($id, $code) = explode(':', $packed);
 413
 414     if (!$id || !$code) {
 415         common_log(LOG_WARNING, 'Malformed rememberme cookie: ' . $packed);
 416         common_forgetme();
 417         return null;
 418     }
 419
 420     $rm = Remember_me::getKV('code', $code);
 421
 422     if (!$rm) {
 423         common_log(LOG_WARNING, 'No such remember code: ' . $code);
 424         common_forgetme();
 425         return null;
 426     }
 427
 428     if ($rm->user_id != $id) {
 429         common_log(LOG_WARNING, 'Rememberme code for wrong user: ' . $rm->user_id . ' != ' . $id);
 430         common_forgetme();
 431         return null;
 432     }
 433
 434     $user = User::getKV('id', $rm->user_id);
 435
 436     if (!$user) {
 437         common_log(LOG_WARNING, 'No such user for rememberme: ' . $rm->user_id);
 438         common_forgetme();
 439         return null;
 440     }
 441
 442     // successful!
 443     $result = $rm->delete();
 444
 445     if (!$result) {
 446         common_log_db_error($rm, 'DELETE', __FILE__);
 447         common_log(LOG_WARNING, 'Could not delete rememberme: ' . $code);
 448         common_forgetme();
 449         return null;
 450     }
 451
 452     common_log(LOG_INFO, 'logging in ' . $user->nickname . ' using rememberme code ' . $rm->code);
 453
 454     common_set_user($user);
 455     common_real_login(false);
 456
 457     // We issue a new cookie, so they can log in
 458     // automatically again after this session
 459
 460     common_rememberme($user);
 461
 462     return $user;
 463 }
 464
 465 /**
 466  * must be called with a valid user!
 467  */
 468 function common_forgetme()
 469 {
 470     common_set_cookie(REMEMBERME, '', 0);
 471 }
 472
 473 /**
 474  * Who is the current user?
 475  */
 476 function common_current_user()
 477 {
 478     global $_cur;
 479
 480     if (!_have_config()) {
 481         return null;
 482     }
 483
 484     if ($_cur === false) {
 485
 486         if (isset($_COOKIE[session_name()]) || isset($_GET[session_name()])
 487             || (isset($_SESSION['userid']) && $_SESSION['userid'])) {
 488             common_ensure_session();
 489             $id = isset($_SESSION['userid']) ? $_SESSION['userid'] : false;
 490             if ($id) {
 491                 $user = User::getKV($id);
 492                 if ($user) {
 493                         $_cur = $user;
 494                         return $_cur;
 495                 }
 496             }
 497         }
 498
 499         // that didn't work; try to remember; will init $_cur to null on failure
 500         $_cur = common_remembered_user();
 501
 502         if ($_cur) {
 503             // XXX: Is this necessary?
 504             $_SESSION['userid'] = $_cur->id;
 505         }
 506     }
 507
 508     return $_cur;
 509 }
 510
 511 /**
 512  * Logins that are 'remembered' aren't 'real' -- they're subject to
 513  * cookie-stealing. So, we don't let them do certain things. New reg,
 514  * OpenID, and password logins _are_ real.
 515  */
 516 function common_real_login($real=true)
 517 {
 518     common_ensure_session();
 519     $_SESSION['real_login'] = $real;
 520 }
 521
 522 function common_is_real_login()
 523 {
 524     return common_logged_in() && $_SESSION['real_login'];
 525 }
 526
 527 /**
 528  * Get a hash portion for HTTP caching Etags and such including
 529  * info on the current user's session. If login/logout state changes,
 530  * or we've changed accounts, or we've renamed the current user,
 531  * we'll get a new hash value.
 532  *
 533  * This should not be considered secure information.
 534  *
 535  * @param User $user (optional; uses common_current_user() if left out)
 536  * @return string
 537  */
 538 function common_user_cache_hash($user=false)
 539 {
 540     if ($user === false) {
 541         $user = common_current_user();
 542     }
 543     if ($user) {
 544         return crc32($user->id . ':' . $user->nickname);
 545     } else {
 546         return '0';
 547     }
 548 }
 549
 550 /**
 551  * get canonical version of nickname for comparison
 552  *
 553  * @param string $nickname
 554  * @return string
 555  *
 556  * @throws NicknameException on invalid input
 557  * @deprecated call Nickname::normalize() directly.
 558  */
 559 function common_canonical_nickname($nickname)
 560 {
 561     return Nickname::normalize($nickname);
 562 }
 563
 564 /**
 565  * get canonical version of email for comparison
 566  *
 567  * @fixme actually normalize
 568  * @fixme reject invalid input
 569  *
 570  * @param string $email
 571  * @return string
 572  */
 573 function common_canonical_email($email)
 574 {
 575     // XXX: canonicalize UTF-8
 576     // XXX: lcase the domain part
 577     return $email;
 578 }
 579
 580 /**
 581  * Partial notice markup rendering step: build links to !group references.
 582  *
 583  * @param string $text partially rendered HTML
 584  * @param Notice $notice in whose context we're working
 585  * @return string partially rendered HTML
 586  */
 587 function common_render_content($text, $notice)
 588 {
 589     $r = common_render_text($text);
 590     $id = $notice->profile_id;
 591     $r = common_linkify_mentions($r, $notice);
 592     $r = preg_replace_callback('/(^|[\s\.\,\:\;]+)!(' . Nickname::DISPLAY_FMT . ')/',
 593                       function ($m) { return "{$m[1]}!".common_group_link($id, $m[2]); }, $r);
 594     return $r;
 595 }
 596
 597 /**
 598  * Finds @-mentions within the partially-rendered text section and
 599  * turns them into live links.
 600  *
 601  * Should generally not be called except from common_render_content().
 602  *
 603  * @param string $text partially-rendered HTML
 604  * @param Notice $notice in-progress or complete Notice object for context
 605  * @return string partially-rendered HTML
 606  */
 607 function common_linkify_mentions($text, $notice)
 608 {
 609     $mentions = common_find_mentions($text, $notice);
 610
 611     // We need to go through in reverse order by position,
 612     // so our positions stay valid despite our fudging with the
 613     // string!
 614
 615     $points = array();
 616
 617     foreach ($mentions as $mention)
 618     {
 619         $points[$mention['position']] = $mention;
 620     }
 621
 622     krsort($points);
 623
 624     foreach ($points as $position => $mention) {
 625
 626         $linkText = common_linkify_mention($mention);
 627
 628         $text = substr_replace($text, $linkText, $position, mb_strlen($mention['text']));
 629     }
 630
 631     return $text;
 632 }
 633
 634 function common_linkify_mention($mention)
 635 {
 636     $output = null;
 637
 638     if (Event::handle('StartLinkifyMention', array($mention, &$output))) {
 639
 640         $xs = new XMLStringer(false);
 641
 642         $attrs = array('href' => $mention['url'],
 643                        'class' => 'url');
 644
 645         if (!empty($mention['title'])) {
 646             $attrs['title'] = $mention['title'];
 647         }
 648
 649         $xs->elementStart('span', 'vcard');
 650         $xs->elementStart('a', $attrs);
 651         $xs->element('span', 'fn nickname mention', $mention['text']);
 652         $xs->elementEnd('a');
 653         $xs->elementEnd('span');
 654
 655         $output = $xs->getString();
 656
 657         Event::handle('EndLinkifyMention', array($mention, &$output));
 658     }
 659
 660     return $output;
 661 }
 662
 663 /**
 664  * Find @-mentions in the given text, using the given notice object as context.
 665  * References will be resolved with common_relative_profile() against the user
 666  * who posted the notice.
 667  *
 668  * Note the return data format is internal, to be used for building links and
 669  * such. Should not be used directly; rather, call common_linkify_mentions().
 670  *
 671  * @param string $text
 672  * @param Notice $notice notice in whose context we're building links
 673  *
 674  * @return array
 675  *
 676  * @access private
 677  */
 678 function common_find_mentions($text, $notice)
 679 {
 680     $mentions = array();
 681
 682     $sender = Profile::getKV('id', $notice->profile_id);
 683
 684     if (empty($sender)) {
 685         return $mentions;
 686     }
 687
 688     if (Event::handle('StartFindMentions', array($sender, $text, &$mentions))) {
 689         // Get the context of the original notice, if any
 690         $originalAuthor   = null;
 691         $originalNotice   = null;
 692         $originalMentions = array();
 693
 694         // Is it a reply?
 695
 696         if (!empty($notice) && !empty($notice->reply_to)) {
 697             $originalNotice = Notice::getKV('id', $notice->reply_to);
 698             if (!empty($originalNotice)) {
 699                 $originalAuthor = Profile::getKV('id', $originalNotice->profile_id);
 700
 701                 $ids = $originalNotice->getReplies();
 702
 703                 foreach ($ids as $id) {
 704                     $repliedTo = Profile::getKV('id', $id);
 705                     if (!empty($repliedTo)) {
 706                         $originalMentions[$repliedTo->nickname] = $repliedTo;
 707                     }
 708                 }
 709             }
 710         }
 711
 712         $matches = common_find_mentions_raw($text);
 713
 714         foreach ($matches as $match) {
 715             try {
 716                 $nickname = Nickname::normalize($match[0]);
 717             } catch (NicknameException $e) {
 718                 // Bogus match? Drop it.
 719                 continue;
 720             }
 721
 722             // Try to get a profile for this nickname.
 723             // Start with conversation context, then go to
 724             // sender context.
 725
 726             if (!empty($originalAuthor) && $originalAuthor->nickname == $nickname) {
 727                 $mentioned = $originalAuthor;
 728             } else if (!empty($originalMentions) &&
 729                        array_key_exists($nickname, $originalMentions)) {
 730                 $mentioned = $originalMentions[$nickname];
 731             } else {
 732                 $mentioned = common_relative_profile($sender, $nickname);
 733             }
 734
 735             if (!empty($mentioned)) {
 736                 $user = User::getKV('id', $mentioned->id);
 737
 738                 if ($user) {
 739                     $url = common_local_url('userbyid', array('id' => $user->id));
 740                 } else {
 741                     $url = $mentioned->profileurl;
 742                 }
 743
 744                 $mention = array('mentioned' => array($mentioned),
 745                                  'text' => $match[0],
 746                                  'position' => $match[1],
 747                                  'url' => $url);
 748
 749                 if (!empty($mentioned->fullname)) {
 750                     $mention['title'] = $mentioned->fullname;
 751                 }
 752
 753                 $mentions[] = $mention;
 754             }
 755         }
 756
 757         // @#tag => mention of all subscriptions tagged 'tag'
 758
 759         preg_match_all('/(?:^|[\s\.\,\:\;]+)@#([\pL\pN_\-\.]{1,64})/',
 760                        $text,
 761                        $hmatches,
 762                        PREG_OFFSET_CAPTURE);
 763
 764         foreach ($hmatches[1] as $hmatch) {
 765
 766             $tag = common_canonical_tag($hmatch[0]);
 767             $plist = Profile_list::getByTaggerAndTag($sender->id, $tag);
 768             if (!empty($plist) && !$plist->private) {
 769                 $tagged = $sender->getTaggedSubscribers($tag);
 770
 771                 $url = common_local_url('showprofiletag',
 772                                         array('tagger' => $sender->nickname,
 773                                               'tag' => $tag));
 774
 775                 $mentions[] = array('mentioned' => $tagged,
 776                                     'text' => $hmatch[0],
 777                                     'position' => $hmatch[1],
 778                                     'url' => $url);
 779             }
 780         }
 781
 782         Event::handle('EndFindMentions', array($sender, $text, &$mentions));
 783     }
 784
 785     return $mentions;
 786 }
 787
 788 /**
 789  * Does the actual regex pulls to find @-mentions in text.
 790  * Should generally not be called directly; for use in common_find_mentions.
 791  *
 792  * @param string $text
 793  * @return array of PCRE match arrays
 794  */
 795 function common_find_mentions_raw($text)
 796 {
 797     $tmatches = array();
 798     preg_match_all('/^T (' . Nickname::DISPLAY_FMT . ') /',
 799                    $text,
 800                    $tmatches,
 801                    PREG_OFFSET_CAPTURE);
 802
 803     $atmatches = array();
 804     preg_match_all('/(?:^|\s+)@(' . Nickname::DISPLAY_FMT . ')\b/',
 805                    $text,
 806                    $atmatches,
 807                    PREG_OFFSET_CAPTURE);
 808
 809     $matches = array_merge($tmatches[1], $atmatches[1]);
 810     return $matches;
 811 }
 812
 813 function common_render_text($text)
 814 {
 815     $r = htmlspecialchars($text);
 816
 817     $r = preg_replace('/[\x{0}-\x{8}\x{b}-\x{c}\x{e}-\x{19}]/', '', $r);
 818     $r = common_replace_urls_callback($r, 'common_linkify');
 819     $r = preg_replace_callback('/(^|\&quot\;|\'|\(|\[|\{|\s+)#([\pL\pN_\-\.]{1,64})/u',
 820                 function ($m) { return "{$m[1]}#".common_tag_link($m[2]); }, $r);
 821     // XXX: machine tags
 822     return $r;
 823 }
 824
 825 /**
 826  * Find links in the given text and pass them to the given callback function.
 827  *
 828  * @param string $text
 829  * @param function($text, $arg) $callback: return replacement text
 830  * @param mixed $arg: optional argument will be passed on to the callback
 831  */
 832 function common_replace_urls_callback($text, $callback, $arg = null) {
 833     // Start off with a regex
 834     $regex = '#'.
 835     '(?:^|[\s\<\>\(\)\[\]\{\}\\\'\\\";]+)(?![\@\!\#])'.
 836     '('.
 837         '(?:'.
 838             '(?:'. //Known protocols
 839                 '(?:'.
 840                     '(?:(?:https?|ftps?|mms|rtsp|gopher|news|nntp|telnet|wais|file|prospero|webcal|irc)://)'.
 841                     '|'.
 842                     '(?:(?:mailto|aim|tel|xmpp):)'.
 843                 ')'.
 844                 '(?:[\pN\pL\-\_\+\%\~]+(?::[\pN\pL\-\_\+\%\~]+)?\@)?'. //user:pass@
 845                 '(?:'.
 846                     '(?:'.
 847                         '\[[\pN\pL\-\_\:\.]+(?<![\.\:])\]'. //[dns]
 848                     ')|(?:'.
 849                         '[\pN\pL\-\_\:\.]+(?<![\.\:])'. //dns
 850                     ')'.
 851                 ')'.
 852             ')'.
 853             '|(?:(?: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
 854             '|(?:'. //IPv6
 855                 '\[?(?:(?:(?:[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})))\]?(?<!:)'.
 856             ')|(?:'. //DNS
 857                 '(?:[\pN\pL\-\_\+\%\~]+(?:\:[\pN\pL\-\_\+\%\~]+)?\@)?'. //user:pass@
 858                 '[\pN\pL\-\_]+(?:\.[\pN\pL\-\_]+)*\.'.
 859                 //tld list from http://data.iana.org/TLD/tlds-alpha-by-domain.txt, also added local, loc, and onion
 860                 '(?: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)'.
 861             ')(?![\pN\pL\-\_])'.
 862         ')'.
 863         '(?:'.
 864             '(?:\:\d+)?'. //:port
 865             '(?:/[\pN\pL$\,\!\(\)\.\:\-\_\+\/\=\&\;\%\~\*\$\+\'@]*)?'. // /path
 866             '(?:\?[\pN\pL\$\,\!\(\)\.\:\-\_\+\/\=\&\;\%\~\*\$\+\'@\/]*)?'. // ?query string
 867             '(?:\#[\pN\pL$\,\!\(\)\.\:\-\_\+\/\=\&\;\%\~\*\$\+\'\@/\?\#]*)?'. // #fragment
 868         ')(?<![\?\.\,\#\,])'.
 869     ')'.
 870     '#ixu';
 871     //preg_match_all($regex,$text,$matches);
 872     //print_r($matches);
 873     return preg_replace_callback($regex, curry('callback_helper',$callback,$arg) ,$text);
 874 }
 875
 876 /**
 877  * Intermediate callback for common_replace_links(), helps resolve some
 878  * ambiguous link forms before passing on to the final callback.
 879  *
 880  * @param array $matches
 881  * @param callable $callback
 882  * @param mixed $arg optional argument to pass on as second param to callback
 883  * @return string
 884  *
 885  * @access private
 886  */
 887 function callback_helper($matches, $callback, $arg=null) {
 888     $url=$matches[1];
 889     $left = strpos($matches[0],$url);
 890     $right = $left+strlen($url);
 891
 892     $groupSymbolSets=array(
 893         array(
 894             'left'=>'(',
 895             'right'=>')'
 896         ),
 897         array(
 898             'left'=>'[',
 899             'right'=>']'
 900         ),
 901         array(
 902             'left'=>'{',
 903             'right'=>'}'
 904         ),
 905         array(
 906             'left'=>'<',
 907             'right'=>'>'
 908         )
 909     );
 910     $cannotEndWith=array('.','?',',','#');
 911     $original_url=$url;
 912     do{
 913         $original_url=$url;
 914         foreach($groupSymbolSets as $groupSymbolSet){
 915             if(substr($url,-1)==$groupSymbolSet['right']){
 916                 $group_left_count = substr_count($url,$groupSymbolSet['left']);
 917                 $group_right_count = substr_count($url,$groupSymbolSet['right']);
 918                 if($group_left_count<$group_right_count){
 919                     $right-=1;
 920                     $url=substr($url,0,-1);
 921                 }
 922             }
 923         }
 924         if(in_array(substr($url,-1),$cannotEndWith)){
 925             $right-=1;
 926             $url=substr($url,0,-1);
 927         }
 928     }while($original_url!=$url);
 929
 930     $result = call_user_func_array($callback, array($url, $arg));
 931     return substr($matches[0],0,$left) . $result . substr($matches[0],$right);
 932 }
 933
 934 if (version_compare(PHP_VERSION, '5.3.0', 'ge')) {
 935     // lambda implementation in a separate file; PHP 5.2 won't parse it.
 936     require_once INSTALLDIR . "/lib/curry.php";
 937 } else {
 938     function curry($fn) {
 939         $args = func_get_args();
 940         array_shift($args);
 941         $id = uniqid('_partial');
 942         $GLOBALS[$id] = array($fn, $args);
 943         return create_function('',
 944                                '$args = func_get_args(); '.
 945                                'return call_user_func_array('.
 946                                '$GLOBALS["'.$id.'"][0],'.
 947                                'array_merge('.
 948                                '$args,'.
 949                                '$GLOBALS["'.$id.'"][1]));');
 950     }
 951 }
 952
 953 function common_linkify($url) {
 954     // It comes in special'd, so we unspecial it before passing to the stringifying
 955     // functions
 956     $url = htmlspecialchars_decode($url);
 957
 958     if (strpos($url, '@') !== false && strpos($url, ':') === false && Validate::email($url)) {
 959         //url is an email address without the mailto: protocol
 960         $canon = "mailto:$url";
 961         $longurl = "mailto:$url";
 962     } else {
 963
 964         $canon = File_redirection::_canonUrl($url);
 965
 966         $longurl_data = File_redirection::where($canon, common_config('attachments', 'process_links'));
 967         if (is_array($longurl_data)) {
 968             $longurl = $longurl_data['url'];
 969         } elseif (is_string($longurl_data)) {
 970             $longurl = $longurl_data;
 971         } else {
 972             // Unable to reach the server to verify contents, etc
 973             // Just pass the link on through for now.
 974             common_log(LOG_ERR, "Can't linkify url '$url'");
 975             $longurl = $url;
 976         }
 977     }
 978
 979     $attrs = array('href' => $canon, 'title' => $longurl);
 980
 981     $is_attachment = false;
 982     $attachment_id = null;
 983     $has_thumb = false;
 984
 985     // Check to see whether this is a known "attachment" URL.
 986
 987     $f = File::getKV('url', $longurl);
 988
 989     if (empty($f)) {
 990         if (common_config('attachments', 'process_links')) {
 991             // XXX: this writes to the database. :<
 992             $f = File::processNew($longurl);
 993         }
 994     }
 995
 996     if (!empty($f)) {
 997         if ($f->getEnclosure()) {
 998             $is_attachment = true;
 999             $attachment_id = $f->id;
1000
1001             $thumb = File_thumbnail::getKV('file_id', $f->id);
1002             if (!empty($thumb)) {
1003                 $has_thumb = true;
1004             }
1005         }
1006     }
1007
1008     // Add clippy
1009     if ($is_attachment) {
1010         $attrs['class'] = 'attachment';
1011         if ($has_thumb) {
1012             $attrs['class'] = 'attachment thumbnail';
1013         }
1014         $attrs['id'] = "attachment-{$attachment_id}";
1015     }
1016
1017     // Whether to nofollow
1018
1019     $nf = common_config('nofollow', 'external');
1020
1021     if ($nf == 'never') {
1022         $attrs['rel'] = 'external';
1023     } else {
1024         $attrs['rel'] = 'nofollow external';
1025     }
1026
1027     return XMLStringer::estring('a', $attrs, $url);
1028 }
1029
1030 /**
1031  * Find and shorten links in a given chunk of text if it's longer than the
1032  * configured notice content limit (or unconditionally).
1033  *
1034  * Side effects: may save file and file_redirection records for referenced URLs.
1035  *
1036  * Pass the $user option or call $user->shortenLinks($text) to ensure the proper
1037  * user's options are used; otherwise the current web session user's setitngs
1038  * will be used or ur1.ca if there is no active web login.
1039  *
1040  * @param string $text
1041  * @param boolean $always (optional)
1042  * @param User $user (optional)
1043  *
1044  * @return string
1045  */
1046 function common_shorten_links($text, $always = false, User $user=null)
1047 {
1048     if ($user === null) {
1049         $user = common_current_user();
1050     }
1051
1052     $maxLength = User_urlshortener_prefs::maxNoticeLength($user);
1053
1054     if ($always || ($maxLength != -1 && mb_strlen($text) > $maxLength)) {
1055         return common_replace_urls_callback($text, array('File_redirection', 'forceShort'), $user);
1056     } else {
1057         return common_replace_urls_callback($text, array('File_redirection', 'makeShort'), $user);
1058     }
1059 }
1060
1061 /**
1062  * Very basic stripping of invalid UTF-8 input text.
1063  *
1064  * @param string $str
1065  * @return mixed string or null if invalid input
1066  *
1067  * @todo ideally we should drop bad chars, and maybe do some of the checks
1068  *       from common_xml_safe_str. But we can't strip newlines, etc.
1069  * @todo Unicode normalization might also be useful, but not needed now.
1070  */
1071 function common_validate_utf8($str)
1072 {
1073     // preg_replace will return NULL on invalid UTF-8 input.
1074     //
1075     // Note: empty regex //u also caused NULL return on some
1076     // production machines, but none of our test machines.
1077     //
1078     // This should be replaced with a more reliable check.
1079     return preg_replace('/\x00/u', '', $str);
1080 }
1081
1082 /**
1083  * Make sure an arbitrary string is safe for output in XML as a single line.
1084  *
1085  * @param string $str
1086  * @return string
1087  */
1088 function common_xml_safe_str($str)
1089 {
1090     // Replace common eol and extra whitespace input chars
1091     $unWelcome = array(
1092         "\t",  // tab
1093         "\n",  // newline
1094         "\r",  // cr
1095         "\0",  // null byte eos
1096         "\x0B" // vertical tab
1097     );
1098
1099     $replacement = array(
1100         ' ', // single space
1101         ' ',
1102         '',  // nothing
1103         '',
1104         ' '
1105     );
1106
1107     $str = str_replace($unWelcome, $replacement, $str);
1108
1109     // Neutralize any additional control codes and UTF-16 surrogates
1110     // (Twitter uses '*')
1111     return preg_replace('/[\p{Cc}\p{Cs}]/u', '*', $str);
1112 }
1113
1114 function common_tag_link($tag)
1115 {
1116     $canonical = common_canonical_tag($tag);
1117     if (common_config('singleuser', 'enabled')) {
1118         // regular TagAction isn't set up in 1user mode
1119         $nickname = User::singleUserNickname();
1120         $url = common_local_url('showstream',
1121                                 array('nickname' => $nickname,
1122                                       'tag' => $canonical));
1123     } else {
1124         $url = common_local_url('tag', array('tag' => $canonical));
1125     }
1126     $xs = new XMLStringer();
1127     $xs->elementStart('span', 'tag');
1128     $xs->element('a', array('href' => $url,
1129                             'rel' => 'tag'),
1130                  $tag);
1131     $xs->elementEnd('span');
1132     return $xs->getString();
1133 }
1134
1135 function common_canonical_tag($tag)
1136 {
1137   // only alphanum
1138   $tag = preg_replace('/[^\pL\pN]/u', '', $tag);
1139   $tag = mb_convert_case($tag, MB_CASE_LOWER, "UTF-8");
1140   $tag = substr($tag, 0, 64);
1141   return $tag;
1142 }
1143
1144 function common_valid_profile_tag($str)
1145 {
1146     return preg_match('/^[A-Za-z0-9_\-\.]{1,64}$/', $str);
1147 }
1148
1149 /**
1150  *
1151  * @param <type> $sender_id
1152  * @param <type> $nickname
1153  * @return <type>
1154  * @access private
1155  */
1156 function common_group_link($sender_id, $nickname)
1157 {
1158     $sender = Profile::getKV($sender_id);
1159     $group = User_group::getForNickname($nickname, $sender);
1160     if ($sender && $group && $sender->isMember($group)) {
1161         $attrs = array('href' => $group->permalink(),
1162                        'class' => 'url');
1163         if (!empty($group->fullname)) {
1164             $attrs['title'] = $group->getFancyName();
1165         }
1166         $xs = new XMLStringer();
1167         $xs->elementStart('span', 'vcard');
1168         $xs->elementStart('a', $attrs);
1169         $xs->element('span', 'fn nickname group', $nickname);
1170         $xs->elementEnd('a');
1171         $xs->elementEnd('span');
1172         return $xs->getString();
1173     } else {
1174         return $nickname;
1175     }
1176 }
1177
1178 /**
1179  * Resolve an ambiguous profile nickname reference, checking in following order:
1180  * - profiles that $sender subscribes to
1181  * - profiles that subscribe to $sender
1182  * - local user profiles
1183  *
1184  * WARNING: does not validate or normalize $nickname -- MUST BE PRE-VALIDATED
1185  * OR THERE MAY BE A RISK OF SQL INJECTION ATTACKS. THIS FUNCTION DOES NOT
1186  * ESCAPE SQL.
1187  *
1188  * @fixme validate input
1189  * @fixme escape SQL
1190  * @fixme fix or remove mystery third parameter
1191  * @fixme is $sender a User or Profile?
1192  *
1193  * @param <type> $sender the user or profile in whose context we're looking
1194  * @param string $nickname validated nickname of
1195  * @param <type> $dt unused mystery parameter; in Notice reply-to handling a timestamp is passed.
1196  *
1197  * @return Profile or null
1198  */
1199 function common_relative_profile($sender, $nickname, $dt=null)
1200 {
1201     // Will throw exception on invalid input.
1202     $nickname = Nickname::normalize($nickname);
1203
1204     // Try to find profiles this profile is subscribed to that have this nickname
1205     $recipient = new Profile();
1206     // XXX: use a join instead of a subquery
1207     $recipient->whereAdd('EXISTS (SELECT subscribed from subscription where subscriber = '.intval($sender->id).' and subscribed = id)', 'AND');
1208     $recipient->whereAdd("nickname = '" . $recipient->escape($nickname) . "'", 'AND');
1209     if ($recipient->find(true)) {
1210         // XXX: should probably differentiate between profiles with
1211         // the same name by date of most recent update
1212         return $recipient;
1213     }
1214     // Try to find profiles that listen to this profile and that have this nickname
1215     $recipient = new Profile();
1216     // XXX: use a join instead of a subquery
1217     $recipient->whereAdd('EXISTS (SELECT subscriber from subscription where subscribed = '.intval($sender->id).' and subscriber = id)', 'AND');
1218     $recipient->whereAdd("nickname = '" . $recipient->escape($nickname) . "'", 'AND');
1219     if ($recipient->find(true)) {
1220         // XXX: should probably differentiate between profiles with
1221         // the same name by date of most recent update
1222         return $recipient;
1223     }
1224     // If this is a local user, try to find a local user with that nickname.
1225     $sender = User::getKV($sender->id);
1226     if ($sender) {
1227         $recipient_user = User::getKV('nickname', $nickname);
1228         if ($recipient_user) {
1229             return $recipient_user->getProfile();
1230         }
1231     }
1232     // Otherwise, no links. @messages from local users to remote users,
1233     // or from remote users to other remote users, are just
1234     // outside our ability to make intelligent guesses about
1235     return null;
1236 }
1237
1238 function common_local_url($action, $args=null, $params=null, $fragment=null, $addSession=true)
1239 {
1240     if (Event::handle('StartLocalURL', array(&$action, &$params, &$fragment, &$addSession, &$url))) {
1241         $r = Router::get();
1242         $path = $r->build($action, $args, $params, $fragment);
1243
1244         $ssl = StatusNet::isHTTPS() || common_is_sensitive($action);
1245
1246         if (common_config('site','fancy')) {
1247             $url = common_path($path, $ssl, $addSession);
1248         } else {
1249             if (mb_strpos($path, '/index.php') === 0) {
1250                 $url = common_path($path, $ssl, $addSession);
1251             } else {
1252                 $url = common_path('index.php/'.$path, $ssl, $addSession);
1253             }
1254         }
1255         Event::handle('EndLocalURL', array(&$action, &$params, &$fragment, &$addSession, &$url));
1256     }
1257     return $url;
1258 }
1259
1260 function common_is_sensitive($action)
1261 {
1262     static $sensitive = array(
1263         'login',
1264         'register',
1265         'passwordsettings',
1266         'api',
1267         'ApiOAuthRequestToken',
1268         'ApiOAuthAccessToken',
1269         'ApiOAuthAuthorize',
1270         'ApiOAuthPin',
1271         'showapplication'
1272     );
1273     $ssl = null;
1274
1275     if (Event::handle('SensitiveAction', array($action, &$ssl))) {
1276         $ssl = in_array($action, $sensitive);
1277     }
1278
1279     return $ssl;
1280 }
1281
1282 function common_path($relative, $ssl=false, $addSession=true)
1283 {
1284     $pathpart = (common_config('site', 'path')) ? common_config('site', 'path')."/" : '';
1285
1286     if (($ssl && (common_config('site', 'ssl') === 'sometimes'))
1287         || common_config('site', 'ssl') === 'always') {
1288         $proto = 'https';
1289         if (is_string(common_config('site', 'sslserver')) &&
1290             mb_strlen(common_config('site', 'sslserver')) > 0) {
1291             $serverpart = common_config('site', 'sslserver');
1292         } else if (common_config('site', 'server')) {
1293             $serverpart = common_config('site', 'server');
1294         } else {
1295             common_log(LOG_ERR, 'Site server not configured, unable to determine site name.');
1296         }
1297     } else {
1298         $proto = 'http';
1299         if (common_config('site', 'server')) {
1300             $serverpart = common_config('site', 'server');
1301         } else {
1302             common_log(LOG_ERR, 'Site server not configured, unable to determine site name.');
1303         }
1304     }
1305
1306     if ($addSession) {
1307         $relative = common_inject_session($relative, $serverpart);
1308     }
1309
1310     return $proto.'://'.$serverpart.'/'.$pathpart.$relative;
1311 }
1312
1313 function common_inject_session($url, $serverpart = null)
1314 {
1315     if (common_have_session()) {
1316
1317         if (empty($serverpart)) {
1318             $serverpart = parse_url($url, PHP_URL_HOST);
1319         }
1320
1321         $currentServer = (array_key_exists('HTTP_HOST', $_SERVER)) ? $_SERVER['HTTP_HOST'] : null;
1322
1323         // Are we pointing to another server (like an SSL server?)
1324
1325         if (!empty($currentServer) &&
1326             0 != strcasecmp($currentServer, $serverpart)) {
1327             // Pass the session ID as a GET parameter
1328             $sesspart = session_name() . '=' . session_id();
1329             $i = strpos($url, '?');
1330             if ($i === false) { // no GET params, just append
1331                 $url .= '?' . $sesspart;
1332             } else {
1333                 $url = substr($url, 0, $i + 1).$sesspart.'&'.substr($url, $i + 1);
1334             }
1335         }
1336     }
1337
1338     return $url;
1339 }
1340
1341 function common_date_string($dt)
1342 {
1343     // XXX: do some sexy date formatting
1344     // return date(DATE_RFC822, $dt);
1345     $t = strtotime($dt);
1346     $now = time();
1347     $diff = $now - $t;
1348
1349     if ($now < $t) { // that shouldn't happen!
1350         return common_exact_date($dt);
1351     } else if ($diff < 60) {
1352         // TRANS: Used in notices to indicate when the notice was made compared to now.
1353         return _('a few seconds ago');
1354     } else if ($diff < 92) {
1355         // TRANS: Used in notices to indicate when the notice was made compared to now.
1356         return _('about a minute ago');
1357     } else if ($diff < 3300) {
1358         $minutes = round($diff/60);
1359         // TRANS: Used in notices to indicate when the notice was made compared to now.
1360         return sprintf( _m('about one minute ago', 'about %d minutes ago', $minutes), $minutes);
1361     } else if ($diff < 5400) {
1362         // TRANS: Used in notices to indicate when the notice was made compared to now.
1363         return _('about an hour ago');
1364     } else if ($diff < 22 * 3600) {
1365         $hours = round($diff/3600);
1366         // TRANS: Used in notices to indicate when the notice was made compared to now.
1367         return sprintf( _m('about one hour ago', 'about %d hours ago', $hours), $hours);
1368     } else if ($diff < 37 * 3600) {
1369         // TRANS: Used in notices to indicate when the notice was made compared to now.
1370         return _('about a day ago');
1371     } else if ($diff < 24 * 24 * 3600) {
1372         $days = round($diff/(24*3600));
1373         // TRANS: Used in notices to indicate when the notice was made compared to now.
1374         return sprintf( _m('about one day ago', 'about %d days ago', $days), $days);
1375     } else if ($diff < 46 * 24 * 3600) {
1376         // TRANS: Used in notices to indicate when the notice was made compared to now.
1377         return _('about a month ago');
1378     } else if ($diff < 330 * 24 * 3600) {
1379         $months = round($diff/(30*24*3600));
1380         // TRANS: Used in notices to indicate when the notice was made compared to now.
1381         return sprintf( _m('about one month ago', 'about %d months ago',$months), $months);
1382     } else if ($diff < 480 * 24 * 3600) {
1383         // TRANS: Used in notices to indicate when the notice was made compared to now.
1384         return _('about a year ago');
1385     } else {
1386         return common_exact_date($dt);
1387     }
1388 }
1389
1390 function common_exact_date($dt)
1391 {
1392     static $_utc;
1393     static $_siteTz;
1394
1395     if (!$_utc) {
1396         $_utc = new DateTimeZone('UTC');
1397         $_siteTz = new DateTimeZone(common_timezone());
1398     }
1399
1400     $dateStr = date('d F Y H:i:s', strtotime($dt));
1401     $d = new DateTime($dateStr, $_utc);
1402     $d->setTimezone($_siteTz);
1403     return $d->format(DATE_RFC850);
1404 }
1405
1406 function common_date_w3dtf($dt)
1407 {
1408     $dateStr = date('d F Y H:i:s', strtotime($dt));
1409     $d = new DateTime($dateStr, new DateTimeZone('UTC'));
1410     $d->setTimezone(new DateTimeZone(common_timezone()));
1411     return $d->format(DATE_W3C);
1412 }
1413
1414 function common_date_rfc2822($dt)
1415 {
1416     $dateStr = date('d F Y H:i:s', strtotime($dt));
1417     $d = new DateTime($dateStr, new DateTimeZone('UTC'));
1418     $d->setTimezone(new DateTimeZone(common_timezone()));
1419     return $d->format('r');
1420 }
1421
1422 function common_date_iso8601($dt)
1423 {
1424     $dateStr = date('d F Y H:i:s', strtotime($dt));
1425     $d = new DateTime($dateStr, new DateTimeZone('UTC'));
1426     $d->setTimezone(new DateTimeZone(common_timezone()));
1427     return $d->format('c');
1428 }
1429
1430 function common_sql_now()
1431 {
1432     return common_sql_date(time());
1433 }
1434
1435 function common_sql_date($datetime)
1436 {
1437     return strftime('%Y-%m-%d %H:%M:%S', $datetime);
1438 }
1439
1440 /**
1441  * Return an SQL fragment to calculate an age-based weight from a given
1442  * timestamp or datetime column.
1443  *
1444  * @param string $column name of field we're comparing against current time
1445  * @param integer $dropoff divisor for age in seconds before exponentiation
1446  * @return string SQL fragment
1447  */
1448 function common_sql_weight($column, $dropoff)
1449 {
1450     if (common_config('db', 'type') == 'pgsql') {
1451         // PostgreSQL doesn't support timestampdiff function.
1452         // @fixme will this use the right time zone?
1453         // @fixme does this handle cross-year subtraction correctly?
1454         return "sum(exp(-extract(epoch from (now() - $column)) / $dropoff))";
1455     } else {
1456         return "sum(exp(timestampdiff(second, utc_timestamp(), $column) / $dropoff))";
1457     }
1458 }
1459
1460 function common_redirect($url, $code=307)
1461 {
1462     static $status = array(301 => "Moved Permanently",
1463                            302 => "Found",
1464                            303 => "See Other",
1465                            307 => "Temporary Redirect");
1466
1467     header('HTTP/1.1 '.$code.' '.$status[$code]);
1468     header("Location: $url");
1469     header("Connection: close");
1470
1471     $xo = new XMLOutputter();
1472     $xo->startXML('a',
1473                   '-//W3C//DTD XHTML 1.0 Strict//EN',
1474                   'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd');
1475     $xo->element('a', array('href' => $url), $url);
1476     $xo->endXML();
1477     exit;
1478 }
1479
1480 // Stick the notice on the queue
1481
1482 function common_enqueue_notice($notice)
1483 {
1484     static $localTransports = array('ping');
1485
1486     $transports = array();
1487     if (common_config('sms', 'enabled')) {
1488         $transports[] = 'sms';
1489     }
1490     if (Event::hasHandler('HandleQueuedNotice')) {
1491         $transports[] = 'plugin';
1492     }
1493
1494     // We can skip these for gatewayed notices.
1495     if ($notice->isLocal()) {
1496         $transports = array_merge($transports, $localTransports);
1497     }
1498
1499     if (Event::handle('StartEnqueueNotice', array($notice, &$transports))) {
1500
1501         $qm = QueueManager::get();
1502
1503         foreach ($transports as $transport)
1504         {
1505             $qm->enqueue($notice, $transport);
1506         }
1507
1508         Event::handle('EndEnqueueNotice', array($notice, $transports));
1509     }
1510
1511     return true;
1512 }
1513
1514 /**
1515  * Legacy function to broadcast profile updates to OMB remote subscribers.
1516  *
1517  * XXX: This probably needs killing, but there are several bits of code
1518  *      that broadcast profile changes that need to be dealt with. AFAIK
1519  *      this function is only used for OMB. -z
1520  *
1521  * Since this may be slow with a lot of subscribers or bad remote sites,
1522  * this is run through the background queues if possible.
1523  */
1524 function common_broadcast_profile(Profile $profile)
1525 {
1526     Event::handle('BroadcastProfile', array($profile));
1527 }
1528
1529 function common_profile_url($nickname)
1530 {
1531     return common_local_url('showstream', array('nickname' => $nickname),
1532                             null, null, false);
1533 }
1534
1535 /**
1536  * Should make up a reasonable root URL
1537  */
1538 function common_root_url($ssl=false)
1539 {
1540     $url = common_path('', $ssl, false);
1541     $i = strpos($url, '?');
1542     if ($i !== false) {
1543         $url = substr($url, 0, $i);
1544     }
1545     return $url;
1546 }
1547
1548 /**
1549  * returns $bytes bytes of random data as a hexadecimal string
1550  * "good" here is a goal and not a guarantee
1551  */
1552 function common_good_rand($bytes)
1553 {
1554     // XXX: use random.org...?
1555     if (@file_exists('/dev/urandom')) {
1556         return common_urandom($bytes);
1557     } else { // FIXME: this is probably not good enough
1558         return common_mtrand($bytes);
1559     }
1560 }
1561
1562 function common_urandom($bytes)
1563 {
1564     $h = fopen('/dev/urandom', 'rb');
1565     // should not block
1566     $src = fread($h, $bytes);
1567     fclose($h);
1568     $enc = '';
1569     for ($i = 0; $i < $bytes; $i++) {
1570         $enc .= sprintf("%02x", (ord($src[$i])));
1571     }
1572     return $enc;
1573 }
1574
1575 function common_mtrand($bytes)
1576 {
1577     $enc = '';
1578     for ($i = 0; $i < $bytes; $i++) {
1579         $enc .= sprintf("%02x", mt_rand(0, 255));
1580     }
1581     return $enc;
1582 }
1583
1584 /**
1585  * Record the given URL as the return destination for a future
1586  * form submission, to be read by common_get_returnto().
1587  *
1588  * @param string $url
1589  *
1590  * @fixme as a session-global setting, this can allow multiple forms
1591  * to conflict and overwrite each others' returnto destinations if
1592  * the user has multiple tabs or windows open.
1593  *
1594  * Should refactor to index with a token or otherwise only pass the
1595  * data along its intended path.
1596  */
1597 function common_set_returnto($url)
1598 {
1599     common_ensure_session();
1600     $_SESSION['returnto'] = $url;
1601 }
1602
1603 /**
1604  * Fetch a return-destination URL previously recorded by
1605  * common_set_returnto().
1606  *
1607  * @return mixed URL string or null
1608  *
1609  * @fixme as a session-global setting, this can allow multiple forms
1610  * to conflict and overwrite each others' returnto destinations if
1611  * the user has multiple tabs or windows open.
1612  *
1613  * Should refactor to index with a token or otherwise only pass the
1614  * data along its intended path.
1615  */
1616 function common_get_returnto()
1617 {
1618     common_ensure_session();
1619     return (array_key_exists('returnto', $_SESSION)) ? $_SESSION['returnto'] : null;
1620 }
1621
1622 function common_timestamp()
1623 {
1624     return date('YmdHis');
1625 }
1626
1627 function common_ensure_syslog()
1628 {
1629     static $initialized = false;
1630     if (!$initialized) {
1631         openlog(common_config('syslog', 'appname'), 0,
1632             common_config('syslog', 'facility'));
1633         $initialized = true;
1634     }
1635 }
1636
1637 function common_log_line($priority, $msg)
1638 {
1639     static $syslog_priorities = array('LOG_EMERG', 'LOG_ALERT', 'LOG_CRIT', 'LOG_ERR',
1640                                       'LOG_WARNING', 'LOG_NOTICE', 'LOG_INFO', 'LOG_DEBUG');
1641     return date('Y-m-d H:i:s') . ' ' . $syslog_priorities[$priority] . ': ' . $msg . PHP_EOL;
1642 }
1643
1644 function common_request_id()
1645 {
1646     $pid = getmypid();
1647     $server = common_config('site', 'server');
1648     if (php_sapi_name() == 'cli') {
1649         $script = basename($_SERVER['PHP_SELF']);
1650         return "$server:$script:$pid";
1651     } else {
1652         static $req_id = null;
1653         if (!isset($req_id)) {
1654             $req_id = substr(md5(mt_rand()), 0, 8);
1655         }
1656         if (isset($_SERVER['REQUEST_URI'])) {
1657             $url = $_SERVER['REQUEST_URI'];
1658         }
1659         $method = $_SERVER['REQUEST_METHOD'];
1660         return "$server:$pid.$req_id $method $url";
1661     }
1662 }
1663
1664 function common_log($priority, $msg, $filename=null)
1665 {
1666     if(Event::handle('StartLog', array(&$priority, &$msg, &$filename))){
1667         $msg = (empty($filename)) ? $msg : basename($filename) . ' - ' . $msg;
1668         $msg = '[' . common_request_id() . '] ' . $msg;
1669         $logfile = common_config('site', 'logfile');
1670         if ($logfile) {
1671             $log = fopen($logfile, "a");
1672             if ($log) {
1673                 $output = common_log_line($priority, $msg);
1674                 fwrite($log, $output);
1675                 fclose($log);
1676             }
1677         } else {
1678             common_ensure_syslog();
1679             syslog($priority, $msg);
1680         }
1681         Event::handle('EndLog', array($priority, $msg, $filename));
1682     }
1683 }
1684
1685 function common_debug($msg, $filename=null)
1686 {
1687     if ($filename) {
1688         common_log(LOG_DEBUG, basename($filename).' - '.$msg);
1689     } else {
1690         common_log(LOG_DEBUG, $msg);
1691     }
1692 }
1693
1694 function common_log_db_error(&$object, $verb, $filename=null)
1695 {
1696     $objstr = common_log_objstring($object);
1697     $last_error = &PEAR::getStaticProperty('DB_DataObject','lastError');
1698     if (is_object($last_error)) {
1699         $msg = $last_error->message;
1700     } else {
1701         $msg = 'Unknown error (' . var_export($last_error, true) . ')';
1702     }
1703     common_log(LOG_ERR, $msg . '(' . $verb . ' on ' . $objstr . ')', $filename);
1704 }
1705
1706 function common_log_objstring(&$object)
1707 {
1708     if (is_null($object)) {
1709         return "null";
1710     }
1711     if (!($object instanceof DB_DataObject)) {
1712         return "(unknown)";
1713     }
1714     $arr = $object->toArray();
1715     $fields = array();
1716     foreach ($arr as $k => $v) {
1717         if (is_object($v)) {
1718             $fields[] = "$k='".get_class($v)."'";
1719         } else {
1720             $fields[] = "$k='$v'";
1721         }
1722     }
1723     $objstring = $object->tableName() . '[' . implode(',', $fields) . ']';
1724     return $objstring;
1725 }
1726
1727 function common_valid_http_url($url, $secure=false)
1728 {
1729     // If $secure is true, only allow https URLs to pass
1730     // (if false, we use '?' in 'https?' to say the 's' is optional)
1731     $regex = $secure ? '/^https$/' : '/^https?$/';
1732     return filter_var($url, FILTER_VALIDATE_URL)
1733             && preg_match($regex, parse_url($url, PHP_URL_SCHEME));
1734 }
1735
1736 function common_valid_tag($tag)
1737 {
1738     if (preg_match('/^tag:(.*?),(\d{4}(-\d{2}(-\d{2})?)?):(.*)$/', $tag, $matches)) {
1739         return (Validate::email($matches[1]) ||
1740                 preg_match('/^([\w-\.]+)$/', $matches[1]));
1741     }
1742     return false;
1743 }
1744
1745 /**
1746  * Determine if given domain or address literal is valid
1747  * eg for use in JIDs and URLs. Does not check if the domain
1748  * exists!
1749  *
1750  * @param string $domain
1751  * @return boolean valid or not
1752  */
1753 function common_valid_domain($domain)
1754 {
1755     $octet = "(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])";
1756     $ipv4 = "(?:$octet(?:\.$octet){3})";
1757     if (preg_match("/^$ipv4$/u", $domain)) return true;
1758
1759     $group = "(?:[0-9a-f]{1,4})";
1760     $ipv6 = "(?:\[($group(?::$group){0,7})?(::)?($group(?::$group){0,7})?\])"; // http://tools.ietf.org/html/rfc3513#section-2.2
1761
1762     if (preg_match("/^$ipv6$/ui", $domain, $matches)) {
1763         $before = explode(":", $matches[1]);
1764         $zeroes = $matches[2];
1765         $after = explode(":", $matches[3]);
1766         if ($zeroes) {
1767             $min = 0;
1768             $max = 7;
1769         } else {
1770             $min = 1;
1771             $max = 8;
1772         }
1773         $explicit = count($before) + count($after);
1774         if ($explicit < $min || $explicit > $max) {
1775             return false;
1776         }
1777         return true;
1778     }
1779
1780     try {
1781         require_once "Net/IDNA.php";
1782         $idn = Net_IDNA::getInstance();
1783         $domain = $idn->encode($domain);
1784     } catch (Exception $e) {
1785         return false;
1786     }
1787
1788     $subdomain = "(?:[a-z0-9][a-z0-9-]*)"; // @fixme
1789     $fqdn = "(?:$subdomain(?:\.$subdomain)*\.?)";
1790
1791     return preg_match("/^$fqdn$/ui", $domain);
1792 }
1793
1794 /* Following functions are copied from MediaWiki GlobalFunctions.php
1795  * and written by Evan Prodromou. */
1796
1797 function common_accept_to_prefs($accept, $def = '*/*')
1798 {
1799     // No arg means accept anything (per HTTP spec)
1800     if(!$accept) {
1801         return array($def => 1);
1802     }
1803
1804     $prefs = array();
1805
1806     $parts = explode(',', $accept);
1807
1808     foreach($parts as $part) {
1809         // FIXME: doesn't deal with params like 'text/html; level=1'
1810         @list($value, $qpart) = explode(';', trim($part));
1811         $match = array();
1812         if(!isset($qpart)) {
1813             $prefs[$value] = 1;
1814         } elseif(preg_match('/q\s*=\s*(\d*\.\d+)/', $qpart, $match)) {
1815             $prefs[$value] = $match[1];
1816         }
1817     }
1818
1819     return $prefs;
1820 }
1821
1822 function common_mime_type_match($type, $avail)
1823 {
1824     if(array_key_exists($type, $avail)) {
1825         return $type;
1826     } else {
1827         $parts = explode('/', $type);
1828         if(array_key_exists($parts[0] . '/*', $avail)) {
1829             return $parts[0] . '/*';
1830         } elseif(array_key_exists('*/*', $avail)) {
1831             return '*/*';
1832         } else {
1833             return null;
1834         }
1835     }
1836 }
1837
1838 function common_negotiate_type($cprefs, $sprefs)
1839 {
1840     $combine = array();
1841
1842     foreach(array_keys($sprefs) as $type) {
1843         $parts = explode('/', $type);
1844         if($parts[1] != '*') {
1845             $ckey = common_mime_type_match($type, $cprefs);
1846             if($ckey) {
1847                 $combine[$type] = $sprefs[$type] * $cprefs[$ckey];
1848             }
1849         }
1850     }
1851
1852     foreach(array_keys($cprefs) as $type) {
1853         $parts = explode('/', $type);
1854         if($parts[1] != '*' && !array_key_exists($type, $sprefs)) {
1855             $skey = common_mime_type_match($type, $sprefs);
1856             if($skey) {
1857                 $combine[$type] = $sprefs[$skey] * $cprefs[$type];
1858             }
1859         }
1860     }
1861
1862     $bestq = 0;
1863     $besttype = 'text/html';
1864
1865     foreach(array_keys($combine) as $type) {
1866         if($combine[$type] > $bestq) {
1867             $besttype = $type;
1868             $bestq = $combine[$type];
1869         }
1870     }
1871
1872     if ('text/html' === $besttype) {
1873         return "text/html; charset=utf-8";
1874     }
1875     return $besttype;
1876 }
1877
1878 function common_config($main, $sub)
1879 {
1880     global $config;
1881     return (array_key_exists($main, $config) &&
1882             array_key_exists($sub, $config[$main])) ? $config[$main][$sub] : false;
1883 }
1884
1885 function common_config_set($main, $sub, $value)
1886 {
1887     global $config;
1888     if (!array_key_exists($main, $config)) {
1889         $config[$main] = array();
1890     }
1891     $config[$main][$sub] = $value;
1892 }
1893
1894 function common_config_append($main, $sub, $value)
1895 {
1896     global $config;
1897     if (!array_key_exists($main, $config)) {
1898         $config[$main] = array();
1899     }
1900     if (!array_key_exists($sub, $config[$main])) {
1901         $config[$main][$sub] = array();
1902     }
1903     if (!is_array($config[$main][$sub])) {
1904         $config[$main][$sub] = array($config[$main][$sub]);
1905     }
1906     array_push($config[$main][$sub], $value);
1907 }
1908
1909 /**
1910  * Pull arguments from a GET/POST/REQUEST array with first-level input checks:
1911  * strips "magic quotes" slashes if necessary, and kills invalid UTF-8 strings.
1912  *
1913  * @param array $from
1914  * @return array
1915  */
1916 function common_copy_args($from)
1917 {
1918     $to = array();
1919     $strip = get_magic_quotes_gpc();
1920     foreach ($from as $k => $v) {
1921         if(is_array($v)) {
1922             $to[$k] = common_copy_args($v);
1923         } else {
1924             if ($strip) {
1925                 $v = stripslashes($v);
1926             }
1927             $to[$k] = strval(common_validate_utf8($v));
1928         }
1929     }
1930     return $to;
1931 }
1932
1933 /**
1934  * Neutralise the evil effects of magic_quotes_gpc in the current request.
1935  * This is used before handing a request off to OAuthRequest::from_request.
1936  * @fixme Doesn't consider vars other than _POST and _GET?
1937  * @fixme Can't be undone and could corrupt data if run twice.
1938  */
1939 function common_remove_magic_from_request()
1940 {
1941     if(get_magic_quotes_gpc()) {
1942         $_POST=array_map('stripslashes',$_POST);
1943         $_GET=array_map('stripslashes',$_GET);
1944     }
1945 }
1946
1947 function common_user_uri(&$user)
1948 {
1949     return common_local_url('userbyid', array('id' => $user->id),
1950                             null, null, false);
1951 }
1952
1953 function common_notice_uri(&$notice)
1954 {
1955     return common_local_url('shownotice',
1956                             array('notice' => $notice->id),
1957                             null, null, false);
1958 }
1959
1960 // 36 alphanums - lookalikes (0, O, 1, I) = 32 chars = 5 bits
1961
1962 function common_confirmation_code($bits)
1963 {
1964     // 36 alphanums - lookalikes (0, O, 1, I) = 32 chars = 5 bits
1965     static $codechars = '23456789ABCDEFGHJKLMNPQRSTUVWXYZ';
1966     $chars = ceil($bits/5);
1967     $code = '';
1968     for ($i = 0; $i < $chars; $i++) {
1969         // XXX: convert to string and back
1970         $num = hexdec(common_good_rand(1));
1971         // XXX: randomness is too precious to throw away almost
1972         // 40% of the bits we get!
1973         $code .= $codechars[$num%32];
1974     }
1975     return $code;
1976 }
1977
1978 // convert markup to HTML
1979
1980 function common_markup_to_html($c, $args=null)
1981 {
1982     if (is_null($args)) {
1983         $args = array();
1984     }
1985
1986     // XXX: not very efficient
1987
1988     foreach ($args as $name => $value) {
1989         $c = preg_replace('/%%arg.'.$name.'%%/', $value, $c);
1990     }
1991
1992     $c = preg_replace_callback('/%%user.(\w+)%%/', function ($m) { return common_user_property($m[1]); }, $c);
1993     $c = preg_replace_callback('/%%action.(\w+)%%/', function ($m) { return common_local_url($m[1]); }, $c);
1994     $c = preg_replace_callback('/%%doc.(\w+)%%/', function ($m) { return common_local_url('doc', array('title'=>$m[1])); }, $c);
1995     $c = preg_replace_callback('/%%(\w+).(\w+)%%/', function ($m) { return common_config($m[1], $m[2]); }, $c);
1996     return Markdown($c);
1997 }
1998
1999 function common_user_property($property)
2000 {
2001     $profile = Profile::current();
2002
2003     if (empty($profile)) {
2004         return null;
2005     }
2006
2007     switch ($property) {
2008     case 'profileurl':
2009     case 'nickname':
2010     case 'fullname':
2011     case 'location':
2012     case 'bio':
2013         return $profile->$property;
2014         break;
2015     case 'avatar':
2016         try {
2017             return $profile->getAvatar(AVATAR_STREAM_SIZE);
2018         } catch (Exception $e) {
2019             return null;
2020         }
2021         break;
2022     case 'bestname':
2023         return $profile->getBestName();
2024         break;
2025     default:
2026         return null;
2027     }
2028 }
2029
2030 function common_profile_uri($profile)
2031 {
2032     $uri = null;
2033
2034     if (!empty($profile)) {
2035         if (Event::handle('StartCommonProfileURI', array($profile, &$uri))) {
2036             $user = User::getKV($profile->id);
2037             if (!empty($user)) {
2038                 $uri = $user->uri;
2039             }
2040             Event::handle('EndCommonProfileURI', array($profile, &$uri));
2041         }
2042     }
2043
2044     // XXX: this is a very bad profile!
2045     return $uri;
2046 }
2047
2048 function common_canonical_sms($sms)
2049 {
2050     // strip non-digits
2051     preg_replace('/\D/', '', $sms);
2052     return $sms;
2053 }
2054
2055 function common_error_handler($errno, $errstr, $errfile, $errline, $errcontext)
2056 {
2057     switch ($errno) {
2058
2059      case E_ERROR:
2060      case E_COMPILE_ERROR:
2061      case E_CORE_ERROR:
2062      case E_USER_ERROR:
2063      case E_PARSE:
2064      case E_RECOVERABLE_ERROR:
2065         common_log(LOG_ERR, "[$errno] $errstr ($errfile:$errline) [ABORT]");
2066         die();
2067         break;
2068
2069      case E_WARNING:
2070      case E_COMPILE_WARNING:
2071      case E_CORE_WARNING:
2072      case E_USER_WARNING:
2073         common_log(LOG_WARNING, "[$errno] $errstr ($errfile:$errline)");
2074         break;
2075
2076      case E_NOTICE:
2077      case E_USER_NOTICE:
2078         common_log(LOG_NOTICE, "[$errno] $errstr ($errfile:$errline)");
2079         break;
2080
2081      case E_STRICT:
2082      case E_DEPRECATED:
2083      case E_USER_DEPRECATED:
2084         // XXX: config variable to log this stuff, too
2085         break;
2086
2087      default:
2088         common_log(LOG_ERR, "[$errno] $errstr ($errfile:$errline) [UNKNOWN LEVEL, die()'ing]");
2089         die();
2090         break;
2091     }
2092
2093     // FIXME: show error page if we're on the Web
2094     /* Don't execute PHP internal error handler */
2095     return true;
2096 }
2097
2098 function common_session_token()
2099 {
2100     common_ensure_session();
2101     if (!array_key_exists('token', $_SESSION)) {
2102         $_SESSION['token'] = common_good_rand(64);
2103     }
2104     return $_SESSION['token'];
2105 }
2106
2107 function common_license_terms($uri)
2108 {
2109     if(preg_match('/creativecommons.org\/licenses\/([^\/]+)/', $uri, $matches)) {
2110         return explode('-',$matches[1]);
2111     }
2112     return array($uri);
2113 }
2114
2115 function common_compatible_license($from, $to)
2116 {
2117     $from_terms = common_license_terms($from);
2118     // public domain and cc-by are compatible with everything
2119     if(count($from_terms) == 1 && ($from_terms[0] == 'publicdomain' || $from_terms[0] == 'by')) {
2120         return true;
2121     }
2122     $to_terms = common_license_terms($to);
2123     // sa is compatible across versions. IANAL
2124     if(in_array('sa',$from_terms) || in_array('sa',$to_terms)) {
2125         return count(array_diff($from_terms, $to_terms)) == 0;
2126     }
2127     // XXX: better compatibility check needed here!
2128     // Should at least normalise URIs
2129     return ($from == $to);
2130 }
2131
2132 /**
2133  * returns a quoted table name, if required according to config
2134  */
2135 function common_database_tablename($tablename)
2136 {
2137   if(common_config('db','quote_identifiers')) {
2138       $tablename = '"'. $tablename .'"';
2139   }
2140   //table prefixes could be added here later
2141   return $tablename;
2142 }
2143
2144 /**
2145  * Shorten a URL with the current user's configured shortening service,
2146  * or ur1.ca if configured, or not at all if no shortening is set up.
2147  *
2148  * @param string  $long_url original URL
2149  * @param User $user to specify a particular user's options
2150  * @param boolean $force    Force shortening (used when notice is too long)
2151  * @return string may return the original URL if shortening failed
2152  *
2153  * @fixme provide a way to specify a particular shortener
2154  */
2155 function common_shorten_url($long_url, User $user=null, $force = false)
2156 {
2157     $long_url = trim($long_url);
2158
2159     $user = common_current_user();
2160
2161     $maxUrlLength = User_urlshortener_prefs::maxUrlLength($user);
2162
2163     // $force forces shortening even if it's not strictly needed
2164     // I doubt URL shortening is ever 'strictly' needed. - ESP
2165
2166     if (($maxUrlLength == -1 || mb_strlen($long_url) < $maxUrlLength) && !$force) {
2167         return $long_url;
2168     }
2169
2170     $shortenerName = User_urlshortener_prefs::urlShorteningService($user);
2171
2172     if (Event::handle('StartShortenUrl',
2173                       array($long_url, $shortenerName, &$shortenedUrl))) {
2174         if ($shortenerName == 'internal') {
2175             $f = File::processNew($long_url);
2176             if (empty($f)) {
2177                 return $long_url;
2178             } else {
2179                 $shortenedUrl = common_local_url('redirecturl',
2180                                                  array('id' => $f->id));
2181                 if ((mb_strlen($shortenedUrl) < mb_strlen($long_url)) || $force) {
2182                     return $shortenedUrl;
2183                 } else {
2184                     return $long_url;
2185                 }
2186             }
2187         } else {
2188             return $long_url;
2189         }
2190     } else {
2191         //URL was shortened, so return the result
2192         return trim($shortenedUrl);
2193     }
2194 }
2195
2196 /**
2197  * @return mixed array($proxy, $ip) for web requests; proxy may be null
2198  *               null if not a web request
2199  *
2200  * @fixme X-Forwarded-For can be chained by multiple proxies;
2201           we should parse the list and provide a cleaner array
2202  * @fixme X-Forwarded-For can be forged by clients; only use them if trusted
2203  * @fixme X_Forwarded_For headers will override X-Forwarded-For read through $_SERVER;
2204  *        use function to get exact request headers from Apache if possible.
2205  */
2206 function common_client_ip()
2207 {
2208     if (!isset($_SERVER) || !array_key_exists('REQUEST_METHOD', $_SERVER)) {
2209         return null;
2210     }
2211
2212     if (array_key_exists('HTTP_X_FORWARDED_FOR', $_SERVER)) {
2213         if (array_key_exists('HTTP_CLIENT_IP', $_SERVER)) {
2214             $proxy = $_SERVER['HTTP_CLIENT_IP'];
2215         } else {
2216             $proxy = $_SERVER['REMOTE_ADDR'];
2217         }
2218         $ip = $_SERVER['HTTP_X_FORWARDED_FOR'];
2219     } else {
2220         $proxy = null;
2221         if (array_key_exists('HTTP_CLIENT_IP', $_SERVER)) {
2222             $ip = $_SERVER['HTTP_CLIENT_IP'];
2223         } else {
2224             $ip = $_SERVER['REMOTE_ADDR'];
2225         }
2226     }
2227
2228     return array($proxy, $ip);
2229 }
2230
2231 function common_url_to_nickname($url)
2232 {
2233     static $bad = array('query', 'user', 'password', 'port', 'fragment');
2234
2235     $parts = parse_url($url);
2236
2237     // If any of these parts exist, this won't work
2238
2239     foreach ($bad as $badpart) {
2240         if (array_key_exists($badpart, $parts)) {
2241             return null;
2242         }
2243     }
2244
2245     // We just have host and/or path
2246
2247     // If it's just a host...
2248     if (array_key_exists('host', $parts) &&
2249         (!array_key_exists('path', $parts) || strcmp($parts['path'], '/') == 0))
2250     {
2251         $hostparts = explode('.', $parts['host']);
2252
2253         // Try to catch common idiom of nickname.service.tld
2254
2255         if ((count($hostparts) > 2) &&
2256             (strlen($hostparts[count($hostparts) - 2]) > 3) && # try to skip .co.uk, .com.au
2257             (strcmp($hostparts[0], 'www') != 0))
2258         {
2259             return common_nicknamize($hostparts[0]);
2260         } else {
2261             // Do the whole hostname
2262             return common_nicknamize($parts['host']);
2263         }
2264     } else {
2265         if (array_key_exists('path', $parts)) {
2266             // Strip starting, ending slashes
2267             $path = preg_replace('@/$@', '', $parts['path']);
2268             $path = preg_replace('@^/@', '', $path);
2269             $path = basename($path);
2270
2271             // Hack for MediaWiki user pages, in the form:
2272             // http://example.com/wiki/User:Myname
2273             // ('User' may be localized.)
2274             if (strpos($path, ':')) {
2275                 $parts = array_filter(explode(':', $path));
2276                 $path = $parts[count($parts) - 1];
2277             }
2278
2279             if ($path) {
2280                 return common_nicknamize($path);
2281             }
2282         }
2283     }
2284
2285     return null;
2286 }
2287
2288 function common_nicknamize($str)
2289 {
2290     try {
2291         return Nickname::normalize($str);
2292     } catch (NicknameException $e) {
2293         return null;
2294     }
2295 }
2296
2297 function common_perf_counter($key, $val=null)
2298 {
2299     global $_perfCounters;
2300     if (isset($_perfCounters)) {
2301         if (common_config('site', 'logperf')) {
2302             if (array_key_exists($key, $_perfCounters)) {
2303                 $_perfCounters[$key][] = $val;
2304             } else {
2305                 $_perfCounters[$key] = array($val);
2306             }
2307             if (common_config('site', 'logperf_detail')) {
2308                 common_log(LOG_DEBUG, "PERF COUNTER HIT: $key $val");
2309             }
2310         }
2311     }
2312 }
2313
2314 function common_log_perf_counters()
2315 {
2316     if (common_config('site', 'logperf')) {
2317         global $_startTime, $_perfCounters;
2318
2319         if (isset($_startTime)) {
2320             $endTime = microtime(true);
2321             $diff = round(($endTime - $_startTime) * 1000);
2322             common_log(LOG_DEBUG, "PERF runtime: ${diff}ms");
2323         }
2324         $counters = $_perfCounters;
2325         ksort($counters);
2326         foreach ($counters as $key => $values) {
2327             $count = count($values);
2328             $unique = count(array_unique($values));
2329             common_log(LOG_DEBUG, "PERF COUNTER: $key $count ($unique unique)");
2330         }
2331     }
2332 }
2333
2334 function common_is_email($str)
2335 {
2336     return (strpos($str, '@') !== false);
2337 }
2338
2339 function common_init_stats()
2340 {
2341     global $_mem, $_ts;
2342
2343     $_mem = memory_get_usage(true);
2344     $_ts  = microtime(true);
2345 }
2346
2347 function common_log_delta($comment=null)
2348 {
2349     global $_mem, $_ts;
2350
2351     $mold = $_mem;
2352     $told = $_ts;
2353
2354     $_mem = memory_get_usage(true);
2355     $_ts  = microtime(true);
2356
2357     $mtotal = $_mem - $mold;
2358     $ttotal = $_ts - $told;
2359
2360     if (empty($comment)) {
2361         $comment = 'Delta';
2362     }
2363
2364     common_debug(sprintf("%s: %d %d", $comment, $mtotal, round($ttotal * 1000000)));
2365 }