Subversion Repositories – MLAB

(root)/WebSVN/include/configclass.php

Rev 4993

<?php
// WebSVN - Subversion repository viewing via the web using PHP
// Copyright (C) 2004-2006 Tim Armes
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA     02111-1307      USA
//
// --
//
// configclass.php
//
// General class for handling configuration options

require_once 'include/command.php';
require_once 'include/authz.php';
require_once 'include/version.php';

// Auxillary functions used to sort repositories by name/group

// {{{ cmpReps($a, $b)

function cmpReps($a, $b) {
        // First, sort by group
        $g = strcasecmp((string) $a->group, (string) $b->group);
        if ($g) return $g;

        // Same group? Sort by name
        return strcasecmp($a->name, $b->name);
}

// }}}

// {{{ cmpGroups($a, $b)

function cmpGroups($a, $b) {
        $g = strcasecmp((string) $a->group, (string) $b->group);
        if ($g) return $g;

        return 0;
}

// }}}

// {{{ mergesort(&$array, [$cmp_function])

function mergesort(&$array, $cmp_function = 'strcmp') {
        // Arrays of size < 2 require no action

        if (count($array) < 2) return;

        // Split the array in half
        $halfway = count($array) / 2;
        $array1 = array_slice($array, 0, $halfway);
        $array2 = array_slice($array, $halfway);

        // Recurse to sort the two halves
        mergesort($array1, $cmp_function);
        mergesort($array2, $cmp_function);

        // If all of $array1 is <= all of $array2, just append them.
        if (call_user_func($cmp_function, end($array1), $array2[0]) < 1) {
                $array = array_merge($array1, $array2);
                return;
        }

        // Merge the two sorted arrays into a single sorted array
        $array = array();
        $array1count = count($array1);
        $array2count = count($array2);
        $ptr1 = 0;
        $ptr2 = 0;
        while ($ptr1 < $array1count && $ptr2 < $array2count) {
                if (call_user_func($cmp_function, $array1[$ptr1], $array2[$ptr2]) < 1) {
                        $array[] = $array1[$ptr1++];
                } else {
                        $array[] = $array2[$ptr2++];
                }
        }

        // Merge the remainder
        while ($ptr1 < $array1count) $array[] = $array1[$ptr1++];
        while ($ptr2 < $array2count) $array[] = $array2[$ptr2++];

        return;
}

// }}}

// A Repository parent path configuration class

class ParentPath {
        // {{{ Properties

        var $path;
        var $group;
        var $pattern;
        var $skipAlreadyAdded;
        var $clientRootURL;

        // }}}

        // {{{ __construct($path [, $group [, $pattern [, $skipAlreadyAdded [, $clientRootURL]]]])
        function __construct($path, $group = null, $pattern = false, $skipAlreadyAdded = true, $clientRootURL = '') {
                $this->path = $path;
                $this->group = $group;
                $this->pattern = $pattern;
                $this->skipAlreadyAdded = $skipAlreadyAdded;
                $this->clientRootURL = rtrim($clientRootURL, '/');
        }
        // }}}

        // {{{ findRepository($name)
        // look for a repository with $name
        function &findRepository($name) {
                global $config;
                if ($this->group != null) {
                        $prefix = $this->group.'.';
                        if (substr($name, 0, strlen($prefix)) == $prefix) {
                                $name = substr($name, strlen($prefix));
                        } else {
                                $null = null;
                                return $null;
                        }
                }
                // is there a directory named $name?
                $fullpath = $this->path.DIRECTORY_SEPARATOR.$name;
                if (is_dir($fullpath) && is_readable($fullpath)) {
                        // And that contains a db directory (in an attempt to not include non svn repositories.
                        $dbfullpath = $fullpath.DIRECTORY_SEPARATOR.'db';
                        if (is_dir($dbfullpath) && is_readable($dbfullpath)) {
                                // And matches the pattern if specified
                                if ($this->pattern === false || preg_match($this->pattern, $name)) {
                                        $url = $config->fileUrlPrefix.$fullpath;
                                        $url = str_replace(DIRECTORY_SEPARATOR, '/', $url);
                                        if ($url[ strlen($url) - 1 ] == '/') {
                                                $url = substr($url, 0, -1);
                                        }

                                        if (!in_array($url, $config->_excluded, true)) {
                                                $clientRootURL = ($this->clientRootURL) ? $this->clientRootURL.'/'.$name : '';
                                                $rep = new Repository($name, $name, $url, $this->group, null, null, null, $clientRootURL);
                                                return $rep;
                                        }
                                }
                        }
                }
                $null = null;
                return $null;
        }
        // }}}

