upgrade

main/inc/lib/pear/Text/CAPTCHA.php

@@ -0,0 +1,156 @@
+<?php
+
+/**
+ * Text_CAPTCHA - creates a CAPTCHA for Turing tests.
+ * Base class file for using Text_CAPTCHA.
+ *
+ * PHP version 5
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   Christian Wenz <wenz@php.net>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ */
+
+/**
+ * Text_CAPTCHA - creates a CAPTCHA for Turing tests.
+ * Class to create a Turing test for websites by creating an image, ASCII art or
+ * something else with some (obfuscated) characters.
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   Christian Wenz <wenz@php.net>
+ * @author   Michael Cramer <michael@bigmichi1.de>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ */
+class Text_CAPTCHA
+{
+    /**
+     * driver for Text_CAPTCHA
+     *
+     * @var Text_CAPTCHA_Driver_Base
+     */
+    private $_driver;
+
+    /**
+     * check if an initial driver init was done.
+     *
+     * @var bool
+     */
+    private $_driverInitDone = false;
+
+    /**
+     * Constructor for the TEXT_CAPTCHA object with the given driver.
+     *
+     * @param Text_CAPTCHA_Driver $driver driver
+     *
+     * @throws Text_CAPTCHA_Exception no driver given
+     */
+    function __construct($driver)
+    {
+        if (is_null($driver)) {
+            throw new Text_CAPTCHA_Exception("No driver given");
+        }
+        $this->_driver = $driver;
+        $this->_driverInitDone = false;
+    }
+
+    /**
+     * Create a new Text_CAPTCHA object.
+     *
+     * @param string $driver name of driver class to initialize
+     *
+     * @return Text_CAPTCHA a newly created Text_CAPTCHA object
+     * @throws Text_CAPTCHA_Exception when driver could not be loaded
+     *
+     */
+    public static function factory($driver)
+    {
+        $driver = basename($driver);
+        $class = 'Text_CAPTCHA_Driver_' . $driver;
+        /*$file = str_replace('_', '/', $class) . '.php';
+        //check if it exists and can be loaded
+        if (!@fclose(@fopen($file, 'r', true))) {
+            throw new Text_CAPTCHA_Exception(
+                'Driver ' . $driver . ' cannot be loaded.'
+            );
+        }
+        //continue with including the driver
+        include_once $file;*/
+
+        $driver = new $class;
+
+        return new Text_CAPTCHA($driver);
+    }
+
+    /**
+     * Create random CAPTCHA phrase
+     *
+     * @param boolean|string $newPhrase new Phrase to use or true to generate a new
+     *                                  one
+     *
+     * @return void
+     * @throws Text_CAPTCHA_Exception when driver is not initialized
+     */
+    public final function generate($newPhrase = false)
+    {
+        if (!$this->_driverInitDone) {
+            throw new Text_CAPTCHA_Exception("Driver not initialized");
+        }
+        if ($newPhrase === true || is_null($this->_driver->getPhrase())) {
+            $this->_driver->createPhrase();
+        } else if (strlen($newPhrase) > 0) {
+            $this->_driver->setPhrase($newPhrase);
+        }
+        $this->_driver->createCAPTCHA();
+    }
+
+    /**
+     * Reinitialize the entire Text_CAPTCHA object.
+     *
+     * @param array $options Options to pass in.
+     *
+     * @return void
+     */
+    public final function init($options = array())
+    {
+        $this->_driver->resetDriver();
+        $this->_driver->initDriver($options);
+        $this->_driverInitDone = true;
+        $this->generate();
+    }
+
+    /**
+     * Place holder for the real getCAPTCHA() method used by extended classes to
+     * return the generated CAPTCHA (as an image resource, as an ASCII text, ...).
+     *
+     * @return string|object
+     */
+    public final function getCAPTCHA()
+    {
+        return $this->_driver->getCAPTCHA();
+    }
+
+    /**
+     * Return secret CAPTCHA phrase.
+     *
+     * @return string secret phrase
+     */
+    public final function getPhrase()
+    {
+        return $this->_driver->getPhrase();
+    }
+
+    /**
+     * Place holder for the real getCAPTCHA() method used by extended classes to
+     * return the generated CAPTCHA (as an image resource, as an ASCII text, ...).
+     *
+     * @return string|object
+     */
+    public function getCAPTCHAAsJPEG()
+    {
+        return $this->_driver->_getCAPTCHAAsJPEG();
+    }
+}

main/inc/lib/pear/Text/CAPTCHA/Driver.php

@@ -0,0 +1,56 @@
+<?php
+/**
+ * Interface for Drivers
+ *
+ * PHP version 5
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   Michael Cramer <michael@bigmichi1.de>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ */
+/**
+ * Interface for Text_CAPTCHA drivers
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   Michael Cramer <michael@bigmichi1.de>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ */
+interface Text_CAPTCHA_Driver
+{
+    /**
+     * Clear the internal state of the driver.
+     *
+     * @return void
+     */
+    function resetDriver();
+
+    /**
+     * Initialize the driver with the given options.
+     *
+     * @param array $options options for the driver as array
+     *
+     * @return void
+     * @throws Text_CAPTCHA_Exception something went wrong during init
+     */
+    function initDriver($options);
+
+    /**
+     * Generate the CAPTCHA.
+     *
+     * @return void
+     * @throws Text_CAPTCHA_Exception something went wrong during creation of CAPTCHA
+     */
+    function createCAPTCHA();
+
+    /**
+     * Generate the phrase for the CAPTCHA.
+     *
+     * @return void
+     * @throws Text_CAPTCHA_Exception something went wrong during creation of phrase
+     */
+    function createPhrase();
+}

main/inc/lib/pear/Text/CAPTCHA/Driver/Base.php

@@ -0,0 +1,97 @@
+<?php
+/**
+ * Base class file for all Text_CAPTCHA drivers.
+ *
+ * PHP version 5
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   Michael Cramer <michael@bigmichi1.de>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ */
+
+/**
+ * Base class file for all Text_CAPTCHA drivers.
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   Michael Cramer <michael@bigmichi1.de>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ */
+abstract class Text_CAPTCHA_Driver_Base implements Text_CAPTCHA_Driver
+{
+    /**
+     * Captcha
+     *
+     * @var object|string
+     */
+    private $_captcha;
+
+    /**
+     * Phrase
+     *
+     * @var string
+     */
+    private $_phrase;
+
+    /**
+     * Sets secret CAPTCHA phrase.
+     * This method sets the CAPTCHA phrase (use null for a random phrase)
+     *
+     * @param string $phrase The (new) phrase
+     *
+     * @return void
+     */
+    public final function setPhrase($phrase)
+    {
+        $this->_phrase = $phrase;
+    }
+
+    /**
+     * Return secret CAPTCHA phrase
+     * This method returns the CAPTCHA phrase
+     *
+     * @return  string   secret phrase
+     */
+    public final function getPhrase()
+    {
+        return $this->_phrase;
+    }
+
+    /**
+     * Sets the generated captcha.
+     *
+     * @param object|string $captcha the generated captcha
+     *
+     * @return void
+     */
+    protected final function setCaptcha($captcha)
+    {
+        $this->_captcha = $captcha;
+    }
+
+    /**
+     * Place holder for the real getCAPTCHA() method
+     * used by extended classes to return the generated CAPTCHA
+     * (as an image resource, as an ASCII text, ...)
+     *
+     * @return string|object
+     */
+    public final function getCAPTCHA()
+    {
+        return $this->_captcha;
+    }
+
+    /**
+     * Reset the phrase and the CAPTCHA.
+     *
+     * @return void
+     */
+    public function resetDriver()
+    {
+        $this->setPhrase(null);
+        $this->setCaptcha(null);
+    }
+}

main/inc/lib/pear/Text/CAPTCHA/Driver/Equation.php

@@ -0,0 +1,215 @@
+<?php
+/**
+ * Equation driver for Text_CAPTCHA.
+ * Returns simple equations as string, e.g. "9 - 2"
+ *
+ * PHP version 5
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   Christian Weiske <cweiske@php.net>
+ * @author   Christian Wenz <wenz@php.net>
+ * @author   Michael Cramer <michael@bigmichi1.de>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ */
+
+/**
+ * Equation driver for Text_CAPTCHA.
+ * Returns simple equations as string, e.g. "9 - 2"
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   Christian Weiske <cweiske@php.net>
+ * @author   Christian Wenz <wenz@php.net>
+ * @author   Michael Cramer <michael@bigmichi1.de>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ */
+class Text_CAPTCHA_Driver_Equation extends Text_CAPTCHA_Driver_Base
+{
+    /**
+     * Operators that may be used in the equation. Two numbers have to be filled in,
+     * and %s is needed since number2text conversion may be applied and strings
+     * filled in.
+     *
+     * @var array
+     */
+    private $_operators = array(
+        '%s * %s',
+        '%s + %s',
+        '%s - %s',
+        'min(%s, %s)',
+        'max(%s, %s)'
+    );
+
+    /**
+     * Minimal number to use in an equation.
+     *
+     * @var int
+     */
+    private $_min = 1;
+
+    /**
+     * Maximum number to use in an equation.
+     *
+     * @var int
+     */
+    private $_max = 10;
+
+    /**
+     * Whether numbers shall be converted to text.
+     *
+     * @var bool
+     */
+    private $_numbersToText = false;
+
+    /**
+     * This variable holds the locale for Numbers_Words.
+     *
+     * @var string
+     */
+    private $_locale = '';
+
+    /**
+     * Complexity of the generated equations.<br>
+     * 1 - simple ones such as "1 + 10"<br>
+     * 2 - harder ones such as "(3-2)*(min(5,6))"
+     *
+     * @var int
+     */
+    private $_severity = 1;
+
+    /**
+     * Initialize the driver.
+     *
+     * @param array $options CAPTCHA options with these keys:<br>
+     *                       min           minimum numeric value
+     *                       max           maximum numeric value
+     *                       numbersToText boolean for number to text conversion
+     *                       locale        locale for number to text conversion
+     *                       severity      number for complexity
+     *
+     * @return void
+     * @throws Text_CAPTCHA_Exception when numbersToText is true, but Number_Words
+     *                                package is not available
+     */
+    public function initDriver($options = array())
+    {
+        if (isset($options['min'])) {
+            $this->_min = (int)$options['min'];
+        } else {
+            $this->_min = 1;
+        }
+        if (isset($options['max'])) {
+            $this->_max = (int)$options['max'];
+        } else {
+            $this->_max = 10;
+        }
+        if (isset($options['numbersToText'])) {
+            $this->_numbersToText = (bool)$options['numbersToText'];
+        } else {
+            $this->_numbersToText = false;
+        }
+        if (isset($options['locale'])) {
+            $this->_locale = (string)$options['locale'];
+        } else {
+            $this->_locale = '';
+        }
+        if (isset($options['severity'])) {
+            $this->_severity = (int)$options['severity'];
+        } else {
+            $this->_severity = 1;
+        }
+
+        if ($this->_numbersToText) {
+            include_once 'Numbers/Words.php';
+            if (!class_exists('Numbers_Words')) {
+                throw new Text_CAPTCHA_Exception('Number_Words package required');
+            }
+        }
+    }
+
+    /**
+     * Create random CAPTCHA equation.
+     * This method creates a random equation.
+     *
+     * @return void
+     * @throws Text_CAPTCHA_Exception when invalid severity is specified
+     */
+    public function createCAPTCHA()
+    {
+        switch ($this->_severity) {
+        case 1:
+            list($equation, $phrase) = $this->_createSimpleEquation();
+            break;
+        case 2:
+            list($eq1, $sol1) = $this->_createSimpleEquation();
+            list($eq2, $sol2) = $this->_createSimpleEquation();
+            $op3 = $this->_operators[mt_rand(0, count($this->_operators) - 1)];
+            list(, $phrase) = $this->_solveSimpleEquation($sol1, $sol2, $op3);
+            $equation = sprintf($op3, '(' . $eq1 . ')', '(' . $eq2 . ')');
+            break;
+        default:
+            throw new Text_CAPTCHA_Exception(
+                'Equation complexity of ' . $this->_severity . ' not supported'
+            );
+        }
+        $this->setCaptcha($equation);
+        $this->setPhrase($phrase);
+    }
+
+    /**
+     * Creates a simple equation of type (number operator number).
+     *
+     * @return array Array with equation and solution
+     */
+    private function _createSimpleEquation()
+    {
+        $one = mt_rand($this->_min, $this->_max);
+        $two = mt_rand($this->_min, $this->_max);
+        $operator = $this->_operators[mt_rand(0, count($this->_operators) - 1)];
+
+        return $this->_solveSimpleEquation($one, $two, $operator);
+    }
+
+    /**
+     * Solves a simple equation with two given numbers and one operator as defined
+     * in $this->_operators.
+     * Also converts the numbers to words if required.
+     *
+     * @param int    $one      First number
+     * @param int    $two      Second number
+     * @param string $operator Operator used with those two numbers
+     *
+     * @return array    Array with equation and solution
+     */
+    private function _solveSimpleEquation($one, $two, $operator)
+    {
+        $equation = sprintf($operator, $one, $two);
+
+        $function = create_function('', 'return ' . $equation . ';');
+
+        if ($this->_numbersToText) {
+            $numberWords = new Numbers_Words();
+            $equation = sprintf(
+                $operator,
+                $numberWords->toWords($one, $this->_locale),
+                $numberWords->toWords($two, $this->_locale)
+            );
+        }
+        return array($equation, $function());
+    }
+
+    /**
+     * Creates the captcha. This method is a placeholder, since the equation is
+     * created in createCAPTCHA()
+     *
+     * @return void
+     * @see createCAPTCHA()
+     */
+    public function createPhrase()
+    {
+        $this->setPhrase(null);
+    }
+}

main/inc/lib/pear/Text/CAPTCHA/Driver/Figlet.php

