lib/WikiUser.php

   1 <?php //-*-php-*-
   2 rcs_id('$Id: WikiUser.php,v 1.57 2004-06-04 12:40:21 rurban Exp $');
   3
   4 // It is anticipated that when userid support is added to phpwiki,
   5 // this object will hold much more information (e-mail,
   6 // home(wiki)page, etc.) about the user.
   7
   8 // There seems to be no clean way to "log out" a user when using HTTP
   9 // authentication. So we'll hack around this by storing the currently
  10 // logged in username and other state information in a cookie.
  11
  12 // 2002-09-08 11:44:04 rurban
  13 // Todo: Fix prefs cookie/session handling:
  14 //       _userid and _homepage cookie/session vars still hold the
  15 //       serialized string.
  16 //       If no homepage, fallback to prefs in cookie as in 1.3.3.
  17
  18 define('WIKIAUTH_FORBIDDEN', -1); // Completely not allowed.
  19 define('WIKIAUTH_ANON', 0);
  20 define('WIKIAUTH_BOGO', 1);     // any valid WikiWord is enough
  21 define('WIKIAUTH_USER', 2);     // real auth from a database/file/server.
  22
  23 define('WIKIAUTH_ADMIN', 10);  // Wiki Admin
  24 define('WIKIAUTH_UNOBTAINABLE', 100);  // Permissions that no user can achieve
  25
  26 if (!defined('COOKIE_EXPIRATION_DAYS')) define('COOKIE_EXPIRATION_DAYS', 365);
  27 if (!defined('COOKIE_DOMAIN'))          define('COOKIE_DOMAIN', '/');
  28
  29 $UserPreferences = array(
  30                          'userid'        => new _UserPreference(''), // really store this also?
  31                          'passwd'        => new _UserPreference(''),
  32                          'email'         => new _UserPreference(''),
  33                          'emailVerified' => new _UserPreference_bool(),
  34                          'notifyPages'   => new _UserPreference(''),
  35                          'theme'         => new _UserPreference_theme(THEME),
  36                          'lang'          => new _UserPreference_language(DEFAULT_LANGUAGE),
  37                          'editWidth'     => new _UserPreference_int(80, 30, 150),
  38                          'noLinkIcons'   => new _UserPreference_bool(),
  39                          'editHeight'    => new _UserPreference_int(22, 5, 80),
  40                          'timeOffset'    => new _UserPreference_numeric(0, -26, 26),
  41                          'relativeDates' => new _UserPreference_bool(),
  42                          'googleLink'    => new _UserPreference_bool(), // 1.3.10
  43                          );
  44
  45 function WikiUserClassname() {
  46     return 'WikiUser';
  47 }
  48
  49 function UpgradeUser ($olduser, $user) {
  50     if (isa($user,'WikiUser') and isa($olduser,'WikiUser')) {
  51         // populate the upgraded class with the values from the old object
  52         foreach (get_object_vars($olduser) as $k => $v) {
  53             $user->$k = $v;
  54         }
  55         $GLOBALS['request']->_user = $user;
  56         return $user;
  57     } else {
  58         return false;
  59     }
  60 }
  61
  62 /**
  63 *
  64 */
  65 class WikiUser {
  66     var $_userid = false;
  67     var $_level  = false;
  68     var $_request, $_dbi, $_authdbi, $_homepage;
  69     var $_authmethod = '', $_authhow = '';
  70
  71     /**
  72      * Constructor.
  73      *
  74      * Populates the instance variables and calls $this->_ok()
  75      * to ensure that the parameters are valid.
  76      * @param mixed $userid String of username or WikiUser object.
  77      * @param integer $authlevel Authorization level.
  78      */
  79     function WikiUser (&$request, $userid = false, $authlevel = false) {
  80         $this->_request = &$request;
  81         $this->_dbi = &$this->_request->getDbh();
  82
  83         if (isa($userid, 'WikiUser')) {
  84             $this->_userid   = $userid->_userid;
  85             $this->_level    = $userid->_level;
  86         }
  87         else {
  88             $this->_userid = $userid;
  89             $this->_level = $authlevel;
  90         }
  91         if (!$this->_ok()) {
  92             // Paranoia: if state is at all inconsistent, log out...
  93             $this->_userid = false;
  94             $this->_level = false;
  95             $this->_homepage = false;
  96             $this->_authhow .= ' paranoia logout';
  97         }
  98         if ($this->_userid) {
  99             $this->_homepage = $this->_dbi->getPage($this->_userid);
 100         }
 101     }
 102
 103     /**
 104     * Get the string indicating how the user was authenticated.
 105     *
 106     * Get the string indicating how the user was authenticated.
 107     * Does not seem to be set - jbw
 108     * @return string The method of authentication.
 109     */
 110     function auth_how() {
 111         return $this->_authhow;
 112     }
 113
 114     /**
 115      * Invariant
 116      *
 117      * If the WikiUser object has a valid authorization level and the
 118      * userid is a string returns true, else false.
 119      * @return boolean If valid level and username string true, else false
 120      */
 121     function _ok () {
 122         if ((in_array($this->_level, array(WIKIAUTH_BOGO,
 123                                            WIKIAUTH_USER,
 124                                            WIKIAUTH_ADMIN))
 125             &&
 126             (is_string($this->_userid)))) {
 127             return true;
 128         }
 129         return false;
 130     }
 131
 132     function UserName() {
 133         return $this->_userid;
 134     }
 135
 136     function getId () {
 137         return ( $this->isSignedIn()
 138                  ? $this->_userid
 139                  : $this->_request->get('REMOTE_ADDR') ); // FIXME: globals
 140     }
 141
 142     function getAuthenticatedId() {
 143         return ( $this->isAuthenticated()
 144                  ? $this->_userid
 145                  : $this->_request->get('REMOTE_ADDR') ); // FIXME: globals
 146     }
 147
 148     function isSignedIn () {
 149         return $this->_level >= WIKIAUTH_BOGO;
 150     }
 151
 152     function isAuthenticated () {
 153         return $this->_level >= WIKIAUTH_BOGO;
 154     }
 155
 156     function isAdmin () {
 157         return $this->_level == WIKIAUTH_ADMIN;
 158     }
 159
 160     function hasAuthority ($require_level) {
 161         return $this->_level >= $require_level;
 162     }
 163
 164     function isValidName ($userid = false) {
 165         if (!$userid)
 166             $userid = $this->_userid;
 167         return preg_match("/^[\w\.@\-]+$/",$userid) and strlen($userid) < 32;
 168     }
 169
 170     function AuthCheck ($postargs) {
 171         // Normalize args, and extract.
 172         $keys = array('userid', 'passwd', 'require_level', 'login', 'logout',
 173                       'cancel');
 174         foreach ($keys as $key)
 175             $args[$key] = isset($postargs[$key]) ? $postargs[$key] : false;
 176         extract($args);
 177         $require_level = max(0, min(WIKIAUTH_ADMIN, (int)$require_level));
 178
 179         if ($logout)
 180             return new WikiUser($this->_request); // Log out
 181         elseif ($cancel)
 182             return false;        // User hit cancel button.
 183         elseif (!$login && !$userid)
 184             return false;       // Nothing to do?
 185
 186         if (!$this->isValidName($userid))
 187             return _("Invalid username.");
 188
 189         $authlevel = $this->_pwcheck($userid, $passwd);
 190         if (!$authlevel)
 191             return _("Invalid password or userid.");
 192         elseif ($authlevel < $require_level)
 193             return _("Insufficient permissions.");
 194
 195         // Successful login.
 196         $user = new WikiUser($this->_request,$userid,$authlevel);
 197         return $user;
 198     }
 199
 200     function PrintLoginForm (&$request, $args, $fail_message = false,
 201                              $seperate_page = true) {
 202         include_once('lib/Template.php');
 203         // Call update_locale in case the system's default language is not 'en'.
 204         // (We have no user pref for lang at this point yet, no one is logged in.)
 205         update_locale(DEFAULT_LANGUAGE);
 206         $userid = '';
 207         $require_level = 0;
 208         extract($args); // fixme
 209
 210         $require_level = max(0, min(WIKIAUTH_ADMIN, (int)$require_level));
 211
 212         $pagename = $request->getArg('pagename');
 213         $login = new Template('login', $request,
 214                               compact('pagename', 'userid', 'require_level',
 215                                       'fail_message', 'pass_required'));
 216         if ($seperate_page) {
 217             $page = $request->getPage($pagename);
 218             $revision = $page->getCurrentRevision();
 219             return GeneratePage($login,_("Sign In"),$revision);
 220         } else {
 221             return $login;
 222         }
 223     }
 224
 225     /**
 226      * Check password.
 227      */
 228     function _pwcheck ($userid, $passwd) {
 229         global $WikiNameRegexp;
 230
 231         if (!empty($userid) && $userid == ADMIN_USER) {
 232             // $this->_authmethod = 'pagedata';
 233             if (defined('ENCRYPTED_PASSWD') && ENCRYPTED_PASSWD)
 234                 if ( !empty($passwd)
 235                      && crypt($passwd, ADMIN_PASSWD) == ADMIN_PASSWD )
 236                     return WIKIAUTH_ADMIN;
 237                 else
 238                     return false;
 239             if (!empty($passwd)) {
 240                 if ($passwd == ADMIN_PASSWD)
 241                   return WIKIAUTH_ADMIN;
 242                 else {
 243                     // maybe we forgot to enable ENCRYPTED_PASSWD?
 244                     if ( function_exists('crypt')
 245                          && crypt($passwd, ADMIN_PASSWD) == ADMIN_PASSWD ) {
 246                         trigger_error(_("You forgot to set ENCRYPTED_PASSWD to true. Please update your /index.php"),
 247                                       E_USER_WARNING);
 248                         return WIKIAUTH_ADMIN;
 249                     }
 250                 }
 251             }
 252             return false;
 253         }
 254         // HTTP Authentication
 255         elseif (ALLOW_HTTP_AUTH_LOGIN && !empty($PHP_AUTH_USER)) {
 256             // if he ignored the password field, because he is already
 257             // authenticated try the previously given password.
 258             if (empty($passwd))
 259                 $passwd = $PHP_AUTH_PW;
 260         }
 261
 262         // WikiDB_User DB/File Authentication from $DBAuthParams
 263         // Check if we have the user. If not try other methods.
 264         if (ALLOW_USER_LOGIN) { // && !empty($passwd)) {
 265             if (!$this->isValidName($userid)) {
 266                 trigger_error(_("Invalid username."), E_USER_WARNING);
 267                 return false;
 268             }
 269             $request = $this->_request;
 270             // first check if the user is known
 271             if ($this->exists($userid)) {
 272                 $this->_authmethod = 'pagedata';
 273                 return ($this->checkPassword($passwd)) ? WIKIAUTH_USER : false;
 274             } else {
 275                 // else try others such as LDAP authentication:
 276                 if (ALLOW_LDAP_LOGIN && defined(LDAP_AUTH_HOST) && !empty($passwd) && !strstr($userid,'*')) {
 277                     if ($ldap = ldap_connect(LDAP_AUTH_HOST)) { // must be a valid LDAP server!
 278                         $r = @ldap_bind($ldap); // this is an anonymous bind
 279                         $st_search = "uid=$userid";
 280                         // Need to set the right root search information. see ../index.php
 281                         $sr = ldap_search($ldap, LDAP_BASE_DN,
 282                                           "$st_search");
 283                         $info = ldap_get_entries($ldap, $sr); // there may be more hits with this userid. try every
 284                         for ($i = 0; $i < $info["count"]; $i++) {
 285                             $dn = $info[$i]["dn"];
 286                             // The password is still plain text.
 287                             if ($r = @ldap_bind($ldap, $dn, $passwd)) {
 288                                 // ldap_bind will return TRUE if everything matches
 289                                 ldap_close($ldap);
 290                                 $this->_authmethod = 'LDAP';
 291                                 return WIKIAUTH_USER;
 292                             }
 293                         }
 294                     } else {
 295                         trigger_error("Unable to connect to LDAP server "
 296                                       . LDAP_AUTH_HOST, E_USER_WARNING);
 297                     }
 298                 }
 299                 // imap authentication. added by limako
 300                 if (ALLOW_IMAP_LOGIN && !empty($passwd)) {
 301                     $mbox = @imap_open( "{" . IMAP_AUTH_HOST . "}INBOX",
 302                                         $userid, $passwd, OP_HALFOPEN );
 303                     if($mbox) {
 304                         imap_close($mbox);
 305                         $this->_authmethod = 'IMAP';
 306                         return WIKIAUTH_USER;
 307                     }
 308                 }
 309             }
 310         }
 311         if ( ALLOW_BOGO_LOGIN
 312              && preg_match('/\A' . $WikiNameRegexp . '\z/', $userid) ) {
 313             $this->_authmethod = 'BOGO';
 314             return WIKIAUTH_BOGO;
 315         }
 316         return false;
 317     }
 318
 319     // Todo: try our WikiDB backends.
 320     function getPreferences() {
 321         // Restore saved preferences.
 322
 323         // I'd rather prefer only to store the UserId in the cookie or
 324         // session, and get the preferences from the db or page.
 325         if (!($prefs = $this->_request->getCookieVar('WIKI_PREFS2')))
 326             $prefs = $this->_request->getSessionVar('wiki_prefs');
 327
 328         //if (!$this->_userid && !empty($GLOBALS['HTTP_COOKIE_VARS']['WIKI_ID'])) {
 329         //    $this->_userid = $GLOBALS['HTTP_COOKIE_VARS']['WIKI_ID'];
 330         //}
 331
 332         // before we get his prefs we should check if he is signed in
 333         if (USE_PREFS_IN_PAGE && $this->homePage()) { // in page metadata
 334             // old array
 335             if ($pref = $this->_homepage->get('pref')) {
 336                 //trigger_error("pref=".$pref);//debugging
 337                 $prefs = unserialize($pref);
 338             }
 339         }
 340         return new UserPreferences($prefs);
 341     }
 342
 343     // No cookies anymore for all prefs, only the userid. PHP creates
 344     // a session cookie in memory, which is much more efficient,
 345     // but not persistent. Get persistency with a homepage or DB Prefs
 346     //
 347     // Return the number of changed entries
 348     function setPreferences($prefs, $id_only = false) {
 349         if (!is_object($prefs)) {
 350             $prefs = new UserPreferences($prefs);
 351         }
 352         // update the session and id
 353         $this->_request->setSessionVar('wiki_prefs', $prefs);
 354         // $this->_request->setCookieVar('WIKI_PREFS2', $this->_prefs, 365);
 355         // simple unpacked cookie
 356         if ($this->_userid) setcookie('WIKI_ID', $this->_userid, 365, '/');
 357
 358         // We must ensure that any password is encrypted.
 359         // We don't need any plaintext password.
 360         if (! $id_only ) {
 361             if ($this->isSignedIn()) {
 362                 if ($this->isAdmin())
 363                     $prefs->set('passwd', '');
 364                 // already stored in index.php, and it might be
 365                 // plaintext! well oh well
 366                 if ($homepage = $this->homePage()) {
 367                     // check for page revision 0
 368                     if (! $this->_dbi->isWikiPage($this->_userid)) {
 369                         trigger_error(_("Your home page has not been created yet so your preferences cannot not be saved."),
 370                                       E_USER_WARNING);
 371                     }
 372                     else {
 373                         if ($this->isAdmin() || !$homepage->get('locked')) {
 374                             $homepage->set('pref', serialize($prefs->_prefs));
 375                             return sizeof($prefs->_prefs);
 376                         }
 377                         else {
 378                             // An "empty" page could still be
 379                             // intentionally locked by admin to
 380                             // prevent its creation.
 381                             //
 382                             // FIXME: This permission situation should
 383                             // probably be handled by the DB backend,
 384                             // once the new WikiUser code has been
 385                             // implemented.
 386                             trigger_error(_("Your home page is locked so your preferences cannot not be saved.")
 387                                           . " " . _("Please contact your PhpWiki administrator for assistance."),
 388                                           E_USER_WARNING);
 389                         }
 390                     }
 391                 } else {
 392                     trigger_error("No homepage for user found. Creating one...",
 393                                   E_USER_WARNING);
 394                     $this->createHomepage($prefs);
 395                     //$homepage->set('pref', serialize($prefs->_prefs));
 396                     return sizeof($prefs->_prefs);
 397                 }
 398             } else {
 399                 trigger_error("you must be signed in", E_USER_WARNING);
 400             }
 401         }
 402         return 0;
 403     }
 404
 405     // check for homepage with user flag.
 406     // can be overriden from the auth backends
 407     function exists() {
 408         $homepage = $this->homePage();
 409         return ($this->_userid && $homepage && $homepage->get('pref'));
 410     }
 411
 412     // doesn't check for existance!!! hmm.
 413     // how to store metadata in not existing pages? how about versions?
 414     function homePage() {
 415         if (!$this->_userid)
 416             return false;
 417         if (!empty($this->_homepage)) {
 418             return $this->_homepage;
 419         } else {
 420             $this->_homepage = $this->_dbi->getPage($this->_userid);
 421             return $this->_homepage;
 422         }
 423     }
 424
 425     function hasHomePage() {
 426         return !$this->homePage();
 427     }
 428
 429     // create user by checking his homepage
 430     function createUser ($pref, $createDefaultHomepage = true) {
 431         if ($this->exists())
 432             return;
 433         if ($createDefaultHomepage) {
 434             $this->createHomepage($pref);
 435         } else {
 436             // empty page
 437             include "lib/loadsave.php";
 438             $pageinfo = array('pagedata' => array('pref' => serialize($pref->_pref)),
 439                               'versiondata' => array('author' => $this->_userid),
 440                               'pagename' => $this->_userid,
 441                               'content' => _('CategoryHomepage'));
 442             SavePage ($this->_request, $pageinfo, false, false);
 443         }
 444         $this->setPreferences($pref);
 445     }
 446
 447     // create user and default user homepage
 448     function createHomepage ($pref) {
 449         $pagename = $this->_userid;
 450         include "lib/loadsave.php";
 451
 452         // create default homepage:
 453         //  properly expanded template and the pref metadata
 454         $template = Template('homepage.tmpl', $this->_request);
 455         $text  = $template->getExpansion();
 456         $pageinfo = array('pagedata' => array('pref' => serialize($pref->_pref)),
 457                           'versiondata' => array('author' => $this->_userid),
 458                           'pagename' => $pagename,
 459                           'content' => $text);
 460         SavePage ($this->_request, $pageinfo, false, false);
 461
 462         // create Calender
 463         $pagename = $this->_userid . SUBPAGE_SEPARATOR . _('Preferences');
 464         if (! isWikiPage($pagename)) {
 465             $pageinfo = array('pagedata' => array(),
 466                               'versiondata' => array('author' => $this->_userid),
 467                               'pagename' => $pagename,
 468                               'content' => "<?plugin Calender ?>\n");
 469             SavePage ($this->_request, $pageinfo, false, false);
 470         }
 471
 472         // create Preferences
 473         $pagename = $this->_userid . SUBPAGE_SEPARATOR . _('Preferences');
 474         if (! isWikiPage($pagename)) {
 475             $pageinfo = array('pagedata' => array(),
 476                               'versiondata' => array('author' => $this->_userid),
 477                               'pagename' => $pagename,
 478                               'content' => "<?plugin UserPreferences ?>\n");
 479             SavePage ($this->_request, $pageinfo, false, false);
 480         }
 481     }
 482
 483     function tryAuthBackends() {
 484         return ''; // crypt('') will never be ''
 485     }
 486
 487     // Auth backends must store the crypted password where?
 488     // Not in the preferences.
 489     function checkPassword($passwd) {
 490         $prefs = $this->getPreferences();
 491         $stored_passwd = $prefs->get('passwd'); // crypted
 492         if (empty($prefs->_prefs['passwd']))    // not stored in the page
 493             // allow empty passwords? At least store a '*' then.
 494             // try other backend. hmm.
 495             $stored_passwd = $this->tryAuthBackends($this->_userid);
 496         if (empty($stored_passwd)) {
 497             trigger_error(sprintf(_("Old UserPage %s without stored password updated with empty password. Set a password in your UserPreferences."),
 498                                   $this->_userid), E_USER_NOTICE);
 499             $prefs->set('passwd','*');
 500             return true;
 501         }
 502         if ($stored_passwd == '*')
 503             return true;
 504         if ( !empty($passwd)
 505              && crypt($passwd, $stored_passwd) == $stored_passwd )
 506             return true;
 507         else
 508             return false;
 509     }
 510
 511     function changePassword($newpasswd, $passwd2 = false) {
 512         if (! $this->mayChangePass() ) {
 513             trigger_error(sprintf("Attempt to change an external password for '%s'. Not allowed!",
 514                                   $this->_userid), E_USER_ERROR);
 515             return;
 516         }
 517         if ($passwd2 && $passwd2 != $newpasswd) {
 518             trigger_error("The second password must be the same as the first to change it",
 519                           E_USER_ERROR);
 520             return;
 521         }
 522         $prefs = $this->getPreferences();
 523         //$oldpasswd = $prefs->get('passwd');
 524         $prefs->set('passwd', crypt($newpasswd));
 525         $this->setPreferences($prefs);
 526     }
 527
 528     function mayChangePass() {
 529         // on external DBAuth maybe. on IMAP or LDAP not
 530         // on internal DBAuth yes
 531         if (in_array($this->_authmethod, array('IMAP', 'LDAP')))
 532             return false;
 533         if ($this->isAdmin())
 534             return false;
 535         if ($this->_authmethod == 'pagedata')
 536             return true;
 537         if ($this->_authmethod == 'authdb')
 538             return true;
 539     }
 540                          }
 541
 542 // create user and default user homepage
 543 // FIXME: delete this, not used?
 544 /*
 545 function createUser ($userid, $pref) {
 546     global $request;
 547     $user = new WikiUser ($request, $userid);
 548     $user->createUser($pref);
 549 }
 550 */
 551
 552 class _UserPreference
 553 {
 554     function _UserPreference ($default_value) {
 555         $this->default_value = $default_value;
 556     }
 557
 558     function sanify ($value) {
 559         return (string)$value;
 560     }
 561
 562     function update ($value) {
 563     }
 564 }
 565
 566 class _UserPreference_numeric
 567 extends _UserPreference
 568 {
 569     function _UserPreference_numeric ($default, $minval = false,
 570                                       $maxval = false) {
 571         $this->_UserPreference((double)$default);
 572         $this->_minval = (double)$minval;
 573         $this->_maxval = (double)$maxval;
 574     }
 575
 576     function sanify ($value) {
 577         $value = (double)$value;
 578         if ($this->_minval !== false && $value < $this->_minval)
 579             $value = $this->_minval;
 580         if ($this->_maxval !== false && $value > $this->_maxval)
 581             $value = $this->_maxval;
 582         return $value;
 583     }
 584 }
 585
 586 class _UserPreference_int
 587 extends _UserPreference_numeric
 588 {
 589     function _UserPreference_int ($default, $minval = false, $maxval = false) {
 590         $this->_UserPreference_numeric((int)$default, (int)$minval,
 591                                        (int)$maxval);
 592     }
 593
 594     function sanify ($value) {
 595         return (int)parent::sanify((int)$value);
 596     }
 597 }
 598
 599 class _UserPreference_bool
 600 extends _UserPreference
 601 {
 602     function _UserPreference_bool ($default = false) {
 603         $this->_UserPreference((bool)$default);
 604     }
 605
 606     function sanify ($value) {
 607         if (is_array($value)) {
 608             /* This allows for constructs like:
 609              *
 610              *   <input type="hidden" name="pref[boolPref][]" value="0" />
 611              *   <input type="checkbox" name="pref[boolPref][]" value="1" />
 612              *
 613              * (If the checkbox is not checked, only the hidden input
 614              * gets sent. If the checkbox is sent, both inputs get
 615              * sent.)
 616              */
 617             foreach ($value as $val) {
 618                 if ($val)
 619                     return true;
 620             }
 621             return false;
 622         }
 623         return (bool) $value;
 624     }
 625 }
 626
 627 class _UserPreference_language
 628 extends _UserPreference
 629 {
 630     function _UserPreference_language ($default = DEFAULT_LANGUAGE) {
 631         $this->_UserPreference($default);
 632     }
 633
 634     // FIXME: check for valid locale
 635     function sanify ($value) {
 636         // Revert to DEFAULT_LANGUAGE if user does not specify
 637         // language in UserPreferences or chooses <system language>.
 638         if ($value == '' or empty($value))
 639             $value = DEFAULT_LANGUAGE;
 640
 641         return (string) $value;
 642     }
 643 }
 644
 645 class _UserPreference_theme
 646 extends _UserPreference
 647 {
 648     function _UserPreference_theme ($default = THEME) {
 649         $this->_UserPreference($default);
 650     }
 651
 652     function sanify ($value) {
 653         if (findFile($this->_themefile($value), true))
 654             return $value;
 655         return $this->default_value;
 656     }
 657
 658     function update ($newvalue) {
 659         global $Theme;
 660         include_once($this->_themefile($newvalue));
 661         if (empty($Theme))
 662             include_once($this->_themefile(THEME));
 663     }
 664
 665     function _themefile ($theme) {
 666         return "themes/$theme/themeinfo.php";
 667     }
 668 }
 669
 670 // don't save default preferences for efficiency.
 671 class UserPreferences {
 672     function UserPreferences ($saved_prefs = false) {
 673         $this->_prefs = array();
 674
 675         if (isa($saved_prefs, 'UserPreferences') && $saved_prefs->_prefs) {
 676             foreach ($saved_prefs->_prefs as $name => $value)
 677                 $this->set($name, $value);
 678         } elseif (is_array($saved_prefs)) {
 679             foreach ($saved_prefs as $name => $value)
 680                 $this->set($name, $value);
 681         }
 682     }
 683
 684     function _getPref ($name) {
 685         global $UserPreferences;
 686         if (!isset($UserPreferences[$name])) {
 687             if ($name == 'passwd2') return false;
 688             trigger_error("$name: unknown preference", E_USER_NOTICE);
 689             return false;
 690         }
 691         return $UserPreferences[$name];
 692     }
 693
 694     function get ($name) {
 695         if (isset($this->_prefs[$name]))
 696             return $this->_prefs[$name];
 697         if (!($pref = $this->_getPref($name)))
 698             return false;
 699         return $pref->default_value;
 700     }
 701
 702     function set ($name, $value) {
 703         if (!($pref = $this->_getPref($name)))
 704             return false;
 705
 706         $newvalue = $pref->sanify($value);
 707         $oldvalue = $this->get($name);
 708
 709         // update on changes
 710         if ($newvalue != $oldvalue)
 711             $pref->update($newvalue);
 712
 713         // don't set default values to save space (in cookies, db and
 714         // sesssion)
 715         if ($value == $pref->default_value)
 716             unset($this->_prefs[$name]);
 717         else
 718             $this->_prefs[$name] = $newvalue;
 719     }
 720
 721     function pack ($nonpacked) {
 722         return serialize($nonpacked);
 723     }
 724     function unpack ($packed) {
 725         if (!$packed)
 726             return false;
 727         if (substr($packed,0,2) == "O:") {
 728             // Looks like a serialized object
 729             return unserialize($packed);
 730         }
 731         //trigger_error("DEBUG: Can't unpack bad UserPreferences",
 732         //E_USER_WARNING);
 733         return false;
 734     }
 735
 736     function hash () {
 737         return hash($this->_prefs);
 738     }
 739 }
 740
 741 // $Log: not supported by cvs2svn $
 742 // Revision 1.56  2004/06/03 12:36:03  rurban
 743 // fix eval warning on signin
 744 //
 745 // Revision 1.55  2004/06/03 09:39:51  rurban
 746 // fix LDAP injection (wildcard in username) detected by Steve Christey, MITRE
 747 //
 748 // Revision 1.54  2004/04/29 17:18:19  zorloc
 749 // Fixes permission failure issues.  With PagePermissions and Disabled Actions when user did not have permission WIKIAUTH_FORBIDDEN was returned.  In WikiUser this was ok because WIKIAUTH_FORBIDDEN had a value of 11 -- thus no user could perform that action.  But WikiUserNew has a WIKIAUTH_FORBIDDEN value of -1 -- thus a user without sufficent permission to do anything.  The solution is a new high value permission level (WIKIAUTH_UNOBTAINABLE) to be the default level for access failure.
 750 //
 751 // Revision 1.53  2004/04/10 05:34:35  rurban
 752 // sf bug#830912
 753 //
 754 // Revision 1.52  2004/04/10 02:55:48  rurban
 755 // fixed old WikiUser
 756 //
 757 // Revision 1.51  2004/04/06 20:00:10  rurban
 758 // Cleanup of special PageList column types
 759 // Added support of plugin and theme specific Pagelist Types
 760 // Added support for theme specific UserPreferences
 761 // Added session support for ip-based throttling
 762 //   sql table schema change: ALTER TABLE session ADD sess_ip CHAR(15);
 763 // Enhanced postgres schema
 764 // Added DB_Session_dba support
 765 //
 766 // Revision 1.50  2004/02/26 01:32:03  rurban
 767 // fixed session login with old WikiUser object. strangely, the errormask gets corruoted to 1, Pear???
 768 //
 769 // Revision 1.49  2004/02/15 21:34:37  rurban
 770 // PageList enhanced and improved.
 771 // fixed new WikiAdmin... plugins
 772 // editpage, Theme with exp. htmlarea framework
 773 //   (htmlarea yet committed, this is really questionable)
 774 // WikiUser... code with better session handling for prefs
 775 // enhanced UserPreferences (again)
 776 // RecentChanges for show_deleted: how should pages be deleted then?
 777 //
 778 // Revision 1.48  2004/02/01 09:14:11  rurban
 779 // Started with Group_Ldap (not yet ready)
 780 // added new _AuthInfo plugin to help in auth problems (warning: may display passwords)
 781 // fixed some configurator vars
 782 // renamed LDAP_AUTH_SEARCH to LDAP_BASE_DN
 783 // changed PHPWIKI_VERSION from 1.3.8a to 1.3.8pre
 784 // USE_DB_SESSION defaults to true on SQL
 785 // changed GROUP_METHOD definition to string, not constants
 786 // changed sample user DBAuthParams from UPDATE to REPLACE to be able to
 787 //   create users. (Not to be used with external databases generally, but
 788 //   with the default internal user table)
 789 //
 790 // fixed the IndexAsConfigProblem logic. this was flawed:
 791 //   scripts which are the same virtual path defined their own lib/main call
 792 //   (hmm, have to test this better, phpwiki.sf.net/demo works again)
 793 //
 794 // Revision 1.47  2004/01/27 23:23:39  rurban
 795 // renamed ->Username => _userid for consistency
 796 // renamed mayCheckPassword => mayCheckPass
 797 // fixed recursion problem in WikiUserNew
 798 // fixed bogo login (but not quite 100% ready yet, password storage)
 799 //
 800 // Revision 1.46  2004/01/26 09:17:48  rurban
 801 // * changed stored pref representation as before.
 802 //   the array of objects is 1) bigger and 2)
 803 //   less portable. If we would import packed pref
 804 //   objects and the object definition was changed, PHP would fail.
 805 //   This doesn't happen with an simple array of non-default values.
 806 // * use $prefs->retrieve and $prefs->store methods, where retrieve
 807 //   understands the interim format of array of objects also.
 808 // * simplified $prefs->get() and fixed $prefs->set()
 809 // * added $user->_userid and class '_WikiUser' portability functions
 810 // * fixed $user object ->_level upgrading, mostly using sessions.
 811 //   this fixes yesterdays problems with loosing authorization level.
 812 // * fixed WikiUserNew::checkPass to return the _level
 813 // * fixed WikiUserNew::isSignedIn
 814 // * added explodePageList to class PageList, support sortby arg
 815 // * fixed UserPreferences for WikiUserNew
 816 // * fixed WikiPlugin for empty defaults array
 817 // * UnfoldSubpages: added pagename arg, renamed pages arg,
 818 //   removed sort arg, support sortby arg
 819 //
 820 // Revision 1.45  2003/12/09 20:00:43  carstenklapp
 821 // Bugfix: The last BogoUserPrefs-bugfix prevented the admin from saving
 822 // prefs into his own homepage, fixed broken logic. Tightened up BogoUser
 823 // prefs saving ability by checking for true existance of homepage
 824 // (previously a page revision of 0 also counted as valid, again due to
 825 // somewhat flawed logic).
 826 //
 827 // Revision 1.44  2003/12/06 04:56:23  carstenklapp
 828 // Security bugfix (minor): Prevent BogoUser~s from saving extraneous
 829 // _pref object meta-data within locked pages.
 830 //
 831 // Previously, BogoUser~s who signed in with a (valid) WikiWord such as
 832 // "HomePage" could actually save preferences into that page, even though
 833 // it was already locked by the administrator. Thus, any subsequent
 834 // WikiLink~s to that page would become prefixed with "that nice little"
 835 // UserIcon, as if that page represented a valid user.
 836 //
 837 // Note that the admin can lock (even) non-existant pages as desired or
 838 // necessary (i.e. any DB page whose revision==0), to prevent the
 839 // arbitrary BogoUser from saving preference metadata into such a page;
 840 // for example, the silly WikiName "@qmgi`Vcft_x|" (that is the
 841 // \$examplechars presented in login.tmpl, in case it is not visible here
 842 // in the CVS comments).
 843 //
 844 // http://phpwiki.sourceforge.net/phpwiki/
 845 // %C0%F1%ED%E7%E9%E0%D6%E3%E6%F4%DF%F8%FC?action=lock
 846 //
 847 // To remove the prefs metadata from a page, the admin can use the
 848 // EditMetaData plugin, enter pref as the key, leave the value box empty
 849 // and then submit the change. For example:
 850 //
 851 // http://phpwiki.sourceforge.net/phpwiki/
 852 // _EditMetaData?page=%C0%F1%ED%E7%E9%E0%D6%E3%E6%F4%DF%F8%FC
 853 //
 854 // (It seems a rethinking of WikiUserNew.php with its WikiUser and
 855 // UserPreferences classes is in order. Ideally the WikiDB would
 856 // transparently handle such a situation, perhaps BogoUser~s should
 857 // simply be restricted to saving preferences into a cookie until his/her
 858 // e-mail address has been verified.)
 859 //
 860 // Revision 1.43  2003/12/04 19:33:30  carstenklapp
 861 // Bugfix: Under certain PhpWiki installations (such as the PhpWiki at
 862 // SF), the user was unable to select a theme other than the server's
 863 // default. (Use the more robust Theme::findFile instead of PHP's
 864 // file_exists function to detect installed themes).
 865 //
 866 // Revision 1.42  2003/11/30 18:18:13  carstenklapp
 867 // Minor code optimization: use include_once instead of require_once
 868 // inside functions that might not always called.
 869 //
 870 // Revision 1.41  2003/11/21 21:32:39  carstenklapp
 871 // Bugfix: When DEFAULT_LANGUAGE was not 'en', a user's language prefs
 872 // would revert to 'en' when the default <system language> was selected
 873 // in UserPreferences and the user saved his preferences. (Check for
 874 // empty or blank language pref in sanify function of class
 875 // _UserPreference_language and return DEFAULT_LANGUAGE if nothing or
 876 // default selected in UserPreferences.)
 877 //
 878 // Revision 1.40  2003/11/21 16:54:58  carstenklapp
 879 // Bugfix: login.tmpl was always displayed in English despite
 880 // DEFAULT_LANGUAGE set in index.php. (Added call to
 881 // update_locale(DEFAULT_LANGUAGE) before printing login form).
 882 //
 883 // Revision 1.39  2003/10/28 21:13:46  carstenklapp
 884 // Security bug fix for admin password, submitted by Julien Charbon.
 885 //
 886 // Revision 1.38  2003/09/13 22:25:38  carstenklapp
 887 // Hook for new user preference 'noLinkIcons'.
 888 //
 889 // Revision 1.37  2003/02/22 20:49:55  dairiki
 890 // Fixes for "Call-time pass by reference has been deprecated" errors.
 891 //
 892 // Revision 1.36  2003/02/21 22:50:51  dairiki
 893 // Ensure that language preference is a string.
 894 //
 895 // Revision 1.35  2003/02/16 20:04:47  dairiki
 896 // Refactor the HTTP validator generation/checking code.
 897 //
 898 // This also fixes a number of bugs with yesterdays validator mods.
 899 //
 900 // Revision 1.34  2003/02/15 02:21:54  dairiki
 901 // API Change!  Explicit $request argument added to contructor for WikiUser.
 902 //
 903 // This seemed the best way to fix a problem whereby the WikiDB
 904 // was being opened twice.  (Which while being merely inefficient
 905 // when using an SQL backend causes hangage when using a dba backend.)
 906 //
 907 // Revision 1.33  2003/01/22 03:21:40  zorloc
 908 // Modified WikiUser constructor to move the DB request for the homepage to
 909 // the end of the logic to prevent it from being requested and then dropped.
 910 // Added more phpdoc comments.
 911 //
 912 // Revision 1.32  2003/01/21 07:40:50  zorloc
 913 // Modified WikiUser::_ok() -- Inverted the logic so the default is to return
 914 // false and to return true only in the desired condition.  Added phpdoc
 915 // comments
 916 //
 917 // Revision 1.31  2003/01/15 05:37:20  carstenklapp
 918 // code reformatting
 919 //
 920 // Revision 1.30  2003/01/15 04:59:27  carstenklapp
 921 // Bugfix: Previously stored preferences were not loading when user
 922 // signed in. (Fixed... I hope.)
 923 //
 924
 925 // Local Variables:
 926 // mode: php
 927 // tab-width: 8
 928 // c-basic-offset: 4
 929 // c-hanging-comment-ender-p: nil
 930 // indent-tabs-mode: nil
 931 // End:
 932 ?>