        // {{{ getRepositories()
        // return all repositories in the parent path matching pattern
        function &getRepositories() {
                global $config;
                $repos = array();
                $handle = @opendir($this->path);

                if (!$handle) return $repos;

                // For each file...
                while (false !== ($name = readdir($handle))) {
                        $fullpath = $this->path.DIRECTORY_SEPARATOR.$name;
                        if ($name[0] != '.' && is_dir($fullpath) && is_readable($fullpath)) {
                                // And that contains a db directory (in an attempt to not include non svn repositories.
                                $dbfullpath = $fullpath.DIRECTORY_SEPARATOR.'db';
                                if (is_dir($dbfullpath) && is_readable($dbfullpath)) {
                                        // And matches the pattern if specified
                                        if ($this->pattern === false || preg_match($this->pattern, $name)) {
                                                $url = $config->fileUrlPrefix.$fullpath;
                                                $url = str_replace(DIRECTORY_SEPARATOR, '/', $url);
                                                if ($url[strlen($url) - 1] == '/') {
                                                        $url = substr($url, 0, -1);
                                                }
                                                $clientRootURL = ($this->clientRootURL) ? $this->clientRootURL.'/'.$name : '';
                                                $repos[] = new Repository($name, $name, $url, $this->group, null, null, null, $clientRootURL);
                                        }
                                }
                        }
                }
                closedir($handle);

                // Sort the repositories into alphabetical order
                if (!empty($repos)) {
                        usort($repos, 'cmpReps');
                }

                return $repos;
        }
        // }}}

        // {{{ getSkipAlreadyAdded()
        // Return if we should skip already added repos for this parent path.
        function getSkipAlreadyAdded() {
                return $this->skipAlreadyAdded;
        }
        // }}}
}

// A Repository configuration class

class Repository {
        // {{{ Properties

        var $name;
        var $svnName;
        var $path;
        var $subpath;
        var $group;
        var $username = null;
        var $password = null;
        var $clientRootURL;

        // Local configuration options must start off unset

        var $allowDownload;
        var $minDownloadLevel;
        var $allowedExceptions = array();
        var $disallowedExceptions = array();
        var $logsShowChanges;
        var $rss;
        var $rssCaching;
        var $rssMaxEntries;
        var $spaces;
        var $ignoreSvnMimeTypes;
        var $ignoreWebSVNContentTypes;
        var $bugtraq;
        var $bugtraqProperties;
        var $authz = null;
        var $templatePath = false;

        // }}}

        // {{{ __construct($name, $svnName, $serverRootURL [, $group [, $username [, $password [, $clientRootURL]]]])

        function __construct($name, $svnName, $serverRootURL, $group = null, $username = null, $password = null, $subpath = null, $clientRootURL = null) {
                $this->name = $name;
                $this->svnName = $svnName;
                $this->path = $serverRootURL;
                $this->subpath = $subpath;
                $this->group = $group;
                $this->username = $username;
                $this->password = $password;
                $this->clientRootURL = rtrim($clientRootURL, '/');
        }

        // }}}

        // {{{ getDisplayName()

        function getDisplayName() {
                if (!empty($this->group)) {
                        return $this->group.'.'.$this->name;
                }

                return $this->name;
        }

        // }}}

        // {{{ svnCredentials

        function svnCredentials() {
                $params = '';
                if ($this->username !== null && $this->username !== '') {
                        $params .= ' --username '.quote($this->username);
                }
                if ($this->password !== null) {
                        $params .= ' --password '.quote($this->password);
                }
                return $params;
        }

        // }}}

        // Local configuration accessors

        function setLogsShowChanges($enabled = true) {
                $this->logsShowChanges = $enabled;
        }

        function logsShowChanges() {
                global $config;

                if (isset($this->logsShowChanges))
                        return $this->logsShowChanges;
                else
                        return $config->logsShowChanges();
        }

        // {{{ RSS Feed

        function setRssEnabled($enabled) {
                $this->rss = $enabled;
        }

        function isRssEnabled() {
                global $config;

                if (isset($this->rss))
                        return $this->rss;
                else
                        return $config->isRssEnabled();
        }

        function setRssCachingEnabled($enabled = true) {
                $this->rssCaching = $enabled;
        }

        function isRssCachingEnabled() {
                global $config;

                if (isset($this->rssCaching))
                        return $this->rssCaching;
                else
                        return $config->isRssCachingEnabled();
        }

        function setRssMaxEntries($max) {
                $this->rssMaxEntries = $max;
        }

        function getRssMaxEntries() {
                global $config;

                if (isset($this->rssMaxEntries))
                        return $this->rssMaxEntries;
                else
                        return $config->getRssMaxEntries();
        }

        // }}}

        // {{{ Download

        function allowDownload() {
                $this->allowDownload = true;
        }

        function disallowDownload() {
                $this->allowDownload = false;
        }

        function getAllowDownload() {
                global $config;

                if (isset($this->allowDownload)) {
                        return $this->allowDownload;
                }

                return $config->getAllowDownload();
        }

        function setMinDownloadLevel($level) {
                $this->minDownloadLevel = $level;
        }

        function getMinDownloadLevel() {
                global $config;

                if (isset($this->minDownloadLevel)) {
                        return $this->minDownloadLevel;
                }

                return $config->getMinDownloadLevel();
        }

        function addAllowedDownloadException($path) {
                if ($path[strlen($path) - 1] != '/') $path .= '/';

                $this->allowedExceptions[] = $path;
        }

        function addDisallowedDownloadException($path) {
                if ($path[strlen($path) - 1] != '/') $path .= '/';

                $this->disallowedExceptions[] = $path;
        }

        function isDownloadAllowed($path) {
                global $config;

                // Check global download option
                if (!$this->getAllowDownload()) {
                        return false;
                }

                // Check with access module
                if (!$this->hasUnrestrictedReadAccess($path)) {
                        return false;
                }

                $subs = explode('/', $path);
                $level = count($subs) - 2;
                if ($level >= $this->getMinDownloadLevel()) {
                        // Level OK, search for disallowed exceptions

                        if ($config->findException($path, $this->disallowedExceptions)) {
                                return false;
                        }

                        if ($config->findException($path, $config->disallowedExceptions)) {
                                return false;
                        }

                        return true;

                } else {
                        // Level not OK, search for disallowed exceptions

                        if ($config->findException($path, $this->allowedExceptions)) {
                                return true;
                        }

                        if ($config->findException($path, $config->allowedExceptions)) {
                                return true;
                        }

                        return false;
                }
        }