@@ -0,0 +1,231 @@
+<?php
+/**
+ * Require Figlet class for rendering the text.
+ *
+ * PHP version 5
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   Aaron Wormus <wormus@php.net>
+ * @author   Christian Wenz <wenz@php.net>
+ * @author   Michael Cramer <michael@bigmichi1.de>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ */
+/**
+ * Text_CAPTCHA_Driver_Figlet - Text_CAPTCHA driver Figlet based CAPTCHAs
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   Aaron Wormus <wormus@php.net>
+ * @author   Christian Wenz <wenz@php.net>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ * @todo     define an obfuscation algorithm
+ */
+class Text_CAPTCHA_Driver_Figlet extends Text_CAPTCHA_Driver_Base
+{
+    /**
+     * Text_Password options.
+     *
+     * @var array
+     */
+    private $_textPasswordOptions;
+
+    /**
+     * Width of CAPTCHA
+     *
+     * @var int
+     */
+    private $_width;
+
+    /**
+     * Length of CAPTCHA
+     *
+     * @var int
+     */
+    private $_length;
+
+    /**
+     * Figlet font
+     *
+     * @var string
+     */
+    private $_font;
+
+    /**
+     * Figlet font
+     *
+     * @var array
+     */
+    private $_style = array();
+
+    /**
+     * Output Format
+     *
+     * @var string
+     */
+    private $_output;
+
+    /**
+     * init function
+     *
+     * Initializes the new Text_CAPTCHA_Driver_Figlet object and creates a GD image
+     *
+     * @param array $options CAPTCHA options
+     *
+     * @return void
+     * @throws Text_CAPTCHA_Exception when no options are given
+     */
+    public function initDriver($options = array())
+    {
+        if (!empty($options['output'])) {
+            $this->_output = (string)$options['output'];
+        } else {
+            $this->_output = 'html';
+        }
+
+        if (isset($options['width']) && $options['width']) {
+            $this->_width = (int)$options['width'];
+        } else {
+            $this->_width = 200;
+        }
+
+        if (!empty($options['length'])) {
+            $this->_length = $options['length'];
+        } else {
+            $this->_length = 6;
+        }
+
+        if (!isset($options['phrase']) || empty($options['phrase'])) {
+            $phraseOptions = (isset($options['phraseOptions'])
+                && is_array($options['phraseOptions']))
+                ? $options['phraseOptions'] : array();
+            $this->_textPasswordOptions = $phraseOptions;
+        } else {
+            $this->setPhrase($options['phrase']);
+        }
+
+        if (!empty($options['style'])
+            && is_array($options['style'])
+        ) {
+            $this->_style = $options['style'];
+        }
+
+        if (empty($this->_style['padding'])) {
+            $this->_style['padding'] = '5px';
+        }
+
+        if (!empty($options['font_file'])) {
+            if (is_array($options['font_file'])) {
+                $arr = $options['font_file'];
+                $this->_font = $arr[array_rand($arr)];
+            } else {
+                $this->_font = $options['font_file'];
+            }
+        }
+    }
+
+    /**
+     * Create the passphrase.
+     *
+     * @return string
+     */
+    public function createPhrase()
+    {
+        $options = $this->_textPasswordOptions;
+        $textPassword = new Text_Password();
+        if (!is_array($options) || count($options) === 0) {
+            $this->setPhrase($textPassword->create($this->_length));
+        } else {
+            if (count($options) === 1) {
+                $this->setPhrase($textPassword->create($this->_length, $options[0]));
+            } else {
+                $this->setPhrase(
+                    $textPassword->create($this->_length, $options[0], $options[1])
+                );
+            }
+        }
+    }
+
+    /**
+     * Create CAPTCHA image.
+     *
+     * This method creates a CAPTCHA image.
+     *
+     * @return void on error
+     * @throws Text_CAPTCHA_Exception when loading font fails
+     */
+    public function createCAPTCHA()
+    {
+        $pear = new PEAR();
+        $figlet = new Text_Figlet();
+        if ($pear->isError($figlet->loadFont($this->_font))) {
+            throw new Text_CAPTCHA_Exception('Error loading Text_Figlet font');
+        }
+
+        $outputString = $figlet->lineEcho($this->getPhrase());
+
+        switch ($this->_output) {
+        case 'text':
+            $this->setCaptcha($outputString);
+            break;
+        case 'html':
+            $this->setCaptcha($this->_getCAPTCHAAsHTML($outputString));
+            break;
+        case 'javascript':
+            $this->setCaptcha($this->_getCAPTCHAAsJavascript($outputString));
+            break;
+        default:
+            throw new Text_CAPTCHA_Exception('Invalid output option given');
+        }
+    }
+
+    /**
+     * Return CAPTCHA as HTML.
+     *
+     * This method returns the CAPTCHA as HTML.
+     *
+     * @param string $figletOutput output string from Figlet.
+     *
+     * @return string HTML Figlet image or PEAR error
+     */
+    private function _getCAPTCHAAsHTML($figletOutput)
+    {
+        $charWidth = strpos($figletOutput, "\n");
+        $data = str_replace("\n", '<br />', $figletOutput);
+        $textSize = ($this->_width / $charWidth) * 1.4;
+        $cssOutput = "";
+        foreach ($this->_style as $key => $value) {
+            $cssOutput .= "$key: $value;";
+        }
+
+        $htmlOutput = '<div style="font-family: courier;
+          font-size: ' . $textSize . 'px;
+          width:' . $this->_width . 'px;
+          text-align:center;">';
+        $htmlOutput .= '<div style="' . $cssOutput . 'margin:0px;">
+          <pre style="padding: 0px; margin: 0px;">' . $data . '</pre></div></div>';
+
+        return $htmlOutput;
+    }
+
+    /**
+     * Return CAPTCHA as Javascript version of HTML.
+     *
+     * This method returns the CAPTCHA as a Javascript string.
+     * I'm not exactly sure what the point of doing this would be.
+     *
+     * @param string $figletOutput output string from Figlet.
+     *
+     * @return string javascript string or PEAR error
+     */
+    private function _getCAPTCHAAsJavascript($figletOutput)
+    {
+        $obfusData = rawurlencode($figletOutput);
+        $javascript = "<script language=\"javascript\">
+          document.write(unescape(\"$obfusData\" ) );
+          </script>";
+        return $javascript;
+    }
+}

main/inc/lib/pear/Text/CAPTCHA/Driver/Image.php

@@ -0,0 +1,289 @@
+<?php
+/**
+ * Require Image_Text class for generating the text.
+ *
+ * PHP version 5
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   Christian Wenz <wenz@php.net>
+ * @author   Michael Cramer <michael@bigmichi1.de>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ */
+
+/**
+ * Text_CAPTCHA_Driver_Image - Text_CAPTCHA driver graphical CAPTCHAs
+ *
+ * Class to create a graphical Turing test
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   Christian Wenz <wenz@php.net>
+ * @author   Michael Cramer <michael@bigmichi1.de>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ * @todo     refine the obfuscation algorithm :-)
+ * @todo     consider removing Image_Text dependency
+ */
+class Text_CAPTCHA_Driver_Image extends Text_CAPTCHA_Driver_Base
+{
+    /**
+     * Text_Password options.
+     *
+     * @var array
+     */
+    private $_textPasswordOptions;
+    /**
+     * Width of CAPTCHA
+     *
+     * @var int
+     */
+    private $_width;
+
+    /**
+     * Height of CAPTCHA
+     *
+     * @var int
+     */
+    private $_height;
+
+    /**
+     * CAPTCHA output format
+     *
+     * @var string
+     */
+    private $_output;
+
+    /**
+     * Further options (here: for Image_Text)
+     *
+     * @var array
+     */
+    private $_imageOptions = array(
+        'font_size' => 24,
+        'font_path' => './',
+        'font_file' => 'COUR.TTF',
+        'text_color' => '#000000',
+        'lines_color' => '#CACACA',
+        'background_color' => '#555555',
+        'antialias' => false
+    );
+
+    /**
+     * Init function
+     *
+     * Initializes the new Text_CAPTCHA_Driver_Image object and creates a GD image
+     *
+     * @param array $options CAPTCHA options
+     *
+     * @return void
+     */
+    public function initDriver($options = array())
+    {
+        if (is_array($options)) {
+            if (isset($options['width']) && is_int($options['width'])) {
+                $this->_width = $options['width'];
+            } else {
+                $this->_width = 200;
+            }
+            if (isset($options['height']) && is_int($options['height'])) {
+                $this->_height = $options['height'];
+            } else {
+                $this->_height = 80;
+            }
+            if (!isset($options['phrase']) || empty($options['phrase'])) {
+                $phraseOptions = (isset($options['phraseOptions'])
+                    && is_array($options['phraseOptions']))
+                    ? $options['phraseOptions'] : array();
+                $this->_textPasswordOptions = $phraseOptions;
+            } else {
+                $this->setPhrase($options['phrase']);
+            }
+            if (!isset($options['output']) || empty($options['output'])) {
+                $this->_output = 'jpeg';
+            } else {
+                $this->_output = $options['output'];
+            }
+            if (isset($options['imageOptions'])
+                && is_array($options['imageOptions'])
+                && count($options['imageOptions']) > 0
+            ) {
+                $this->_imageOptions = array_merge(
+                    $this->_imageOptions, $options['imageOptions']
+                );
+            }
+        }
+    }
+
+    /**
+     * Create CAPTCHA image.
+     *
+     * This method creates a CAPTCHA image.
+     *
+     * @return void
+     * @throws Text_CAPTCHA_Exception when image generation with Image_Text produces
+     *               an error
+     */
+    public function createCAPTCHA()
+    {
+        $options['canvas'] = array(
+            'width' => $this->_width,
+            'height' => $this->_height
+        );
+        $options['width'] = $this->_width - 20;
+        $options['height'] = $this->_height - 20;
+        $options['cx'] = ceil(($this->_width) / 2 + 10);
+        $options['cy'] = ceil(($this->_height) / 2 + 10);
+        $options['angle'] = rand(0, 30) - 15;
+        $options['font_size'] = $this->_imageOptions['font_size'];
+        $options['font_path'] = $this->_imageOptions['font_path'];
+        $options['font_file'] = $this->_imageOptions['font_file'];
+        $options['color'] = array($this->_imageOptions['text_color']);
+        $options['background_color'] = $this->_imageOptions['background_color'];
+        $options['max_lines'] = 1;
+        $options['mode'] = 'auto';
+
+        do {
+            $imageText = new Image_Text($this->getPhrase(), $options);
+            $imageText->init();
+            $result = $imageText->measurize();
+        } while ($result === false && --$options['font_size'] > 0);
+        if ($result === false) {
+            throw new Text_CAPTCHA_Exception(
+                'The text provided does not fit in the image dimensions'
+            );
+        }
+        $imageText->render();
+        $image = $imageText->getImg();
+
+        if ($this->_imageOptions['antialias'] && function_exists('imageantialias')) {
+            imageantialias($image, true);
+        }
+
+        $colors = Image_Text::convertString2RGB(
+            $this->_imageOptions['lines_color']
+        );
+        $linesColor = imagecolorallocate(
+            $image, $colors['r'], $colors['g'], $colors['b']
+        );
+        //some obfuscation
+        for ($i = 0; $i < 3; $i++) {
+            $x1 = rand(0, $this->_width - 1);
+            $y1 = rand(0, round($this->_height / 10, 0));
+            $x2 = rand(0, round($this->_width / 10, 0));
+            $y2 = rand(0, $this->_height - 1);
+            imageline($image, $x1, $y1, $x2, $y2, $linesColor);
+            $x1 = rand(0, $this->_width - 1);
+            $y1 = $this->_height - rand(1, round($this->_height / 10, 0));
+            $x2 = $this->_width - rand(1, round($this->_width / 10, 0));
+            $y2 = rand(0, $this->_height - 1);
+            imageline($image, $x1, $y1, $x2, $y2, $linesColor);
+            $cx = rand(0, $this->_width - 50) + 25;
+            $cy = rand(0, $this->_height - 50) + 25;
+            $w = rand(1, 24);
+            imagearc($image, $cx, $cy, $w, $w, 0, 360, $linesColor);
+        }
+
+        // @todo remove hardcoded value
+        $this->_output = 'jpg';
+
+        if ($this->_output == 'gif' && imagetypes() & IMG_GIF) {
+            $this->setCaptcha($this->_getCAPTCHAAsGIF($image));
+        } else if (($this->_output == 'jpg' && imagetypes() & IMG_JPG)
+            || ($this->_output == 'jpeg' && imagetypes() & IMG_JPEG)
+        ) {
+            $this->setCaptcha($this->_getCAPTCHAAsJPEG($image));
+        } else if ($this->_output == 'png' && imagetypes() & IMG_PNG) {
+            $this->setCaptcha($this->_getCAPTCHAAsPNG($image));
+        } else if ($this->_output == 'resource') {
+            $this->setCaptcha($image);
+        } else {
+            throw new Text_CAPTCHA_Exception(
+                "Unknown or unsupported output type specified"
+            );
+        }
+
+        imagedestroy($image);
+    }
+
+    /**
+     * Return CAPTCHA as PNG.
+     *
+     * This method returns the CAPTCHA as PNG.
+     *
+     * @param resource $image generated image
+     *
+     * @return string image contents
+     */
+    private function _getCAPTCHAAsPNG($image)
+    {
+        ob_start();
+        imagepng($image);
+        $data = ob_get_contents();
+        ob_end_clean();
+        return $data;
+    }
+
+    /**
+     * Return CAPTCHA as JPEG.
+     *
+     * This method returns the CAPTCHA as JPEG.
+     *
+     * @param resource $image generated image
+     *
+     * @return string image contents
+     */
+    public function _getCAPTCHAAsJPEG($image)
+    {
+        ob_start();
+        imagejpeg($image);
+        $data = ob_get_contents();
+        ob_end_clean();
+        return $data;
+    }
+
+    /**
+     * Return CAPTCHA as GIF.
+     *
+     * This method returns the CAPTCHA as GIF.
+     *
+     * @param resource $image generated image
+     *
+     * @return string image contents
+     */
+    private function _getCAPTCHAAsGIF($image)
+    {
+        ob_start();
+        imagegif($image);
+        $data = ob_get_contents();
+        ob_end_clean();
+        return $data;
+    }
+
+    /**
+     * Create random CAPTCHA phrase, Image edition (with size check).
+     *
+     * This method creates a random phrase, maximum 8 characters or width / 25,
+     * whatever is smaller.
+     *
+     * @return void
+     */
+    public function createPhrase()
+    {
+        $len = intval(min(8, $this->_width / 25));
+        $options = $this->_textPasswordOptions;
+        $textPassword = new Text_Password();
+        if (!is_array($options) || count($options) === 0) {
+            $this->setPhrase($textPassword->create($len));
+        } else {
+            if (count($options) === 1) {
+                $this->setPhrase($textPassword->create($len, $options[0]));
+            } else {
+                $this->setPhrase(
+                    $textPassword->create($len, $options[0], $options[1])
+                );
+            }
+        }
+    }
+}

main/inc/lib/pear/Text/CAPTCHA/Driver/Numeral.php

@@ -0,0 +1,268 @@
+<?php
+/**
+ * Class used for numeral captchas
+ *
+ * PHP version 5
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   David Coallier <davidc@agoraproduction.com>
+ * @author   Christian Wenz <wenz@php.net>
+ * @author   Michael Cramer <michael@bigmichi1.de>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ */
+
+/**
+ * Class used for numeral captchas
+ *
+ * This class is intended to be used to generate numeral captchas as such as:
+ * Example:
+ *  Give me the answer to "54 + 2" to prove that you are human.
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   David Coallier <davidc@agoraproduction.com>
+ * @author   Christian Wenz <wenz@php.net>
+ * @author   Michael Cramer <michael@bigmichi1.de>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ */
+class Text_CAPTCHA_Driver_Numeral extends Text_CAPTCHA_Driver_Base
+{
+    /**
+     * This variable holds the minimum range value default set to "1".
+     *
+     * @var integer $_minValue The minimum value of the number range.
+     */
+    private $_minValue = 1;
+
+    /**
+     * This variable holds the maximum range value default set to "50".
+     *
+     * @var integer $_maxValue The maximum value of the number range.
+     */
+    private $_maxValue = 50;
+
+    /**
+     * The valid operators to use in the numeral captcha. We could use / and * but
+     * not yet.
+     *
+     * @var array $_operators The operations for the captcha.
+     */
+    private $_operators = array('-', '+');
+
+    /**
+     * This variable is basically the operation that we're going to be using in the
+     * numeral captcha we are about to generate.
+     *
+     * @var string $_operator The operation's operator to use.
+     */
+    private $_operator = '';
+
+    /**
+     * This variable holds the first number of the numeral operation we are about to
+     * generate.
+     *
+     * @var integer $_firstNumber The first number of the operation.
+     */
+    private $_firstNumber = 0;
+
+    /**
+     * This variable holds the value of the second variable of the operation we are
+     * about to generate for the captcha.
+     *
+     * @var integer $_secondNumber The second number of the operation.
+     */
+    private $_secondNumber = 0;
+
+    /**
+     * Initialize numeric CAPTCHA.
+     *
+     * @param array $options CAPTCHA options with these keys:<br>
+     *                       minValue minimum value<br>
+     *                       maxValue maximum value
+     *
+     * @return void
+     */
+    public function initDriver($options = array())
+    {
+        if (isset($options['minValue'])) {
+            $this->_minValue = (int)$options['minValue'];
+        } else {
+            $this->_minValue = 1;
+        }
+        if (isset($options['maxValue'])) {
+            $this->_maxValue = (int)$options['maxValue'];
+        } else {
+            $this->_maxValue = 50;
+        }
+        if (isset($options['operator'])) {
+            $this->_operator = $options['operator'];
+        } else {
+            $this->_operator = '';
+        }
+        if (isset($options['firstValue'])) {
+            $this->_firstNumber = (int)$options['firstValue'];
+        } else {
+            $this->_firstNumber = 0;
+        }
+        if (isset($options['secondValue'])) {
+            $this->_secondNumber = (int)$options['secondValue'];
+        } else {
+            $this->_secondNumber = 0;
+        }
+    }
+
+    /**
+     * Create the CAPTCHA (the numeral expression).
+     *
+     * This function determines a random numeral expression and set the associated
+     * class properties.
+     *
+     * @return void
+     * @see _generateFirstNumber()
+     * @see _generateSecondNumber()
+     * @see _generateOperator()
+     * @see _generateOperation()
+     */
+    public function createCAPTCHA()
+    {
+        if ($this->_firstNumber == 0) {
+            $this->_firstNumber = $this->_generateNumber();
+        }
+        if ($this->_secondNumber == 0) {
+            $this->_secondNumber = $this->_generateNumber();
+        }
+        if (empty($this->_operator)) {
+            $this->_operator = $this->_operators[array_rand($this->_operators)];
+        }
+        $this->_generateOperation();
+    }
+
+    /**
+     * Set operation.
+     *
+     * This variable sets the operation variable by taking the firstNumber,
+     * secondNumber and operator.
+     *
+     * @return void
+     * @see _operation
+     * @see _firstNumber
+     * @see _operator
+     * @see _secondNumber
+     */
+    private function _setOperation()
+    {
+        $this->setCaptcha(
+            $this->_firstNumber . ' ' . $this->_operator . ' ' . $this->_secondNumber
+        );
+    }
+
+    /**
+     * Generate a number.
+     *
+     * This function takes the parameters that are in the $this->_maxValue and
+     * $this->_minValue and get the random number from them using mt_rand().
+     *
+     * @return integer Random value between _minValue and _maxValue
+     * @see _minValue
+     * @see _maxValue
+     */
+    private function _generateNumber()
+    {
+        return mt_rand($this->_minValue, $this->_maxValue);
+    }
+
+    /**
+     * Adds values.
+     *
+     * This function will add the firstNumber and the secondNumber value and then
+     * call setAnswer to set the answer value.
+     *
+     * @return void
+     * @see _firstNumber
+     * @see _secondNumber
+     * @see _setAnswer()
+     */
+    private function _doAdd()
+    {
+        $phrase = $this->_firstNumber + $this->_secondNumber;
+        $this->setPhrase($phrase);
+    }
+
+    /**
+     * Does a subtract on the values.
+     *
+     * This function executes a subtraction on the firstNumber and the secondNumber
+     * to then call $this->setAnswer to set the answer value.
+     *
+     * If the _firstNumber value is smaller than the _secondNumber value then we
+     * regenerate the first number and regenerate the operation.
+     *
+     * @return void
+     * @see _firstNumber
+     * @see _secondNumber
+     * @see _setOperation()
+     * @see Text_CAPTCHA::setPhrase()
+     */
+    private function _doSubtract()
+    {
+        $first = $this->_firstNumber;
+        $second = $this->_secondNumber;
+
+        /**
+         * Check if firstNumber is smaller than secondNumber
+         */
+        if ($first < $second) {
+            $this->_firstNumber = $second;
+            $this->_secondNumber = $first;
+            $this->_setOperation();
+        }
+
+        $phrase = $this->_firstNumber - $this->_secondNumber;
+        $this->setPhrase($phrase);
+    }
+
+    /**
+     * Generate the operation
+     *
+     * This function will call the _setOperation() function to set the operation
+     * string that will be called to display the operation, and call the function
+     * necessary depending on which operation is set by this->operator.
+     *
+     * @return void
+     * @see _setOperation()
+     * @see _operator
+     * @see _doAdd()
+     * @see _doSubtract()
+     */
+    private function _generateOperation()
+    {
+        $this->_setOperation();
+        switch ($this->_operator) {
+        case '+':
+            $this->_doAdd();
+            break;
+        case '-':
+            $this->_doSubtract();
+            break;
+        default:
+            $this->_operator = "+";
+            $this->_setOperation();
+            $this->_doAdd();
+            break;
+        }
+    }
+
+    /**
+     * Create random CAPTCHA phrase. This method is a placeholder, since the equation
+     * is created in createCAPTCHA()
+     *
+     * @return string
+     */
+    public function createPhrase()
+    {
+        $this->setCaptcha(null);
+    }
+}

main/inc/lib/pear/Text/CAPTCHA/Driver/Word.php

@@ -0,0 +1,126 @@
+<?php
+/**
+ * Text_CAPTCHA_Driver_Word - Text_CAPTCHA driver word CAPTCHAs
+ * Class to create a textual Turing test
+ *
+ * PHP version 5
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   Tobias Schlitt <schlitt@php.net>
+ * @author   Christian Wenz <wenz@php.net>
+ * @author   Michael Cramer <michael@bigmichi1.de>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ */
+
+/**
+ * Require Numbers_Words class for generating the text.
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   Tobias Schlitt <schlitt@php.net>
+ * @author   Christian Wenz <wenz@php.net>
+ * @author   Michael Cramer <michael@bigmichi1.de>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ */
+class Text_CAPTCHA_Driver_Word extends Text_CAPTCHA_Driver_Base
+{
+    /**
+     * Phrase length.
+     * This variable holds the length of the Word.
+     *
+     * @var integer
+     */
+    private $_length;
+
+    /**
+     * Numbers_Words mode.
+     * This variable holds the mode for Numbers_Words.
+     *
+     * @var String
+     */
+    private $_mode;
+
+    /**
+     * Locale
+     * This variable holds the locale for Numbers_Words
+     *
+     * @var string
+     */
+    private $_locale;
+
+    /**
+     * Initializes the new Text_CAPTCHA_Driver_Word object.
+     *
+     * @param array $options CAPTCHA options with these keys:<br>
+     *                       phrase  The "secret word" of the CAPTCHA<br>
+     *                       length  The number of characters in the phrase<br>
+     *                       locale  The locale for Numbers_Words<br>
+     *                       mode    The mode for Numbers_Words
+     *
+     * @return void
+     */
+    public function initDriver($options = array())
+    {
+        if (isset($options['length']) && is_int($options['length'])) {
+            $this->_length = $options['length'];
+        } else {
+            $this->_length = 4;
+        }
+        if (isset($options['phrase']) && !empty($options['phrase'])) {
+            $this->setPhrase((string)$options['phrase']);
+        } else {
+            $this->createPhrase();
+        }
+        if (isset($options['mode']) && !empty($options['mode'])) {
+            $this->_mode = $options['mode'];
+        } else {
+            $this->_mode = 'single';
+        }
+        if (isset($options['locale']) && !empty($options['locale'])) {
+            $this->_locale = $options['locale'];
+        } else {
+            $this->_locale = 'en_US';
+        }
+    }
+
+    /**
+     * Create random CAPTCHA phrase, "Word edition" (numbers only).
+     * This method creates a random phrase
+     *
+     * @return void
+     */
+    public function createPhrase()
+    {
+        $phrase = new Text_Password();
+        $this->setPhrase(
+            $phrase->create(
+                $this->_length, 'unpronounceable', 'numeric'
+            )
+        );
+    }
+
+    /**
+     * Place holder for the real _createCAPTCHA() method
+     * used by extended classes to generate CAPTCHA from phrase
+     *
+     * @return void
+     */
+    public function createCAPTCHA()
+    {
+        $res = '';
+        $numberWords = new Numbers_Words();
+        $phrase = $this->getPhrase();
+        if ($this->_mode == 'single') {
+            $phraseArr = str_split($phrase);
+            for ($i = 0; $i < strlen($phrase); $i++) {
+                $res .= ' ' . $numberWords->toWords($phraseArr[$i], $this->_locale);
+            }
+        } else {
+            $res = $numberWords->toWords($phrase, $this->_locale);
+        }
+        $this->setCaptcha($res);
+    }
+}

main/inc/lib/pear/Text/CAPTCHA/Exception.php

@@ -0,0 +1,27 @@
+<?php
+/**
+ * Exception for Text_CAPTCHA
+ *
+ * PHP version 5
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   Christian Weiske <cweiske@php.net>
+ * @author   Christian Wenz <wenz@php.net>
+ * @author   Michael Cramer <michael@bigmichi1.de>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ */
+/**
+ * Exception for Text_CAPTCHA
+ *
+ * @category Text
+ * @package  Text_CAPTCHA
+ * @author   Michael Cramer <michael@bigmichi1.de>
+ * @license  http://www.opensource.org/licenses/bsd-license.php BSD License
+ * @link     http://pear.php.net/package/Text_CAPTCHA
+ */
+class Text_CAPTCHA_Exception extends PEAR_Exception
+{
+
+}

main/inc/lib/pear/Text/Diff.php

@@ -0,0 +1,457 @@
+<?php
+/**
+ * General API for generating and formatting diffs - the differences between
+ * two sequences of strings.
+ *
+ * The original PHP version of this code was written by Geoffrey T. Dairiki
+ * <dairiki@dairiki.org>, and is used/adapted with his permission.
+ *
+ * $Horde: framework/Text_Diff/Diff.php,v 1.11.2.12 2009/01/06 15:23:41 jan Exp $
+ *
+ * Copyright 2004 Geoffrey T. Dairiki <dairiki@dairiki.org>
+ * Copyright 2004-2009 The Horde Project (http://www.horde.org/)
+ *
+ * See the enclosed file COPYING for license information (LGPL). If you did
+ * not receive this file, see http://opensource.org/licenses/lgpl-license.php.
+ *
+ * @package Text_Diff
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ */
+class Text_Diff
+{
+
+    /**
+     * Array of changes.
+     *
+     * @var array
+     */
+    var $_edits;
+
+    /**
+     * Computes diffs between sequences of strings.
+     *
+     * @param string $engine     Name of the diffing engine to use.  'auto'
+     *                           will automatically select the best.
+     * @param array $params      Parameters to pass to the diffing engine.
+     *                           Normally an array of two arrays, each
+     *                           containing the lines from a file.
+     */
+    public function __construct($engine, $params)
+    {
+        // Backward compatibility workaround.
+        if (!is_string($engine)) {
+            $params = array($engine, $params);
+            $engine = 'auto';
+        }
+
+        if ($engine == 'auto') {
+            $engine = extension_loaded('xdiff') ? 'xdiff' : 'native';
+        } else {
+            $engine = basename($engine);
+        }
+
+        //require_once 'Text/Diff/Engine/' . $engine . '.php';
+        $class = 'Text_Diff_Engine_' . $engine;
+        $diff_engine = new $class();
+
+        $this->_edits = call_user_func_array(array($diff_engine, 'diff'), $params);
+    }
+
+    /**
+     * Returns the array of differences.
+     */
+    function getDiff()
+    {
+        return $this->_edits;
+    }
+
+    /**
+     * returns the number of new (added) lines in a given diff.
+     *
+     * @since Text_Diff 1.1.0
+     * @since Horde 3.2
+     *
+     * @return integer The number of new lines
+     */
+    function countAddedLines()
+    {
+        $count = 0;
+        foreach ($this->_edits as $edit) {
+            if (is_a($edit, 'Text_Diff_Op_add') ||
+                is_a($edit, 'Text_Diff_Op_change')) {
+                $count += $edit->nfinal();
+            }
+        }
+        return $count;
+    }
+
+    /**
+     * Returns the number of deleted (removed) lines in a given diff.
+     *
+     * @since Text_Diff 1.1.0
+     * @since Horde 3.2
+     *
+     * @return integer The number of deleted lines
+     */
+    function countDeletedLines()
+    {
+        $count = 0;
+        foreach ($this->_edits as $edit) {
+            if (is_a($edit, 'Text_Diff_Op_delete') ||
+                is_a($edit, 'Text_Diff_Op_change')) {
+                $count += $edit->norig();
+            }
+        }
+        return $count;
+    }
+
+    /**
+     * Computes a reversed diff.
+     *
+     * Example:
+     * <code>
+     * $diff = new Text_Diff($lines1, $lines2);
+     * $rev = $diff->reverse();
+     * </code>
+     *
+     * @return Text_Diff  A Diff object representing the inverse of the
+     *                    original diff.  Note that we purposely don't return a
+     *                    reference here, since this essentially is a clone()
+     *                    method.
+     */
+    function reverse()
+    {
+        if (version_compare(zend_version(), '2', '>')) {
+            $rev = clone($this);
+        } else {
+            $rev = $this;
+        }
+        $rev->_edits = array();
+        foreach ($this->_edits as $edit) {
+            $rev->_edits[] = $edit->reverse();
+        }
+        return $rev;
+    }
+
+    /**
+     * Checks for an empty diff.
+     *
+     * @return boolean  True if two sequences were identical.
+     */
+    function isEmpty()
+    {
+        foreach ($this->_edits as $edit) {
+            if (!is_a($edit, 'Text_Diff_Op_copy')) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Computes the length of the Longest Common Subsequence (LCS).
+     *
+     * This is mostly for diagnostic purposes.
+     *
+     * @return integer  The length of the LCS.
+     */
+    function lcs()
+    {
+        $lcs = 0;
+        foreach ($this->_edits as $edit) {
+            if (is_a($edit, 'Text_Diff_Op_copy')) {
+                $lcs += count($edit->orig);
+            }
+        }
+        return $lcs;
+    }
+
+    /**
+     * Gets the original set of lines.
+     *
+     * This reconstructs the $from_lines parameter passed to the constructor.
+     *
+     * @return array  The original sequence of strings.
+     */
+    function getOriginal()
+    {
+        $lines = array();
+        foreach ($this->_edits as $edit) {
+            if ($edit->orig) {
+                array_splice($lines, count($lines), 0, $edit->orig);
+            }
+        }
+        return $lines;
+    }
+
+    /**
+     * Gets the final set of lines.
+     *
+     * This reconstructs the $to_lines parameter passed to the constructor.
+     *
+     * @return array  The sequence of strings.
+     */
+    function getFinal()
+    {
+        $lines = array();
+        foreach ($this->_edits as $edit) {
+            if ($edit->final) {
+                array_splice($lines, count($lines), 0, $edit->final);
+            }
+        }
+        return $lines;
+    }
+
+    /**
+     * Removes trailing newlines from a line of text. This is meant to be used
+     * with array_walk().
+     *
+     * @param string $line  The line to trim.
+     * @param integer $key  The index of the line in the array. Not used.
+     */
+    public static function trimNewlines(&$line, $key)
+    {
+        $line = str_replace(array("\n", "\r"), '', $line);
+    }
+
+    /**
+     * Determines the location of the system temporary directory.
+     *
+     * @static
+     *
+     * @access protected
+     *
+     * @return string  A directory name which can be used for temp files.
+     *                 Returns false if one could not be found.
+     */
+    function _getTempDir()
+    {
+        $tmp_locations = array('/tmp', '/var/tmp', 'c:\WUTemp', 'c:\temp',
+                               'c:\windows\temp', 'c:\winnt\temp');
+
+        /* Try PHP's upload_tmp_dir directive. */
+        $tmp = ini_get('upload_tmp_dir');
+
+        /* Otherwise, try to determine the TMPDIR environment variable. */
+        if (!strlen($tmp)) {
+            $tmp = getenv('TMPDIR');
+        }
+
+        /* If we still cannot determine a value, then cycle through a list of
+         * preset possibilities. */
+        while (!strlen($tmp) && count($tmp_locations)) {
+            $tmp_check = array_shift($tmp_locations);
+            if (@is_dir($tmp_check)) {
+                $tmp = $tmp_check;
+            }
+        }
+
+        /* If it is still empty, we have failed, so return false; otherwise
+         * return the directory determined. */
+        return strlen($tmp) ? $tmp : false;
+    }
+
+    /**
+     * Checks a diff for validity.
+     *
+     * This is here only for debugging purposes.
+     */
+    function _check($from_lines, $to_lines)
+    {
+        if (serialize($from_lines) != serialize($this->getOriginal())) {
+            trigger_error("Reconstructed original doesn't match", E_USER_ERROR);
+        }
+        if (serialize($to_lines) != serialize($this->getFinal())) {
+            trigger_error("Reconstructed final doesn't match", E_USER_ERROR);
+        }
+
+        $rev = $this->reverse();
+        if (serialize($to_lines) != serialize($rev->getOriginal())) {
+            trigger_error("Reversed original doesn't match", E_USER_ERROR);
+        }
+        if (serialize($from_lines) != serialize($rev->getFinal())) {
+            trigger_error("Reversed final doesn't match", E_USER_ERROR);
+        }
+
+        $prevtype = null;
+        foreach ($this->_edits as $edit) {
+            if ($prevtype == get_class($edit)) {
+                trigger_error("Edit sequence is non-optimal", E_USER_ERROR);
+            }
+            $prevtype = get_class($edit);
+        }
+
+        return true;
+    }
+
+}
+
+/**
+ * @package Text_Diff
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ */
+class Text_MappedDiff extends Text_Diff
+{
+
+    /**
+     * Computes a diff between sequences of strings.
+     *
+     * This can be used to compute things like case-insensitve diffs, or diffs
+     * which ignore changes in white-space.
+     *
+     * @param array $from_lines         An array of strings.
+     * @param array $to_lines           An array of strings.
+     * @param array $mapped_from_lines  This array should have the same size
+     *                                  number of elements as $from_lines.  The
+     *                                  elements in $mapped_from_lines and
+     *                                  $mapped_to_lines are what is actually
+     *                                  compared when computing the diff.
+     * @param array $mapped_to_lines    This array should have the same number
+     *                                  of elements as $to_lines.
+     */
+    public function __construct($from_lines, $to_lines,
+                             $mapped_from_lines, $mapped_to_lines)
+    {
+        assert(count($from_lines) == count($mapped_from_lines));
+        assert(count($to_lines) == count($mapped_to_lines));
+
+        parent::__construct($mapped_from_lines, $mapped_to_lines);
+
+        $xi = $yi = 0;
+        for ($i = 0; $i < count($this->_edits); $i++) {
+            $orig = &$this->_edits[$i]->orig;
+            if (is_array($orig)) {
+                $orig = array_slice($from_lines, $xi, count($orig));
+                $xi += count($orig);
+            }
+
+            $final = &$this->_edits[$i]->final;
+            if (is_array($final)) {
+                $final = array_slice($to_lines, $yi, count($final));
+                $yi += count($final);
+            }
+        }
+    }
+
+}
+
+/**
+ * @package Text_Diff
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ *
+ * @access private
+ */
+class Text_Diff_Op {
+
+    var $orig;
+    var $final;
+
+    function &reverse()
+    {
+        trigger_error('Abstract method', E_USER_ERROR);
+    }
+
+    function norig()
+    {
+        return $this->orig ? count($this->orig) : 0;
+    }
+
+    function nfinal()
+    {
+        return $this->final ? count($this->final) : 0;
+    }
+
+}
+
+/**
+ * @package Text_Diff
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ *
+ * @access private
+ */
+class Text_Diff_Op_copy extends Text_Diff_Op
+{
+
+    public function __construct($orig, $final = false)
+    {
+        if (!is_array($final)) {
+            $final = $orig;
+        }
+        $this->orig = $orig;
+        $this->final = $final;
+    }
+
+    function &reverse()
+    {
+        $reverse = new Text_Diff_Op_copy($this->final, $this->orig);
+        return $reverse;
+    }
+}
+
+/**
+ * @package Text_Diff
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ *
+ * @access private
+ */
+class Text_Diff_Op_delete extends Text_Diff_Op
+{
+
+    public function __construct($lines)
+    {
+        $this->orig = $lines;
+        $this->final = false;
+    }
+
+    function &reverse()
+    {
+        $reverse = new Text_Diff_Op_add($this->orig);
+        return $reverse;
+    }
+
+}
+
+/**
+ * @package Text_Diff
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ *
+ * @access private
+ */
+class Text_Diff_Op_add extends Text_Diff_Op {
+
+    public function __construct($lines)
+    {
+        $this->final = $lines;
+        $this->orig = false;
+    }
+
+    function &reverse()
+    {
+        $reverse = new Text_Diff_Op_delete($this->final);
+        return $reverse;
+    }
+
+}
+
+/**
+ * @package Text_Diff
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ *
+ * @access private
+ */
+class Text_Diff_Op_change extends Text_Diff_Op
+{
+
+    public function __construct($orig, $final)
+    {
+        $this->orig = $orig;
+        $this->final = $final;
+    }
+
+    function &reverse()
+    {
+        $reverse = new Text_Diff_Op_change($this->final, $this->orig);
+        return $reverse;
+    }
+
+}

main/inc/lib/pear/Text/Diff/Engine/index.html

@@ -0,0 +1,6 @@
+<html>
+<head>
+</head>
+<body>
+</body>
+</html>

main/inc/lib/pear/Text/Diff/Engine/native.php

@@ -0,0 +1,438 @@
+<?php
+/**
+ * Class used internally by Text_Diff to actually compute the diffs.
+ *
+ * This class is implemented using native PHP code.
+ *
+ * The algorithm used here is mostly lifted from the perl module
+ * Algorithm::Diff (version 1.06) by Ned Konz, which is available at:
+ * http://www.perl.com/CPAN/authors/id/N/NE/NEDKONZ/Algorithm-Diff-1.06.zip
+ *
+ * More ideas are taken from: http://www.ics.uci.edu/~eppstein/161/960229.html
+ *
+ * Some ideas (and a bit of code) are taken from analyze.c, of GNU
+ * diffutils-2.7, which can be found at:
+ * ftp://gnudist.gnu.org/pub/gnu/diffutils/diffutils-2.7.tar.gz
+ *
+ * Some ideas (subdivision by NCHUNKS > 2, and some optimizations) are from
+ * Geoffrey T. Dairiki <dairiki@dairiki.org>. The original PHP version of this
+ * code was written by him, and is used/adapted with his permission.
+ *
+ * $Horde: framework/Text_Diff/Diff/Engine/native.php,v 1.7.2.5 2009/01/06 15:23:41 jan Exp $
+ *
+ * Copyright 2004-2009 The Horde Project (http://www.horde.org/)
+ *
+ * See the enclosed file COPYING for license information (LGPL). If you did
+ * not receive this file, see http://opensource.org/licenses/lgpl-license.php.
+ *
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ * @package Text_Diff
+ */
+class Text_Diff_Engine_native {
+
+    function diff($from_lines, $to_lines)
+    {
+        array_walk($from_lines, array('Text_Diff', 'trimNewlines'));
+        array_walk($to_lines, array('Text_Diff', 'trimNewlines'));
+
+        $n_from = count($from_lines);
+        $n_to = count($to_lines);
+
+        $this->xchanged = $this->ychanged = array();
+        $this->xv = $this->yv = array();
+        $this->xind = $this->yind = array();
+        unset($this->seq);
+        unset($this->in_seq);
+        unset($this->lcs);
+
+        // Skip leading common lines.
+        for ($skip = 0; $skip < $n_from && $skip < $n_to; $skip++) {
+            if ($from_lines[$skip] !== $to_lines[$skip]) {
+                break;
+            }
+            $this->xchanged[$skip] = $this->ychanged[$skip] = false;
+        }
+
+        // Skip trailing common lines.
+        $xi = $n_from; $yi = $n_to;
+        for ($endskip = 0; --$xi > $skip && --$yi > $skip; $endskip++) {
+            if ($from_lines[$xi] !== $to_lines[$yi]) {
+                break;
+            }
+            $this->xchanged[$xi] = $this->ychanged[$yi] = false;
+        }
+
+        // Ignore lines which do not exist in both files.
+        for ($xi = $skip; $xi < $n_from - $endskip; $xi++) {
+            $xhash[$from_lines[$xi]] = 1;
+        }
+        for ($yi = $skip; $yi < $n_to - $endskip; $yi++) {
+            $line = $to_lines[$yi];
+            if (($this->ychanged[$yi] = empty($xhash[$line]))) {
+                continue;
+            }
+            $yhash[$line] = 1;
+            $this->yv[] = $line;
+            $this->yind[] = $yi;
+        }
+        for ($xi = $skip; $xi < $n_from - $endskip; $xi++) {
+            $line = $from_lines[$xi];
+            if (($this->xchanged[$xi] = empty($yhash[$line]))) {
+                continue;
+            }
+            $this->xv[] = $line;
+            $this->xind[] = $xi;
+        }
+
+        // Find the LCS.
+        $this->_compareseq(0, count($this->xv), 0, count($this->yv));
+
+        // Merge edits when possible.
+        $this->_shiftBoundaries($from_lines, $this->xchanged, $this->ychanged);
+        $this->_shiftBoundaries($to_lines, $this->ychanged, $this->xchanged);
+
+        // Compute the edit operations.
+        $edits = array();
+        $xi = $yi = 0;
+        while ($xi < $n_from || $yi < $n_to) {
+            assert($yi < $n_to || $this->xchanged[$xi]);
+            assert($xi < $n_from || $this->ychanged[$yi]);
+
+            // Skip matching "snake".
+            $copy = array();
+            while ($xi < $n_from && $yi < $n_to
+                   && !$this->xchanged[$xi] && !$this->ychanged[$yi]) {
+                $copy[] = $from_lines[$xi++];
+                ++$yi;
+            }
+            if ($copy) {
+                $edits[] = new Text_Diff_Op_copy($copy);
+            }
+
+            // Find deletes & adds.
+            $delete = array();
+            while ($xi < $n_from && $this->xchanged[$xi]) {
+                $delete[] = $from_lines[$xi++];
+            }
+
+            $add = array();
+            while ($yi < $n_to && $this->ychanged[$yi]) {
+                $add[] = $to_lines[$yi++];
+            }
+
+            if ($delete && $add) {
+                $edits[] = new Text_Diff_Op_change($delete, $add);
+            } elseif ($delete) {
+                $edits[] = new Text_Diff_Op_delete($delete);
+            } elseif ($add) {
+                $edits[] = new Text_Diff_Op_add($add);
+            }
+        }
+
+        return $edits;
+    }
+
+    /**
+     * Divides the Largest Common Subsequence (LCS) of the sequences (XOFF,
+     * XLIM) and (YOFF, YLIM) into NCHUNKS approximately equally sized
+     * segments.
+     *
+     * Returns (LCS, PTS).  LCS is the length of the LCS. PTS is an array of
+     * NCHUNKS+1 (X, Y) indexes giving the diving points between sub
+     * sequences.  The first sub-sequence is contained in (X0, X1), (Y0, Y1),
+     * the second in (X1, X2), (Y1, Y2) and so on.  Note that (X0, Y0) ==
+     * (XOFF, YOFF) and (X[NCHUNKS], Y[NCHUNKS]) == (XLIM, YLIM).
+     *
+     * This function assumes that the first lines of the specified portions of
+     * the two files do not match, and likewise that the last lines do not
+     * match.  The caller must trim matching lines from the beginning and end
+     * of the portions it is going to specify.
+     */
+    function _diag ($xoff, $xlim, $yoff, $ylim, $nchunks)
+    {
+        $flip = false;
+
+        if ($xlim - $xoff > $ylim - $yoff) {
+            /* Things seems faster (I'm not sure I understand why) when the
+             * shortest sequence is in X. */
+            $flip = true;
+            list ($xoff, $xlim, $yoff, $ylim)
+                = array($yoff, $ylim, $xoff, $xlim);
+        }
+
+        if ($flip) {
+            for ($i = $ylim - 1; $i >= $yoff; $i--) {
+                $ymatches[$this->xv[$i]][] = $i;
+            }
+        } else {
+            for ($i = $ylim - 1; $i >= $yoff; $i--) {
+                $ymatches[$this->yv[$i]][] = $i;
+            }
+        }
+
+        $this->lcs = 0;
+        $this->seq[0]= $yoff - 1;
+        $this->in_seq = array();
+        $ymids[0] = array();
+
+        $numer = $xlim - $xoff + $nchunks - 1;
+        $x = $xoff;
+        for ($chunk = 0; $chunk < $nchunks; $chunk++) {
+            if ($chunk > 0) {
+                for ($i = 0; $i <= $this->lcs; $i++) {
+                    $ymids[$i][$chunk - 1] = $this->seq[$i];
+                }
+            }
+
+            $x1 = $xoff + (int)(($numer + ($xlim - $xoff) * $chunk) / $nchunks);
+            for (; $x < $x1; $x++) {
+                $line = $flip ? $this->yv[$x] : $this->xv[$x];
+                if (empty($ymatches[$line])) {
+                    continue;
+                }
+                $matches = $ymatches[$line];
+                reset($matches);
+                while (list(, $y) = each($matches)) {
+                    if (empty($this->in_seq[$y])) {
+                        $k = $this->_lcsPos($y);
+                        assert($k > 0);
+                        $ymids[$k] = $ymids[$k - 1];
+                        break;
+                    }
+                }
+                while (list(, $y) = each($matches)) {
+                    if ($y > $this->seq[$k - 1]) {
+                        assert($y <= $this->seq[$k]);
+                        /* Optimization: this is a common case: next match is
+                         * just replacing previous match. */
+                        $this->in_seq[$this->seq[$k]] = false;
+                        $this->seq[$k] = $y;
+                        $this->in_seq[$y] = 1;
+                    } elseif (empty($this->in_seq[$y])) {
+                        $k = $this->_lcsPos($y);
+                        assert($k > 0);
+                        $ymids[$k] = $ymids[$k - 1];
+                    }
+                }
+            }
+        }
+
+        $seps[] = $flip ? array($yoff, $xoff) : array($xoff, $yoff);
+        $ymid = $ymids[$this->lcs];
+        for ($n = 0; $n < $nchunks - 1; $n++) {
+            $x1 = $xoff + (int)(($numer + ($xlim - $xoff) * $n) / $nchunks);
+            $y1 = $ymid[$n] + 1;
+            $seps[] = $flip ? array($y1, $x1) : array($x1, $y1);
+        }
+        $seps[] = $flip ? array($ylim, $xlim) : array($xlim, $ylim);
+
+        return array($this->lcs, $seps);
+    }
+
+    function _lcsPos($ypos)
+    {
+        $end = $this->lcs;
+        if ($end == 0 || $ypos > $this->seq[$end]) {
+            $this->seq[++$this->lcs] = $ypos;
+            $this->in_seq[$ypos] = 1;
+            return $this->lcs;
+        }
+
+        $beg = 1;
+        while ($beg < $end) {
+            $mid = (int)(($beg + $end) / 2);
+            if ($ypos > $this->seq[$mid]) {
+                $beg = $mid + 1;
+            } else {
+                $end = $mid;
+            }
+        }
+
+        assert($ypos != $this->seq[$end]);
+
+        $this->in_seq[$this->seq[$end]] = false;
+        $this->seq[$end] = $ypos;
+        $this->in_seq[$ypos] = 1;
+        return $end;
+    }
+
+    /**
+     * Finds LCS of two sequences.
+     *
+     * The results are recorded in the vectors $this->{x,y}changed[], by
+     * storing a 1 in the element for each line that is an insertion or
+     * deletion (ie. is not in the LCS).
+     *
+     * The subsequence of file 0 is (XOFF, XLIM) and likewise for file 1.
+     *
+     * Note that XLIM, YLIM are exclusive bounds.  All line numbers are
+     * origin-0 and discarded lines are not counted.
+     */
+    function _compareseq ($xoff, $xlim, $yoff, $ylim)
+    {
+        /* Slide down the bottom initial diagonal. */
+        while ($xoff < $xlim && $yoff < $ylim
+               && $this->xv[$xoff] == $this->yv[$yoff]) {
+            ++$xoff;
+            ++$yoff;
+        }
+
+        /* Slide up the top initial diagonal. */
+        while ($xlim > $xoff && $ylim > $yoff
+               && $this->xv[$xlim - 1] == $this->yv[$ylim - 1]) {
+            --$xlim;
+            --$ylim;
+        }
+
+        if ($xoff == $xlim || $yoff == $ylim) {
+            $lcs = 0;
+        } else {
+            /* This is ad hoc but seems to work well.  $nchunks =
+             * sqrt(min($xlim - $xoff, $ylim - $yoff) / 2.5); $nchunks =
+             * max(2,min(8,(int)$nchunks)); */
+            $nchunks = min(7, $xlim - $xoff, $ylim - $yoff) + 1;
+            list($lcs, $seps)
+                = $this->_diag($xoff, $xlim, $yoff, $ylim, $nchunks);
+        }
+
+        if ($lcs == 0) {
+            /* X and Y sequences have no common subsequence: mark all
+             * changed. */
+            while ($yoff < $ylim) {
+                $this->ychanged[$this->yind[$yoff++]] = 1;
+            }
+            while ($xoff < $xlim) {
+                $this->xchanged[$this->xind[$xoff++]] = 1;
+            }
+        } else {
+            /* Use the partitions to split this problem into subproblems. */
+            reset($seps);
+            $pt1 = $seps[0];
+            while ($pt2 = next($seps)) {
+                $this->_compareseq ($pt1[0], $pt2[0], $pt1[1], $pt2[1]);
+                $pt1 = $pt2;
+            }
+        }
+    }
+
+    /**
+     * Adjusts inserts/deletes of identical lines to join changes as much as
+     * possible.
+     *
+     * We do something when a run of changed lines include a line at one end
+     * and has an excluded, identical line at the other.  We are free to
+     * choose which identical line is included.  `compareseq' usually chooses
+     * the one at the beginning, but usually it is cleaner to consider the
+     * following identical line to be the "change".
+     *
+     * This is extracted verbatim from analyze.c (GNU diffutils-2.7).
+     */
+    function _shiftBoundaries($lines, &$changed, $other_changed)
+    {
+        $i = 0;
+        $j = 0;
+
+        assert('count($lines) == count($changed)');
+        $len = count($lines);
+        $other_len = count($other_changed);
+
+        while (1) {
+            /* Scan forward to find the beginning of another run of
+             * changes. Also keep track of the corresponding point in the
+             * other file.
+             *
+             * Throughout this code, $i and $j are adjusted together so that
+             * the first $i elements of $changed and the first $j elements of
+             * $other_changed both contain the same number of zeros (unchanged
+             * lines).
+             *
+             * Furthermore, $j is always kept so that $j == $other_len or
+             * $other_changed[$j] == false. */
+            while ($j < $other_len && $other_changed[$j]) {
+                $j++;
+            }
+
+            while ($i < $len && ! $changed[$i]) {
+                assert('$j < $other_len && ! $other_changed[$j]');
+                $i++; $j++;
+                while ($j < $other_len && $other_changed[$j]) {
+                    $j++;
+                }
+            }
+
+            if ($i == $len) {
+                break;
+            }
+
+            $start = $i;
+
+            /* Find the end of this run of changes. */
+            while (++$i < $len && $changed[$i]) {
+                continue;
+            }
+
+            do {
+                /* Record the length of this run of changes, so that we can
+                 * later determine whether the run has grown. */
+                $runlength = $i - $start;
+
+                /* Move the changed region back, so long as the previous
+                 * unchanged line matches the last changed one.  This merges
+                 * with previous changed regions. */
+                while ($start > 0 && $lines[$start - 1] == $lines[$i - 1]) {
+                    $changed[--$start] = 1;
+                    $changed[--$i] = false;
+                    while ($start > 0 && $changed[$start - 1]) {
+                        $start--;
+                    }
+                    assert('$j > 0');
+                    while ($other_changed[--$j]) {
+                        continue;
+                    }
+                    assert('$j >= 0 && !$other_changed[$j]');
+                }
+
+                /* Set CORRESPONDING to the end of the changed run, at the
+                 * last point where it corresponds to a changed run in the
+                 * other file. CORRESPONDING == LEN means no such point has
+                 * been found. */
+                $corresponding = $j < $other_len ? $i : $len;
+
+                /* Move the changed region forward, so long as the first
+                 * changed line matches the following unchanged one.  This
+                 * merges with following changed regions.  Do this second, so
+                 * that if there are no merges, the changed region is moved
+                 * forward as far as possible. */
+                while ($i < $len && $lines[$start] == $lines[$i]) {
+                    $changed[$start++] = false;
+                    $changed[$i++] = 1;
+                    while ($i < $len && $changed[$i]) {
+                        $i++;
+                    }
+
+                    assert('$j < $other_len && ! $other_changed[$j]');
+                    $j++;
+                    if ($j < $other_len && $other_changed[$j]) {
+                        $corresponding = $i;
+                        while ($j < $other_len && $other_changed[$j]) {
+                            $j++;
+                        }
+                    }
+                }
+            } while ($runlength != $i - $start);
+
+            /* If possible, move the fully-merged run of changes back to a
+             * corresponding run in the other file. */
+            while ($corresponding < $i) {
+                $changed[--$start] = 1;
+                $changed[--$i] = 0;
+                assert('$j > 0');
+                while ($other_changed[--$j]) {
+                    continue;
+                }
+                assert('$j >= 0 && !$other_changed[$j]');
+            }
+        }
+    }
+
+}

main/inc/lib/pear/Text/Diff/Engine/shell.php

@@ -0,0 +1,164 @@
+<?php
+/**
+ * Class used internally by Diff to actually compute the diffs.
+ *
+ * This class uses the Unix `diff` program via shell_exec to compute the
+ * differences between the two input arrays.
+ *
+ * $Horde: framework/Text_Diff/Diff/Engine/shell.php,v 1.6.2.4 2009/01/06 15:23:41 jan Exp $
+ *
+ * Copyright 2007-2009 The Horde Project (http://www.horde.org/)
+ *
+ * See the enclosed file COPYING for license information (LGPL). If you did
+ * not receive this file, see http://opensource.org/licenses/lgpl-license.php.
+ *
+ * @author  Milian Wolff <mail@milianw.de>
+ * @package Text_Diff
+ * @since   0.3.0
+ */
+class Text_Diff_Engine_shell {
+
+    /**
+     * Path to the diff executable
+     *
+     * @var string
+     */
+    var $_diffCommand = 'diff';
+
+    /**
+     * Returns the array of differences.
+     *
+     * @param array $from_lines lines of text from old file
+     * @param array $to_lines   lines of text from new file
+     *
+     * @return array all changes made (array with Text_Diff_Op_* objects)
+     */
+    function diff($from_lines, $to_lines)
+    {
+        array_walk($from_lines, array('Text_Diff', 'trimNewlines'));
+        array_walk($to_lines, array('Text_Diff', 'trimNewlines'));
+
+        $temp_dir = Text_Diff::_getTempDir();
+
+        // Execute gnu diff or similar to get a standard diff file.
+        $from_file = tempnam($temp_dir, 'Text_Diff');
+        $to_file = tempnam($temp_dir, 'Text_Diff');
+        $fp = fopen($from_file, 'w');
+        fwrite($fp, implode("\n", $from_lines));
+        fclose($fp);
+        $fp = fopen($to_file, 'w');
+        fwrite($fp, implode("\n", $to_lines));
+        fclose($fp);
+        $diff = shell_exec($this->_diffCommand . ' ' . $from_file . ' ' . $to_file);
+        unlink($from_file);
+        unlink($to_file);
+
+        if (is_null($diff)) {
+            // No changes were made
+            return array(new Text_Diff_Op_copy($from_lines));
+        }
+
+        $from_line_no = 1;
+        $to_line_no = 1;
+        $edits = array();
+
+        // Get changed lines by parsing something like:
+        // 0a1,2
+        // 1,2c4,6
+        // 1,5d6
+        preg_match_all('#^(\d+)(?:,(\d+))?([adc])(\d+)(?:,(\d+))?$#m', $diff,
+            $matches, PREG_SET_ORDER);
+
+        foreach ($matches as $match) {
+            if (!isset($match[5])) {
+                // This paren is not set every time (see regex).
+                $match[5] = false;
+            }
+
+            if ($match[3] == 'a') {
+                $from_line_no--;
+            }
+
+            if ($match[3] == 'd') {
+                $to_line_no--;
+            }
+
+            if ($from_line_no < $match[1] || $to_line_no < $match[4]) {
+                // copied lines
+                assert('$match[1] - $from_line_no == $match[4] - $to_line_no');
+                array_push($edits,
+                    new Text_Diff_Op_copy(
+                        $this->_getLines($from_lines, $from_line_no, $match[1] - 1),
+                        $this->_getLines($to_lines, $to_line_no, $match[4] - 1)));
+            }
+
+            switch ($match[3]) {
+            case 'd':
+                // deleted lines
+                array_push($edits,
+                    new Text_Diff_Op_delete(
+                        $this->_getLines($from_lines, $from_line_no, $match[2])));
+                $to_line_no++;
+                break;
+
+            case 'c':
+                // changed lines
+                array_push($edits,
+                    new Text_Diff_Op_change(
+                        $this->_getLines($from_lines, $from_line_no, $match[2]),
+                        $this->_getLines($to_lines, $to_line_no, $match[5])));
+                break;
+
+            case 'a':
+                // added lines
+                array_push($edits,
+                    new Text_Diff_Op_add(
+                        $this->_getLines($to_lines, $to_line_no, $match[5])));
+                $from_line_no++;
+                break;
+            }
+        }
+
+        if (!empty($from_lines)) {
+            // Some lines might still be pending. Add them as copied
+            array_push($edits,
+                new Text_Diff_Op_copy(
+                    $this->_getLines($from_lines, $from_line_no,
+                                     $from_line_no + count($from_lines) - 1),
+                    $this->_getLines($to_lines, $to_line_no,
+                                     $to_line_no + count($to_lines) - 1)));
+        }
+
+        return $edits;
+    }
+
+    /**
+     * Get lines from either the old or new text
+     *
+     * @access private
+     *
+     * @param array &$text_lines Either $from_lines or $to_lines
+     * @param int   &$line_no    Current line number
+     * @param int   $end         Optional end line, when we want to chop more
+     *                           than one line.
+     *
+     * @return array The chopped lines
+     */
+    function _getLines(&$text_lines, &$line_no, $end = false)
+    {
+        if (!empty($end)) {
+            $lines = array();
+            // We can shift even more
+            while ($line_no <= $end) {
+                array_push($lines, array_shift($text_lines));
+                $line_no++;
+            }
+        } else {
+            $lines = array(array_shift($text_lines));
+            $line_no++;
+        }
+
+        return $lines;
+    }
+
+}

main/inc/lib/pear/Text/Diff/Engine/string.php

@@ -0,0 +1,250 @@
+<?php
+/**
+ * Parses unified or context diffs output from eg. the diff utility.
+ *
+ * Example:
+ * <code>
+ * $patch = file_get_contents('example.patch');
+ * $diff = new Text_Diff('string', array($patch));
+ * $renderer = new Text_Diff_Renderer_inline();
+ * echo $renderer->render($diff);
+ * </code>
+ *
+ * $Horde: framework/Text_Diff/Diff/Engine/string.php,v 1.5.2.7 2009/07/24 13:04:43 jan Exp $
+ *
+ * Copyright 2005 <20>rjan Persson <o@42mm.org>
+ * Copyright 2005-2009 The Horde Project (http://www.horde.org/)
+ *
+ * See the enclosed file COPYING for license information (LGPL). If you did
+ * not receive this file, see http://opensource.org/licenses/lgpl-license.php.
+ *
+ * @author  <20>rjan Persson <o@42mm.org>
+ * @package Text_Diff
+ * @since   0.2.0
+ */
+class Text_Diff_Engine_string {
+
+    /**
+     * Parses a unified or context diff.
+     *
+     * First param contains the whole diff and the second can be used to force
+     * a specific diff type. If the second parameter is 'autodetect', the
+     * diff will be examined to find out which type of diff this is.
+     *
+     * @param string $diff  The diff content.
+     * @param string $mode  The diff mode of the content in $diff. One of
+     *                      'context', 'unified', or 'autodetect'.
+     *
+     * @return array  List of all diff operations.
+     */
+    function diff($diff, $mode = 'autodetect')
+    {
+        // Detect line breaks.
+        $lnbr = "\n";
+        if (strpos($diff, "\r\n") !== false) {
+            $lnbr = "\r\n";
+        } elseif (strpos($diff, "\r") !== false) {
+            $lnbr = "\r";
+        }
+
+        // Make sure we have a line break at the EOF.
+        if (substr($diff, -strlen($lnbr)) != $lnbr) {
+            $diff .= $lnbr;
+        }
+
+        if ($mode != 'autodetect' && $mode != 'context' && $mode != 'unified') {
+            return PEAR::raiseError('Type of diff is unsupported');
+        }
+
+        if ($mode == 'autodetect') {
+            $context = strpos($diff, '***');
+            $unified = strpos($diff, '---');
+            if ($context === $unified) {
+                return PEAR::raiseError('Type of diff could not be detected');
+            } elseif ($context === false || $unified === false) {
+                $mode = $context !== false ? 'context' : 'unified';
+            } else {
+                $mode = $context < $unified ? 'context' : 'unified';
+            }
+        }
+
+        // Split by new line and remove the diff header, if there is one.
+        $diff = explode($lnbr, $diff);
+        if (($mode == 'context' && strpos($diff[0], '***') === 0) ||
+            ($mode == 'unified' && strpos($diff[0], '---') === 0)) {
+            array_shift($diff);
+            array_shift($diff);
+        }
+
+        if ($mode == 'context') {
+            return $this->parseContextDiff($diff);
+        } else {
+            return $this->parseUnifiedDiff($diff);
+        }
+    }
+
+    /**
+     * Parses an array containing the unified diff.
+     *
+     * @param array $diff  Array of lines.
+     *
+     * @return array  List of all diff operations.
+     */
+    function parseUnifiedDiff($diff)
+    {
+        $edits = array();
+        $end = count($diff) - 1;
+        for ($i = 0; $i < $end;) {
+            $diff1 = array();
+            switch (substr($diff[$i], 0, 1)) {
+            case ' ':
+                do {
+                    $diff1[] = substr($diff[$i], 1);
+                } while (++$i < $end && substr($diff[$i], 0, 1) == ' ');
+                $edits[] = new Text_Diff_Op_copy($diff1);
+                break;
+
+            case '+':
+                // get all new lines
+                do {
+                    $diff1[] = substr($diff[$i], 1);
+                } while (++$i < $end && substr($diff[$i], 0, 1) == '+');
+                $edits[] = new Text_Diff_Op_add($diff1);
+                break;
+
+            case '-':
+                // get changed or removed lines
+                $diff2 = array();
+                do {
+                    $diff1[] = substr($diff[$i], 1);
+                } while (++$i < $end && substr($diff[$i], 0, 1) == '-');
+
+                while ($i < $end && substr($diff[$i], 0, 1) == '+') {
+                    $diff2[] = substr($diff[$i++], 1);
+                }
+                if (count($diff2) == 0) {
+                    $edits[] = new Text_Diff_Op_delete($diff1);
+                } else {
+                    $edits[] = new Text_Diff_Op_change($diff1, $diff2);
+                }
+                break;
+
+            default:
+                $i++;
+                break;
+            }
+        }
+
+        return $edits;
+    }
+
+    /**
+     * Parses an array containing the context diff.
+     *
+     * @param array $diff  Array of lines.
+     *
+     * @return array  List of all diff operations.
+     */
+    function parseContextDiff(&$diff)
+    {
+        $edits = array();
+        $i = $max_i = $j = $max_j = 0;
+        $end = count($diff) - 1;
+        while ($i < $end && $j < $end) {
+            while ($i >= $max_i && $j >= $max_j) {
+                // Find the boundaries of the diff output of the two files
+                for ($i = $j;
+                     $i < $end && substr($diff[$i], 0, 3) == '***';
+                     $i++);
+                for ($max_i = $i;
+                     $max_i < $end && substr($diff[$max_i], 0, 3) != '---';
+                     $max_i++);
+                for ($j = $max_i;
+                     $j < $end && substr($diff[$j], 0, 3) == '---';
+                     $j++);
+                for ($max_j = $j;
+                     $max_j < $end && substr($diff[$max_j], 0, 3) != '***';
+                     $max_j++);
+            }
+
+            // find what hasn't been changed
+            $array = array();
+            while ($i < $max_i &&
+                   $j < $max_j &&
+                   strcmp($diff[$i], $diff[$j]) == 0) {
+                $array[] = substr($diff[$i], 2);
+                $i++;
+                $j++;
+            }
+
+            while ($i < $max_i && ($max_j-$j) <= 1) {
+                if ($diff[$i] != '' && substr($diff[$i], 0, 1) != ' ') {
+                    break;
+                }
+                $array[] = substr($diff[$i++], 2);
+            }
+
+            while ($j < $max_j && ($max_i-$i) <= 1) {
+                if ($diff[$j] != '' && substr($diff[$j], 0, 1) != ' ') {
+                    break;
+                }
+                $array[] = substr($diff[$j++], 2);
+            }
+            if (count($array) > 0) {
+                $edits[] = new Text_Diff_Op_copy($array);
+            }
+
+            if ($i < $max_i) {
+                $diff1 = array();
+                switch (substr($diff[$i], 0, 1)) {
+                case '!':
+                    $diff2 = array();
+                    do {
+                        $diff1[] = substr($diff[$i], 2);
+                        if ($j < $max_j && substr($diff[$j], 0, 1) == '!') {
+                            $diff2[] = substr($diff[$j++], 2);
+                        }
+                    } while (++$i < $max_i && substr($diff[$i], 0, 1) == '!');
+                    $edits[] = new Text_Diff_Op_change($diff1, $diff2);
+                    break;
+
+                case '+':
+                    do {
+                        $diff1[] = substr($diff[$i], 2);
+                    } while (++$i < $max_i && substr($diff[$i], 0, 1) == '+');
+                    $edits[] = new Text_Diff_Op_add($diff1);
+                    break;
+
+                case '-':
+                    do {
+                        $diff1[] = substr($diff[$i], 2);
+                    } while (++$i < $max_i && substr($diff[$i], 0, 1) == '-');
+                    $edits[] = new Text_Diff_Op_delete($diff1);
+                    break;
+                }
+            }
+
+            if ($j < $max_j) {
+                $diff2 = array();
+                switch (substr($diff[$j], 0, 1)) {
+                case '+':
+                    do {
+                        $diff2[] = substr($diff[$j++], 2);
+                    } while ($j < $max_j && substr($diff[$j], 0, 1) == '+');
+                    $edits[] = new Text_Diff_Op_add($diff2);
+                    break;
+
+                case '-':
+                    do {
+                        $diff2[] = substr($diff[$j++], 2);
+                    } while ($j < $max_j && substr($diff[$j], 0, 1) == '-');
+                    $edits[] = new Text_Diff_Op_delete($diff2);
+                    break;
+                }
+            }
+        }
+
+        return $edits;
+    }
+
+}

main/inc/lib/pear/Text/Diff/Engine/xdiff.php

@@ -0,0 +1,66 @@
+<?php
+/**
+ * Class used internally by Diff to actually compute the diffs.
+ *
+ * This class uses the xdiff PECL package (http://pecl.php.net/package/xdiff)
+ * to compute the differences between the two input arrays.
+ *
+ * $Horde: framework/Text_Diff/Diff/Engine/xdiff.php,v 1.4.2.5 2009/07/24 13:06:24 jan Exp $
+ *
+ * Copyright 2004-2009 The Horde Project (http://www.horde.org/)
+ *
+ * See the enclosed file COPYING for license information (LGPL). If you did
+ * not receive this file, see http://opensource.org/licenses/lgpl-license.php.
+ *
+ * @author  Jon Parise <jon@horde.org>
+ * @package Text_Diff
+ */
+class Text_Diff_Engine_xdiff {
+
+    /**
+     */
+    function diff($from_lines, $to_lines)
+    {
+        array_walk($from_lines, array('Text_Diff', 'trimNewlines'));
+        array_walk($to_lines, array('Text_Diff', 'trimNewlines'));
+
+        /* Convert the two input arrays into strings for xdiff processing. */
+        $from_string = implode("\n", $from_lines);
+        $to_string = implode("\n", $to_lines);
+
+        /* Diff the two strings and convert the result to an array. */
+        $diff = xdiff_string_diff($from_string, $to_string, count($to_lines));
+        $diff = explode("\n", $diff);
+
+        /* Walk through the diff one line at a time.  We build the $edits
+         * array of diff operations by reading the first character of the
+         * xdiff output (which is in the "unified diff" format).
+         *
+         * Note that we don't have enough information to detect "changed"
+         * lines using this approach, so we can't add Text_Diff_Op_changed
+         * instances to the $edits array.  The result is still perfectly
+         * valid, albeit a little less descriptive and efficient. */
+        $edits = array();
+        foreach ($diff as $line) {
+            if (!strlen($line)) {
+                continue;
+            }
+            switch ($line[0]) {
+            case ' ':
+                $edits[] = new Text_Diff_Op_copy(array(substr($line, 1)));
+                break;
+
+            case '+':
+                $edits[] = new Text_Diff_Op_add(array(substr($line, 1)));
+                break;
+
+            case '-':
+                $edits[] = new Text_Diff_Op_delete(array(substr($line, 1)));
+                break;
+            }
+        }
+
+        return $edits;
+    }
+
+}

main/inc/lib/pear/Text/Diff/Mapped.php

@@ -0,0 +1,55 @@
+<?php
+/**
+ * $Horde: framework/Text_Diff/Diff/Mapped.php,v 1.3.2.4 2009/01/06 15:23:41 jan Exp $
+ *
+ * Copyright 2007-2009 The Horde Project (http://www.horde.org/)
+ *
+ * See the enclosed file COPYING for license information (LGPL). If you did
+ * not receive this file, see http://opensource.org/licenses/lgpl-license.php.
+ *
+ * @package Text_Diff
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ */
+class Text_Diff_Mapped extends Text_Diff {
+
+    /**
+     * Computes a diff between sequences of strings.
+     *
+     * This can be used to compute things like case-insensitve diffs, or diffs
+     * which ignore changes in white-space.
+     *
+     * @param array $from_lines         An array of strings.
+     * @param array $to_lines           An array of strings.
+     * @param array $mapped_from_lines  This array should have the same size
+     *                                  number of elements as $from_lines.  The
+     *                                  elements in $mapped_from_lines and
+     *                                  $mapped_to_lines are what is actually
+     *                                  compared when computing the diff.
+     * @param array $mapped_to_lines    This array should have the same number
+     *                                  of elements as $to_lines.
+     */
+    function Text_Diff_Mapped($from_lines, $to_lines,
+                              $mapped_from_lines, $mapped_to_lines)
+    {
+        assert(count($from_lines) == count($mapped_from_lines));
+        assert(count($to_lines) == count($mapped_to_lines));
+
+        parent::Text_Diff($mapped_from_lines, $mapped_to_lines);
+
+        $xi = $yi = 0;
+        for ($i = 0; $i < count($this->_edits); $i++) {
+            $orig = &$this->_edits[$i]->orig;
+            if (is_array($orig)) {
+                $orig = array_slice($from_lines, $xi, count($orig));
+                $xi += count($orig);
+            }
+
+            $final = &$this->_edits[$i]->final;
+            if (is_array($final)) {
+                $final = array_slice($to_lines, $yi, count($final));
+                $yi += count($final);
+            }
+        }
+    }
+
+}

main/inc/lib/pear/Text/Diff/Renderer.php

@@ -0,0 +1,237 @@
+<?php
+/**
+ * A class to render Diffs in different formats.
+ *
+ * This class renders the diff in classic diff format. It is intended that
+ * this class be customized via inheritance, to obtain fancier outputs.
+ *
+ * $Horde: framework/Text_Diff/Diff/Renderer.php,v 1.5.10.12 2009/07/24 13:26:40 jan Exp $
+ *
+ * Copyright 2004-2009 The Horde Project (http://www.horde.org/)
+ *
+ * See the enclosed file COPYING for license information (LGPL). If you did
+ * not receive this file, see http://opensource.org/licenses/lgpl-license.php.
+ *
+ * @package Text_Diff
+ */
+class Text_Diff_Renderer {
+
+    /**
+     * Number of leading context "lines" to preserve.
+     *
+     * This should be left at zero for this class, but subclasses may want to
+     * set this to other values.
+     */
+    var $_leading_context_lines = 0;
+
+    /**
+     * Number of trailing context "lines" to preserve.
+     *
+     * This should be left at zero for this class, but subclasses may want to
+     * set this to other values.
+     */
+    var $_trailing_context_lines = 0;
+
+    /**
+     * Constructor.
+     */
+    public function __construct($params = array())
+    {
+        foreach ($params as $param => $value) {
+            $v = '_' . $param;
+            if (isset($this->$v)) {
+                $this->$v = $value;
+            }
+        }
+    }
+
+    /**
+     * Get any renderer parameters.
+     *
+     * @return array  All parameters of this renderer object.
+     */
+    function getParams()
+    {
+        $params = array();
+        foreach (get_object_vars($this) as $k => $v) {
+            if ($k[0] == '_') {
+                $params[substr($k, 1)] = $v;
+            }
+        }
+
+        return $params;
+    }
+
+    /**
+     * Renders a diff.
+     *
+     * @param Text_Diff $diff  A Text_Diff object.
+     *
+     * @return string  The formatted output.
+     */
+    function render($diff)
+    {
+        $xi = $yi = 1;
+        $block = false;
+        $context = array();
+
+        $nlead = $this->_leading_context_lines;
+        $ntrail = $this->_trailing_context_lines;
+
+        $output = $this->_startDiff();
+
+        $diffs = $diff->getDiff();
+        foreach ($diffs as $i => $edit) {
+            /* If these are unchanged (copied) lines, and we want to keep
+             * leading or trailing context lines, extract them from the copy
+             * block. */
+            if (is_a($edit, 'Text_Diff_Op_copy')) {
+                /* Do we have any diff blocks yet? */
+                if (is_array($block)) {
+                    /* How many lines to keep as context from the copy
+                     * block. */
+                    $keep = $i == count($diffs) - 1 ? $ntrail : $nlead + $ntrail;
+                    if (count($edit->orig) <= $keep) {
+                        /* We have less lines in the block than we want for
+                         * context => keep the whole block. */
+                        $block[] = $edit;
+                    } else {
+                        if ($ntrail) {
+                            /* Create a new block with as many lines as we need
+                             * for the trailing context. */
+                            $context = array_slice($edit->orig, 0, $ntrail);
+                            $block[] = new Text_Diff_Op_copy($context);
+                        }
+                        /* @todo */
+                        $output .= $this->_block($x0, $ntrail + $xi - $x0,
+                                                 $y0, $ntrail + $yi - $y0,
+                                                 $block);
+                        $block = false;
+                    }
+                }
+                /* Keep the copy block as the context for the next block. */
+                $context = $edit->orig;
+            } else {
+                /* Don't we have any diff blocks yet? */
+                if (!is_array($block)) {
+                    /* Extract context lines from the preceding copy block. */
+                    $context = array_slice($context, count($context) - $nlead);
+                    $x0 = $xi - count($context);
+                    $y0 = $yi - count($context);
+                    $block = array();
+                    if ($context) {
+                        $block[] = new Text_Diff_Op_copy($context);
+                    }
+                }
+                $block[] = $edit;
+            }
+
+            if ($edit->orig) {
+                $xi += count($edit->orig);
+            }
+            if ($edit->final) {
+                $yi += count($edit->final);
+            }
+        }
+
+        if (is_array($block)) {
+            $output .= $this->_block($x0, $xi - $x0,
+                                     $y0, $yi - $y0,
+                                     $block);
+        }
+
+        return $output . $this->_endDiff();
+    }
+
+    function _block($xbeg, $xlen, $ybeg, $ylen, &$edits)
+    {
+        $output = $this->_startBlock($this->_blockHeader($xbeg, $xlen, $ybeg, $ylen));
+
+        foreach ($edits as $edit) {
+            switch (strtolower(get_class($edit))) {
+            case 'text_diff_op_copy':
+                $output .= $this->_context($edit->orig);
+                break;
+
+            case 'text_diff_op_add':
+                $output .= $this->_added($edit->final);
+                break;
+
+            case 'text_diff_op_delete':
+                $output .= $this->_deleted($edit->orig);
+                break;
+
+            case 'text_diff_op_change':
+                $output .= $this->_changed($edit->orig, $edit->final);
+                break;
+            }
+        }
+
+        return $output . $this->_endBlock();
+    }
+
+    function _startDiff()
+    {
+        return '';
+    }
+
+    function _endDiff()
+    {
+        return '';
+    }
+
+    function _blockHeader($xbeg, $xlen, $ybeg, $ylen)
+    {
+        if ($xlen > 1) {
+            $xbeg .= ',' . ($xbeg + $xlen - 1);
+        }
+        if ($ylen > 1) {
+            $ybeg .= ',' . ($ybeg + $ylen - 1);
+        }
+
+        // this matches the GNU Diff behaviour
+        if ($xlen && !$ylen) {
+            $ybeg--;
+        } elseif (!$xlen) {
+            $xbeg--;
+        }
+
+        return $xbeg . ($xlen ? ($ylen ? 'c' : 'd') : 'a') . $ybeg;
+    }
+
+    function _startBlock($header)
+    {
+        return $header . "\n";
+    }
+
+    function _endBlock()
+    {
+        return '';
+    }
+
+    function _lines($lines, $prefix = ' ')
+    {
+        return $prefix . implode("\n$prefix", $lines) . "\n";
+    }
+
+    function _context($lines)
+    {
+        return $this->_lines($lines, '  ');
+    }
+
+    function _added($lines)
+    {
+        return $this->_lines($lines, '> ');
+    }
+
+    function _deleted($lines)
+    {
+        return $this->_lines($lines, '< ');
+    }
+
+    function _changed($orig, $final)
+    {
+        return $this->_deleted($orig) . "---\n" . $this->_added($final);
+    }
+
+}

main/inc/lib/pear/Text/Diff/Renderer/context.php

@@ -0,0 +1,75 @@
+<?php
+/**
+ * "Context" diff renderer.
+ *
+ * This class renders the diff in classic "context diff" format.
+ *
+ * $Horde: framework/Text_Diff/Diff/Renderer/context.php,v 1.3.2.4 2009/01/06 15:23:42 jan Exp $
+ *
+ * Copyright 2004-2009 The Horde Project (http://www.horde.org/)
+ *
+ * See the enclosed file COPYING for license information (LGPL). If you did
+ * not receive this file, see http://opensource.org/licenses/lgpl-license.php.
+ *
+ * @package Text_Diff
+ */
+
+
+/**
+ * @package Text_Diff
+ */
+class Text_Diff_Renderer_context extends Text_Diff_Renderer {
+
+    /**
+     * Number of leading context "lines" to preserve.
+     */
+    var $_leading_context_lines = 4;
+
+    /**
+     * Number of trailing context "lines" to preserve.
+     */
+    var $_trailing_context_lines = 4;
+
+    var $_second_block = '';
+
+    function _blockHeader($xbeg, $xlen, $ybeg, $ylen)
+    {
+        if ($xlen != 1) {
+            $xbeg .= ',' . $xlen;
+        }
+        if ($ylen != 1) {
+            $ybeg .= ',' . $ylen;
+        }
+        $this->_second_block = "--- $ybeg ----\n";
+        return "***************\n*** $xbeg ****";
+    }
+
+    function _endBlock()
+    {
+        return $this->_second_block;
+    }
+
+    function _context($lines)
+    {
+        $this->_second_block .= $this->_lines($lines, '  ');
+        return $this->_lines($lines, '  ');
+    }
+
+    function _added($lines)
+    {
+        $this->_second_block .= $this->_lines($lines, '+ ');
+        return '';
+    }
+
+    function _deleted($lines)
+    {
+        return $this->_lines($lines, '- ');
+    }
+
+    function _changed($orig, $final)
+    {
+        $this->_second_block .= $this->_lines($final, '! ');
+        return $this->_lines($orig, '! ');
+    }
+
+}

main/inc/lib/pear/Text/Diff/Renderer/index.html

@@ -0,0 +1,6 @@
+<html>
+<head>
+</head>
+<body>
+</body>
+</html>

main/inc/lib/pear/Text/Diff/Renderer/inline.php

@@ -0,0 +1,169 @@
+<?php
+/**
+ * "Inline" diff renderer.
+ *
+ * $Horde: framework/Text_Diff/Diff/Renderer/inline.php,v 1.4.10.16 2009/07/24 13:25:29 jan Exp $
+ *
+ * Copyright 2004-2009 The Horde Project (http://www.horde.org/)
+ *
+ * See the enclosed file COPYING for license information (LGPL). If you did
+ * not receive this file, see http://opensource.org/licenses/lgpl-license.php.
+ *
+ * @author  Ciprian Popovici
+ * @package Text_Diff
+ */
+
+/**
+ * "Inline" diff renderer.
+ *
+ * This class renders diffs in the Wiki-style "inline" format.
+ *
+ * @author  Ciprian Popovici
+ * @package Text_Diff
+ */
+class Text_Diff_Renderer_inline extends Text_Diff_Renderer {
+
+    /**
+     * Number of leading context "lines" to preserve.
+     */
+    var $_leading_context_lines = 10000;
+
+    /**
+     * Number of trailing context "lines" to preserve.
+     */
+    var $_trailing_context_lines = 10000;
+
+    /**
+     * Prefix for inserted text.
+     */
+    var $_ins_prefix = '<ins>';
+
+    /**
+     * Suffix for inserted text.
+     */
+    var $_ins_suffix = '</ins>';
+
+    /**
+     * Prefix for deleted text.
+     */
+    var $_del_prefix = '<del>';
+
+    /**
+     * Suffix for deleted text.
+     */
+    var $_del_suffix = '</del>';
+
+    /**
+     * Header for each change block.
+     */
+    var $_block_header = '';
+
+    /**
+     * What are we currently splitting on? Used to recurse to show word-level
+     * changes.
+     */
+    var $_split_level = 'lines';
+
+    function _blockHeader($xbeg, $xlen, $ybeg, $ylen)
+    {
+        return $this->_block_header;
+    }
+
+    function _startBlock($header)
+    {
+        return $header;
+    }
+
+    function _lines($lines, $prefix = ' ', $encode = true)
+    {
+        if ($encode) {
+            array_walk($lines, array(&$this, '_encode'));
+        }
+
+        if ($this->_split_level == 'words') {
+            return implode('', $lines);
+        } else {
+            return implode("\n", $lines) . "\n";
+        }
+    }
+
+    function _added($lines)
+    {
+        array_walk($lines, array(&$this, '_encode'));
+        $lines[0] = $this->_ins_prefix . $lines[0];
+        $lines[count($lines) - 1] .= $this->_ins_suffix;
+        return $this->_lines($lines, ' ', false);
+    }
+
+    function _deleted($lines, $words = false)
+    {
+        array_walk($lines, array(&$this, '_encode'));
+        $lines[0] = $this->_del_prefix . $lines[0];
+        $lines[count($lines) - 1] .= $this->_del_suffix;
+        return $this->_lines($lines, ' ', false);
+    }
+
+    function _changed($orig, $final)
+    {
+        /* If we've already split on words, don't try to do so again - just
+         * display. */
+        if ($this->_split_level == 'words') {
+            $prefix = '';
+            while ($orig[0] !== false && $final[0] !== false &&
+                   substr($orig[0], 0, 1) == ' ' &&
+                   substr($final[0], 0, 1) == ' ') {
+                $prefix .= substr($orig[0], 0, 1);
+                $orig[0] = substr($orig[0], 1);
+                $final[0] = substr($final[0], 1);
+            }
+            return $prefix . $this->_deleted($orig) . $this->_added($final);
+        }
+
+        $text1 = implode("\n", $orig);
+        $text2 = implode("\n", $final);
+
+        /* Non-printing newline marker. */
+        $nl = "\0";
+
+        /* We want to split on word boundaries, but we need to
+         * preserve whitespace as well. Therefore we split on words,
+         * but include all blocks of whitespace in the wordlist. */
+        $diff = new Text_Diff('native',
+                              array($this->_splitOnWords($text1, $nl),
+                                    $this->_splitOnWords($text2, $nl)));
+
+        /* Get the diff in inline format. */
+        $renderer = new Text_Diff_Renderer_inline
+            (array_merge($this->getParams(),
+                         array('split_level' => 'words')));
+
+        /* Run the diff and get the output. */
+        return str_replace($nl, "\n", $renderer->render($diff)) . "\n";
+    }
+
+    function _splitOnWords($string, $newlineEscape = "\n")
+    {
+        // Ignore \0; otherwise the while loop will never finish.
+        $string = str_replace("\0", '', $string);
+
+        $words = array();
+        $length = strlen($string);
+        $pos = 0;
+
+        while ($pos < $length) {
+            // Eat a word with any preceding whitespace.
+            $spaces = strspn(substr($string, $pos), " \n");
+            $nextpos = strcspn(substr($string, $pos + $spaces), " \n");
+            $words[] = str_replace("\n", $newlineEscape, substr($string, $pos, $spaces + $nextpos));
+            $pos += $spaces + $nextpos;
+        }
+
+        return $words;
+    }
+
+    function _encode(&$string)
+    {
+        $string = htmlspecialchars($string);
+    }
+
+}

main/inc/lib/pear/Text/Diff/Renderer/unified.php

@@ -0,0 +1,65 @@
+<?php
+/**
+ * "Unified" diff renderer.
+ *
+ * This class renders the diff in classic "unified diff" format.
+ *
+ * $Horde: framework/Text_Diff/Diff/Renderer/unified.php,v 1.3.10.7 2009/01/06 15:23:42 jan Exp $
+ *
+ * Copyright 2004-2009 The Horde Project (http://www.horde.org/)
+ *
+ * See the enclosed file COPYING for license information (LGPL). If you did
+ * not receive this file, see http://opensource.org/licenses/lgpl-license.php.
+ *
+ * @author  Ciprian Popovici
+ * @package Text_Diff
+ */
+
+
+/**
+ * @package Text_Diff
+ */
+class Text_Diff_Renderer_unified extends Text_Diff_Renderer {
+
+    /**
+     * Number of leading context "lines" to preserve.
+     */
+    var $_leading_context_lines = 4;
+
+    /**
+     * Number of trailing context "lines" to preserve.
+     */
+    var $_trailing_context_lines = 4;
+
+    function _blockHeader($xbeg, $xlen, $ybeg, $ylen)
+    {
+        if ($xlen != 1) {
+            $xbeg .= ',' . $xlen;
+        }
+        if ($ylen != 1) {
+            $ybeg .= ',' . $ylen;
+        }
+        return "@@ -$xbeg +$ybeg @@";
+    }
+
+    function _context($lines)
+    {
+        return $this->_lines($lines, ' ');
+    }
+
+    function _added($lines)
+    {
+        return $this->_lines($lines, '+');
+    }
+
+    function _deleted($lines)
+    {
+        return $this->_lines($lines, '-');
+    }
+
+    function _changed($orig, $final)
+    {
+        return $this->_deleted($orig) . $this->_added($final);
+    }
+
+}

main/inc/lib/pear/Text/Diff/ThreeWay.php

@@ -0,0 +1,275 @@
+<?php
+/**
+ * A class for computing three way diffs.
+ *
+ * $Horde: framework/Text_Diff/Diff/ThreeWay.php,v 1.3.2.4 2009/01/06 15:23:41 jan Exp $
+ *
+ * Copyright 2007-2009 The Horde Project (http://www.horde.org/)
+ *
+ * See the enclosed file COPYING for license information (LGPL). If you did
+ * not receive this file, see http://opensource.org/licenses/lgpl-license.php.
+ *
+ * @package Text_Diff
+ * @since   0.3.0
+ */
+
+/** Text_Diff */
+
+/**
+ * A class for computing three way diffs.
+ *
+ * @package Text_Diff
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ */
+class Text_Diff_ThreeWay extends Text_Diff {
+
+    /**
+     * Conflict counter.
+     *
+     * @var integer
+     */
+    var $_conflictingBlocks = 0;
+
+    /**
+     * Computes diff between 3 sequences of strings.
+     *
+     * @param array $orig    The original lines to use.
+     * @param array $final1  The first version to compare to.
+     * @param array $final2  The second version to compare to.
+     */
+    function Text_Diff_ThreeWay($orig, $final1, $final2)
+    {
+        if (extension_loaded('xdiff')) {
+            $engine = new Text_Diff_Engine_xdiff();
+        } else {
+            $engine = new Text_Diff_Engine_native();
+        }
+
+        $this->_edits = $this->_diff3($engine->diff($orig, $final1),
+                                      $engine->diff($orig, $final2));
+    }
+
+    /**
+     */
+    function mergedOutput($label1 = false, $label2 = false)
+    {
+        $lines = array();
+        foreach ($this->_edits as $edit) {
+            if ($edit->isConflict()) {
+                /* FIXME: this should probably be moved somewhere else. */
+                $lines = array_merge($lines,
+                                     array('<<<<<<<' . ($label1 ? ' ' . $label1 : '')),
+                                     $edit->final1,
+                                     array("======="),
+                                     $edit->final2,
+                                     array('>>>>>>>' . ($label2 ? ' ' . $label2 : '')));
+                $this->_conflictingBlocks++;
+            } else {
+                $lines = array_merge($lines, $edit->merged());
+            }
+        }
+
+        return $lines;
+    }
+
+    /**
+     * @access private
+     */
+    function _diff3($edits1, $edits2)
+    {
+        $edits = array();
+        $bb = new Text_Diff_ThreeWay_BlockBuilder();
+
+        $e1 = current($edits1);
+        $e2 = current($edits2);
+        while ($e1 || $e2) {
+            if ($e1 && $e2 && is_a($e1, 'Text_Diff_Op_copy') && is_a($e2, 'Text_Diff_Op_copy')) {
+                /* We have copy blocks from both diffs. This is the (only)
+                 * time we want to emit a diff3 copy block.  Flush current
+                 * diff3 diff block, if any. */
+                if ($edit = $bb->finish()) {
+                    $edits[] = $edit;
+                }
+
+                $ncopy = min($e1->norig(), $e2->norig());
+                assert($ncopy > 0);
+                $edits[] = new Text_Diff_ThreeWay_Op_copy(array_slice($e1->orig, 0, $ncopy));
+
+                if ($e1->norig() > $ncopy) {
+                    array_splice($e1->orig, 0, $ncopy);
+                    array_splice($e1->final, 0, $ncopy);
+                } else {
+                    $e1 = next($edits1);
+                }
+
+                if ($e2->norig() > $ncopy) {
+                    array_splice($e2->orig, 0, $ncopy);
+                    array_splice($e2->final, 0, $ncopy);
+                } else {
+                    $e2 = next($edits2);
+                }
+            } else {
+                if ($e1 && $e2) {
+                    if ($e1->orig && $e2->orig) {
+                        $norig = min($e1->norig(), $e2->norig());
+                        $orig = array_splice($e1->orig, 0, $norig);
+                        array_splice($e2->orig, 0, $norig);
+                        $bb->input($orig);
+                    }
+
+                    if (is_a($e1, 'Text_Diff_Op_copy')) {
+                        $bb->out1(array_splice($e1->final, 0, $norig));
+                    }
+
+                    if (is_a($e2, 'Text_Diff_Op_copy')) {
+                        $bb->out2(array_splice($e2->final, 0, $norig));
+                    }
+                }
+
+                if ($e1 && ! $e1->orig) {
+                    $bb->out1($e1->final);
+                    $e1 = next($edits1);
+                }
+                if ($e2 && ! $e2->orig) {
+                    $bb->out2($e2->final);
+                    $e2 = next($edits2);
+                }
+            }
+        }
+
+        if ($edit = $bb->finish()) {
+            $edits[] = $edit;
+        }
+
+        return $edits;
+    }
+
+}
+
+/**
+ * @package Text_Diff
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ *
+ * @access private
+ */
+class Text_Diff_ThreeWay_Op {
+
+    function Text_Diff_ThreeWay_Op($orig = false, $final1 = false, $final2 = false)
+    {
+        $this->orig = $orig ? $orig : array();
+        $this->final1 = $final1 ? $final1 : array();
+        $this->final2 = $final2 ? $final2 : array();
+    }
+
+    function merged()
+    {
+        if (!isset($this->_merged)) {
+            if ($this->final1 === $this->final2) {
+                $this->_merged = &$this->final1;
+            } elseif ($this->final1 === $this->orig) {
+                $this->_merged = &$this->final2;
+            } elseif ($this->final2 === $this->orig) {
+                $this->_merged = &$this->final1;
+            } else {
+                $this->_merged = false;
+            }
+        }
+
+        return $this->_merged;
+    }
+
+    function isConflict()
+    {
+        return $this->merged() === false;
+    }
+
+}
+
+/**
+ * @package Text_Diff
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ *
+ * @access private
+ */
+class Text_Diff_ThreeWay_Op_copy extends Text_Diff_ThreeWay_Op {
+
+    function Text_Diff_ThreeWay_Op_Copy($lines = false)
+    {
+        $this->orig = $lines ? $lines : array();
+        $this->final1 = &$this->orig;
+        $this->final2 = &$this->orig;
+    }
+
+    function merged()
+    {
+        return $this->orig;
+    }
+
+    function isConflict()
+    {
+        return false;
+    }
+
+}
+
+/**
+ * @package Text_Diff
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ *
+ * @access private
+ */
+class Text_Diff_ThreeWay_BlockBuilder {
+
+    function Text_Diff_ThreeWay_BlockBuilder()
+    {
+        $this->_init();
+    }
+
+    function input($lines)
+    {
+        if ($lines) {
+            $this->_append($this->orig, $lines);
+        }
+    }
+
+    function out1($lines)
+    {
+        if ($lines) {
+            $this->_append($this->final1, $lines);
+        }
+    }
+
+    function out2($lines)
+    {
+        if ($lines) {
+            $this->_append($this->final2, $lines);
+        }
+    }
+
+    function isEmpty()
+    {
+        return !$this->orig && !$this->final1 && !$this->final2;
+    }
+
+    function finish()
+    {
+        if ($this->isEmpty()) {
+            return false;
+        } else {
+            $edit = new Text_Diff_ThreeWay_Op($this->orig, $this->final1, $this->final2);
+            $this->_init();
+            return $edit;
+        }
+    }
+
+    function _init()
+    {
+        $this->orig = $this->final1 = $this->final2 = array();
+    }
+
+    function _append(&$array, $lines)
+    {
+        array_splice($array, sizeof($array), 0, $lines);
+    }
+
+}

main/inc/lib/pear/Text/Diff/index.html

@@ -0,0 +1,6 @@
+<html>
+<head>
+</head>
+<body>
+</body>
+</html>

main/inc/lib/pear/Text/Diff3.php

@@ -0,0 +1,275 @@
+<?php
+/**
+ * A class for computing three way diffs.
+ *
+ * $Horde: framework/Text_Diff/Diff3.php,v 1.2.10.7 2009/01/06 15:23:41 jan Exp $
+ *
+ * Copyright 2007-2009 The Horde Project (http://www.horde.org/)
+ *
+ * See the enclosed file COPYING for license information (LGPL). If you did
+ * not receive this file, see http://opensource.org/licenses/lgpl-license.php.
+ *
+ * @package Text_Diff
+ * @since   0.3.0
+ */
+
+/** Text_Diff */
+
+/**
+ * A class for computing three way diffs.
+ *
+ * @package Text_Diff
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ */
+class Text_Diff3 extends Text_Diff {
+
+    /**
+     * Conflict counter.
+     *
+     * @var integer
+     */
+    var $_conflictingBlocks = 0;
+
+    /**
+     * Computes diff between 3 sequences of strings.
+     *
+     * @param array $orig    The original lines to use.
+     * @param array $final1  The first version to compare to.
+     * @param array $final2  The second version to compare to.
+     */
+    function Text_Diff3($orig, $final1, $final2)
+    {
+        if (extension_loaded('xdiff')) {
+            $engine = new Text_Diff_Engine_xdiff();
+        } else {
+            $engine = new Text_Diff_Engine_native();
+        }
+
+        $this->_edits = $this->_diff3($engine->diff($orig, $final1),
+                                      $engine->diff($orig, $final2));
+    }
+
+    /**
+     */
+    function mergedOutput($label1 = false, $label2 = false)
+    {
+        $lines = array();
+        foreach ($this->_edits as $edit) {
+            if ($edit->isConflict()) {
+                /* FIXME: this should probably be moved somewhere else. */
+                $lines = array_merge($lines,
+                                     array('<<<<<<<' . ($label1 ? ' ' . $label1 : '')),
+                                     $edit->final1,
+                                     array("======="),
+                                     $edit->final2,
+                                     array('>>>>>>>' . ($label2 ? ' ' . $label2 : '')));
+                $this->_conflictingBlocks++;
+            } else {
+                $lines = array_merge($lines, $edit->merged());
+            }
+        }
+
+        return $lines;
+    }
+
+    /**
+     * @access private
+     */
+    function _diff3($edits1, $edits2)
+    {
+        $edits = array();
+        $bb = new Text_Diff3_BlockBuilder();
+
+        $e1 = current($edits1);
+        $e2 = current($edits2);
+        while ($e1 || $e2) {
+            if ($e1 && $e2 && is_a($e1, 'Text_Diff_Op_copy') && is_a($e2, 'Text_Diff_Op_copy')) {
+                /* We have copy blocks from both diffs. This is the (only)
+                 * time we want to emit a diff3 copy block.  Flush current
+                 * diff3 diff block, if any. */
+                if ($edit = $bb->finish()) {
+                    $edits[] = $edit;
+                }
+
+                $ncopy = min($e1->norig(), $e2->norig());
+                assert($ncopy > 0);
+                $edits[] = new Text_Diff3_Op_copy(array_slice($e1->orig, 0, $ncopy));
+
+                if ($e1->norig() > $ncopy) {
+                    array_splice($e1->orig, 0, $ncopy);
+                    array_splice($e1->final, 0, $ncopy);
+                } else {
+                    $e1 = next($edits1);
+                }
+
+                if ($e2->norig() > $ncopy) {
+                    array_splice($e2->orig, 0, $ncopy);
+                    array_splice($e2->final, 0, $ncopy);
+                } else {
+                    $e2 = next($edits2);
+                }
+            } else {
+                if ($e1 && $e2) {
+                    if ($e1->orig && $e2->orig) {
+                        $norig = min($e1->norig(), $e2->norig());
+                        $orig = array_splice($e1->orig, 0, $norig);
+                        array_splice($e2->orig, 0, $norig);
+                        $bb->input($orig);
+                    }
+
+                    if (is_a($e1, 'Text_Diff_Op_copy')) {
+                        $bb->out1(array_splice($e1->final, 0, $norig));
+                    }
+
+                    if (is_a($e2, 'Text_Diff_Op_copy')) {
+                        $bb->out2(array_splice($e2->final, 0, $norig));
+                    }
+                }
+
+                if ($e1 && ! $e1->orig) {
+                    $bb->out1($e1->final);
+                    $e1 = next($edits1);
+                }
+                if ($e2 && ! $e2->orig) {
+                    $bb->out2($e2->final);
+                    $e2 = next($edits2);
+                }
+            }
+        }
+
+        if ($edit = $bb->finish()) {
+            $edits[] = $edit;
+        }
+
+        return $edits;
+    }
+
+}
+
+/**
+ * @package Text_Diff
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ *
+ * @access private
+ */
+class Text_Diff3_Op {
+
+    function Text_Diff3_Op($orig = false, $final1 = false, $final2 = false)
+    {
+        $this->orig = $orig ? $orig : array();
+        $this->final1 = $final1 ? $final1 : array();
+        $this->final2 = $final2 ? $final2 : array();
+    }
+
+    function merged()
+    {
+        if (!isset($this->_merged)) {
+            if ($this->final1 === $this->final2) {
+                $this->_merged = &$this->final1;
+            } elseif ($this->final1 === $this->orig) {
+                $this->_merged = &$this->final2;
+            } elseif ($this->final2 === $this->orig) {
+                $this->_merged = &$this->final1;
+            } else {
+                $this->_merged = false;
+            }
+        }
+
+        return $this->_merged;
+    }
+
+    function isConflict()
+    {
+        return $this->merged() === false;
+    }
+
+}
+
+/**
+ * @package Text_Diff
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ *
+ * @access private
+ */
+class Text_Diff3_Op_copy extends Text_Diff3_Op {
+
+    function Text_Diff3_Op_Copy($lines = false)
+    {
+        $this->orig = $lines ? $lines : array();
+        $this->final1 = &$this->orig;
+        $this->final2 = &$this->orig;
+    }
+
+    function merged()
+    {
+        return $this->orig;
+    }
+
+    function isConflict()
+    {
+        return false;
+    }
+
+}
+
+/**
+ * @package Text_Diff
+ * @author  Geoffrey T. Dairiki <dairiki@dairiki.org>
+ *
+ * @access private
+ */
+class Text_Diff3_BlockBuilder {
+
+    function Text_Diff3_BlockBuilder()
+    {
+        $this->_init();
+    }
+
+    function input($lines)
+    {
+        if ($lines) {
+            $this->_append($this->orig, $lines);
+        }
+    }
+
+    function out1($lines)
+    {
+        if ($lines) {
+            $this->_append($this->final1, $lines);
+        }
+    }
+
+    function out2($lines)
+    {
+        if ($lines) {
+            $this->_append($this->final2, $lines);
+        }
+    }
+
+    function isEmpty()
+    {
+        return !$this->orig && !$this->final1 && !$this->final2;
+    }
+
+    function finish()
+    {
+        if ($this->isEmpty()) {
+            return false;
+        } else {
+            $edit = new Text_Diff3_Op($this->orig, $this->final1, $this->final2);
+            $this->_init();
+            return $edit;
+        }
+    }
+
+    function _init()
+    {
+        $this->orig = $this->final1 = $this->final2 = array();
+    }
+
+    function _append(&$array, $lines)
+    {
+        array_splice($array, sizeof($array), 0, $lines);
+    }
+
+}

main/inc/lib/pear/Text/Password.php

@@ -0,0 +1,533 @@
+<?php
+/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
+
+/**
+ * Class to create passwords
+ *
+ * PHP versions 4 and 5
+ *
+ * LICENSE: This source file is subject to version 3.0 of the PHP license
+ * that is available through the world-wide-web at the following URI:
+ * http://www.php.net/license/3_0.txt.  If you did not receive a copy of
+ * the PHP License and are unable to obtain it through the web, please
+ * send a note to license@php.net so we can mail you a copy immediately.
+ *
+ * @category   Text
+ * @package    Text_Password
+ * @author     Martin Jansen <mj@php.net>
+ * @author     Olivier Vanhoucke <olivier@php.net>
+ * @copyright  2004-2005 Martin Jansen, Olivier Vanhoucke
+ * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
+ * @version    CVS: $Id: Password.php,v 1.18 2008/11/30 13:38:56 mj Exp $
+ * @link       http://pear.php.net/package/Text_Password
+ */
+
+/**
+ * Number of possible characters in the password
+ */
+$GLOBALS['_Text_Password_NumberOfPossibleCharacters'] = 0;
+
+/**
+ * Main class for the Text_Password package
+ *
+ * @category   Text
+ * @package    Text_Password
+ * @author     Martin Jansen <mj@php.net>
+ * @author     Olivier Vanhoucke <olivier@php.net>
+ * @copyright  2004-2005 Martin Jansen, Olivier Vanhoucke
+ * @license    http://www.php.net/license/3_0.txt  PHP License 3.0
+ * @version    Release: @package_version@
+ * @link       http://pear.php.net/package/Text_Password
+ */
+class Text_Password {
+
+    /**
+     * Create a single password.
+     *
+     * @access public
+     * @param  integer Length of the password.
+     * @param  string  Type of password (pronounceable, unpronounceable)
+     * @param  string  Character which could be use in the
+     *                 unpronounceable password ex : 'ABCDEFG'
+     *                 or numeric, alphabetical or alphanumeric.
+     * @return string  Returns the generated password.
+     */
+    function create($length = 10, $type = 'pronounceable', $chars = '')
+    {
+        switch ($type) {
+        case 'unpronounceable' :
+            return Text_Password::_createUnpronounceable($length, $chars);
+
+        case 'pronounceable' :
+        default :
+            return Text_Password::_createPronounceable($length);
+        }
+    }
+
+    /**
+     * Create multiple, different passwords
+     *
+     * Method to create a list of different passwords which are
+     * all different.
+     *
+     * @access public
+     * @param  integer Number of different password
+     * @param  integer Length of the password
+     * @param  string  Type of password (pronounceable, unpronounceable)
+     * @param  string  Character which could be use in the
+     *                 unpronounceable password ex : 'A,B,C,D,E,F,G'
+     *                 or numeric, alphabetical or alphanumeric.
+     * @return array   Array containing the passwords
+     */
+    function createMultiple($number, $length = 10, $type = 'pronounceable', $chars = '')
+    {
+        $passwords = array();
+
+        while ($number > 0) {
+            while (true) {
+                $password = Text_Password::create($length, $type, $chars);
+                if (!in_array($password, $passwords)) {
+                    $passwords[] = $password;
+                    break;
+                }
+            }
+            $number--;
+        }
+        return $passwords;
+    }
+
+    /**
+     * Create password from login
+     *
+     * Method to create password from login
+     *
+     * @access public
+     * @param  string  Login
+     * @param  string  Type
+     * @param  integer Key
+     * @return string
+     */
+    function createFromLogin($login, $type, $key = 0)
+    {
+        switch ($type) {
+        case 'reverse':
+            return strrev($login);
+
+        case 'shuffle':
+            return Text_Password::_shuffle($login);
+
+        case 'xor':
+            return Text_Password::_xor($login, $key);
+
+        case 'rot13':
+            return str_rot13($login);
+
+        case 'rotx':
+            return Text_Password::_rotx($login, $key);
+
+        case 'rotx++':
+            return Text_Password::_rotxpp($login, $key);
+
+        case 'rotx--':
+            return Text_Password::_rotxmm($login, $key);
+
+        case 'ascii_rotx':
+            return Text_Password::_asciiRotx($login, $key);
+
+        case 'ascii_rotx++':
+            return Text_Password::_asciiRotxpp($login, $key);
+
+        case 'ascii_rotx--':
+            return Text_Password::_asciiRotxmm($login, $key);
+        }
+    }
+
+    /**
+     * Create multiple, different passwords from an array of login
+     *
+     * Method to create a list of different password from login
+     *
+     * @access public
+     * @param  array   Login
+     * @param  string  Type
+     * @param  integer Key
+     * @return array   Array containing the passwords
+     */
+    function createMultipleFromLogin($login, $type, $key = 0)
+    {
+        $passwords = array();
+        $number    = count($login);
+        $save      = $number;
+
+        while ($number > 0) {
+            while (true) {
+                $password = Text_Password::createFromLogin($login[$save - $number], $type, $key);
+                if (!in_array($password, $passwords)) {
+                    $passwords[] = $password;
+                    break;
+                }
+            }
+            $number--;
+        }
+        return $passwords;
+    }
+
+    /**
+     * Helper method to create password
+     *
+     * Method to create a password from a login
+     *
+     * @access private
+     * @param  string  Login
+     * @param  integer Key
+     * @return string
+     */
+    function _xor($login, $key)
+    {
+        $tmp = '';
+
+        for ($i = 0; $i < strlen($login); $i++) {
+            $next = ord($login[$i]) ^ $key;
+            if ($next > 255) {
+                $next -= 255;
+            } elseif ($next < 0) {
+                $next += 255;
+            }
+            $tmp .= chr($next);
+        }
+
+        return $tmp;
+    }
+
+    /**
+     * Helper method to create password
+     *
+     * Method to create a password from a login
+     * lowercase only
+     *
+     * @access private
+     * @param  string  Login
+     * @param  integer Key
+     * @return string
+     */
+    function _rotx($login, $key)
+    {
+        $tmp = '';
+        $login = strtolower($login);
+
+        for ($i = 0; $i < strlen($login); $i++) {
+            if ((ord($login[$i]) >= 97) && (ord($login[$i]) <= 122)) { // 65, 90 for uppercase
+                $next = ord($login[$i]) + $key;
+                if ($next > 122) {
+                    $next -= 26;
+                } elseif ($next < 97) {
+                    $next += 26;
+                }
+                $tmp .= chr($next);
+            } else {
+                $tmp .= $login[$i];
+            }
+        }
+
+        return $tmp;
+    }
+
+    /**
+     * Helper method to create password
+     *
+     * Method to create a password from a login
+     * lowercase only
+     *
+     * @access private
+     * @param  string  Login
+     * @param  integer Key
+     * @return string
+     */
+    function _rotxpp($login, $key)
+    {
+        $tmp = '';
+        $login = strtolower($login);
+
+        for ($i = 0; $i < strlen($login); $i++, $key++) {
+            if ((ord($login[$i]) >= 97) && (ord($login[$i]) <= 122)) { // 65, 90 for uppercase
+                $next = ord($login[$i]) + $key;
+                if ($next > 122) {
+                    $next -= 26;
+                } elseif ($next < 97) {
+                    $next += 26;
+                }
+                $tmp .= chr($next);
+            } else {
+                $tmp .= $login[$i];
+            }
+        }
+
+        return $tmp;
+    }
+
+    /**
+     * Helper method to create password
+     *
+     * Method to create a password from a login
+     * lowercase only
+     *
+     * @access private
+     * @param  string  Login
+     * @param  integer Key
+     * @return string
+     */
+    function _rotxmm($login, $key)
+    {
+        $tmp = '';
+        $login = strtolower($login);
+
+        for ($i = 0; $i < strlen($login); $i++, $key--) {
+            if ((ord($login[$i]) >= 97) && (ord($login[$i]) <= 122)) { // 65, 90 for uppercase
+                $next = ord($login[$i]) + $key;
+                if ($next > 122) {
+                    $next -= 26;
+                } elseif ($next < 97) {
+                    $next += 26;
+                }
+                $tmp .= chr($next);
+            } else {
+                $tmp .= $login[$i];
+            }
+        }
+
+        return $tmp;
+    }
+
+    /**
+     * Helper method to create password
+     *
+     * Method to create a password from a login
+     *
+     * @access private
+     * @param  string  Login
+     * @param  integer Key
+     * @return string
+     */
+    function _asciiRotx($login, $key)
+    {
+        $tmp = '';
+
+        for ($i = 0; $i < strlen($login); $i++) {
+            $next = ord($login[$i]) + $key;
+            if ($next > 255) {
+                $next -= 255;
+            } elseif ($next < 0) {
+                $next += 255;
+            }
+            switch ($next) { // delete white space
+            case 0x09:
+            case 0x20:
+            case 0x0A:
+            case 0x0D:
+                $next++;
+            }
+            $tmp .= chr($next);
+        }
+
+        return $tmp;
+    }
+
+    /**
+     * Helper method to create password
+     *
+     * Method to create a password from a login
+     *
+     * @access private
+     * @param  string  Login
+     * @param  integer Key
+     * @return string
+     */
+    function _asciiRotxpp($login, $key)
+    {
+        $tmp = '';
+
+        for ($i = 0; $i < strlen($login); $i++, $key++) {
+            $next = ord($login[$i]) + $key;
+            if ($next > 255) {
+                $next -= 255;
+            } elseif ($next < 0) {
+                $next += 255;
+            }
+            switch ($next) { // delete white space
+            case 0x09:
+            case 0x20:
+            case 0x0A:
+            case 0x0D:
+                $next++;
+            }
+            $tmp .= chr($next);
+        }
+
+        return $tmp;
+    }
+
+    /**
+     * Helper method to create password
+     *
+     * Method to create a password from a login
+     *
+     * @access private
+     * @param  string  Login
+     * @param  integer Key
+     * @return string
+     */
+    function _asciiRotxmm($login, $key)
+    {
+        $tmp = '';
+
+        for ($i = 0; $i < strlen($login); $i++, $key--) {
+            $next = ord($login[$i]) + $key;
+            if ($next > 255) {
+                $next -= 255;
+            } elseif ($next < 0) {
+                $next += 255;
+            }
+            switch ($next) { // delete white space
+            case 0x09:
+            case 0x20:
+            case 0x0A:
+            case 0x0D:
+                $next++;
+            }
+            $tmp .= chr($next);
+        }
+
+        return $tmp;
+    }
+
+    /**
+     * Helper method to create password
+     *
+     * Method to create a password from a login
+     *
+     * @access private
+     * @param  string  Login
+     * @return string
+     */
+    function _shuffle($login)
+    {
+        $tmp = array();
+
+        for ($i = 0; $i < strlen($login); $i++) {
+            $tmp[] = $login[$i];
+        }
+
+        shuffle($tmp);
+
+        return implode($tmp, '');
+    }
+
+    /**
+     * Create pronounceable password
+     *
+     * This method creates a string that consists of
+     * vowels and consonats.
+     *
+     * @access private
+     * @param  integer Length of the password
+     * @return string  Returns the password
+     */
+    function _createPronounceable($length)
+    {
+
+        $retVal = '';
+
+        /**
+         * List of vowels and vowel sounds
+         */
+        $v = array('a', 'e', 'i', 'o', 'u', 'ae', 'ou', 'io',
+                   'ea', 'ou', 'ia', 'ai'
+                   );
+
+        /**
+         * List of consonants and consonant sounds
+         */
+        $c = array('b', 'c', 'd', 'g', 'h', 'j', 'k', 'l', 'm',
+                   'n', 'p', 'r', 's', 't', 'u', 'v', 'w',
+                   'tr', 'cr', 'fr', 'dr', 'wr', 'pr', 'th',
+                   'ch', 'ph', 'st', 'sl', 'cl'
+                   );
+
+        $v_count = 12;
+        $c_count = 29;
+
+        $GLOBALS['_Text_Password_NumberOfPossibleCharacters'] = $v_count + $c_count;
+
+        for ($i = 0; $i < $length; $i++) {
+            $retVal .= $c[mt_rand(0, $c_count-1)] . $v[mt_rand(0, $v_count-1)];
+        }
+
+        return substr($retVal, 0, $length);
+    }
+
+    /**
+     * Create unpronounceable password
+     *
+     * This method creates a random unpronounceable password
+     *
+     * @access private
+     * @param  integer Length of the password
+     * @param  string  Character which could be use in the
+     *                 unpronounceable password ex : 'ABCDEFG'
+     *                 or numeric, alphabetical or alphanumeric.
+     * @return string  Returns the password
+     */
+    function _createUnpronounceable($length, $chars)
+    {
+        $password = '';
+
+        /**
+         * List of character which could be use in the password
+         */
+         switch($chars) {
+
+         case 'alphanumeric':
+             $chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+             $GLOBALS['_Text_Password_NumberOfPossibleCharacters'] = 62;
+             break;
+
+         case 'alphabetical':
+             $chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+             $GLOBALS['_Text_Password_NumberOfPossibleCharacters'] = 52;
+             break;
+
+         case 'numeric':
+             $chars = '0123456789';
+             $GLOBALS['_Text_Password_NumberOfPossibleCharacters'] = 10;
+             break;
+
+         case '':
+             $chars = '_#@%&ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+             $GLOBALS['_Text_Password_NumberOfPossibleCharacters'] = 67;
+             break;
+
+         default:
+             /**
+              * Some characters shouldn't be used
+              */
+             $chars = trim($chars);
+             $chars = str_replace(array('+', '|', '$', '^', '/', '\\', ','), '', $chars);
+
+             $GLOBALS['_Text_Password_NumberOfPossibleCharacters'] = strlen($chars);
+         }
+
+         /**
+          * Generate password
+          */
+         for ($i = 0; $i < $length; $i++) {
+             $num = mt_rand(0, $GLOBALS['_Text_Password_NumberOfPossibleCharacters'] - 1);
+             $password .= $chars[$num];
+         }
+
+         /**
+          * Return password
+          */
+         return $password;
+    }
+}
+?>

main/inc/lib/pear/Text/index.html

@@ -0,0 +1,6 @@
+<html>
+<head>
+</head>
+<body>
+</body>
+</html>