        // }}}

        // {{{ Templates

        function setTemplatePath($path) {
                $this->templatePath = $path;
        }

        function getTemplatePath() {
                global $config;
                if (!empty($this->templatePath)) {
                        return $this->templatePath;
                }

                return $config->getTemplatePath();
        }

        // }}}

        // {{{ Tab expansion

        function expandTabsBy($sp) {
                $this->spaces = $sp;
        }

        function getExpandTabsBy() {
                global $config;

                if (isset($this->spaces)) {
                        return $this->spaces;
                }

                return $config->getExpandTabsBy();
        }

        // }}}

        // {{{ MIME-Type Handing

        function ignoreSvnMimeTypes() {
                $this->ignoreSvnMimeTypes = true;
        }

        function useSvnMimeTypes() {
                $this->ignoreSvnMimeTypes = false;
        }

        function getIgnoreSvnMimeTypes() {
                global $config;

                if (isset($this->ignoreSvnMimeTypes)) {
                        return $this->ignoreSvnMimeTypes;
                }

                return $config->getIgnoreSvnMimeTypes();
        }

        function ignoreWebSVNContentTypes() {
                $this->ignoreWebSVNContentTypes = true;
        }

        function useWebSVNContentTypes() {
                $this->ignoreWebSVNContentTypes = false;
        }

        function getIgnoreWebSVNContentTypes() {
                global $config;

                if (isset($this->ignoreWebSVNContentTypes)) {
                        return $this->ignoreWebSVNContentTypes;
                }

                return $config->getIgnoreWebSVNContentTypes();
        }

        // }}}

        // {{{ Bugtraq issue tracking

        function setBugtraqEnabled($enabled) {
                $this->bugtraq = $enabled;
        }

        function isBugtraqEnabled() {
                global $config;

                if (isset($this->bugtraq))
                        return $this->bugtraq;
                else
                        return $config->isBugtraqEnabled();
        }

        function setBugtraqProperties($properties) {
                $this->bugtraqProperties = $properties;
        }

        function getBugtraqProperties() {
                global $config;

                if (isset($this->bugtraqProperties))
                        return $this->bugtraqProperties;
                else
                        return $config->getBugtraqProperties();
        }

        // }}}

        // {{{ Authorization

        function useAccessFile($file) {
                if (is_readable($file)) {
                        if ($this->authz === null) {
                                $this->authz = new Authorization();
                        }
                        $this->authz->addAccessFile($file);
                } else {
                        die('Unable to read access file "'.$file.'"');
                }
        }

        function &getAuthz() {
                global $config;

                $a = null;
                if ($this->authz !== null) {
                        $a =& $this->authz;
                } else {
                        $a =& $config->getAuthz();
                }
                return $a;
        }

        function _getPathWithSubIf($pathWoSub) {
                if (!$this->subpath) {
                        return $pathWoSub;
                }

                return '/' . $this->subpath . $pathWoSub;
        }

        function hasReadAccess($pathWoSub, $checkSubDirs = false) {
                $path   =  $this->_getPathWithSubIf($pathWoSub);
                $a              =& $this->getAuthz();

                if (!empty($a)) {
                        return $a->hasReadAccess($this->svnName, $path, $checkSubDirs);
                }

                // No access file - free access...
                return true;
        }

        function hasLogReadAccess($pathWithSub) {
                $path   =  $pathWithSub;
                $a              =& $this->getAuthz();

                if (!empty($a)) {
                        return $a->hasReadAccess($this->svnName, $path, false);
                }

                // No access file - free access...
                return true;
        }

        function hasUnrestrictedReadAccess($pathWoSub) {
                $path   =  $this->_getPathWithSubIf($pathWoSub);
                $a              =& $this->getAuthz();

                if (!empty($a)) {
                        return $a->hasUnrestrictedReadAccess($this->svnName, $path);
                }

                // No access file - free access...
                return true;
        }

        // }}}

}

// The general configuration class

class WebSvnConfig {
        // {{{ Properties

        // Tool path locations

        var $_svnCommandPath = '';
        var $_svnConfigDir = '/tmp/websvn';
        var $_svnTrustServerCert = false;
        var $svn = 'svn --non-interactive --config-dir /tmp/websvn';
        var $svnAuthz = 'svnauthz accessof';
        var $diff = 'diff';
        var $enscript = 'enscript -q';
        var $sed = 'sed';
        var $gzip = 'gzip';
        var $tar = 'tar';
        var $zip = 'zip';
        var $locale = '';

        // different modes for file and directory download

        var $defaultFileDlMode = 'plain';
        var $defaultDirectoryDlMode = 'gzip';

        var $validFileDlModes = array( 'gzip', 'zip', 'plain' );
        var $validDirectoryDlModes = array( 'gzip', 'zip' );

        // Other configuration items

        var $treeView = true;
        var $flatIndex = true;
        var $openTree = false;
        var $alphabetic = false;
        var $showLastModInIndex = true;
        var $showLastModInListing = true;
        var $showAgeInsteadOfDate = true;
        var $_showRepositorySelectionForm = true;
        var $_ignoreWhitespacesInDiff = false;
        var $serverIsWindows = false;
        var $multiViews = false;
        var $multiViewsIndex = 'browse';
        var $useEnscript = false;
        var $useEnscriptBefore_1_6_3 = false;
        var $useGeshi = false;
        var $geshiScript = 'geshi.php';
        var $useParsedown = false;
        var $parsedownScript = 'Parsedown.php';
        var $inlineMimeTypes = array();
        var $allowDownload = false;
        var $tempDir = '';
        var $minDownloadLevel = 0;
        var $allowedExceptions = array();
        var $disallowedExceptions = array();
        var $logsShowChanges = false;
        var $rss = true;
        var $rssCaching = false;
        var $rssMaxEntries = 40;
        var $spaces = 8;
        var $bugtraq = false;
        var $bugtraqProperties = null;
        var $authz = null;
        var $blockRobots = false;

        var $loadAllRepos = false;

        var $templatePaths = array();
        var $userTemplate = false;

        var $ignoreSvnMimeTypes = false;
        var $ignoreWebSVNContentTypes = false;

        var $subversionVersion = '';
        var $subversionMajorVersion = '';
        var $subversionMinorVersion = '';

        var $defaultLanguage = 'en';
        var $ignoreAcceptedLanguages = false;

        var $quote = "'";
        var $pathSeparator = ':';
        var $fileUrlPrefix = 'file://';
        var $breadcrumbRepoRootAsRepo = false;

        var $_repositories = array();

        var $_parentPaths = array();    // parent paths to load

        var $_parentPathsLoaded = false;

        var $_excluded = array();

        // }}}

        // {{{ __construct()

        function __construct() {
        }

        // }}}

        // {{{ Repository configuration

        function addRepository($name, $serverRootURL, $group = null, $username = null, $password = null, $clientRootURL = null) {
                $this->addRepositorySubpath($name, $serverRootURL, null, $group, $username, $password, $clientRootURL);
        }

        function addRepositorySubpath($name, $serverRootURL, $subpath, $group = null, $username = null, $password = null, $clientRootURL = null) {
                if (DIRECTORY_SEPARATOR != '/') {
                        $serverRootURL = str_replace(DIRECTORY_SEPARATOR, '/', $serverRootURL);
                        if ($subpath !== null) {
                                $subpath = str_replace(DIRECTORY_SEPARATOR, '/', $subpath);
                        }
                }
                $serverRootURL = trim($serverRootURL, '/');
                $svnName = substr($serverRootURL, strrpos($serverRootURL, '/') + 1);
                $this->_repositories[] = new Repository($name, $svnName, $serverRootURL, $group, $username, $password, $subpath, $clientRootURL);
        }

        // Automatically set up the repositories based on a parent path

        function parentPath($path, $group = null, $pattern = false, $skipAlreadyAdded = true, $clientRootURL = '') {
                $this->_parentPaths[] = new ParentPath($path, $group, $pattern, $skipAlreadyAdded, $clientRootURL);
        }

        function addExcludedPath($path) {
                $url = $this->fileUrlPrefix.$path;
                $url = str_replace(DIRECTORY_SEPARATOR, '/', $url);
                if ($url[strlen($url) - 1] == '/') {
                        $url = substr($url, 0, -1);
                }
                $this->_excluded[] = $url;
        }

        function getRepositories() {
                // lazily load parent paths
                if ($this->_parentPathsLoaded) return $this->_repositories;

                $this->_parentPathsLoaded = true;

                foreach ($this->_parentPaths as $parentPath) {
                        $parentRepos = $parentPath->getRepositories();
                        foreach ($parentRepos as $repo) {
                                if (!$parentPath->getSkipAlreadyAdded()) {
                                        $this->_repositories[] = $repo;
                                } else {
                                        // we have to check if we already have a repo with the same svn name
                                        $duplicate = false;
                                        foreach ($this->_repositories as $knownRepos) {
                                                if ($knownRepos->path == $repo->path && $knownRepos->subpath == $repo->subpath) {
                                                        $duplicate = true;
                                                        break;
                                                }
                                        }

                                        if (!$duplicate && !in_array($repo->path, $this->_excluded, true)) {
                                                $this->_repositories[] = $repo;
                                        }
                                }
                        }
                }

                return $this->_repositories;
        }

        function &findRepository($name) {
                // first look in the "normal repositories"
                foreach ($this->_repositories as $index => $rep) {
                        if (strcmp($rep->getDisplayName(), $name) == 0) {
                                $repref =& $this->_repositories[$index];
                                return $repref;
                        }
                }

                // now if the parent repos have not already been loaded
                // check them
                if (!$this->_parentPathsLoaded) {
                        foreach ($this->_parentPaths as $parentPath) {
                                $repref =& $parentPath->findRepository($name);
                                if ($repref != null) {
                                        $this->_repositories[] = $repref;
                                        return $repref;
                                }
                        }
                }

                // Hack to return a string by reference; value retrieved at setup.php:414
                $str = 'Unable to find repository "'.escape($name).'".';
                $error =& $str;
                return $error;
        }

        // }}}

        // {{{ setServerIsWindows
        //
        // The server is running on Windows

        function setServerIsWindows() {
                $this->serverIsWindows = true;

                // On Windows machines, use double quotes around command line parameters
                $this->quote = '"';

                // On Windows, semicolon separates path entries in a list rather than colon.
                $this->pathSeparator = ';';

                $this->fileUrlPrefix = 'file:///';
        }

        // }}}

        // {{{ MultiViews

        // useMultiViews
        //
        // Use MultiViews to access the repository

        function useMultiViews($multiViewsIndex = 'browse') {
                $this->multiViews = true;
                $this->multiViewsIndex = $multiViewsIndex;
        }

        function getUseMultiViews() {
                return $this->multiViews;
        }

        function getMultiViewsIndex() {
                return $this->multiViewsIndex;
        }

        // }}}

        // {{{ Enscript

        // useEnscript
        //
        // Use Enscript to colourise listings

        function useEnscript($before_1_6_3 = false) {
                $this->useEnscript = true;
                $this->useEnscriptBefore_1_6_3 = $before_1_6_3;
        }

        function getUseEnscript() {
                return $this->useEnscript;
        }

        function getUseEnscriptBefore_1_6_3() {
                return $this->useEnscriptBefore_1_6_3;
        }

        // }}}

        // {{{ GeSHi

        function setGeshiPath($path) {
                $this->_setPath($this->geshiScript, $path, 'geshi.php');
        }

        function getGeshiScript() {
                return $this->geshiScript;
        }

        // useGeshi
        //
        // Use GeSHi to colourise listings
        function useGeshi() {
                $this->useGeshi = true;
        }

        function getUseGeshi() {
                return $this->useGeshi;
        }

        // }}}

        // {{{ Parsedown

        function setParsedownPath($path) {
                $this->_setPath($this->parsedownScript, $path, 'Parsedown.php');
        }

        function getParsedownScript() {
                return $this->parsedownScript;
        }

        // useParsedown
        //
        // Use Parsedown to render README.md
        function useParsedown() {
                $this->useParsedown = true;
        }

        function getUseParsedown() {
                return $this->useParsedown;
        }

        // }}}

        // {{{ Inline MIME Types

        // inlineMimeTypes
        //
        // Specify MIME types to display inline in WebSVN pages
        function addInlineMimeType($type) {
                if (!in_array($type, $this->inlineMimeTypes)) {
                        $this->inlineMimeTypes[] = $type;
                }
        }

        // }}}

        // {{{ Show changed files by default on log.php

        function setLogsShowChanges($enabled = true, $myrep = 0) {
                if (empty($myrep)) {
                        $this->logsShowChanges = $enabled;
                } else {
                        $repo =& $this->findRepository($myrep);
                        $repo->logsShowChanges = $enabled;
                }
        }

        function logsShowChanges() {
                return $this->logsShowChanges;
        }

        // }}}

        // {{{ RSS

        function setRssEnabled($enabled = true, $myrep = 0) {
                if (empty($myrep)) {
                        $this->rss = $enabled;
                } else {
                        $repo =& $this->findRepository($myrep);
                        $repo->setRssEnabled($enabled);
                }
        }

        function isRssEnabled() {
                return $this->rss;
        }

        function setRssCachingEnabled($enabled = true, $myrep = 0) {
                if (empty($myrep)) {
                        $this->rssCaching = true;
                } else {
                        $repo =& $this->findRepository($myrep);
                        $repo->setRssCachingEnabled($enabled);
                }
        }

        function isRssCachingEnabled() {
                return $this->rssCaching;
        }

        // Maximum number of entries in RSS feed

        function setRssMaxEntries($max, $myrep = 0) {
                if (empty($myrep)) {
                        $this->rssMaxEntries = $max;
                } else {
                        $repo =& $this->findRepository($myrep);
                        $repo->setRssMaxEntries($max);
                }
        }

        function getRssMaxEntries() {
                return $this->rssMaxEntries;
        }

        function getHideRSS() {
                return $this->rss;
        }

        // cacheRSS
        //
        // Enable caching of RSS feeds

        function enableRSSCaching($myrep = 0) {
                if (empty($myrep)) {
                        $this->rssCaching = true;
                } else {
                        $repo =& $this->findRepository($myrep);
                        $repo->enableRSSCaching();
                }
        }

        function getRSSCaching() {
                return $this->rssCaching;
        }

        // }}}

        // {{{ Downloads

        // allowDownload
        //
        // Allow download of tarballs

        function allowDownload($myrep = 0) {
                if (empty($myrep)) {
                        $this->allowDownload = true;
                } else {
                        $repo =& $this->findRepository($myrep);
                        $repo->allowDownload();
                }
        }

        function disallowDownload($myrep = 0) {
                if (empty($myrep)) {
                        $this->allowDownload = false;
                } else {
                        $repo =& $this->findRepository($myrep);
                        $repo->disallowDownload();
                }
        }

        function getAllowDownload() {
                return $this->allowDownload;
        }

        function setTempDir($tempDir) {
                $this->tempDir = $tempDir;
        }

        function getTempDir() {
                if (empty($this->tempDir)) {
                        $this->tempDir = sys_get_temp_dir();
                }
                return $this->tempDir;
        }

        function setMinDownloadLevel($level, $myrep = 0) {
                if (empty($myrep)) {
                        $this->minDownloadLevel = $level;
                } else {
                        $repo =& $this->findRepository($myrep);
                        $repo->setMinDownloadLevel($level);
                }
        }

        function getMinDownloadLevel() {
                return $this->minDownloadLevel;
        }

        function addAllowedDownloadException($path, $myrep = 0) {
                if ($path[strlen($path) - 1] != '/') {
                        $path .= '/';
                }

                if (empty($myrep)) {
                        $this->allowedExceptions[] = $path;
                } else {
                        $repo =& $this->findRepository($myrep);
                        $repo->addAllowedDownloadException($path);
                }
        }

        function addDisallowedDownloadException($path, $myrep = 0) {
                if ($path[strlen($path) - 1] != '/') {
                        $path .= '/';
                }

                if (empty($myrep)) {
                        $this->disallowedExceptions[] = $path;
                } else {
                        $repo =& $this->findRepository($myrep);
                        $repo->addDisallowedDownloadException($path);
                }
        }

        function findException($path, $exceptions) {
                foreach ($exceptions as $key => $exc) {
                        if (strncmp($exc, $path, strlen($exc)) == 0) {
                                return true;
                        }
                }

                return false;
        }

        // }}}

        // {{{ getURL
        //
        // Get the URL to a path name based on the current config

        function getURL($rep, $path, $op) {
                list($base, $params) = $this->getUrlParts($rep, $path, $op);
                $url = $base.'?';
                foreach ($params as $k => $v) {
                        $url .= $k.'='.rawurlencode($v).'&amp;';
                }
                return $url;
        }

        // }}}

        // {{{ getUrlParts
        //
        // Get the URL and parameters for a path name based on the current config

        function getUrlParts($rep, $path, $op) {
                $params = array();

                if ($this->multiViews) {
                        $url = $_SERVER['SCRIPT_NAME'];
                        if (preg_match('|\.php$|i', $url)) {
                                // remove the .php extension
                                $url = substr($url, 0, -4);
                        }

                        if ($path && $path[0] != '/') {
                                $path = '/'.$path;
                        }

                        if (substr($url, -5) == 'index') {
                                $url = substr($url, 0, -5).$this->multiViewsIndex;
                        }

                        if ($op == 'index') {
                                $url .= '/';
                        } else if (is_object($rep)) {
                                $url .= '/'.$rep->getDisplayName().str_replace('%2F', '/', rawurlencode($path ?? ''));

                                if ($op && $op != 'dir' && $op != 'file') {
                                        $params['op'] = $op;
                                }
                        }

                } else {
                        switch ($op) {
                                case 'index':
                                        $url = '.';
                                        break;

                                case 'dir':
                                        $url = 'listing.php';
                                        break;

                                case 'revision':
                                        $url = 'revision.php';
                                        break;

                                case 'file':
                                        $url = 'filedetails.php';
                                        break;

                                case 'log':
                                        $url = 'log.php';
                                        break;

                                case 'diff':
                                        $url = 'diff.php';
                                        break;

                                case 'blame':
                                        $url = 'blame.php';
                                        break;

                                case 'form':
                                        $url = 'form.php';
                                        break;

                                case 'rss':
                                        $url = 'rss.php';
                                        break;

                                case 'dl':
                                        $url = 'dl.php';
                                        break;

                                case 'comp':
                                        $url = 'comp.php';
                                        break;

                                case 'search':
                                        $url = 'search.php';
                                        break;
                        }

                        if (is_object($rep) && $op != 'index') {
                                $params['repname'] = $rep->getDisplayName();
                        }
                        if (!empty($path)) {
                                $params['path'] = $path;
                        }
                }

                return array($url, $params);
        }

        // }}}

        // {{{ Paths and Commands

        // setPath
        //
        // Set the location of the given path

        function _setPath(&$var, $path, $name, $params = '') {
                if ($path == '') {
                        // Search in system search path. No check for existence possible
                        $var = $name;
                } else {
                        $lastchar = substr($path, -1, 1);
                        $isDir = ($lastchar == DIRECTORY_SEPARATOR || $lastchar == '/' || $lastchar == '\\');

                        if (!$isDir) $path .= DIRECTORY_SEPARATOR;

                        if (($this->serverIsWindows && !file_exists($path.$name.'.exe')) || (!$this->serverIsWindows && !file_exists($path.$name))) {
                                echo 'Unable to find "'.$name.'" tool at location "'.$path.$name.'"';
                                exit;
                        }

                        // On a windows machine we need to put quotes around the
                        // entire command to allow for spaces in the path
                        if ($this->serverIsWindows) {
                                $var = '"'.$path.$name.'"';
                        } else {
                                $var = $path.$name;
                        }
                }

                // Append parameters
                if ($params != '') $var .= ' '.$params;
        }

        // Define directory path to use for --config-dir parameter
        function setSvnConfigDir($path) {
                $this->_svnConfigDir = $path;
                $this->_updateSvnCommand();
        }

        // Define flag to use --trust-server-cert parameter
        function setTrustServerCert() {
                $this->_svnTrustServerCert = true;
                $this->_updateSvnCommand();
        }

        // Define the location of the svn command (e.g. '/usr/bin')
        function setSvnCommandPath($path) {
                $this->_svnCommandPath = $path;
                $this->_updateSvnCommand();
        }

        // Define the location of the svnauthz command (e.g. '/usr/bin')
        function setSvnAuthzCommandPath($path) {
                $this->_setPath($this->svnAuthz, $path, 'svnauthz', 'accessof');
        }

        function _updateSvnCommand() {
                $this->_setPath($this->svn, $this->_svnCommandPath, 'svn', '--non-interactive --config-dir '.$this->_svnConfigDir.($this->_svnTrustServerCert ? ' --trust-server-cert' : ''));
        }

        function getSvnCommand() {
                return $this->svn;
        }

        function getSvnAuthzCommand() {
                return $this->svnAuthz;
        }

        // setDiffPath
        //
        // Define the location of the diff command

        function setDiffPath($path) {
                $this->_setPath($this->diff, $path, 'diff');
        }

        function getDiffCommand() {
                return $this->diff;
        }

        // setEnscriptPath
        //
        // Define the location of the enscript command

        function setEnscriptPath($path) {
                $this->_setPath($this->enscript, $path, 'enscript', '-q');
        }

        function getEnscriptCommand() {
                return $this->enscript;
        }

        // setSedPath
        //
        // Define the location of the sed command

        function setSedPath($path) {
                $this->_setPath($this->sed, $path, 'sed');
        }

        function getSedCommand() {
                return $this->sed;
        }

        // setTarPath
        //
        // Define the location of the tar command

        function setTarPath($path) {
                $this->_setPath($this->tar, $path, 'tar');
        }

        function getTarCommand() {
                return $this->tar;
        }

        // setGzipPath
        //
        // Define the location of the GZip command

        function setGzipPath($path) {
                $this->_setPath($this->gzip, $path, 'gzip');
        }

        function getGzipCommand() {
                return $this->gzip;
        }

        // setZipPath
        //
        // Define the location of the zip command
        function setZipPath($path) {
                $this->_setPath($this->zip, $path, 'zip');
        }

        function getZipPath() {
                return $this->zip;
        }

        // setLocale
        //
        // Set the locale for PHP and all spawned processes

        function setLocale($locale) {
                $this->locale = $locale;
        }

        function getLocale() {
                return $this->locale;
        }

        // setDefaultFileDlMode
        //
        // Define the default file download mode - one of [gzip, zip, plain]
        function setDefaultFileDlMode($dlmode) {
                if (in_array($dlmode, $this->validFileDlModes)) {
                        $this->defaultFileDlMode = $dlmode;
                } else {
                        echo 'Setting default file download mode to an invalid value "'.$dlmode.'"';
                        exit;
                }
        }

        function getDefaultFileDlMode() {
                return $this->defaultFileDlMode;
        }

        // setDefaultDirectoryDlMode
        //
        // Define the default directory download mode - one of [gzip, zip]
        function setDefaultDirectoryDlMode($dlmode) {
                if (in_array($dlmode, $this->validDirectoryDlModes)) {
                        $this->defaultDirectoryDlMode = $dlmode;
                } else {
                        echo 'Setting default directory download mode to an invalid value "'.$dlmode.'"';
                        exit;
                }
        }

        function setDefaultFolderDlMode($dlmode) {
                $this->setDefaultDirectoryDlMode($dlmode);
        }

        function getDefaultDirectoryDlMode() {
                return $this->defaultDirectoryDlMode;
        }

        function getDefaultFolderDlMode() {
                return $this->getDefaultDirectoryDlMode();
        }

        // Templates

        function addTemplatePath($path) {
                $lastchar = substr($path, -1, 1);
                if ($lastchar != '/' && $lastchar != '\\') {
                        $path .= DIRECTORY_SEPARATOR;
                }

                if (!in_array($path, $this->templatePaths)) {
                        $this->templatePaths[] = $path;
                }
        }

        function setTemplatePath($path, $myrep = null) {
                $lastchar = substr($path, -1, 1);
                if ($lastchar != '/' && $lastchar != '\\') {
                        $path .= DIRECTORY_SEPARATOR;
                }

                if ($myrep !== null) {
                        // fixed template for specific repository
                        $repo =& $this->findRepository($myrep);
                        $repo->setTemplatePath($path);
                } else {
                        // for backward compatibility
                        if (in_array($path, $this->templatePaths)) {
                                array_splice($this->templatePaths, array_search($path, $this->templatePaths), 1);
                        }
                        array_unshift($this->templatePaths, $path);
                }
        }

        function getTemplatePath() {
                if (count($this->templatePaths) == 0) {
                        echo 'No template path added in config file';
                        exit;
                }
                if ($this->userTemplate !== false)
                        return $this->userTemplate;
                else
                        return $this->templatePaths[0];
        }

        // }}}

        function setDefaultLanguage($language) {
                $this->defaultLanguage = $language;
        }

        function getDefaultLanguage() {
                return $this->defaultLanguage;
        }

        function ignoreUserAcceptedLanguages() {
                $this->ignoreAcceptedLanguages = true;
        }

        function useAcceptedLanguages() {
                return !$this->ignoreAcceptedLanguages;
        }

        // {{{ Tab expansion functions

        function expandTabsBy($sp, $myrep = 0) {
                if (empty($myrep)) {
                        $this->spaces = $sp;
                } else {
                        $repo =& $this->findRepository($myrep);
                        $repo->expandTabsBy($sp);
                }
        }

        function getExpandTabsBy() {
                return $this->spaces;
        }

        // }}}

        // {{{ Bugtraq issue tracking

        function setBugtraqEnabled($enabled, $myrep = 0) {
                if (empty($myrep)) {
                        $this->bugtraq = $enabled;
                } else {
                        $repo =& $this->findRepository($myrep);
                        $repo->setBugtraqEnabled($enabled);
                }
        }

        function isBugtraqEnabled() {
                return $this->bugtraq;
        }

        function setBugtraqProperties($message, $logregex, $url, $append = true, $myrep = null) {
                $properties = array();
                $properties['bugtraq:message'] = $message;
                $properties['bugtraq:logregex'] = $logregex;
                $properties['bugtraq:url'] = $url;
                $properties['bugtraq:append'] = (bool)$append;
                if ($myrep === null) {
                        $this->bugtraqProperties = $properties;
                } else {
                        $repo =& $this->findRepository($myrep);
                        $repo->setBugtraqProperties($properties);
                }
        }

        function getBugtraqProperties() {
                return $this->bugtraqProperties;
        }

        // }}}

        // {{{ Misc settings

        function ignoreSvnMimeTypes() {
                $this->ignoreSvnMimeTypes = true;
        }

        function getIgnoreSvnMimeTypes() {
                return $this->ignoreSvnMimeTypes;
        }

        function ignoreWebSVNContentTypes() {
                $this->ignoreWebSVNContentTypes = true;
        }

        function getIgnoreWebSVNContentTypes() {
                return $this->ignoreWebSVNContentTypes;
        }

        function useAccessFile($file, $myrep = 0) {
                if (empty($myrep)) {
                        if (is_readable($file)) {
                                if ($this->authz === null) {
                                        $this->authz = new Authorization();
                                }
                                $this->authz->addAccessFile($file);
                        } else {
                                echo 'Unable to read access file "'.$file.'"';
                                exit;
                        }
                } else {
                        $repo =& $this->findRepository($myrep);
                        $repo->useAccessFile($file);
                }
        }

        function &getAuthz() {
                return $this->authz;
        }

        function areRobotsBlocked() {
                return $this->blockRobots;
        }

        function setBlockRobots($value = true) {
                $this->blockRobots = $value;
        }

        function useTreeView() {
                $this->treeView = true;
        }

        function getUseTreeView() {
                return $this->treeView;
        }

        function useFlatView() {
                $this->treeView = false;
        }

        function useTreeIndex($open) {
                $this->flatIndex = false;
                $this->openTree = $open;
        }

        function getUseFlatIndex() {
                return $this->flatIndex;
        }

        function getOpenTree() {
                return $this->openTree;
        }

        function setLoadAllRepos($flag) {
                $this->loadAllRepos = $flag;
        }

        function showLoadAllRepos() {
                return $this->loadAllRepos;
        }

        function setAlphabeticOrder($flag) {
                $this->alphabetic = $flag;
        }

        function isAlphabeticOrder() {
                return $this->alphabetic;
        }

        function showLastModInIndex() {
                return $this->showLastModInIndex;
        }

        function setShowLastModInIndex($show) {
                $this->showLastModInIndex = $show;
        }

        function showLastModInListing() {
                return $this->showLastModInListing;
        }

        function setShowLastModInListing($show) {
                $this->showLastModInListing = $show;
        }

        function showAgeInsteadOfDate() {
                return $this->showAgeInsteadOfDate;
        }

        function setShowAgeInsteadOfDate($show) {
                $this->showAgeInsteadOfDate = $show;
        }

        function showRepositorySelectionForm() {
                return $this->_showRepositorySelectionForm;
        }

        function setShowRepositorySelectionForm($show) {
                $this->_showRepositorySelectionForm = $show;
        }

        function getIgnoreWhitespacesInDiff() {
                return $this->_ignoreWhitespacesInDiff;
        }

        function setIgnoreWhitespacesInDiff($ignore) {
                $this->_ignoreWhitespacesInDiff = $ignore;
        }

        // Methods for storing version information for the command-line svn tool

        function setSubversionVersion($subversionVersion) {
                $this->subversionVersion = $subversionVersion;
        }

        function getSubversionVersion() {
                return $this->subversionVersion;
        }

        function setSubversionMajorVersion($subversionMajorVersion) {
                $this->subversionMajorVersion = $subversionMajorVersion;
        }

        function getSubversionMajorVersion() {
                return $this->subversionMajorVersion;
        }

        function setSubversionMinorVersion($subversionMinorVersion) {
                $this->subversionMinorVersion = $subversionMinorVersion;
        }

        function getSubversionMinorVersion() {
                return $this->subversionMinorVersion;
        }

        // }}}

        // {{{ Sort the repostories
        //
        // This function sorts the repositories by group name.  The contents of the
        // group are left in there original order, which will either be sorted if the
        // group was added using the parentPath function, or defined for the order in
        // which the repositories were included in the user's config file.
        //
        // Note that as of PHP 4.0.6 the usort command no longer preserves the order
        // of items that are considered equal (in our case, part of the same group).
        // The mergesort function preserves this order.

        function sortByGroup() {
                if (!empty($this->_repositories)) {
                        mergesort($this->_repositories, 'cmpGroups');
                }
        }

        // }}}

        // {{{ Change the name of the breadcrumb root-phrase to that of the current repo?

        function setBreadcrumbRepoRootAsRepo($newValue) {
                $this->breadcrumbRepoRootAsRepo = $newValue;
        }

        function getBreadcrumbRepoRootAsRepo() {
                return $this->breadcrumbRepoRootAsRepo;
        }

        // }}}
}