Merge lp:~yoboy-leguesh/ubuntu-fr-doc/maj20150810a into lp:ubuntu-fr-doc

[YoBoY]

=== modified file 'README'
--- README	2014-06-08 13:04:43 +0000
+++ README	2015-11-12 19:55:23 +0000
@@ -4,7 +4,7 @@
 For Installation Instructions see
 http://www.dokuwiki.org/install
 
-DokuWiki - 2004-2014 (c) Andreas Gohr <[e-mail]>
+DokuWiki - 2004-2015 (c) Andreas Gohr <[e-mail]>
                          and the DokuWiki Community
 See COPYING and file headers for license info
 

=== modified file 'VERSION'
--- VERSION	2014-06-08 13:04:43 +0000
+++ VERSION	2015-11-12 19:55:23 +0000
@@ -1,1 +1,1 @@
-2014-05-05 "Ponder Stibbons"
[phone]a "Detritus"

=== modified file 'bin/dwpage.php'
--- bin/dwpage.php	2014-06-08 13:04:43 +0000
+++ bin/dwpage.php	2015-11-12 19:55:23 +0000
@@ -1,378 +1,318 @@
 #!/usr/bin/php
 <?php
-#------------------------------------------------------------------------------
-if ('cli' != php_sapi_name()) die();
-
-ini_set('memory_limit','128M');
-if(!defined('DOKU_INC')) define('DOKU_INC',realpath(dirname(__FILE__).'/../').'/');
-require_once DOKU_INC.'inc/init.php';
-require_once DOKU_INC.'inc/common.php';
-require_once DOKU_INC.'inc/cliopts.php';
-
-#------------------------------------------------------------------------------
-function usage($action) {
-    switch ( $action ) {
-        case 'checkout':
-            print "Usage: dwpage.php [opts] checkout <wiki:page> [working_file]
-
-    Checks out a file from the repository, using the wiki id and obtaining
-    a lock for the page.
-    If a working_file is specified, this is where the page is copied to.
-    Otherwise defaults to the same as the wiki page in the current
-    working directory.
-
-    EXAMPLE
-    $ ./dwpage.php checkout wiki:syntax ./new_syntax.txt
-
-    OPTIONS
-        -h, --help=<action>: get help
-        -f: force obtaining a lock for the page (generally bad idea)
-";
-        break;
-        case 'commit':
-            print "Usage: dwpage.php [opts] -m \"Msg\" commit <working_file> <wiki:page>
-
-    Checks in the working_file into the repository using the specified
-    wiki id, archiving the previous version.
-
-    EXAMPLE
-    $ ./dwpage.php -m \"Some message\" commit ./new_syntax.txt wiki:syntax
-
-    OPTIONS
-        -h, --help=<action>: get help
-        -f: force obtaining a lock for the page (generally bad idea)
-        -t, trivial: minor change
-        -m (required): Summary message describing the change
-";
-        break;
-        case 'lock':
-            print "Usage: dwpage.php [opts] lock <wiki:page>
-
-    Obtains or updates a lock for a wiki page
-
-    EXAMPLE
-    $ ./dwpage.php lock wiki:syntax
-
-    OPTIONS
-        -h, --help=<action>: get help
-        -f: force obtaining a lock for the page (generally bad idea)
-";
-        break;
-        case 'unlock':
-            print "Usage: dwpage.php [opts] unlock <wiki:page>
-
-    Removes a lock for a wiki page.
-
-    EXAMPLE
-    $ ./dwpage.php unlock wiki:syntax
-
-    OPTIONS
-        -h, --help=<action>: get help
-        -f: force obtaining a lock for the page (generally bad idea)
-";
-        break;
-        default:
-            print "Usage: dwpage.php [opts] <action>
-
-    Utility to help command line Dokuwiki page editing, allow
-    pages to be checked out for editing then committed after changes
-
-    Normal operation would be;
-
-
-
-    ACTIONS
-        checkout: see $ dwpage.php --help=checkout
-        commit: see $ dwpage.php --help=commit
-        lock: see $ dwpage.php --help=lock
-
-    OPTIONS
-        -h, --help=<action>: get help
-            e.g. $ ./dwpage.php -hcommit
-            e.g. $ ./dwpage.php --help=commit
-";
-        break;
-    }
-}
-
-#------------------------------------------------------------------------------
-function getUser() {
-    $user = getenv('USER');
-    if (empty ($user)) {
-        $user = getenv('USERNAME');
-    } else {
+if(!defined('DOKU_INC')) define('DOKU_INC', realpath(dirname(__FILE__).'/../').'/');
+define('NOSESSION', 1);
+require_once(DOKU_INC.'inc/init.php');
+
+/**
+ * Checkout and commit pages from the command line while maintaining the history
+ */
+class PageCLI extends DokuCLI {
+
+    protected $force = false;
+    protected $username = '';
+
+    /**
+     * Register options and arguments on the given $options object
+     *
+     * @param DokuCLI_Options $options
+     * @return void
+     */
+    protected function setup(DokuCLI_Options $options) {
+        /* global */
+        $options->registerOption(
+            'force',
+            'force obtaining a lock for the page (generally bad idea)',
+            'f'
+        );
+        $options->registerOption(
+            'user',
+            'work as this user. defaults to current CLI user',
+            'u',
+            'username'
+        );
+        $options->setHelp(
+            'Utility to help command line Dokuwiki page editing, allow '.
+            'pages to be checked out for editing then committed after changes'
+        );
+
+        /* checkout command */
+        $options->registerCommand(
+            'checkout',
+            'Checks out a file from the repository, using the wiki id and obtaining '.
+            'a lock for the page. '."\n".
+            'If a working_file is specified, this is where the page is copied to. '.
+            'Otherwise defaults to the same as the wiki page in the current '.
+            'working directory.'
+        );
+        $options->registerArgument(
+            'wikipage',
+            'The wiki page to checkout',
+            true,
+            'checkout'
+        );
+        $options->registerArgument(
+            'workingfile',
+            'How to name the local checkout',
+            false,
+            'checkout'
+        );
+
+        /* commit command */
+        $options->registerCommand(
+            'commit',
+            'Checks in the working_file into the repository using the specified '.
+            'wiki id, archiving the previous version.'
+        );
+        $options->registerArgument(
+            'workingfile',
+            'The local file to commit',
+            true,
+            'commit'
+        );
+        $options->registerArgument(
+            'wikipage',
+            'The wiki page to create or update',
+            true,
+            'commit'
+        );
+        $options->registerOption(
+            'message',
+            'Summary describing the change (required)',
+            'm',
+            'summary',
+            'commit'
+        );
+        $options->registerOption(
+            'trivial',
+            'minor change',
+            't',
+            false,
+            'commit'
+        );
+
+        /* lock command */
+        $options->registerCommand(
+            'lock',
+            'Obtains or updates a lock for a wiki page'
+        );
+        $options->registerArgument(
+            'wikipage',
+            'The wiki page to lock',
+            true,
+            'lock'
+        );
+
+        /* unlock command */
+        $options->registerCommand(
+            'unlock',
+            'Removes a lock for a wiki page.'
+        );
+        $options->registerArgument(
+            'wikipage',
+            'The wiki page to unlock',
+            true,
+            'unlock'
+        );
+    }
+
+    /**
+     * Your main program
+     *
+     * Arguments and options have been parsed when this is run
+     *
+     * @param DokuCLI_Options $options
+     * @return void
+     */
+    protected function main(DokuCLI_Options $options) {
+        $this->force    = $options->getOpt('force', false);
+        $this->username = $options->getOpt('user', $this->getUser());
+
+        $command = $options->getCmd();
+        switch($command) {
+            case 'checkout':
+                $wiki_id   = array_shift($options->args);
+                $localfile = array_shift($options->args);
+                $this->commandCheckout($wiki_id, $localfile);
+                break;
+            case 'commit':
+                $localfile = array_shift($options->args);
+                $wiki_id   = array_shift($options->args);
+                $this->commandCommit(
+                    $localfile,
+                    $wiki_id,
+                    $options->getOpt('message', ''),
+                    $options->getOpt('trivial', false)
+                );
+                break;
+            case 'lock':
+                $wiki_id = array_shift($options->args);
+                $this->obtainLock($wiki_id);
+                $this->success("$wiki_id locked");
+                break;
+            case 'unlock':
+                $wiki_id = array_shift($options->args);
+                $this->clearLock($wiki_id);
+                $this->success("$wiki_id unlocked");
+                break;
+            default:
+                echo $options->help();
+        }
+    }
+
+    /**
+     * Check out a file
+     *
+     * @param string $wiki_id
+     * @param string $localfile
+     */
+    protected function commandCheckout($wiki_id, $localfile) {
+        global $conf;
+
+        $wiki_id = cleanID($wiki_id);
+        $wiki_fn = wikiFN($wiki_id);
+
+        if(!file_exists($wiki_fn)) {
+            $this->fatal("$wiki_id does not yet exist");
+        }
+
+        if(empty($localfile)) {
+            $localfile = getcwd().'/'.utf8_basename($wiki_fn);
+        }
+
+        if(!file_exists(dirname($localfile))) {
+            $this->fatal("Directory ".dirname($localfile)." does not exist");
+        }
+
+        if(stristr(realpath(dirname($localfile)), realpath($conf['datadir'])) !== false) {
+            $this->fatal("Attempt to check out file into data directory - not allowed");
+        }
+
+        $this->obtainLock($wiki_id);
+
+        if(!copy($wiki_fn, $localfile)) {
+            $this->clearLock($wiki_id);
+            $this->fatal("Unable to copy $wiki_fn to $localfile");
+        }
+
+        $this->success("$wiki_id > $localfile");
+    }
+
+    /**
+     * Save a file as a new page revision
+     *
+     * @param string $localfile
+     * @param string $wiki_id
+     * @param string $message
+     * @param bool   $minor
+     */
+    protected function commandCommit($localfile, $wiki_id, $message, $minor) {
+        $wiki_id = cleanID($wiki_id);
+        $message = trim($message);
+
+        if(!file_exists($localfile)) {
+            $this->fatal("$localfile does not exist");
+        }
+
+        if(!is_readable($localfile)) {
+            $this->fatal("Cannot read from $localfile");
+        }
+
+        if(!$message) {
+            $this->fatal("Summary message required");
+        }
+
+        $this->obtainLock($wiki_id);
+
+        saveWikiText($wiki_id, file_get_contents($localfile), $message, $minor);
+
+        $this->clearLock($wiki_id);
+
+        $this->success("$localfile > $wiki_id");
+    }
+
+    /**
+     * Lock the given page or exit
+     *
+     * @param string $wiki_id
+     */
+    protected function obtainLock($wiki_id) {
+        if($this->force) $this->deleteLock($wiki_id);
+
+        $_SERVER['REMOTE_USER'] = $this->username;
+
+        if(checklock($wiki_id)) {
+            $this->error("Page $wiki_id is already locked by another user");
+            exit(1);
+        }
+
+        lock($wiki_id);
+
+        if(checklock($wiki_id) != $this->username) {
+            $this->error("Unable to obtain lock for $wiki_id ");
+            var_dump(checklock($wiki_id));
+            exit(1);
+        }
+    }
+
+    /**
+     * Clear the lock on the given page
+     *
+     * @param string $wiki_id
+     */
+    protected function clearLock($wiki_id) {
+        if($this->force) $this->deleteLock($wiki_id);
+
+        $_SERVER['REMOTE_USER'] = $this->username;
+        if(checklock($wiki_id)) {
+            $this->error("Page $wiki_id is locked by another user");
+            exit(1);
+        }
+
+        unlock($wiki_id);
+
+        if(file_exists(wikiLockFN($wiki_id))) {
+            $this->error("Unable to clear lock for $wiki_id");
+            exit(1);
+        }
+    }
+
+    /**
+     * Forcefully remove a lock on the page given
+     *
+     * @param string $wiki_id
+     */
+    protected function deleteLock($wiki_id) {
+        $wikiLockFN = wikiLockFN($wiki_id);
+
+        if(file_exists($wikiLockFN)) {
+            if(!unlink($wikiLockFN)) {
+                $this->error("Unable to delete $wikiLockFN");
+                exit(1);
+            }
+        }
+    }
+
+    /**
+     * Get the current user's username from the environment
+     *
+     * @return string
+     */
+    protected function getUser() {
+        $user = getenv('USER');
+        if(empty ($user)) {
+            $user = getenv('USERNAME');
+        } else {
+            return $user;
+        }
+        if(empty ($user)) {
+            $user = 'admin';
+        }
         return $user;
     }
-    if (empty ($user)) {
-        $user = 'admin';
-    }
-    return $user;
-}
-
-#------------------------------------------------------------------------------
-function getSuppliedArgument($OPTS, $short, $long) {
-    $arg = $OPTS->get($short);
-    if ( is_null($arg) ) {
-        $arg = $OPTS->get($long);
-    }
-    return $arg;
-}
-
-#------------------------------------------------------------------------------
-function obtainLock($WIKI_ID) {
-
-    global $USERNAME;
-
-    if ( !file_exists(wikiFN($WIKI_ID)) ) {
-        fwrite( STDERR, "$WIKI_ID does not yet exist\n");
-    }
-
-    $_SERVER['REMOTE_USER'] = $USERNAME;
-    if ( checklock($WIKI_ID) ) {
-        fwrite( STDERR, "Page $WIKI_ID is already locked by another user\n");
-        exit(1);
-    }
-
-    lock($WIKI_ID);
-
-    $_SERVER['REMOTE_USER'] = '_'.$USERNAME.'_';
-
-    if ( checklock($WIKI_ID) != $USERNAME ) {
-
-        fwrite( STDERR, "Unable to obtain lock for $WIKI_ID\n" );
-        exit(1);
-
-    }
-}
-
-#------------------------------------------------------------------------------
-function clearLock($WIKI_ID) {
-
-    global $USERNAME ;
-
-    if ( !file_exists(wikiFN($WIKI_ID)) ) {
-        fwrite( STDERR, "$WIKI_ID does not yet exist\n");
-    }
-
-    $_SERVER['REMOTE_USER'] = $USERNAME;
-    if ( checklock($WIKI_ID) ) {
-        fwrite( STDERR, "Page $WIKI_ID is locked by another user\n");
-        exit(1);
-    }
-
-    unlock($WIKI_ID);
-
-    if ( file_exists(wikiLockFN($WIKI_ID)) ) {
-        fwrite( STDERR, "Unable to clear lock for $WIKI_ID\n" );
-        exit(1);
-    }
-
-}
-
-#------------------------------------------------------------------------------
-function deleteLock($WIKI_ID) {
-
-    $wikiLockFN = wikiLockFN($WIKI_ID);
-
-    if ( file_exists($wikiLockFN) ) {
-        if ( !unlink($wikiLockFN) ) {
-            fwrite( STDERR, "Unable to delete $wikiLockFN\n" );
-            exit(1);
-        }
-    }
-
-}
-
-#------------------------------------------------------------------------------
-$USERNAME = getUser();
-$CWD = getcwd();
-$SYSTEM_ID = '127.0.0.1';
-
-#------------------------------------------------------------------------------
-$OPTS = Doku_Cli_Opts::getOptions(
-    __FILE__,
-    'h::fm:u:s:t',
-    array(
-        'help==',
-        'user=',
-        'system=',
-        'trivial',
-        )
-);
-
-if ( $OPTS->isError() ) {
-    print $OPTS->getMessage()."\n";
-    exit(1);
-}
-
-if ( $OPTS->has('h') or $OPTS->has('help') or !$OPTS->hasArgs() ) {
-    usage(getSuppliedArgument($OPTS,'h','help'));
-    exit(0);
-}
-
-if ( $OPTS->has('u') or $OPTS->has('user') ) {
-    $USERNAME = getSuppliedArgument($OPTS,'u','user');
-}
-
-if ( $OPTS->has('s') or $OPTS->has('system') ) {
-    $SYSTEM_ID = getSuppliedArgument($OPTS,'s','system');
-}
-
-#------------------------------------------------------------------------------
-switch ( $OPTS->arg(0) ) {
-
-    #----------------------------------------------------------------------
-    case 'checkout':
-
-        $WIKI_ID = $OPTS->arg(1);
-
-        if ( !$WIKI_ID ) {
-            fwrite( STDERR, "Wiki page ID required\n");
-            exit(1);
-        }
-
-        $WIKI_FN = wikiFN($WIKI_ID);
-
-        if ( !file_exists($WIKI_FN) ) {
-            fwrite( STDERR, "$WIKI_ID does not yet exist\n");
-            exit(1);
-        }
-
-        $TARGET_FN = $OPTS->arg(2);
-
-        if ( empty($TARGET_FN) ) {
-            $TARGET_FN = getcwd().'/'.utf8_basename($WIKI_FN);
-        }
-
-        if ( !file_exists(dirname($TARGET_FN)) ) {
-            fwrite( STDERR, "Directory ".dirname($TARGET_FN)." does not exist\n");
-            exit(1);
-        }
-
-        if ( stristr( realpath(dirname($TARGET_FN)), realpath($conf['datadir']) ) !== false ) {
-            fwrite( STDERR, "Attempt to check out file into data directory - not allowed\n");
-            exit(1);
-        }
-
-        if ( $OPTS->has('f') ) {
-            deleteLock($WIKI_ID);
-        }
-
-        obtainLock($WIKI_ID);
-
-        # Need to lock the file first?
-        if ( !copy($WIKI_FN, $TARGET_FN) ) {
-            fwrite( STDERR, "Unable to copy $WIKI_FN to $TARGET_FN\n");
-            clearLock($WIKI_ID);
-            exit(1);
-        }
-
-        print "$WIKI_ID > $TARGET_FN\n";
-        exit(0);
-
-    break;
-
-    #----------------------------------------------------------------------
-    case 'commit':
-
-        $TARGET_FN = $OPTS->arg(1);
-
-        if ( !$TARGET_FN ) {
-            fwrite( STDERR, "Target filename required\n");
-            exit(1);
-        }
-
-        if ( !file_exists($TARGET_FN) ) {
-            fwrite( STDERR, "$TARGET_FN does not exist\n");
-            exit(1);
-        }
-
-        if ( !is_readable($TARGET_FN) ) {
-            fwrite( STDERR, "Cannot read from $TARGET_FN\n");
-            exit(1);
-        }
-
-        $WIKI_ID = $OPTS->arg(2);
-
-        if ( !$WIKI_ID ) {
-            fwrite( STDERR, "Wiki page ID required\n");
-            exit(1);
-        }
-
-        if ( !$OPTS->has('m') ) {
-            fwrite( STDERR, "Summary message required\n");
-            exit(1);
-        }
-
-        if ( $OPTS->has('f') ) {
-            deleteLock($WIKI_ID);
-        }
-
-        $_SERVER['REMOTE_USER'] = $USERNAME;
-        if ( checklock($WIKI_ID) ) {
-            fwrite( STDERR, "$WIKI_ID is locked by another user\n");
-            exit(1);
-        }
-
-        obtainLock($WIKI_ID);
-
-        saveWikiText($WIKI_ID, file_get_contents($TARGET_FN), $OPTS->get('m'), $OPTS->has('t'));
-
-        clearLock($WIKI_ID);
-
-        exit(0);
-
-    break;
-
-    #----------------------------------------------------------------------
-    case 'lock':
-
-        $WIKI_ID = $OPTS->arg(1);
-
-        if ( !$WIKI_ID ) {
-            fwrite( STDERR, "Wiki page ID required\n");
-            exit(1);
-        }
-
-        if ( $OPTS->has('f') ) {
-            deleteLock($WIKI_ID);
-        }
-
-        obtainLock($WIKI_ID);
-
-        print "Locked : $WIKI_ID\n";
-        exit(0);
-
-    break;
-
-    #----------------------------------------------------------------------
-    case 'unlock':
-
-        $WIKI_ID = $OPTS->arg(1);
-
-        if ( !$WIKI_ID ) {
-            fwrite( STDERR, "Wiki page ID required\n");
-            exit(1);
-        }
-
-        if ( $OPTS->has('f') ) {
-            deleteLock($WIKI_ID);
-        } else {
-            clearLock($WIKI_ID);
-        }
-
-        print "Unlocked : $WIKI_ID\n";
-        exit(0);
-
-    break;
-
-    #----------------------------------------------------------------------
-    default:
-
-        fwrite( STDERR, "Invalid action ".$OPTS->arg(0)."\n" );
-        exit(1);
-
-    break;
-
-}
-
+}
+
+
+// Main
+$cli = new PageCLI();
+$cli->run();
\ No newline at end of file

=== modified file 'bin/gittool.php'
--- bin/gittool.php	2014-06-08 13:04:43 +0000
+++ bin/gittool.php	2015-11-12 19:55:23 +0000
@@ -1,84 +1,107 @@
 #!/usr/bin/php
 <?php
-
-if('cli' != php_sapi_name()) die();
-ini_set('memory_limit', '128M');
 if(!defined('DOKU_INC')) define('DOKU_INC', realpath(dirname(__FILE__).'/../').'/');
 define('NOSESSION', 1);
 require_once(DOKU_INC.'inc/init.php');
 
-$GitToolCLI = new GitToolCLI();
-
-array_shift($argv);
-$command = array_shift($argv);
-
-switch($command) {
-    case '':
-    case 'help':
-        $GitToolCLI->cmd_help();
-        break;
-    case 'clone':
-        $GitToolCLI->cmd_clone($argv);
-        break;
-    case 'install':
-        $GitToolCLI->cmd_install($argv);
-        break;
-    case 'repo':
-    case 'repos':
-        $GitToolCLI->cmd_repos();
-        break;
-    default:
-        $GitToolCLI->cmd_git($command, $argv);
-}
-
 /**
  * Easily manage DokuWiki git repositories
  *
  * @author Andreas Gohr <[e-mail]>
  */
-class GitToolCLI {
-    private $color = true;
-
-    public function cmd_help() {
-        echo <<<EOF
-Usage: gittool.php <command> [parameters]
-
-Manage git repositories for DokuWiki and its plugins and templates.
-
-EXAMPLE
-
-$> ./bin/gittool.php clone gallery template:ach
-$> ./bin/gittool.php repos
-$> ./bin/gittool.php origin -v
-
-COMMANDS
-
-help
-    This help screen
-
-clone <extensions>
-    Tries to install a known plugin or template (prefix with template:) via
-    git. Uses the DokuWiki.org plugin repository to find the proper git
-    repository. Multiple extensions can be given as parameters
-
-install <extensions>
-    The same as clone, but when no git source repository can be found, the
-    extension is installed via download
-
-repos
-    Lists all git repositories found in this DokuWiki installation
-
-<any>
-    Any unknown commands are assumed to be arguments to git and will be
-    executed in all repositories found within this DokuWiki installation
-
-EOF;
+class GitToolCLI extends DokuCLI {
+
+    /**
+     * Register options and arguments on the given $options object
+     *
+     * @param DokuCLI_Options $options
+     * @return void
+     */
+    protected function setup(DokuCLI_Options $options) {
+        $options->setHelp(
+            "Manage git repositories for DokuWiki and its plugins and templates.\n\n".
+            "$> ./bin/gittool.php clone gallery template:ach\n".
+            "$> ./bin/gittool.php repos\n".
+            "$> ./bin/gittool.php origin -v"
+        );
+
+        $options->registerArgument(
+            'command',
+            'Command to execute. See below',
+            true
+        );
+
+        $options->registerCommand(
+            'clone',
+            'Tries to install a known plugin or template (prefix with template:) via git. Uses the DokuWiki.org '.
+            'plugin repository to find the proper git repository. Multiple extensions can be given as parameters'
+        );
+        $options->registerArgument(
+            'extension',
+            'name of the extension to install, prefix with \'template:\' for templates',
+            true,
+            'clone'
+        );
+
+        $options->registerCommand(
+            'install',
+            'The same as clone, but when no git source repository can be found, the extension is installed via '.
+            'download'
+        );
+        $options->registerArgument(
+            'extension',
+            'name of the extension to install, prefix with \'template:\' for templates',
+            true,
+            'install'
+        );
+
+        $options->registerCommand(
+            'repos',
+            'Lists all git repositories found in this DokuWiki installation'
+        );
+
+        $options->registerCommand(
+            '*',
+            'Any unknown commands are assumed to be arguments to git and will be executed in all repositories '.
+            'found within this DokuWiki installation'
+        );
+    }
+
+    /**
+     * Your main program
+     *
+     * Arguments and options have been parsed when this is run
+     *
+     * @param DokuCLI_Options $options
+     * @return void
+     */
+    protected function main(DokuCLI_Options $options) {
+        $command = $options->getCmd();
+        if(!$command) $command = array_shift($options->args);
+
+        switch($command) {
+            case '':
+                echo $options->help();
+                break;
+            case 'clone':
+                $this->cmd_clone($options->args);
+                break;
+            case 'install':
+                $this->cmd_install($options->args);
+                break;
+            case 'repo':
+            case 'repos':
+                $this->cmd_repos();
+                break;
+            default:
+                $this->cmd_git($command, $options->args);
+        }
     }
 
     /**
      * Tries to install the given extensions using git clone
      *
-     * @param       $extensions
+     * @param array      $extensions
      */
     public function cmd_clone($extensions) {
         $errors    = array();
@@ -88,7 +111,7 @@
             $repo = $this->getSourceRepo($ext);
 
             if(!$repo) {
-                $this->msg_error("could not find a repository for $ext");
+                $this->error("could not find a repository for $ext");
                 $errors[] = $ext;
             } else {
                 if($this->cloneExtension($ext, $repo)) {
@@ -100,14 +123,14 @@
         }
 
         echo "\n";
-        if($succeeded) $this->msg_success('successfully cloned the following extensions: '.join(', ', $succeeded));
-        if($errors) $this->msg_error('failed to clone the following extensions: '.join(', ', $errors));
+        if($succeeded) $this->success('successfully cloned the following extensions: '.join(', ', $succeeded));
+        if($errors) $this->error('failed to clone the following extensions: '.join(', ', $errors));
     }
 
     /**
      * Tries to install the given extensions using git clone with fallback to install
      *
-     * @param       $extensions
+     * @param array      $extensions
      */
     public function cmd_install($extensions) {
         $errors    = array();
@@ -117,7 +140,7 @@
             $repo = $this->getSourceRepo($ext);
 
             if(!$repo) {
-                $this->msg_info("could not find a repository for $ext");
+                $this->info("could not find a repository for $ext");
                 if($this->downloadExtension($ext)) {
                     $succeeded[] = $ext;
                 } else {
@@ -133,8 +156,8 @@
         }
 
         echo "\n";
-        if($succeeded) $this->msg_success('successfully installed the following extensions: '.join(', ', $succeeded));
-        if($errors) $this->msg_error('failed to install the following extensions: '.join(', ', $errors));
+        if($succeeded) $this->success('successfully installed the following extensions: '.join(', ', $succeeded));
+        if($errors) $this->error('failed to install the following extensions: '.join(', ', $errors));
     }
 
     /**
@@ -152,19 +175,19 @@
 
         foreach($repos as $repo) {
             if(!@chdir($repo)) {
-                $this->msg_error("Could not change into $repo");
+                $this->error("Could not change into $repo");
                 continue;
             }
 
             echo "\n";
-            $this->msg_info("executing $shell in $repo");
+            $this->info("executing $shell in $repo");
             $ret = 0;
             system($shell, $ret);
 
             if($ret == 0) {
-                $this->msg_success("git succeeded in $repo");
+                $this->success("git succeeded in $repo");
             } else {
-                $this->msg_error("git failed in $repo");
+                $this->error("git failed in $repo");
             }
         }
     }
@@ -183,33 +206,34 @@
      * Install extension from the given download URL
      *
      * @param string $ext
-     * @return bool
+     * @return bool|null
      */
     private function downloadExtension($ext) {
         /** @var helper_plugin_extension_extension $plugin */
         $plugin = plugin_load('helper', 'extension_extension');
         if(!$ext) die("extension plugin not available, can't continue");
+
         $plugin->setExtension($ext);
 
         $url = $plugin->getDownloadURL();
         if(!$url) {
-            $this->msg_error("no download URL for $ext");
+            $this->error("no download URL for $ext");
             return false;
         }
 
         $ok = false;
         try {
-            $this->msg_info("installing $ext via download from $url");
+            $this->info("installing $ext via download from $url");
             $ok = $plugin->installFromURL($url);
         } catch(Exception $e) {
-            $this->msg_error($e->getMessage());
+            $this->error($e->getMessage());
         }
 
         if($ok) {
-            $this->msg_success("installed $ext via download");
+            $this->success("installed $ext via download");
             return true;
         } else {
-            $this->msg_success("failed to install $ext via download");
+            $this->success("failed to install $ext via download");
             return false;
         }
     }
@@ -228,14 +252,14 @@
             $target = DOKU_PLUGIN.$ext;
         }
 
-        $this->msg_info("cloning $ext from $repo to $target");
+        $this->info("cloning $ext from $repo to $target");
         $ret = 0;
         system("git clone $repo $target", $ret);
         if($ret === 0) {
-            $this->msg_success("cloning of $ext succeeded");
+            $this->success("cloning of $ext succeeded");
             return true;
         } else {
-            $this->msg_error("cloning of $ext failed");
+            $this->error("cloning of $ext failed");
             return false;
         }
     }
@@ -248,7 +272,7 @@
      * @return array
      */
     private function findRepos() {
-        $this->msg_info('Looking for .git directories');
+        $this->info('Looking for .git directories');
         $data = array_merge(
             glob(DOKU_INC.'.git', GLOB_ONLYDIR),
             glob(DOKU_PLUGIN.'*/.git', GLOB_ONLYDIR),
@@ -256,9 +280,9 @@
         );
 
         if(!$data) {
-            $this->msg_error('Found no .git directories');
+            $this->error('Found no .git directories');
         } else {
-            $this->msg_success('Found '.count($data).' .git directories');
+            $this->success('Found '.count($data).' .git directories');
         }
         $data = array_map('fullpath', array_map('dirname', $data));
         return $data;
@@ -268,12 +292,13 @@
      * Returns the repository for the given extension
      *
      * @param $extension
-     * @return bool|string
+     * @return false|string
      */
     private function getSourceRepo($extension) {
         /** @var helper_plugin_extension_extension $ext */
         $ext = plugin_load('helper', 'extension_extension');
         if(!$ext) die("extension plugin not available, can't continue");
+
         $ext->setExtension($extension);
 
         $repourl = $ext->getSourcerepoURL();
@@ -304,37 +329,8 @@
 
         return false;
     }
-
-    /**
-     * Print an error message
-     *
-     * @param $string
-     */
-    private function msg_error($string) {
-        if($this->color) echo "\033[31m"; // red
-        echo "E: $string\n";
-        if($this->color) echo "\033[37m"; // reset
-    }
-
-    /**
-     * Print a success message
-     *
-     * @param $string
-     */
-    private function msg_success($string) {
-        if($this->color) echo "\033[32m"; // green
-        echo "S: $string\n";
-        if($this->color) echo "\033[37m"; // reset
-    }
-
-    /**
-     * Print an info message
-     *
-     * @param $string
-     */
-    private function msg_info($string) {
-        if($this->color) echo "\033[36m"; // cyan
-        echo "I: $string\n";
-        if($this->color) echo "\033[37m"; // reset
-    }
-}
\ No newline at end of file
+}
+
+// Main
+$cli = new GitToolCLI();
+$cli->run();
\ No newline at end of file

=== modified file 'bin/indexer.php'
--- bin/indexer.php	2014-06-08 13:04:43 +0000
+++ bin/indexer.php	2015-11-12 19:55:23 +0000
@@ -1,98 +1,103 @@
 #!/usr/bin/php
 <?php
-if ('cli' != php_sapi_name()) die();
-
-ini_set('memory_limit','128M');
-if(!defined('DOKU_INC')) define('DOKU_INC',realpath(dirname(__FILE__).'/../').'/');
+if(!defined('DOKU_INC')) define('DOKU_INC', realpath(dirname(__FILE__).'/../').'/');
+define('NOSESSION', 1);
 require_once(DOKU_INC.'inc/init.php');
-require_once(DOKU_INC.'inc/cliopts.php');
-session_write_close();
-
-// handle options
-$short_opts = 'hcuq';
-$long_opts  = array('help', 'clear', 'update', 'quiet');
-$OPTS = Doku_Cli_Opts::getOptions(__FILE__,$short_opts,$long_opts);
-if ( $OPTS->isError() ) {
-    fwrite( STDERR, $OPTS->getMessage() . "\n");
-    _usage();
-    exit(1);
-}
-$CLEAR = false;
-$QUIET = false;
-$INDEXER = null;
-foreach ($OPTS->options as $key => $val) {
-    switch ($key) {
-        case 'h':
-        case 'help':
-            _usage();
-            exit;
-        case 'c':
-        case 'clear':
-            $CLEAR = true;
-            break;
-        case 'q':
-        case 'quiet':
-            $QUIET = true;
-            break;
-    }
-}
-
-#------------------------------------------------------------------------------
-# Action
-
-if($CLEAR) _clearindex();
-_update();
-
-
-
-#------------------------------------------------------------------------------
-
-function _usage() {
-    print "Usage: indexer.php <options>
-
-    Updates the searchindex by indexing all new or changed pages
-    when the -c option is given the index is cleared first.
-
-    OPTIONS
-        -h, --help     show this help and exit
-        -c, --clear    clear the index before updating
-        -q, --quiet    don't produce any output
-";
-}
-
-function _update(){
-    global $conf;
-    $data = array();
-    _quietecho("Searching pages... ");
-    search($data,$conf['datadir'],'search_allpages',array('skipacl' => true));
-    _quietecho(count($data)." pages found.\n");
-
-    foreach($data as $val){
-        _index($val['id']);
-    }
-}
-
-function _index($id){
-    global $CLEAR;
-    global $QUIET;
-
-    _quietecho("$id... ");
-    idx_addPage($id, !$QUIET, $CLEAR);
-    _quietecho("done.\n");
-}
 
 /**
- * Clear all index files
+ * Update the Search Index from command line
  */
-function _clearindex(){
-    _quietecho("Clearing index... ");
-    idx_get_indexer()->clear();
-    _quietecho("done.\n");
-}
-
-function _quietecho($msg) {
-    global $QUIET;
-    if(!$QUIET) echo $msg;
-}
-
-//Setup VIM: ex: et ts=2 :
+class IndexerCLI extends DokuCLI {
+
+    private $quiet = false;
+    private $clear = false;
+
+    /**
+     * Register options and arguments on the given $options object
+     *
+     * @param DokuCLI_Options $options
+     * @return void
+     */
+    protected function setup(DokuCLI_Options $options) {
+        $options->setHelp(
+            'Updates the searchindex by indexing all new or changed pages. When the -c option is '.
+            'given the index is cleared first.'
+        );
+
+        $options->registerOption(
+            'clear',
+            'clear the index before updating',
+            'c'
+        );
+        $options->registerOption(
+            'quiet',
+            'don\'t produce any output',
+            'q'
+        );
+    }
+
+    /**
+     * Your main program
+     *
+     * Arguments and options have been parsed when this is run
+     *
+     * @param DokuCLI_Options $options
+     * @return void
+     */
+    protected function main(DokuCLI_Options $options) {
+        $this->clear = $options->getOpt('clear');
+        $this->quiet = $options->getOpt('quiet');
+
+        if($this->clear) $this->clearindex();
+
+        $this->update();
+    }
+
+    /**
+     * Update the index
+     */
+    function update() {
+        global $conf;
+        $data = array();
+        $this->quietecho("Searching pages... ");
+        search($data, $conf['datadir'], 'search_allpages', array('skipacl' => true));
+        $this->quietecho(count($data)." pages found.\n");
+
+        foreach($data as $val) {
+            $this->index($val['id']);
+        }
+    }
+
+    /**
+     * Index the given page
+     *
+     * @param string $id
+     */
+    function index($id) {
+        $this->quietecho("$id... ");
+        idx_addPage($id, !$this->quiet, $this->clear);
+        $this->quietecho("done.\n");
+    }
+
+    /**
+     * Clear all index files
+     */
+    function clearindex() {
+        $this->quietecho("Clearing index... ");
+        idx_get_indexer()->clear();
+        $this->quietecho("done.\n");
+    }
+
+    /**
+     * Print message if not supressed
+     *
+     * @param string $msg
+     */
+    function quietecho($msg) {
+        if(!$this->quiet) echo $msg;
+    }
+}
+
+// Main
+$cli = new IndexerCLI();
+$cli->run();
\ No newline at end of file

=== modified file 'bin/render.php'
--- bin/render.php	2011-01-24 08:52:15 +0000
+++ bin/render.php	2015-11-12 19:55:23 +0000
@@ -1,5 +1,10 @@
 #!/usr/bin/php
 <?php
+if(!defined('DOKU_INC')) define('DOKU_INC', realpath(dirname(__FILE__).'/../').'/');
+define('NOSESSION', 1);
+require_once(DOKU_INC.'inc/init.php');
+
+
 /**
  * A simple commandline tool to render some DokuWiki syntax with a given
  * renderer.
@@ -9,59 +14,48 @@
  * DokuWiki markup
  *
  * @license GPL2
- * @author Andreas Gohr <[e-mail]>
- */
-if ('cli' != php_sapi_name()) die();
-
-ini_set('memory_limit','128M');
-if(!defined('DOKU_INC')) define('DOKU_INC',realpath(dirname(__FILE__).'/../').'/');
-define('NOSESSION',1);
-require_once(DOKU_INC.'inc/init.php');
-require_once(DOKU_INC.'inc/common.php');
-require_once(DOKU_INC.'inc/parserutils.php');
-require_once(DOKU_INC.'inc/cliopts.php');
-
-// handle options
-$short_opts = 'hr:';
-$long_opts  = array('help','renderer:');
-$OPTS = Doku_Cli_Opts::getOptions(__FILE__,$short_opts,$long_opts);
-if ( $OPTS->isError() ) {
-    fwrite( STDERR, $OPTS->getMessage() . "\n");
-    _usage();
-    exit(1);
-}
-$RENDERER = 'xhtml';
-foreach ($OPTS->options as $key => $val) {
-    switch ($key) {
-        case 'h':
-        case 'help':
-            _usage();
-            exit;
-        case 'r':
-        case 'renderer':
-            $RENDERER = $val;
-    }
-}
-
-
-// do the action
-$source = stream_get_contents(STDIN);
-$info = array();
-$result = p_render($RENDERER,p_get_instructions($source),$info);
-if(is_null($result)) die("No such renderer $RENDERER\n");
-echo $result;
-
-/**
- * Print usage info
- */
-function _usage(){
-    print "Usage: render.php <options>
-
-    Reads DokuWiki syntax from STDIN and renders it with the given renderer
-    to STDOUT
-
-    OPTIONS
-        -h, --help                 show this help and exit
-        -r, --renderer <renderer>  the render mode (default: xhtml)
-";
-}
+ * @author  Andreas Gohr <[e-mail]>
+ */
+class RenderCLI extends DokuCLI {
+
+    /**
+     * Register options and arguments on the given $options object
+     *
+     * @param DokuCLI_Options $options
+     * @return void
+     */
+    protected function setup(DokuCLI_Options $options) {
+        $options->setHelp(
+            'A simple commandline tool to render some DokuWiki syntax with a given renderer.'.
+            "\n\n".
+            'This may not work for plugins that expect a certain environment to be '.
+            'set up before rendering, but should work for most or even all standard '.
+            'DokuWiki markup'
+        );
+        $options->registerOption('renderer', 'The renderer mode to use. Defaults to xhtml', 'r', 'mode');
+    }
+
+    /**
+     * Your main program
+     *
+     * Arguments and options have been parsed when this is run
+     *
+     * @param DokuCLI_Options $options
+     * @throws DokuCLI_Exception
+     * @return void
+     */
+    protected function main(DokuCLI_Options $options) {
+        $renderer = $options->getOpt('renderer', 'xhtml');
+
+        // do the action
+        $source = stream_get_contents(STDIN);
+        $info   = array();
+        $result = p_render($renderer, p_get_instructions($source), $info);
+        if(is_null($result)) throw new DokuCLI_Exception("No such renderer $renderer");
+        echo $result;
+    }
+}
+
+// Main
+$cli = new RenderCLI();
+$cli->run();
\ No newline at end of file

=== modified file 'bin/striplangs.php'
--- bin/striplangs.php	2014-06-08 13:04:43 +0000
+++ bin/striplangs.php	2015-11-12 19:55:23 +0000
@@ -1,148 +1,111 @@
 #!/usr/bin/php
 <?php
+if(!defined('DOKU_INC')) define('DOKU_INC', realpath(dirname(__FILE__).'/../').'/');
+define('NOSESSION', 1);
+require_once(DOKU_INC.'inc/init.php');
+
+
 /**
- * Strip unwanted languages from the DokuWiki install
- *
- * @author Martin 'E.T.' Misuth <[e-mail]>
+ * Remove unwanted languages from a DokuWiki install
  */
-if ('cli' != php_sapi_name()) die();
-
-#------------------------------------------------------------------------------
-if(!defined('DOKU_INC')) define('DOKU_INC',realpath(dirname(__FILE__).'/../').'/');
-require_once DOKU_INC.'inc/cliopts.php';
-
-#------------------------------------------------------------------------------
-function usage($show_examples = false) {
-    print "Usage: striplangs.php [-h [-x]] [-e] [-k lang1[,lang2]..[,langN]]
-
-    Removes all languages from the installation, besides the ones
-    after the -k option. English language is never removed!
-
-    OPTIONS
-        -h, --help     get this help
-        -x, --examples get also usage examples
-        -k, --keep     comma separated list of languages, -e is always implied
-        -e, --english  keeps english, dummy to use without -k\n";
-    if ( $show_examples ) {
-        print "\n
-    EXAMPLES
-        Strips all languages, but keeps 'en' and 'de':
-         striplangs -k de
-
-        Strips all but 'en','ca-valencia','cs','de','is','sk':
-         striplangs --keep ca-valencia,cs,de,is,sk
-
-        Strips all but 'en':
-         striplangs -e
-
-        No option specified, prints usage and throws error:
-         striplangs\n";
-    }
-}
-
-function getSuppliedArgument($OPTS, $short, $long) {
-    $arg = $OPTS->get($short);
-    if ( is_null($arg) ) {
-        $arg = $OPTS->get($long);
-    }
-    return $arg;
-}
-
-function processPlugins($path, $keep_langs) {
-    if (is_dir($path)) {
-        $entries = scandir($path);
-
-        foreach ($entries as $entry) {
-            if ($entry != "." && $entry != "..") {
-                if ( is_dir($path.'/'.$entry) ) {
-
-                    $plugin_langs = $path.'/'.$entry.'/lang';
-
-                    if ( is_dir( $plugin_langs ) ) {
-                        stripDirLangs($plugin_langs, $keep_langs);
+class StripLangsCLI extends DokuCLI {
+
+    /**
+     * Register options and arguments on the given $options object
+     *
+     * @param DokuCLI_Options $options
+     * @return void
+     */
+    protected function setup(DokuCLI_Options $options) {
+
+        $options->setHelp(
+            'Remove all languages from the installation, besides the ones specified. English language '.
+            'is never removed!'
+        );
+
+        $options->registerOption(
+            'keep',
+            'Comma separated list of languages to keep in addition to English.',
+            'k',
+            'langcodes'
+        );
+        $options->registerOption(
+            'english-only',
+            'Remove all languages except English',
+            'e'
+        );
+    }
+
+    /**
+     * Your main program
+     *
+     * Arguments and options have been parsed when this is run
+     *
+     * @param DokuCLI_Options $options
+     * @return void
+     */
+    protected function main(DokuCLI_Options $options) {
+        if($options->getOpt('keep')) {
+            $keep = explode(',', $options->getOpt('keep'));
+            if(!in_array('en', $keep)) $keep[] = 'en';
+        } elseif($options->getOpt('english-only')) {
+            $keep = array('en');
+        } else {
+            echo $options->help();
+            exit(0);
+        }
+
+        // Kill all language directories in /inc/lang and /lib/plugins besides those in $langs array
+        $this->stripDirLangs(realpath(dirname(__FILE__).'/../inc/lang'), $keep);
+        $this->processExtensions(realpath(dirname(__FILE__).'/../lib/plugins'), $keep);
+        $this->processExtensions(realpath(dirname(__FILE__).'/../lib/tpl'), $keep);
+    }
+
+    /**
+     * Strip languages from extensions
+     *
+     * @param string $path       path to plugin or template dir
+     * @param array  $keep_langs languages to keep
+     */
+    protected function processExtensions($path, $keep_langs) {
+        if(is_dir($path)) {
+            $entries = scandir($path);
+
+            foreach($entries as $entry) {
+                if($entry != "." && $entry != "..") {
+                    if(is_dir($path.'/'.$entry)) {
+
+                        $plugin_langs = $path.'/'.$entry.'/lang';
+
+                        if(is_dir($plugin_langs)) {
+                            $this->stripDirLangs($plugin_langs, $keep_langs);
+                        }
                     }
                 }
             }
         }
     }
-}
-
-function stripDirLangs($path, $keep_langs) {
-    $dir = dir($path);
-
-    while(($cur_dir = $dir->read()) !== false) {
-        if( $cur_dir != '.' and $cur_dir != '..' and is_dir($path.'/'.$cur_dir)) {
-
-            if ( !in_array($cur_dir, $keep_langs, true ) ) {
-                killDir($path.'/'.$cur_dir);
-            }
-        }
-    }
-    $dir->close();
-}
-
-function killDir($dir) {
-    if (is_dir($dir)) {
-        $entries = scandir($dir);
-
-        foreach ($entries as $entry) {
-            if ($entry != "." && $entry != "..") {
-                if ( is_dir($dir.'/'.$entry) ) {
-                    killDir($dir.'/'.$entry);
-                } else {
-                    unlink($dir.'/'.$entry);
+
+    /**
+     * Strip languages from path
+     *
+     * @param string $path       path to lang dir
+     * @param array  $keep_langs languages to keep
+     */
+    protected function stripDirLangs($path, $keep_langs) {
+        $dir = dir($path);
+
+        while(($cur_dir = $dir->read()) !== false) {
+            if($cur_dir != '.' and $cur_dir != '..' and is_dir($path.'/'.$cur_dir)) {
+
+                if(!in_array($cur_dir, $keep_langs, true)) {
+                    io_rmdir($path.'/'.$cur_dir, true);
                 }
             }
         }
-        reset($entries);
-        rmdir($dir);
-    }
-}
-#------------------------------------------------------------------------------
-
-// handle options
-$short_opts = 'hxk:e';
-$long_opts  = array('help', 'examples', 'keep=','english');
-
-$OPTS = Doku_Cli_Opts::getOptions(__FILE__, $short_opts, $long_opts);
-
-if ( $OPTS->isError() ) {
-    fwrite( STDERR, $OPTS->getMessage() . "\n");
-    exit(1);
-}
-
-// handle '--examples' option
-$show_examples = ( $OPTS->has('x') or $OPTS->has('examples') ) ? true : false;
-
-// handle '--help' option
-if ( $OPTS->has('h') or $OPTS->has('help') ) {
-    usage($show_examples);
-    exit(0);
-}
-
-// handle both '--keep' and '--english' options
-if ( $OPTS->has('k') or $OPTS->has('keep') ) {
-    $preserved_langs = getSuppliedArgument($OPTS,'k','keep');
-    $langs = explode(',', $preserved_langs);
-
-    // ! always enforce 'en' lang when using '--keep' (DW relies on it)
-    if ( !isset($langs['en']) ) {
-        $langs[]='en';
-    }
-} elseif ( $OPTS->has('e') or $OPTS->has('english') ) {
-    // '--english' was specified strip everything besides 'en'
-    $langs = array ('en');
-} else {
-    // no option was specified, print usage but don't do anything as
-    // this run might not be intented
-    usage();
-    print "\n
-    ERROR
-        No option specified, use either -h -x to get more info,
-        or -e to strip every language besides english.\n";
-    exit(1);
-}
-
-// Kill all language directories in /inc/lang and /lib/plugins besides those in $langs array
-stripDirLangs(realpath(dirname(__FILE__).'/../inc/lang'), $langs);
-processPlugins(realpath(dirname(__FILE__).'/../lib/plugins'), $langs);
+        $dir->close();
+    }
+}
+
+$cli = new StripLangsCLI();
+$cli->run();
\ No newline at end of file

=== modified file 'bin/wantedpages.php'
--- bin/wantedpages.php	2014-06-08 13:04:43 +0000
+++ bin/wantedpages.php	2015-11-12 19:55:23 +0000
@@ -1,134 +1,153 @@
 #!/usr/bin/php
 <?php
-if ('cli' != php_sapi_name()) die();
-
-#------------------------------------------------------------------------------
-ini_set('memory_limit','128M');
-if(!defined('DOKU_INC')) define('DOKU_INC',realpath(dirname(__FILE__).'/../').'/');
-require_once DOKU_INC.'inc/init.php';
-require_once DOKU_INC.'inc/common.php';
-require_once DOKU_INC.'inc/search.php';
-require_once DOKU_INC.'inc/cliopts.php';
-
-#------------------------------------------------------------------------------
-function usage() {
-    print "Usage: wantedpages.php [wiki:namespace]
-
-    Outputs a list of wanted pages (pages which have
-    internal links but do not yet exist).
-
-    If the optional [wiki:namespace] is not provided,
-    defaults to the root wiki namespace
-
-    OPTIONS
-        -h, --help get help
-";
-}
-
-#------------------------------------------------------------------------------
-define ('DW_DIR_CONTINUE',1);
-define ('DW_DIR_NS',2);
-define ('DW_DIR_PAGE',3);
-
-#------------------------------------------------------------------------------
-function dw_dir_filter($entry, $basepath) {
-    if ($entry == '.' || $entry == '..' ) {
-        return DW_DIR_CONTINUE;
-    }
-    if ( is_dir($basepath . '/' . $entry) ) {
-        if ( strpos($entry, '_') === 0 ) {
-            return DW_DIR_CONTINUE;
-        }
-        return DW_DIR_NS;
-    }
-    if ( preg_match('/\.txt$/',$entry) ) {
-        return DW_DIR_PAGE;
-    }
-    return DW_DIR_CONTINUE;
-}
-
-#------------------------------------------------------------------------------
-function dw_get_pages($dir) {
-    static $trunclen = null;
-    if ( !$trunclen ) {
-        global $conf;
-        $trunclen = strlen($conf['datadir'].':');
-    }
-
-    if ( !is_dir($dir) ) {
-        fwrite( STDERR, "Unable to read directory $dir\n");
-        exit(1);
-    }
-
-    $pages = array();
-    $dh = opendir($dir);
-    while ( false !== ( $entry = readdir($dh) ) ) {
-        $status = dw_dir_filter($entry, $dir);
-        if ( $status == DW_DIR_CONTINUE ) {
-            continue;
-        } else if ( $status == DW_DIR_NS ) {
-            $pages = array_merge($pages, dw_get_pages($dir . '/' . $entry));
+if(!defined('DOKU_INC')) define('DOKU_INC', realpath(dirname(__FILE__).'/../').'/');
+define('NOSESSION', 1);
+require_once(DOKU_INC.'inc/init.php');
+
+/**
+ * Find wanted pages
+ */
+class WantedPagesCLI extends DokuCLI {
+
+    const DIR_CONTINUE = 1;
+    const DIR_NS       = 2;
+    const DIR_PAGE     = 3;
+
+    /**
+     * Register options and arguments on the given $options object
+     *
+     * @param DokuCLI_Options $options
+     * @return void
+     */
+    protected function setup(DokuCLI_Options $options) {
+        $options->setHelp(
+            'Outputs a list of wanted pages (pages which have internal links but do not yet exist).'
+        );
+        $options->registerArgument(
+            'namespace',
+            'The namespace to lookup. Defaults to root namespace',
+            false
+        );
+    }
+
+    /**
+     * Your main program
+     *
+     * Arguments and options have been parsed when this is run
+     *
+     * @param DokuCLI_Options $options
+     * @return void
+     */
+    protected function main(DokuCLI_Options $options) {
+
+        if($options->args) {
+            $startdir = dirname(wikiFN($options->args[0].':xxx'));
         } else {
-            $page = array(
-                'id'  => pathID(substr($dir.'/'.$entry,$trunclen)),
-                'file'=> $dir.'/'.$entry,
+            $startdir = dirname(wikiFN('xxx'));
+        }
+
+        $this->info("searching $startdir");
+
+        $wanted_pages = array();
+
+        foreach($this->get_pages($startdir) as $page) {
+            $wanted_pages = array_merge($wanted_pages, $this->internal_links($page));
+        }
+        $wanted_pages = array_unique($wanted_pages);
+        sort($wanted_pages);
+
+        foreach($wanted_pages as $page) {
+            print $page."\n";
+        }
+    }
+
+    /**
+     * Determine directions of the search loop
+     *
+     * @param string $entry
+     * @param string $basepath
+     * @return int
+     */
+    protected function dir_filter($entry, $basepath) {
+        if($entry == '.' || $entry == '..') {
+            return WantedPagesCLI::DIR_CONTINUE;
+        }
+        if(is_dir($basepath.'/'.$entry)) {
+            if(strpos($entry, '_') === 0) {
+                return WantedPagesCLI::DIR_CONTINUE;
+            }
+            return WantedPagesCLI::DIR_NS;
+        }
+        if(preg_match('/\.txt$/', $entry)) {
+            return WantedPagesCLI::DIR_PAGE;
+        }
+        return WantedPagesCLI::DIR_CONTINUE;
+    }
+
+    /**
+     * Collects recursively the pages in a namespace
+     *
+     * @param string $dir
+     * @return array
+     * @throws DokuCLI_Exception
+     */
+    protected function get_pages($dir) {
+        static $trunclen = null;
+        if(!$trunclen) {
+            global $conf;
+            $trunclen = strlen($conf['datadir'].':');
+        }
+
+        if(!is_dir($dir)) {
+            throw new DokuCLI_Exception("Unable to read directory $dir");
+        }
+
+        $pages = array();
+        $dh    = opendir($dir);
+        while(false !== ($entry = readdir($dh))) {
+            $status = $this->dir_filter($entry, $dir);
+            if($status == WantedPagesCLI::DIR_CONTINUE) {
+                continue;
+            } else if($status == WantedPagesCLI::DIR_NS) {
+                $pages = array_merge($pages, $this->get_pages($dir.'/'.$entry));
+            } else {
+                $page    = array(
+                    'id'   => pathID(substr($dir.'/'.$entry, $trunclen)),
+                    'file' => $dir.'/'.$entry,
                 );
-            $pages[] = $page;
-        }
-    }
-    closedir($dh);
-    return $pages;
-}
-
-#------------------------------------------------------------------------------
-function dw_internal_links($page) {
-    global $conf;
-    $instructions = p_get_instructions(file_get_contents($page['file']));
-    $links = array();
-    $cns = getNS($page['id']);
-    $exists = false;
-    foreach($instructions as $ins){
-        if($ins[0] == 'internallink' || ($conf['camelcase'] && $ins[0] == 'camelcaselink') ){
-            $mid = $ins[1][0];
-            resolve_pageid($cns,$mid,$exists);
-            if ( !$exists ) {
-                list($mid) = explode('#',$mid); //record pages without hashs
-                $links[] = $mid;
-            }
-        }
-    }
-    return $links;
-}
-
-#------------------------------------------------------------------------------
-$OPTS = Doku_Cli_Opts::getOptions(__FILE__,'h',array('help'));
-
-if ( $OPTS->isError() ) {
-    fwrite( STDERR, $OPTS->getMessage() . "\n");
-    exit(1);
-}
-
-if ( $OPTS->has('h') or $OPTS->has('help') ) {
-    usage();
-    exit(0);
-}
-
-$START_DIR = $conf['datadir'];
-
-if ( $OPTS->numArgs() == 1 ) {
-    $START_DIR .= '/' . $OPTS->arg(0);
-}
-
-#------------------------------------------------------------------------------
-$WANTED_PAGES = array();
-
-foreach ( dw_get_pages($START_DIR) as $WIKI_PAGE ) {
-    $WANTED_PAGES = array_merge($WANTED_PAGES,dw_internal_links($WIKI_PAGE));
-}
-$WANTED_PAGES = array_unique($WANTED_PAGES);
-sort($WANTED_PAGES);
-
-foreach ( $WANTED_PAGES as $WANTED_PAGE ) {
-    print $WANTED_PAGE."\n";
-}
-exit(0);
+                $pages[] = $page;
+            }
+        }
+        closedir($dh);
+        return $pages;
+    }
+
+    /**
+     * Parse instructions and returns the non-existing links
+     *
+     * @param array $page array with page id and file path
+     * @return array
+     */
+    function internal_links($page) {
+        global $conf;
+        $instructions = p_get_instructions(file_get_contents($page['file']));
+        $links        = array();
+        $cns          = getNS($page['id']);
+        $exists       = false;
+        foreach($instructions as $ins) {
+            if($ins[0] == 'internallink' || ($conf['camelcase'] && $ins[0] == 'camelcaselink')) {
+                $mid = $ins[1][0];
+                resolve_pageid($cns, $mid, $exists);
+                if(!$exists) {
+                    list($mid) = explode('#', $mid); //record pages without hashs
+                    $links[] = $mid;
+                }
+            }
+        }
+        return $links;
+    }
+}
+
+// Main
+$cli = new WantedPagesCLI();
+$cli->run();
\ No newline at end of file

=== modified file 'conf/interwiki.conf'
--- conf/interwiki.conf	2014-06-08 13:04:43 +0000
+++ conf/interwiki.conf	2015-11-12 19:55:23 +0000
@@ -1,37 +1,41 @@
-# Each URL may contain one of the placeholders {URL} or {NAME}
+# Each URL may contain one of these placeholders
 # {URL}  is replaced by the URL encoded representation of the wikiname
 #        this is the right thing to do in most cases
 # {NAME} this is replaced by the wikiname as given in the document
-#        no further encoding is done
+#        only mandatory encoded is done, urlencoding if the link
+#        is an external URL, or encoding as a wikiname if it is an
+#        internal link (begins with a colon)
+# {SCHEME}
+# {HOST}
+# {PORT}
+# {PATH}
+# {QUERY} these placeholders will be replaced with the appropriate part
+#         of the link when parsed as a URL
 # If no placeholder is defined the urlencoded name is appended to the URL
 
 # To prevent losing your added InterWiki shortcuts after an upgrade,
 # you should add new ones to interwiki.local.conf
 
-wp        http://en.wikipedia.org/wiki/{NAME}
-wpfr      http://fr.wikipedia.org/wiki/{NAME}
-wpde      http://de.wikipedia.org/wiki/{NAME}
-wpes      http://es.wikipedia.org/wiki/{NAME}
-wppl      http://pl.wikipedia.org/wiki/{NAME}
-wpjp      http://ja.wikipedia.org/wiki/{NAME}
-wpmeta    http://meta.wikipedia.org/wiki/{NAME}
-doku      http://www.dokuwiki.org/
-dokubug   http://bugs.dokuwiki.org/index.php?do=details&amp;task_id=
-rfc       http://tools.ietf.org/html/rfc
+wp        https://en.wikipedia.org/wiki/{NAME}
+wpfr      https://fr.wikipedia.org/wiki/{NAME}
+wpde      https://de.wikipedia.org/wiki/{NAME}
+wpes      https://es.wikipedia.org/wiki/{NAME}
+wppl      https://pl.wikipedia.org/wiki/{NAME}
+wpjp      https://ja.wikipedia.org/wiki/{NAME}
+wpmeta    https://meta.wikipedia.org/wiki/{NAME}
+doku      https://www.dokuwiki.org/
+rfc       https://tools.ietf.org/html/rfc
 man       http://man.cx/
-amazon    http://www.amazon.com/exec/obidos/ASIN/{URL}/splitbrain-20/
-amazon.de http://www.amazon.de/exec/obidos/ASIN/{URL}/splitbrain-21/
-amazon.uk http://www.amazon.co.uk/exec/obidos/ASIN/
+amazon    https://www.amazon.com/exec/obidos/ASIN/{URL}/splitbrain-20/
+amazon.de https://www.amazon.de/exec/obidos/ASIN/{URL}/splitbrain-21/
+amazon.uk https://www.amazon.co.uk/exec/obidos/ASIN/
 paypal    https://www.paypal.com/cgi-bin/webscr?cmd=_xclick&amp;business=
-phpfn     http://www.php.net/{NAME}
-coral     http://{HOST}.{PORT}.nyud.net:8090{PATH}?{QUERY}
-freecache http://freecache.org/{NAME}
-sb        http://www.splitbrain.org/go/
+phpfn     https://www.php.net/{NAME}
 skype     skype:{NAME}
-google.de http://www.google.de/search?q=
-go        http://www.google.com/search?q={URL}&amp;btnI=lucky
+google.de https://www.google.de/search?q=
+go        https://www.google.com/search?q={URL}&amp;btnI=lucky
 user      :user:{NAME}
 
-# To support VoIP/SIP links
+# To support VoIP/SIP/TEL links
 callto    callto://{NAME}
-
+tel       tel:{NAME}

=== modified file 'conf/mime.conf'
--- conf/mime.conf	2014-06-08 13:15:48 +0000
+++ conf/mime.conf	2015-11-12 19:55:23 +0000
@@ -9,7 +9,6 @@
 png     image/png
 ico     image/vnd.microsoft.icon
 
-#swf     application/x-shockwave-flash
 mp3     audio/mpeg
 ogg     audio/ogg
 wav     audio/wav
@@ -66,3 +65,7 @@
 #xml     text/xml
 #csv     text/csv
 
+# Also flash may be able to execute arbitrary scripts in the website's
+# context
+#swf     application/x-shockwave-flash
+

=== modified file 'conf/mysql.conf.php.example'
--- conf/mysql.conf.php.example	2014-06-08 13:04:43 +0000
+++ conf/mysql.conf.php.example	2015-11-12 19:55:23 +0000
@@ -56,7 +56,7 @@
  * of the user. If the result table is empty or contains more than one
  * row, access will be denied.
  *
- * The plugin accesses the password as 'pass' so a alias might be necessary.
+ * The plugin accesses the password as 'pass' so an alias might be necessary.
  *
  * Following patters will be replaced:
  *   %{user}    user name
@@ -107,10 +107,10 @@
 /* This statement should return a table containing all user login names
  * that meet certain filter criteria. The filter expressions will be added
  * case dependend by the plugin. At the end a sort expression will be added.
- * Important is that this list contains no double entries fo a user. Each
+ * Important is that this list contains no double entries for a user. Each
  * user name is only allowed once in the table.
  *
- * The login name will be accessed as 'user' to a alias might be neseccary.
+ * The login name will be accessed as 'user' to an alias might be neseccary.
  * No patterns will be replaced in this statement but following patters
  * will be replaced in the filter expressions:
  *   %{user}    in FilterLogin  user's login name
@@ -174,7 +174,7 @@
                                                WHERE gid='%{gid}'";
 
 /* This statement should return the database index of a given user name.
- * The plugin will access the index with the name 'id' so a alias might be
+ * The plugin will access the index with the name 'id' so an alias might be
  * necessary.
  * following patters will be replaced:
  *   %{user}    user name
@@ -240,7 +240,7 @@
                                                AND gid='%{gid}'";
 
 /* This statement should return the database index of a given group name.
- * The plugin will access the index with the name 'id' so a alias might
+ * The plugin will access the index with the name 'id' so an alias might
  * be necessary.
  *
  * Following patters will be replaced:

=== modified file 'conf/wordblock.conf'
--- conf/wordblock.conf	2014-06-08 13:04:43 +0000
+++ conf/wordblock.conf	2015-11-12 19:55:23 +0000
@@ -2,16 +2,12 @@
 # patches welcome
 #
 https?:\/\/(\S*?)(-side-effects|top|pharm|pill|discount|discount-|deal|price|order|now|best|cheap|cheap-|online|buy|buy-|sale|sell)(\S*?)(cialis|viagra|prazolam|xanax|zanax|soma|vicodin|zenical|xenical|meridia|paxil|prozac|claritin|allegra|lexapro|wellbutrin|zoloft|retin|valium|levitra|phentermine)
-gay\s*sex
-bi\s*sex
-incest
+https?:\/\/(\S*?)(bi\s*sex|gay\s*sex|fetish|incest|penis|\brape\b)
 zoosex
 gang\s*bang
 facials
 ladyboy
-fetish
 \btits\b
-\brape\b
 bolea\.com
 52crystal
 baida\.org

=== modified file 'doku.php'
--- doku.php	2014-06-08 13:15:48 +0000
+++ doku.php	2015-11-12 19:55:23 +0000
@@ -8,13 +8,18 @@
  * @global Input $INPUT
  */
 
-// update message version
-$updateVersion = 44;
+// update message version - always use a string to avoid localized floats!
+$updateVersion = "47.1";
 
 //  xdebug_start_profiling();
 
 if(!defined('DOKU_INC')) define('DOKU_INC', dirname(__FILE__).'/');
 
+// define all DokuWiki globals here (needed within test requests but also helps to keep track)
+global  $ACT,  $INPUT, $QUERY, $ID, $REV, $DATE_AT, $IDX,
+        $DATE, $RANGE, $HIGH, $TEXT, $PRE, $SUF, $SUM, $INFO, $JSINFO;
+
+
 if(isset($_SERVER['HTTP_X_DOKUWIKI_DO'])) {
     $ACT = trim(strtolower($_SERVER['HTTP_X_DOKUWIKI_DO']));
 } elseif(!empty($_REQUEST['idx'])) {
@@ -29,7 +34,6 @@
     Header('Location: /maintenance-search.php');
     exit;
 }
-
 // load and initialize the core system
 require_once(DOKU_INC.'inc/init.php');
 
@@ -39,6 +43,7 @@
 $ID             = getID();
 
 $REV   = $INPUT->int('rev');
+$DATE_AT = $INPUT->str('at');
 $IDX   = $INPUT->str('idx');
 $DATE  = $INPUT->int('date');
 $RANGE = $INPUT->str('range');
@@ -52,7 +57,41 @@
 $SUF = cleanText($INPUT->post->str('suffix'));
 $SUM = $INPUT->post->str('summary');
 
-//make info about the selected page available
+
+//parse DATE_AT
+if($DATE_AT) {
+    $date_parse = strtotime($DATE_AT);
+    if($date_parse) {
+        $DATE_AT = $date_parse;
+    } else { // check for UNIX Timestamp
+        $date_parse = @date('Ymd',$DATE_AT);
+        if(!$date_parse || $date_parse === '19700101') {
+            msg(sprintf($lang['unable_to_parse_date'], $DATE_AT));
+            $DATE_AT = null;
+        }
+    }
+}
+
+//check for existing $REV related to $DATE_AT
+if($DATE_AT) {
+    $pagelog = new PageChangeLog($ID);
+    $rev_t = $pagelog->getLastRevisionAt($DATE_AT);
+    if($rev_t === '') { //current revision
+        $REV = null;
+        $DATE_AT = null;
+    } else if ($rev_t === false) { //page did not exist
+        $rev_n = $pagelog->getRelativeRevision($DATE_AT,+1);
+        msg(sprintf($lang['page_nonexist_rev'],
+            strftime($conf['dformat'],$DATE_AT),
+            wl($ID, array('rev' => $rev_n)),
+            strftime($conf['dformat'],$rev_n)));
+        $REV = $DATE_AT; //will result in a page not exists message
+    } else {
+        $REV = $rev_t;
+    }
+}
+
+//make infos about the selected page available
 $INFO = pageinfo();
 
 //export minimal info to JS, plugins can add more

=== modified file 'feed.php'
--- feed.php	2014-06-08 13:04:43 +0000
+++ feed.php	2015-11-12 19:55:23 +0000
@@ -127,6 +127,8 @@
                 'items'        => array('int', 'num', $conf['recent']),
                 // Boolean, only used in rc mode
                 'show_minor'   => array('bool', 'minor', false),
+                // String, only used in list mode
+                'sort'         => array('str', 'sort', 'natural'),
                 // String, only used in search mode
                 'search_query' => array('str', 'q', null),
                 // One of: pages, media, both
@@ -138,6 +140,7 @@
 
     $opt['items']      = max(0, (int) $opt['items']);
     $opt['show_minor'] = (bool) $opt['show_minor'];
+    $opt['sort'] = valid_input_set('sort', array('default' => 'natural', 'date'), $opt);
 
     $opt['guardmail'] = ($conf['mailguard'] != '' && $conf['mailguard'] != 'none');
 
@@ -215,7 +218,7 @@
                 $date = $ditem['date'];
             } elseif ($ditem['media']) {
                 $date = @filemtime(mediaFN($id));
-            } elseif (@file_exists(wikiFN($id))) {
+            } elseif (file_exists(wikiFN($id))) {
                 $date = @filemtime(wikiFN($id));
             } elseif($meta['date']['modified']) {
                 $date = $meta['date']['modified'];
@@ -303,7 +306,7 @@
                         $src_r = '';
                         $src_l = '';
 
-                        if($size = media_image_preview_size($id, false, new JpegMeta(mediaFN($id)), 300)) {
+                        if($size = media_image_preview_size($id, '', new JpegMeta(mediaFN($id)), 300)) {
                             $more  = 'w='.$size[0].'&h='.$size[1].'&t='.@filemtime(mediaFN($id));
                             $src_r = ml($id, $more, true, '&amp;', true);
                         }
@@ -352,7 +355,7 @@
                     break;
                 case 'html':
                     if($ditem['media']) {
-                        if($size = media_image_preview_size($id, false, new JpegMeta(mediaFN($id)))) {
+                        if($size = media_image_preview_size($id, '', new JpegMeta(mediaFN($id)))) {
                             $more    = 'w='.$size[0].'&h='.$size[1].'&t='.@filemtime(mediaFN($id));
                             $src     = ml($id, $more, true, '&amp;', true);
                             $content = '<img src="'.$src.'" alt="'.$id.'" />';
@@ -383,7 +386,7 @@
                 case 'abstract':
                 default:
                     if($ditem['media']) {
-                        if($size = media_image_preview_size($id, false, new JpegMeta(mediaFN($id)))) {
+                        if($size = media_image_preview_size($id, '', new JpegMeta(mediaFN($id)))) {
                             $more    = 'w='.$size[0].'&h='.$size[1].'&t='.@filemtime(mediaFN($id));
                             $src     = ml($id, $more, true, '&amp;', true);
                             $content = '<img src="'.$src.'" alt="'.$id.'" />';
@@ -405,6 +408,7 @@
                 if($userInfo) {
                     switch($conf['showuseras']) {
                         case 'username':
+                        case 'username_link':
                             $item->author = $userInfo['name'];
                             break;
                         default:
@@ -479,7 +483,7 @@
     global $conf;
 
     $ns = ':'.cleanID($opt['namespace']);
-    $ns = str_replace(':', '/', $ns);
+    $ns = utf8_encodeFN(str_replace(':', '/', $ns));
 
     $data = array();
     $search_opts = array(
@@ -487,7 +491,7 @@
         'pagesonly' => true,
         'listfiles' => true
     );
-    search($data, $conf['datadir'], 'search_universal', $search_opts, $ns);
+    search($data, $conf['datadir'], 'search_universal', $search_opts, $ns, $lvl = 1, $opt['sort']);
 
     return $data;
 }

=== modified file 'inc/DifferenceEngine.php'
--- inc/DifferenceEngine.php	2014-06-08 13:04:43 +0000
+++ inc/DifferenceEngine.php	2015-11-12 19:55:23 +0000
@@ -14,6 +14,9 @@
     var $orig;
     var $closing;
 
+    /**
+     * @return _DiffOp
+     */
     function reverse() {
         trigger_error("pure virtual", E_USER_ERROR);
     }
@@ -104,6 +107,21 @@
  */
 class _DiffEngine {
 
+    var $xchanged = array();
+    var $ychanged = array();
+    var $xv = array();
+    var $yv = array();
+    var $xind = array();
+    var $yind = array();
+    var $seq;
+    var $in_seq;
+    var $lcs;
+
+    /**
+     * @param array $from_lines
+     * @param array $to_lines
+     * @return _DiffOp[]
+     */
     function diff($from_lines, $to_lines) {
         $n_from = count($from_lines);
         $n_to = count($to_lines);
@@ -495,9 +513,9 @@
      * Constructor.
      * Computes diff between sequences of strings.
      *
-     * @param $from_lines array An array of strings.
-     *      (Typically these are lines from a file.)
-     * @param $to_lines array An array of strings.
+     * @param array $from_lines An array of strings.
+     *                          (Typically these are lines from a file.)
+     * @param array $to_lines   An array of strings.
      */
     function __construct($from_lines, $to_lines) {
         $eng = new _DiffEngine;
@@ -512,8 +530,9 @@
      *
      *  $diff = new Diff($lines1, $lines2);
      *  $rev = $diff->reverse();
-     * @return object A Diff object representing the inverse of the
-     *          original diff.
+     *
+     * @return Diff  A Diff object representing the inverse of the
+     *               original diff.
      */
     function reverse() {
         $rev = $this;
@@ -631,19 +650,19 @@
      * case-insensitve diffs, or diffs which ignore
      * changes in white-space.
      *
-     * @param $from_lines array An array of strings.
-     *  (Typically these are lines from a file.)
-     *
-     * @param $to_lines array An array of strings.
-     *
-     * @param $mapped_from_lines array 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 $mapped_to_lines array This array should
-     *  have the same number of elements as $to_lines.
+     * @param string[] $from_lines         An array of strings.
+     *                                     (Typically these are lines from a file.)
+     *
+     * @param string[] $to_lines           An array of strings.
+     *
+     * @param string[] $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 string[] $mapped_to_lines    This array should
+     *                                     have the same number of elements as $to_lines.
      */
     function __construct($from_lines, $to_lines, $mapped_from_lines, $mapped_to_lines) {
 
@@ -697,12 +716,13 @@
     /**
      * Format a diff.
      *
-     * @param $diff object A Diff object.
+     * @param Diff $diff A Diff object.
      * @return string The formatted output.
      */
     function format($diff) {
 
         $xi = $yi = 1;
+        $x0 = $y0 = 0;
         $block = false;
         $context = array();
 
@@ -752,6 +772,13 @@
         return $this->_end_diff();
     }
 
+    /**
+     * @param int $xbeg
+     * @param int $xlen
+     * @param int $ybeg
+     * @param int $ylen
+     * @param array $edits
+     */
     function _block($xbeg, $xlen, $ybeg, $ylen, &$edits) {
         $this->_start_block($this->_block_header($xbeg, $xlen, $ybeg, $ylen));
         foreach ($edits as $edit) {
@@ -779,6 +806,13 @@
         return $val;
     }
 
+    /**
+     * @param int $xbeg
+     * @param int $xlen
+     * @param int $ybeg
+     * @param int $ylen
+     * @return string
+     */
     function _block_header($xbeg, $xlen, $ybeg, $ylen) {
         if ($xlen > 1)
             $xbeg .= "," . ($xbeg + $xlen - 1);
@@ -788,6 +822,9 @@
         return $xbeg . ($xlen ? ($ylen ? 'c' : 'd') : 'a') . $ybeg;
     }
 
+    /**
+     * @param string $header
+     */
     function _start_block($header) {
         echo $header;
     }
@@ -896,6 +933,9 @@
         $this->_tag = $new_tag;
     }
 
+    /**
+     * @param string $new_tag
+     */
     function _flushLine($new_tag) {
         $this->_flushGroup($new_tag);
         if ($this->_line != '')
@@ -1055,6 +1095,10 @@
         $this->trailing_context_lines = 2;
     }
 
+    /**
+     * @param Diff $diff
+     * @return string
+     */
     function format($diff) {
         // Preserve whitespaces by converting some to non-breaking spaces.
         // Do not convert all of them to allow word-wrap.
@@ -1165,6 +1209,10 @@
         $this->trailing_context_lines = 2;
     }
 
+    /**
+     * @param Diff $diff
+     * @return string
+     */
     function format($diff) {
         // Preserve whitespaces by converting some to non-breaking spaces.
         // Do not convert all of them to allow word-wrap.

=== added directory 'inc/Form'
=== added file 'inc/Form/ButtonElement.php'
--- inc/Form/ButtonElement.php	1970-01-01 00:00:00 +0000
+++ inc/Form/ButtonElement.php	2015-11-12 19:55:23 +0000
@@ -0,0 +1,34 @@
+<?php
+namespace dokuwiki\Form;
+
+/**
+ * Class ButtonElement
+ *
+ * Represents a simple button
+ *
+ * @package dokuwiki\Form
+ */
+class ButtonElement extends Element {
+
+    /** @var string HTML content */
+    protected $content = '';
+
+    /**
+     * @param string $name
+     * @param string $content HTML content of the button. You have to escape it yourself.
+     */
+    function __construct($name, $content = '') {
+        parent::__construct('button', array('name' => $name, 'value' => 1));
+        $this->content = $content;
+    }
+
+    /**
+     * The HTML representation of this element
+     *
+     * @return string
+     */
+    public function toHTML() {
+        return '<button ' . buildAttributes($this->attrs()) . '>'.$this->content.'</button>';
+    }
+
+}

=== added file 'inc/Form/CheckableElement.php'
--- inc/Form/CheckableElement.php	1970-01-01 00:00:00 +0000
+++ inc/Form/CheckableElement.php	2015-11-12 19:55:23 +0000
@@ -0,0 +1,62 @@
+<?php
+namespace dokuwiki\Form;
+
+/**
+ * Class CheckableElement
+ *
+ * For Radio- and Checkboxes
+ *
+ * @package DokuForm
+ */
+class CheckableElement extends InputElement {
+
+    /**
+     * @param string $type The type of this element
+     * @param string $name The name of this form element
+     * @param string $label The label text for this element
+     */
+    public function __construct($type, $name, $label) {
+        parent::__construct($type, $name, $label);
+        // default value is 1
+        $this->attr('value', 1);
+    }
+
+    /**
+     * Handles the useInput flag and sets the checked attribute accordingly
+     */
+    protected function prefillInput() {
+        global $INPUT;
+        list($name, $key) = $this->getInputName();
+        $myvalue = $this->val();
+
+        if(!$INPUT->has($name)) return;
+
+        if($key === null) {
+            // no key - single value
+            $value = $INPUT->str($name);
+            if($value == $myvalue) {
+                $this->attr('checked', 'checked');
+            } else {
+                $this->rmattr('checked');
+            }
+        } else {
+            // we have an array, there might be several values in it
+            $input = $INPUT->arr($name);
+            if(isset($input[$key])) {
+                $this->rmattr('checked');
+
+                // values seem to be in another sub array
+                if(is_array($input[$key])) {
+                    $input = $input[$key];
+                }
+
+                foreach($input as $value) {
+                    if($value == $myvalue) {
+                        $this->attr('checked', 'checked');
+                    }
+                }
+            }
+        }
+    }
+
+}

=== added file 'inc/Form/Element.php'
--- inc/Form/Element.php	1970-01-01 00:00:00 +0000
+++ inc/Form/Element.php	2015-11-12 19:55:23 +0000
@@ -0,0 +1,151 @@
+<?php
+namespace dokuwiki\Form;
+
+/**
+ * Class Element
+ *
+ * The basic building block of a form
+ *
+ * @package dokuwiki\Form
+ */
+abstract class Element {
+
+    /**
+     * @var array the attributes of this element
+     */
+    protected $attributes = array();
+
+    /**
+     * @var string The type of this element
+     */
+    protected $type;
+
+    /**
+     * @param string $type The type of this element
+     * @param array $attributes
+     */
+    public function __construct($type, $attributes = array()) {
+        $this->type = $type;
+        $this->attributes = $attributes;
+    }
+
+    /**
+     * Type of this element
+     *
+     * @return string
+     */
+    public function getType() {
+        return $this->type;
+    }
+
+    /**
+     * Gets or sets an attribute
+     *
+     * When no $value is given, the current content of the attribute is returned.
+     * An empty string is returned for unset attributes.
+     *
+     * When a $value is given, the content is set to that value and the Element
+     * itself is returned for easy chaining
+     *
+     * @param string $name Name of the attribute to access
+     * @param null|string $value New value to set
+     * @return string|$this
+     */
+    public function attr($name, $value = null) {
+        // set
+        if($value !== null) {
+            $this->attributes[$name] = $value;
+            return $this;
+        }
+
+        // get
+        if(isset($this->attributes[$name])) {
+            return $this->attributes[$name];
+        } else {
+            return '';
+        }
+    }
+
+    /**
+     * Removes the given attribute if it exists
+     *
+     * @param $name
+     * @return $this
+     */
+    public function rmattr($name) {
+        if(isset($this->attributes[$name])) {
+            unset($this->attributes[$name]);
+        }
+        return $this;
+    }
+
+    /**
+     * Gets or adds a all given attributes at once
+     *
+     * @param array|null $attributes
+     * @return array|$this
+     */
+    public function attrs($attributes = null) {
+        // set
+        if($attributes) {
+            foreach((array) $attributes as $key => $val) {
+                $this->attr($key, $val);
+            }
+            return $this;
+        }
+        // get
+        return $this->attributes;
+    }
+
+    /**
+     * Adds a class to the class attribute
+     *
+     * This is the preferred method of setting the element's class
+     *
+     * @param string $class the new class to add
+     * @return $this
+     */
+    public function addClass($class) {
+        $classes = explode(' ', $this->attr('class'));
+        $classes[] = $class;
+        $classes = array_unique($classes);
+        $classes = array_filter($classes);
+        $this->attr('class', join(' ', $classes));
+        return $this;
+    }
+
+    /**
+     * Get or set the element's ID
+     *
+     * This is the preferred way of setting the element's ID
+     *
+     * @param null|string $id
+     * @return string|$this
+     */
+    public function id($id = null) {
+        if(strpos($id, '__') === false) {
+            throw new \InvalidArgumentException('IDs in DokuWiki have to contain two subsequent underscores');
+        }
+
+        return $this->attr('id', $id);
+    }
+
+    /**
+     * Get or set the element's value
+     *
+     * This is the preferred way of setting the element's value
+     *
+     * @param null|string $value
+     * @return string|$this
+     */
+    public function val($value = null) {
+        return $this->attr('value', $value);
+    }
+
+    /**
+     * The HTML representation of this element
+     *
+     * @return string
+     */
+    abstract public function toHTML();
+}

=== added file 'inc/Form/FieldsetCloseElement.php'
--- inc/Form/FieldsetCloseElement.php	1970-01-01 00:00:00 +0000
+++ inc/Form/FieldsetCloseElement.php	2015-11-12 19:55:23 +0000
@@ -0,0 +1,30 @@
+<?php
+namespace dokuwiki\Form;
+
+/**
+ * Class FieldsetCloseElement
+ *
+ * Closes an open Fieldset
+ *
+ * @package dokuwiki\Form
+ */
+class FieldsetCloseElement extends TagCloseElement {
+
+    /**
+     * @param array $attributes
+     */
+    public function __construct($attributes = array()) {
+        parent::__construct('', $attributes);
+        $this->type = 'fieldsetclose';
+    }
+
+
+    /**
+     * The HTML representation of this element
+     *
+     * @return string
+     */
+    public function toHTML() {
+        return '</fieldset>';
+    }
+}

=== added file 'inc/Form/FieldsetOpenElement.php'
--- inc/Form/FieldsetOpenElement.php	1970-01-01 00:00:00 +0000
+++ inc/Form/FieldsetOpenElement.php	2015-11-12 19:55:23 +0000
@@ -0,0 +1,36 @@
+<?php
+namespace dokuwiki\Form;
+
+/**
+ * Class FieldsetOpenElement
+ *
+ * Opens a Fieldset with an optional legend
+ *
+ * @package dokuwiki\Form
+ */
+class FieldsetOpenElement extends TagOpenElement {
+
+    /**
+     * @param string $legend
+     * @param array $attributes
+     */
+    public function __construct($legend='', $attributes = array()) {
+        // this is a bit messy and we just do it for the nicer class hierarchy
+        // the parent would expect the tag in $value but we're storing the
+        // legend there, so we have to set the type manually
+        parent::__construct($legend, $attributes);
+        $this->type = 'fieldsetopen';
+    }
+
+    /**
+     * The HTML representation of this element
+     *
+     * @return string
+     */
+    public function toHTML() {
+        $html = '<fieldset '.buildAttributes($this->attrs()).'>';
+        $legend = $this->val();
+        if($legend) $html .= DOKU_LF.'<legend>'.hsc($legend).'</legend>';
+        return $html;
+    }
+}

=== added file 'inc/Form/Form.php'
--- inc/Form/Form.php	1970-01-01 00:00:00 +0000
+++ inc/Form/Form.php	2015-11-12 19:55:23 +0000
@@ -0,0 +1,426 @@
+<?php
+namespace dokuwiki\Form;
+
+/**
+ * Class Form
+ *
+ * Represents the whole Form. This is what you work on, and add Elements to
+ *
+ * @package dokuwiki\Form
+ */
+class Form extends Element {
+
+    /**
+     * @var array name value pairs for hidden values
+     */
+    protected $hidden = array();
+
+    /**
+     * @var Element[] the elements of the form
+     */
+    protected $elements = array();
+
+    /**
+     * Creates a new, empty form with some default attributes
+     *
+     * @param array $attributes
+     */
+    public function __construct($attributes = array()) {
+        global $ID;
+
+        parent::__construct('form', $attributes);
+
+        // use the current URL as default action
+        if(!$this->attr('action')) {
+            $get = $_GET;
+            if(isset($get['id'])) unset($get['id']);
+            $self = wl($ID, $get, false, '&'); //attributes are escaped later
+            $this->attr('action', $self);
+        }
+
+        // post is default
+        if(!$this->attr('method')) {
+            $this->attr('method', 'post');
+        }
+
+        // we like UTF-8
+        if(!$this->attr('accept-charset')) {
+            $this->attr('accept-charset', 'utf-8');
+        }
+
+        // add the security token by default
+        $this->setHiddenField('sectok', getSecurityToken());
+
+        // identify this as a new form based form in HTML
+        $this->addClass('doku_form');
+    }
+
+    /**
+     * Sets a hidden field
+     *
+     * @param $name
+     * @param $value
+     * @return $this
+     */
+    public function setHiddenField($name, $value) {
+        $this->hidden[$name] = $value;
+        return $this;
+    }
+
+    #region element query function
+
+    /**
+     * Returns the numbers of elements in the form
+     *
+     * @return int
+     */
+    public function elementCount() {
+        return count($this->elements);
+    }
+
+    /**
+     * Returns a reference to the element at a position.
+     * A position out-of-bounds will return either the
+     * first (underflow) or last (overflow) element.
+     *
+     * @param $pos
+     * @return Element
+     */
+    public function getElementAt($pos) {
+        if($pos < 0) $pos = count($this->elements) + $pos;
+        if($pos < 0) $pos = 0;
+        if($pos >= count($this->elements)) $pos = count($this->elements) - 1;
+        return $this->elements[$pos];
+    }
+
+    /**
+     * Gets the position of the first of a type of element
+     *
+     * @param string $type Element type to look for.
+     * @param int $offset search from this position onward
+     * @return false|int position of element if found, otherwise false
+     */
+    public function findPositionByType($type, $offset = 0) {
+        $len = $this->elementCount();
+        for($pos = $offset; $pos < $len; $pos++) {
+            if($this->elements[$pos]->getType() == $type) {
+                return $pos;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Gets the position of the first element matching the attribute
+     *
+     * @param string $name Name of the attribute
+     * @param string $value Value the attribute should have
+     * @param int $offset search from this position onward
+     * @return false|int position of element if found, otherwise false
+     */
+    public function findPositionByAttribute($name, $value, $offset = 0) {
+        $len = $this->elementCount();
+        for($pos = $offset; $pos < $len; $pos++) {
+            if($this->elements[$pos]->attr($name) == $value) {
+                return $pos;
+            }
+        }
+        return false;
+    }
+
+    #endregion
+
+    #region Element positioning functions
+
+    /**
+     * Adds or inserts an element to the form
+     *
+     * @param Element $element
+     * @param int $pos 0-based position in the form, -1 for at the end
+     * @return Element
+     */
+    public function addElement(Element $element, $pos = -1) {
+        if(is_a($element, '\dokuwiki\Form\Form')) throw new \InvalidArgumentException('You can\'t add a form to a form');
+        if($pos < 0) {
+            $this->elements[] = $element;
+        } else {
+            array_splice($this->elements, $pos, 0, array($element));
+        }
+        return $element;
+    }
+
+    /**
+     * Replaces an existing element with a new one
+     *
+     * @param Element $element the new element
+     * @param $pos 0-based position of the element to replace
+     */
+    public function replaceElement(Element $element, $pos) {
+        if(is_a($element, '\dokuwiki\Form\Form')) throw new \InvalidArgumentException('You can\'t add a form to a form');
+        array_splice($this->elements, $pos, 1, array($element));
+    }
+
+    /**
+     * Remove an element from the form completely
+     *
+     * @param $pos 0-based position of the element to remove
+     */
+    public function removeElement($pos) {
+        array_splice($this->elements, $pos, 1);
+    }
+
+    #endregion
+
+    #region Element adding functions
+
+    /**
+     * Adds a text input field
+     *
+     * @param $name
+     * @param $label
+     * @param int $pos
+     * @return InputElement
+     */
+    public function addTextInput($name, $label = '', $pos = -1) {
+        return $this->addElement(new InputElement('text', $name, $label), $pos);
+    }
+
+    /**
+     * Adds a password input field
+     *
+     * @param $name
+     * @param $label
+     * @param int $pos
+     * @return InputElement
+     */
+    public function addPasswordInput($name, $label = '', $pos = -1) {
+        return $this->addElement(new InputElement('password', $name, $label), $pos);
+    }
+
+    /**
+     * Adds a radio button field
+     *
+     * @param $name
+     * @param $label
+     * @param int $pos
+     * @return CheckableElement
+     */
+    public function addRadioButton($name, $label = '', $pos = -1) {
+        return $this->addElement(new CheckableElement('radio', $name, $label), $pos);
+    }
+
+    /**
+     * Adds a checkbox field
+     *
+     * @param $name
+     * @param $label
+     * @param int $pos
+     * @return CheckableElement
+     */
+    public function addCheckbox($name, $label = '', $pos = -1) {
+        return $this->addElement(new CheckableElement('checkbox', $name, $label), $pos);
+    }
+
+    /**
+     * Adds a textarea field
+     *
+     * @param $name
+     * @param $label
+     * @param int $pos
+     * @return TextareaElement
+     */
+    public function addTextarea($name, $label = '', $pos = -1) {
+        return $this->addElement(new TextareaElement($name, $label), $pos);
+    }
+
+    /**
+     * Adds a simple button, escapes the content for you
+     *
+     * @param string $name
+     * @param string $content
+     * @param int $pos
+     * @return Element
+     */
+    public function addButton($name, $content, $pos = -1) {
+        return $this->addElement(new ButtonElement($name, hsc($content)), $pos);
+    }
+
+    /**
+     * Adds a simple button, allows HTML for content
+     *
+     * @param string $name
+     * @param string $html
+     * @param int $pos
+     * @return Element
+     */
+    public function addButtonHTML($name, $html, $pos = -1) {
+        return $this->addElement(new ButtonElement($name, $html), $pos);
+    }
+
+    /**
+     * Adds a label referencing another input element, escapes the label for you
+     *
+     * @param $label
+     * @param string $for
+     * @param int $pos
+     * @return Element
+     */
+    public function addLabel($label, $for='', $pos = -1) {
+        return $this->addLabelHTML(hsc($label), $for, $pos);
+    }
+
+    /**
+     * Adds a label referencing another input element, allows HTML for content
+     *
+     * @param string $content
+     * @param string|Element $for
+     * @param int $pos
+     * @return Element
+     */
+    public function addLabelHTML($content, $for='', $pos = -1) {
+        $element = new LabelElement(hsc($content));
+
+        if(is_a($for, '\dokuwiki\Form\Element')) {
+            /** @var Element $for */
+            $for = $for->id();
+        }
+        $for = (string) $for;
+        if($for !== '') {
+            $element->attr('for', $for);
+        }
+
+        return $this->addElement($element, $pos);
+    }
+
+    /**
+     * Add fixed HTML to the form
+     *
+     * @param $html
+     * @param int $pos
+     * @return HTMLElement
+     */
+    public function addHTML($html, $pos = -1) {
+        return $this->addElement(new HTMLElement($html), $pos);
+    }
+
+    /**
+     * Add a closed HTML tag to the form
+     *
+     * @param $tag
+     * @param int $pos
+     * @return TagElement
+     */
+    public function addTag($tag, $pos = -1) {
+        return $this->addElement(new TagElement($tag), $pos);
+    }
+
+    /**
+     * Add an open HTML tag to the form
+     *
+     * Be sure to close it again!
+     *
+     * @param $tag
+     * @param int $pos
+     * @return TagOpenElement
+     */
+    public function addTagOpen($tag, $pos = -1) {
+        return $this->addElement(new TagOpenElement($tag), $pos);
+    }
+
+    /**
+     * Add a closing HTML tag to the form
+     *
+     * Be sure it had been opened before
+     *
+     * @param $tag
+     * @param int $pos
+     * @return TagCloseElement
+     */
+    public function addTagClose($tag, $pos = -1) {
+        return $this->addElement(new TagCloseElement($tag), $pos);
+    }
+
+    /**
+     * Open a Fieldset
+     *
+     * @param $legend
+     * @param int $pos
+     * @return FieldsetOpenElement
+     */
+    public function addFieldsetOpen($legend = '', $pos = -1) {
+        return $this->addElement(new FieldsetOpenElement($legend), $pos);
+    }
+
+    /**
+     * Close a fieldset
+     *
+     * @param int $pos
+     * @return TagCloseElement
+     */
+    public function addFieldsetClose($pos = -1) {
+        return $this->addElement(new FieldsetCloseElement(), $pos);
+    }
+
+    #endregion
+
+    /**
+     * Adjust the elements so that fieldset open and closes are matching
+     */
+    protected function balanceFieldsets() {
+        $lastclose = 0;
+        $isopen = false;
+        $len = count($this->elements);
+
+        for($pos = 0; $pos < $len; $pos++) {
+            $type = $this->elements[$pos]->getType();
+            if($type == 'fieldsetopen') {
+                if($isopen) {
+                    //close previous fieldset
+                    $this->addFieldsetClose($pos);
+                    $lastclose = $pos + 1;
+                    $pos++;
+                    $len++;
+                }
+                $isopen = true;
+            } else if($type == 'fieldsetclose') {
+                if(!$isopen) {
+                    // make sure there was a fieldsetopen
+                    // either right after the last close or at the begining
+                    $this->addFieldsetOpen('', $lastclose);
+                    $len++;
+                    $pos++;
+                }
+                $lastclose = $pos;
+                $isopen = false;
+            }
+        }
+
+        // close open fieldset at the end
+        if($isopen) {
+            $this->addFieldsetClose();
+        }
+    }
+
+    /**
+     * The HTML representation of the whole form
+     *
+     * @return string
+     */
+    public function toHTML() {
+        $this->balanceFieldsets();
+
+        $html = '<form ' . buildAttributes($this->attrs()) . '>' . DOKU_LF;
+
+        foreach($this->hidden as $name => $value) {
+            $html .= '<input type="hidden" name="' . $name . '" value="' . formText($value) . '" />' . DOKU_LF;
+        }
+
+        foreach($this->elements as $element) {
+            $html .= $element->toHTML() . DOKU_LF;
+        }
+
+        $html .= '</form>' . DOKU_LF;
+
+        return $html;
+    }
+}

=== added file 'inc/Form/HTMLElement.php'
--- inc/Form/HTMLElement.php	1970-01-01 00:00:00 +0000
+++ inc/Form/HTMLElement.php	2015-11-12 19:55:23 +0000
@@ -0,0 +1,29 @@
+<?php
+namespace dokuwiki\Form;
+
+/**
+ * Class HTMLElement
+ *
+ * Holds arbitrary HTML that is added as is to the Form
+ *
+ * @package dokuwiki\Form
+ */
+class HTMLElement extends ValueElement {
+
+
+    /**
+     * @param string $html
+     */
+    public function __construct($html) {
+        parent::__construct('html', $html);
+    }
+
+    /**
+     * The HTML representation of this element
+     *
+     * @return string
+     */
+    public function toHTML() {
+        return $this->val();
+    }
+}

=== added file 'inc/Form/InputElement.php'
--- inc/Form/InputElement.php	1970-01-01 00:00:00 +0000
+++ inc/Form/InputElement.php	2015-11-12 19:55:23 +0000
@@ -0,0 +1,161 @@
+<?php
+namespace dokuwiki\Form;
+
+/**
+ * Class InputElement
+ *
+ * Base class for all input elements. Uses a wrapping label when label
+ * text is given.
+ *
+ * @todo figure out how to make wrapping or related label configurable
+ * @package dokuwiki\Form
+ */
+class InputElement extends Element {
+    /**
+     * @var LabelElement
+     */
+    protected $label = null;
+
+    /**
+     * @var bool if the element should reflect posted values
+     */
+    protected $useInput = true;
+
+    /**
+     * @param string $type The type of this element
+     * @param string $name The name of this form element
+     * @param string $label The label text for this element (will be autoescaped)
+     */
+    public function __construct($type, $name, $label = '') {
+        parent::__construct($type, array('name' => $name));
+        $this->attr('name', $name);
+        $this->attr('type', $type);
+        if($label) $this->label = new LabelElement($label);
+    }
+
+    /**
+     * Returns the label element if there's one set
+     *
+     * @return LabelElement|null
+     */
+    public function getLabel() {
+        return $this->label;
+    }
+
+    /**
+     * Should the user sent input be used to initialize the input field
+     *
+     * The default is true. Any set values will be overwritten by the INPUT
+     * provided values.
+     *
+     * @param bool $useinput
+     * @return $this
+     */
+    public function useInput($useinput) {
+        $this->useInput = (bool) $useinput;
+        return $this;
+    }
+
+    /**
+     * Get or set the element's ID
+     *
+     * @param null|string $id
+     * @return string|$this
+     */
+    public function id($id = null) {
+        if($this->label) $this->label->attr('for', $id);
+        return parent::id($id);
+    }
+
+    /**
+     * Adds a class to the class attribute
+     *
+     * This is the preferred method of setting the element's class
+     *
+     * @param string $class the new class to add
+     * @return $this
+     */
+    public function addClass($class) {
+        if($this->label) $this->label->addClass($class);
+        return parent::addClass($class);
+    }
+
+    /**
+     * Figures out how to access the value for this field from INPUT data
+     *
+     * The element's name could have been given as a simple string ('foo')
+     * or in array notation ('foo[bar]').
+     *
+     * Note: this function only handles one level of arrays. If your data
+     * is nested deeper, you should call useInput(false) and set the
+     * correct value yourself
+     *
+     * @return array name and array key (null if not an array)
+     */
+    protected function getInputName() {
+        $name = $this->attr('name');
+        parse_str("$name=1", $parsed);
+
+        $name = array_keys($parsed);
+        $name = array_shift($name);
+
+        if(is_array($parsed[$name])) {
+            $key = array_keys($parsed[$name]);
+            $key = array_shift($key);
+        } else {
+            $key = null;
+        }
+
+        return array($name, $key);
+    }
+
+    /**
+     * Handles the useInput flag and set the value attribute accordingly
+     */
+    protected function prefillInput() {
+        global $INPUT;
+
+        list($name, $key) = $this->getInputName();
+        if(!$INPUT->has($name)) return;
+
+        if($key === null) {
+            $value = $INPUT->str($name);
+        } else {
+            $value = $INPUT->arr($name);
+            if(isset($value[$key])) {
+                $value = $value[$key];
+            } else {
+                $value = '';
+            }
+        }
+        if($value !== '') {
+            $this->val($value);
+        }
+    }
+
+    /**
+     * The HTML representation of this element
+     *
+     * @return string
+     */
+    protected function mainElementHTML() {
+        if($this->useInput) $this->prefillInput();
+        return '<input ' . buildAttributes($this->attrs()) . ' />';
+    }
+
+    /**
+     * The HTML representation of this element wrapped in a label
+     *
+     * @return string
+     */
+    public function toHTML() {
+        if($this->label) {
+            return '<label ' . buildAttributes($this->label->attrs()) . '>' . DOKU_LF .
+            '<span>' . hsc($this->label->val()) . '</span>' . DOKU_LF .
+            $this->mainElementHTML() . DOKU_LF .
+            '</label>';
+        } else {
+            return $this->mainElementHTML();
+        }
+    }
+}

=== added file 'inc/Form/LabelElement.php'
--- inc/Form/LabelElement.php	1970-01-01 00:00:00 +0000
+++ inc/Form/LabelElement.php	2015-11-12 19:55:23 +0000
@@ -0,0 +1,27 @@
+<?php
+namespace dokuwiki\Form;
+
+/**
+ * Class Label
+ * @package dokuwiki\Form
+ */
+class LabelElement extends ValueElement {
+
+    /**
+     * Creates a new Label
+     *
+     * @param string $label This is is raw HTML and will not be escaped
+     */
+    public function __construct($label) {
+        parent::__construct('label', $label);
+    }
+
+    /**
+     * The HTML representation of this element
+     *
+     * @return string
+     */
+    public function toHTML() {
+        return '<label ' . buildAttributes($this->attrs()) . '>' . $this->val() . '</label>';
+    }
+}

=== added file 'inc/Form/LegacyForm.php'
--- inc/Form/LegacyForm.php	1970-01-01 00:00:00 +0000
+++ inc/Form/LegacyForm.php	2015-11-12 19:55:23 +0000
@@ -0,0 +1,181 @@
+<?php
+namespace dokuwiki\Form;
+
+/**
+ * Class LegacyForm
+ *
+ * Provides a compatibility layer to the old Doku_Form API
+ *
+ * This can be used to work with the modern API on forms provided by old events for
+ * example. When you start new forms, just use Form\Form
+ *
+ * @package dokuwiki\Form
+ */
+class LegacyForm extends Form {
+
+    /**
+     * Creates a new modern form from an old legacy Doku_Form
+     *
+     * @param \Doku_Form $oldform
+     */
+    public function __construct(\Doku_Form $oldform) {
+        parent::__construct($oldform->params);
+
+        $this->hidden = $oldform->_hidden;
+
+        foreach($oldform->_content as $element) {
+            list($ctl, $attr) = $this->parseLegacyAttr($element);
+
+            if(is_array($element)) {
+                switch($ctl['elem']) {
+                    case 'wikitext':
+                        $this->addTextarea('wikitext')
+                             ->attrs($attr)
+                             ->id('wiki__text')
+                             ->val($ctl['text'])
+                             ->addClass($ctl['class']);
+                        break;
+                    case 'textfield':
+                        $this->addTextInput($ctl['name'], $ctl['text'])
+                             ->attrs($attr)
+                             ->id($ctl['id'])
+                             ->addClass($ctl['class']);
+                        break;
+                    case 'passwordfield':
+                        $this->addPasswordInput($ctl['name'], $ctl['text'])
+                             ->attrs($attr)
+                             ->id($ctl['id'])
+                             ->addClass($ctl['class']);
+                        break;
+                    case 'checkboxfield':
+                        $this->addCheckbox($ctl['name'], $ctl['text'])
+                             ->attrs($attr)
+                             ->id($ctl['id'])
+                             ->addClass($ctl['class']);
+                        break;
+                    case 'radiofield':
+                        $this->addRadioButton($ctl['name'], $ctl['text'])
+                             ->attrs($attr)
+                             ->id($ctl['id'])
+                             ->addClass($ctl['class']);
+                        break;
+                    case 'tag':
+                        $this->addTag($ctl['tag'])
+                             ->attrs($attr)
+                             ->attr('name', $ctl['name'])
+                             ->id($ctl['id'])
+                             ->addClass($ctl['class']);
+                        break;
+                    case 'opentag':
+                        $this->addTagOpen($ctl['tag'])
+                             ->attrs($attr)
+                             ->attr('name', $ctl['name'])
+                             ->id($ctl['id'])
+                             ->addClass($ctl['class']);
+                        break;
+                    case 'closetag':
+                        $this->addTagClose($ctl['tag']);
+                        break;
+                    case 'openfieldset':
+                        $this->addFieldsetOpen($ctl['legend'])
+                            ->attrs($attr)
+                            ->attr('name', $ctl['name'])
+                            ->id($ctl['id'])
+                            ->addClass($ctl['class']);
+                        break;
+                    case 'closefieldset':
+                        $this->addFieldsetClose();
+                        break;
+                    case 'button':
+                    case 'field':
+                    case 'fieldright':
+                    case 'filefield':
+                    case 'menufield':
+                    case 'listboxfield':
+                        throw new \UnexpectedValueException('Unsupported legacy field ' . $ctl['elem']);
+                        break;
+                    default:
+                        throw new \UnexpectedValueException('Unknown legacy field ' . $ctl['elem']);
+
+                }
+            } else {
+                $this->addHTML($element);
+            }
+        }
+
+    }
+
+    /**
+     * Parses out what is the elements attributes and what is control info
+     *
+     * @param array $legacy
+     * @return array
+     */
+    protected function parseLegacyAttr($legacy) {
+        $attributes = array();
+        $control = array();
+
+        foreach($legacy as $key => $val) {
+            if($key{0} == '_') {
+                $control[substr($key, 1)] = $val;
+            } elseif($key == 'name') {
+                $control[$key] = $val;
+            } elseif($key == 'id') {
+                $control[$key] = $val;
+            } else {
+                $attributes[$key] = $val;
+            }
+        }
+
+        return array($control, $attributes);
+    }
+
+    /**
+     * Translates our types to the legacy types
+     *
+     * @param string $type
+     * @return string
+     */
+    protected function legacyType($type) {
+        static $types = array(
+            'text' => 'textfield',
+            'password' => 'passwordfield',
+            'checkbox' => 'checkboxfield',
+            'radio' => 'radiofield',
+            'tagopen' => 'opentag',
+            'tagclose' => 'closetag',
+            'fieldsetopen' => 'openfieldset',
+            'fieldsetclose' => 'closefieldset',
+        );
+        if(isset($types[$type])) return $types[$type];
+        return $type;
+    }
+
+    /**
+     * Creates an old legacy form from this modern form's data
+     *
+     * @return \Doku_Form
+     */
+    public function toLegacy() {
+        $this->balanceFieldsets();
+
+        $legacy = new \Doku_Form($this->attrs());
+        $legacy->_hidden = $this->hidden;
+        foreach($this->elements as $element) {
+            if(is_a($element, 'dokuwiki\Form\HTMLElement')) {
+                $legacy->_content[] = $element->toHTML();
+            } elseif(is_a($element, 'dokuwiki\Form\InputElement')) {
+                /** @var InputElement $element */
+                $data = $element->attrs();
+                $data['_elem'] = $this->legacyType($element->getType());
+                $label = $element->getLabel();
+                if($label) {
+                    $data['_class'] = $label->attr('class');
+                }
+                $legacy->_content[] = $data;
+            }
+        }
+
+        return $legacy;
+    }
+}

=== added file 'inc/Form/TagCloseElement.php'
--- inc/Form/TagCloseElement.php	1970-01-01 00:00:00 +0000
+++ inc/Form/TagCloseElement.php	2015-11-12 19:55:23 +0000
@@ -0,0 +1,76 @@
+<?php
+namespace dokuwiki\Form;
+
+/**
+ * Class TagCloseElement
+ *
+ * Creates an HTML close tag. You have to make sure it has been opened
+ * before or this will produce invalid HTML
+ *
+ * @package dokuwiki\Form
+ */
+class TagCloseElement extends ValueElement {
+
+    /**
+     * @param string $tag
+     * @param array $attributes
+     */
+    public function __construct($tag, $attributes = array()) {
+        parent::__construct('tagclose', $tag, $attributes);
+    }
+
+    /**
+     * do not call this
+     *
+     * @param $class
+     * @return void
+     * @throws \BadMethodCallException
+     */
+    public function addClass($class) {
+        throw new \BadMethodCallException('You can\t add classes to closing tag');
+    }
+
+    /**
+     * do not call this
+     *
+     * @param $id
+     * @return void
+     * @throws \BadMethodCallException
+     */
+    public function id($id = null) {
+        throw new \BadMethodCallException('You can\t add ID to closing tag');
+    }
+
+    /**
+     * do not call this
+     *
+     * @param $name
+     * @param $value
+     * @return void
+     * @throws \BadMethodCallException
+     */
+    public function attr($name, $value = null) {
+        throw new \BadMethodCallException('You can\t add attributes to closing tag');
+    }
+
+    /**
+     * do not call this
+     *
+     * @param $attributes
+     * @return void
+     * @throws \BadMethodCallException
+     */
+    public function attrs($attributes = null) {
+        throw new \BadMethodCallException('You can\t add attributes to closing tag');
+    }
+
+    /**
+     * The HTML representation of this element
+     *
+     * @return string
+     */
+    public function toHTML() {
+        return '</'.$this->val().'>';
+    }
+
+}

=== added file 'inc/Form/TagElement.php'
--- inc/Form/TagElement.php	1970-01-01 00:00:00 +0000
+++ inc/Form/TagElement.php	2015-11-12 19:55:23 +0000
@@ -0,0 +1,29 @@
+<?php
+namespace dokuwiki\Form;
+
+/**
+ * Class TagElement
+ *
+ * Creates a self closing HTML tag
+ *
+ * @package dokuwiki\Form
+ */
+class TagElement extends ValueElement {
+
+    /**
+     * @param string $tag
+     * @param array $attributes
+     */
+    public function __construct($tag, $attributes = array()) {
+        parent::__construct('tag', $tag, $attributes);
+    }
+
+    /**
+     * The HTML representation of this element
+     *
+     * @return string
+     */
+    public function toHTML() {
+        return '<'.$this->val().' '.buildAttributes($this->attrs()).' />';
+    }
+}

=== added file 'inc/Form/TagOpenElement.php'
--- inc/Form/TagOpenElement.php	1970-01-01 00:00:00 +0000
+++ inc/Form/TagOpenElement.php	2015-11-12 19:55:23 +0000
@@ -0,0 +1,30 @@
+<?php
+namespace dokuwiki\Form;
+
+/**
+ * Class TagOpenElement
+ *
+ * Creates an open HTML tag. You have to make sure you close it
+ * again or this will produce invalid HTML
+ *
+ * @package dokuwiki\Form
+ */
+class TagOpenElement extends ValueElement {
+
+    /**
+     * @param string $tag
+     * @param array $attributes
+     */
+    public function __construct($tag, $attributes = array()) {
+        parent::__construct('tagopen', $tag, $attributes);
+    }
+
+    /**
+     * The HTML representation of this element
+     *
+     * @return string
+     */
+    public function toHTML() {
+        return '<'.$this->val().' '.buildAttributes($this->attrs()).'>';
+    }
+}

=== added file 'inc/Form/TextareaElement.php'
--- inc/Form/TextareaElement.php	1970-01-01 00:00:00 +0000
+++ inc/Form/TextareaElement.php	2015-11-12 19:55:23 +0000
@@ -0,0 +1,51 @@
+<?php
+namespace dokuwiki\Form;
+
+/**
+ * Class TextareaElement
+ * @package dokuwiki\Form
+ */
+class TextareaElement extends InputElement {
+
+    /**
+     * @var string the actual text within the area
+     */
+    protected $text;
+
+    /**
+     * @param string $name The name of this form element
+     * @param string $label The label text for this element
+     */
+    public function __construct($name, $label) {
+        parent::__construct('textarea', $name, $label);
+        $this->attr('dir', 'auto');
+    }
+
+    /**
+     * Get or set the element's value
+     *
+     * This is the preferred way of setting the element's value
+     *
+     * @param null|string $value
+     * @return string|$this
+     */
+    public function val($value = null) {
+        if($value !== null) {
+            $this->text = $value;
+            return $this;
+        }
+        return $this->text;
+    }
+
+    /**
+     * The HTML representation of this element
+     *
+     * @return string
+     */
+    protected function mainElementHTML() {
+        if($this->useInput) $this->prefillInput();
+        return '<textarea ' . buildAttributes($this->attrs()) . '>' .
+        formText($this->val()) . '</textarea>';
+    }
+
+}

=== added file 'inc/Form/ValueElement.php'
--- inc/Form/ValueElement.php	1970-01-01 00:00:00 +0000
+++ inc/Form/ValueElement.php	2015-11-12 19:55:23 +0000
@@ -0,0 +1,45 @@
+<?php
+
+namespace dokuwiki\Form;
+
+/**
+ * Class ValueElement
+ *
+ * Just like an Element but it's value is not part of its attributes
+ *
+ * What the value is (tag name, content, etc) is defined by the actual implementations
+ *
+ * @package dokuwiki\Form
+ */
+abstract class ValueElement extends Element {
+
+    /**
+     * @var string holds the element's value
+     */
+    protected $value = '';
+
+    /**
+     * @param string $type
+     * @param array|string $value
+     * @param array $attributes
+     */
+    public function __construct($type, $value, $attributes = array()) {
+        parent::__construct($type, $attributes);
+        $this->val($value);
+    }
+
+    /**
+     * Get or set the element's value
+     *
+     * @param null|string $value
+     * @return string|$this
+     */
+    public function val($value = null) {
+        if($value !== null) {
+            $this->value = $value;
+            return $this;
+        }
+        return $this->value;
+    }
+
+}

=== modified file 'inc/HTTPClient.php'
--- inc/HTTPClient.php	2014-06-08 13:04:43 +0000
+++ inc/HTTPClient.php	2015-11-12 19:55:23 +0000
@@ -35,6 +35,19 @@
         $this->proxy_pass   = conf_decodeString($conf['proxy']['pass']);
         $this->proxy_ssl    = $conf['proxy']['ssl'];
         $this->proxy_except = $conf['proxy']['except'];
+
+        // allow enabling debugging via URL parameter (if debugging allowed)
+        if($conf['allowdebug']) {
+            if(
+                isset($_REQUEST['httpdebug']) ||
+                (
+                    isset($_SERVER['HTTP_REFERER']) &&
+                    strpos($_SERVER['HTTP_REFERER'], 'httpdebug') !== false
+                )
+            ) {
+                $this->debug = true;
+            }
+        }
     }
 
 
@@ -44,6 +57,12 @@
      * @triggers HTTPCLIENT_REQUEST_SEND
      * @author   Andreas Gohr <[e-mail]>
      */
+    /**
+     * @param string $url
+     * @param string|array $data the post data either as array or raw data
+     * @param string $method
+     * @return bool
+     */
     function sendRequest($url,$data='',$method='GET'){
         $httpdata = array('url'    => $url,
                           'data'   => $data,
@@ -61,6 +80,9 @@
 
 }
 
+/**
+ * Class HTTPClientException
+ */
 class HTTPClientException extends Exception { }
 
 /**
@@ -88,7 +110,7 @@
     var $header_regexp; // if set this RE must match against the headers, else abort
     var $headers;
     var $debug;
-    var $start = 0; // for timings
+    var $start = 0.0; // for timings
     var $keep_alive = true; // keep alive rocks
 
     // don't set these, read on error
@@ -150,7 +172,8 @@
      *
      * @param  string $url       The URL to fetch
      * @param  bool   $sloppy304 Return body on 304 not modified
-     * @return bool|string  response body, false on error
+     * @return false|string  response body, false on error
+     *
      * @author Andreas Gohr <[e-mail]>
      */
     function get($url,$sloppy304=false){
@@ -171,7 +194,8 @@
      * @param  string $url       The URL to fetch
      * @param  array  $data      Associative array of parameters
      * @param  bool   $sloppy304 Return body on 304 not modified
-     * @return bool|string  response body, false on error
+     * @return false|string  response body, false on error
+     *
      * @author Andreas Gohr <[e-mail]>
      */
     function dget($url,$data,$sloppy304=false){
@@ -191,7 +215,7 @@
      *
      * @param  string $url       The URL to fetch
      * @param  array  $data      Associative array of parameters
-     * @return bool|string  response body, false on error
+     * @return false|string  response body, false on error
      * @author Andreas Gohr <[e-mail]>
      */
     function post($url,$data){
@@ -213,6 +237,7 @@
      * @param  mixed  $data   - the post data either as array or raw data
      * @param  string $method - HTTP Method usually GET or POST.
      * @return bool - true on success
+     *
      * @author Andreas Goetz <[e-mail]>
      * @author Andreas Gohr <[e-mail]>
      */
@@ -249,7 +274,6 @@
             if (empty($port)) $port = 8080;
         }else{
             $request_url = $path;
-            $server      = $server;
             if (!isset($port)) $port = ($uri['scheme'] == 'https') ? 443 : 80;
         }
 
@@ -280,7 +304,6 @@
                 }
             }
             $headers['Content-Length'] = strlen($data);
-            $rmethod = 'POST';
         }elseif($method == 'GET'){
             $data = ''; //no data allowed on GET requests
         }
@@ -343,7 +366,7 @@
 
         try {
             //set non-blocking
-            stream_set_blocking($socket, false);
+            stream_set_blocking($socket, 0);
 
             // build request
             $request  = "$method $request_url HTTP/".$this->http.HTTP_NL;
@@ -458,7 +481,7 @@
 
                     if ($chunk_size > 0) {
                         $r_body .= $this->_readData($socket, $chunk_size, 'chunk');
-                        $byte = $this->_readData($socket, 2, 'chunk'); // read trailing \r\n
+                        $this->_readData($socket, 2, 'chunk'); // read trailing \r\n
                     }
                 } while ($chunk_size && !$abort);
             }elseif(isset($this->resp_headers['content-length']) && !isset($this->resp_headers['transfer-encoding'])){
@@ -480,7 +503,6 @@
                 $r_body = $this->_readData($socket, $this->max_bodysize, 'response (content-length limited)', true);
             }else{
                 // read entire socket
-                $r_size = 0;
                 while (!feof($socket)) {
                     $r_body .= $this->_readData($socket, 4096, 'response (unlimited)', true);
                 }
@@ -509,7 +531,6 @@
         if (!$this->keep_alive ||
                 (isset($this->resp_headers['connection']) && $this->resp_headers['connection'] == 'Close')) {
             // close socket
-            $status = socket_get_status($socket);
             fclose($socket);
             unset(self::$connections[$connectionId]);
         }
@@ -568,10 +589,25 @@
 
         $this->_debug('SSL Tunnel Response',$r_headers);
         if(preg_match('/^HTTP\/1\.[01] 200/i',$r_headers)){
-            if (stream_socket_enable_crypto($socket, true, STREAM_CRYPTO_METHOD_SSLv3_CLIENT)) {
-                $requesturl = $requestinfo['path'];
-                return true;
-            }
+            // set correct peer name for verification (enabled since PHP 5.6)
+            stream_context_set_option($socket, 'ssl', 'peer_name', $requestinfo['host']);
+
+            // because SSLv3 is mostly broken, we try TLS connections here first.
+            // according to  https://github.com/splitbrain/dokuwiki/commit/c05ef534 we had problems with certain
+            // setups with this solution before, but we have no usable test for that and TLS should be the more
+            // common crypto by now
+            if (@stream_socket_enable_crypto($socket, true, STREAM_CRYPTO_METHOD_TLS_CLIENT)) {
+                $requesturl = $requestinfo['path'];
+                return true;
+            }
+
+            // if the above failed, this will most probably not work either, but we can try
+            if (@stream_socket_enable_crypto($socket, true, STREAM_CRYPTO_METHOD_SSLv3_CLIENT)) {
+                $requesturl = $requestinfo['path'];
+                return true;
+            }
+
+            throw new HTTPClientException('Failed to set up crypto for secure connection to '.$requestinfo['host'], -151);
         }
 
         throw new HTTPClientException('Failed to establish secure proxy connection', -150);
@@ -584,6 +620,7 @@
      * @param  string   $data       The data to write
      * @param  string   $message    Description of what is being read
      * @throws HTTPClientException
+     *
      * @author Tom N Harris <[e-mail]>
      */
     function _sendData($socket, $data, $message) {
@@ -628,6 +665,7 @@
      * @param  bool     $ignore_eof End-of-file is not an error if this is set
      * @throws HTTPClientException
      * @return string
+     *
      * @author Tom N Harris <[e-mail]>
      */
     function _readData($socket, $nbytes, $message, $ignore_eof = false) {
@@ -677,6 +715,7 @@
      * @param  string   $message    Description of what is being read
      * @throws HTTPClientException
      * @return string
+     *
      * @author Tom N Harris <[e-mail]>
      */
     function _readLine($socket, $message) {
@@ -711,6 +750,9 @@
      * Uses _debug_text or _debug_html depending on the SAPI name
      *
      * @author Andreas Gohr <[e-mail]>
+     *
+     * @param string $info
+     * @param mixed  $var
      */
     function _debug($info,$var=null){
         if(!$this->debug) return;
@@ -724,8 +766,8 @@
     /**
      * print debug info as HTML
      *
-     * @param      $info
-     * @param null $var
+     * @param string $info
+     * @param mixed  $var
      */
     function _debug_html($info, $var=null){
         print '<b>'.$info.'</b> '.($this->_time() - $this->start).'s<br />';
@@ -741,8 +783,8 @@
     /**
      * prints debug info as plain text
      *
-     * @param      $info
-     * @param null $var
+     * @param string $info
+     * @param mixed  $var
      */
     function _debug_text($info, $var=null){
         print '*'.$info.'* '.($this->_time() - $this->start)."s\n";
@@ -752,6 +794,8 @@
 
     /**
      * Return current timestamp in microsecond resolution
+     *
+     * @return float
      */
     static function _time(){
         list($usec, $sec) = explode(" ", microtime());
@@ -764,6 +808,9 @@
      * All Keys are lowercased.
      *
      * @author Andreas Gohr <[e-mail]>
+     *
+     * @param string $string
+     * @return array
      */
     function _parseHeaders($string){
         $headers = array();
@@ -792,11 +839,14 @@
      * convert given header array to header string
      *
      * @author Andreas Gohr <[e-mail]>
+     *
+     * @param array $headers
+     * @return string
      */
     function _buildHeaders($headers){
         $string = '';
         foreach($headers as $key => $value){
-            if(empty($value)) continue;
+            if($value === '') continue;
             $string .= $key.': '.$value.HTTP_NL;
         }
         return $string;
@@ -806,6 +856,8 @@
      * get cookies as http header string
      *
      * @author Andreas Goetz <[e-mail]>
+     *
+     * @return string
      */
     function _getCookies(){
         $headers = '';
@@ -821,6 +873,9 @@
      * Encode data for posting
      *
      * @author Andreas Gohr <[e-mail]>
+     *
+     * @param array $data
+     * @return string
      */
     function _postEncode($data){
         return http_build_query($data,'','&');
@@ -831,6 +886,9 @@
      *
      * @fixme use of urlencode might be wrong here
      * @author Andreas Gohr <[e-mail]>
+     *
+     * @param array $data
+     * @return string
      */
     function _postMultipartEncode($data){
         $boundary = '--'.$this->boundary;

=== modified file 'inc/IXR_Library.php'
--- inc/IXR_Library.php	2012-10-21 21:14:10 +0000
+++ inc/IXR_Library.php	2015-11-12 19:55:23 +0000
@@ -1,101 +1,146 @@
 <?php
+
 /**
- * IXR - The Inutio XML-RPC Library - (c) Incutio Ltd 2002
- *
- * @version 1.61
- * @author  Simon Willison
- * @date    11th July 2003
- * @link    http://scripts.incutio.com/xmlrpc/
- * @link    http://scripts.incutio.com/xmlrpc/manual.php
- * @license Artistic License http://www.opensource.org/licenses/artistic-license.php
+ * IXR - The Incutio XML-RPC Library
+ *
+ * Copyright (c) 2010, Incutio Ltd.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  - Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  - Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  - Neither the name of Incutio Ltd. nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+ * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @package IXR
+ * @since 1.5
+ *
+ * @copyright  Incutio Ltd 2010 (http://www.incutio.com)
+ * @version    1.7.4 7th September 2010
+ * @author     Simon Willison
+ * @link       http://scripts.incutio.com/xmlrpc/ Site/manual
  *
  * Modified for DokuWiki
  * @author  Andreas Gohr <[e-mail]>
  */
-
-
 class IXR_Value {
+
+    /** @var  IXR_Value[]|IXR_Date|IXR_Base64|int|bool|double|string */
     var $data;
+    /** @var string */
     var $type;
-    function IXR_Value ($data, $type = false) {
+
+    /**
+     * @param mixed $data
+     * @param bool $type
+     */
+    function __construct($data, $type = false) {
         $this->data = $data;
-        if (!$type) {
+        if(!$type) {
             $type = $this->calculateType();
         }
         $this->type = $type;
-        if ($type == 'struct') {
-            /* Turn all the values in the array in to new IXR_Value objects */
-            foreach ($this->data as $key => $value) {
+        if($type == 'struct') {
+            // Turn all the values in the array in to new IXR_Value objects
+            foreach($this->data as $key => $value) {
                 $this->data[$key] = new IXR_Value($value);
             }
         }
-        if ($type == 'array') {
-            for ($i = 0, $j = count($this->data); $i < $j; $i++) {
+        if($type == 'array') {
+            for($i = 0, $j = count($this->data); $i < $j; $i++) {
                 $this->data[$i] = new IXR_Value($this->data[$i]);
             }
         }
     }
+
+    /**
+     * @return string
+     */
     function calculateType() {
-        if ($this->data === true || $this->data === false) {
+        if($this->data === true || $this->data === false) {
             return 'boolean';
         }
-        if (is_integer($this->data)) {
+        if(is_integer($this->data)) {
             return 'int';
         }
-        if (is_double($this->data)) {
+        if(is_double($this->data)) {
             return 'double';
         }
+
         // Deal with IXR object types base64 and date
-        if (is_object($this->data) && is_a($this->data, 'IXR_Date')) {
+        if(is_object($this->data) && is_a($this->data, 'IXR_Date')) {
             return 'date';
         }
-        if (is_object($this->data) && is_a($this->data, 'IXR_Base64')) {
+        if(is_object($this->data) && is_a($this->data, 'IXR_Base64')) {
             return 'base64';
         }
+
         // If it is a normal PHP object convert it in to a struct
-        if (is_object($this->data)) {
-
+        if(is_object($this->data)) {
             $this->data = get_object_vars($this->data);
             return 'struct';
         }
-        if (!is_array($this->data)) {
+        if(!is_array($this->data)) {
             return 'string';
         }
-        /* We have an array - is it an array or a struct ? */
-        if ($this->isStruct($this->data)) {
+
+        // We have an array - is it an array or a struct?
+        if($this->isStruct($this->data)) {
             return 'struct';
         } else {
             return 'array';
         }
     }
+
+    /**
+     * @return bool|string
+     */
     function getXml() {
-        /* Return XML for this value */
-        switch ($this->type) {
+        // Return XML for this value
+        switch($this->type) {
             case 'boolean':
-                return '<boolean>'.(($this->data) ? '1' : '0').'</boolean>';
+                return '<boolean>' . (($this->data) ? '1' : '0') . '</boolean>';
                 break;
             case 'int':
-                return '<int>'.$this->data.'</int>';
+                return '<int>' . $this->data . '</int>';
                 break;
             case 'double':
-                return '<double>'.$this->data.'</double>';
+                return '<double>' . $this->data . '</double>';
                 break;
             case 'string':
-                return '<string>'.htmlspecialchars($this->data).'</string>';
+                return '<string>' . htmlspecialchars($this->data) . '</string>';
                 break;
             case 'array':
-                $return = '<array><data>'."\n";
-                foreach ($this->data as $item) {
-                    $return .= '  <value>'.$item->getXml()."</value>\n";
+                $return = '<array><data>' . "\n";
+                foreach($this->data as $item) {
+                    $return .= '  <value>' . $item->getXml() . "</value>\n";
                 }
                 $return .= '</data></array>';
                 return $return;
                 break;
             case 'struct':
-                $return = '<struct>'."\n";
-                foreach ($this->data as $name => $value) {
+                $return = '<struct>' . "\n";
+                foreach($this->data as $name => $value) {
                     $return .= "  <member><name>$name</name><value>";
-                    $return .= $value->getXml()."</value></member>\n";
+                    $return .= $value->getXml() . "</value></member>\n";
                 }
                 $return .= '</struct>';
                 return $return;
@@ -107,11 +152,17 @@
         }
         return false;
     }
+
+    /**
+     * Checks whether or not the supplied array is a struct or not
+     *
+     * @param array $array
+     * @return boolean
+     */
     function isStruct($array) {
-        /* Nasty function to check if an array is a struct or not */
         $expected = 0;
-        foreach ($array as $key => $value) {
-            if ((string)$key != (string)$expected) {
+        foreach($array as $key => $value) {
+            if((string) $key != (string) $expected) {
                 return true;
             }
             $expected++;
@@ -120,18 +171,25 @@
     }
 }
 
-
+/**
+ * IXR_MESSAGE
+ *
+ * @package IXR
+ * @since 1.5
+ *
+ */
 class IXR_Message {
     var $message;
-    var $messageType;  // methodCall / methodResponse / fault
+    var $messageType; // methodCall / methodResponse / fault
     var $faultCode;
     var $faultString;
     var $methodName;
     var $params;
+
     // Current variable stacks
-    var $_arraystructs = array();   // The stack used to keep track of the current array/struct
+    var $_arraystructs = array(); // The stack used to keep track of the current array/struct
     var $_arraystructstypes = array(); // Stack keeping track of if things are structs or array
-    var $_currentStructName = array();  // A stack as well
+    var $_currentStructName = array(); // A stack as well
     var $_param;
     var $_value;
     var $_currentTag;
@@ -139,12 +197,23 @@
     var $_lastseen;
     // The XML parser
     var $_parser;
-    function IXR_Message ($message) {
-        $this->message = $message;
+
+    /**
+     * @param string $message
+     */
+    function __construct($message) {
+        $this->message =& $message;
     }
+
+    /**
+     * @return bool
+     */
     function parse() {
         // first remove the XML declaration
-        $this->message = preg_replace('/<\?xml(.*)?\?'.'>/', '', $this->message);
+        // merged from WP #10698 - this method avoids the RAM usage of preg_replace on very large messages
+        $header = preg_replace('/<\?xml.*?\?' . '>/', '', substr($this->message, 0, 100), 1);
+        $this->message = substr_replace($this->message, $header, 0, 100);
+
         // workaround for a bug in PHP/libxml2, see http://bugs.php.net/bug.php?id=45996
         $this->message = str_replace('&lt;', '&#60;', $this->message);
         $this->message = str_replace('&gt;', '&#62;', $this->message);
@@ -152,7 +221,7 @@
         $this->message = str_replace('&apos;', '&#39;', $this->message);
         $this->message = str_replace('&quot;', '&#34;', $this->message);
         $this->message = str_replace("\x0b", ' ', $this->message); //vertical tab
-        if (trim($this->message) == '') {
+        if(trim($this->message) == '') {
             return false;
         }
         $this->_parser = xml_parser_create();
@@ -162,23 +231,40 @@
         xml_set_object($this->_parser, $this);
         xml_set_element_handler($this->_parser, 'tag_open', 'tag_close');
         xml_set_character_data_handler($this->_parser, 'cdata');
-        if (!xml_parse($this->_parser, $this->message)) {
-            /* die(sprintf('XML error: %s at line %d',
-                xml_error_string(xml_get_error_code($this->_parser)),
-                xml_get_current_line_number($this->_parser))); */
-            return false;
-        }
+        $chunk_size = 262144; // 256Kb, parse in chunks to avoid the RAM usage on very large messages
+        $final = false;
+        do {
+            if(strlen($this->message) <= $chunk_size) {
+                $final = true;
+            }
+            $part = substr($this->message, 0, $chunk_size);
+            $this->message = substr($this->message, $chunk_size);
+            if(!xml_parse($this->_parser, $part, $final)) {
+                return false;
+            }
+            if($final) {
+                break;
+            }
+        } while(true);
         xml_parser_free($this->_parser);
+
         // Grab the error messages, if any
-        if ($this->messageType == 'fault') {
+        if($this->messageType == 'fault') {
             $this->faultCode = $this->params[0]['faultCode'];
             $this->faultString = $this->params[0]['faultString'];
         }
         return true;
     }
+
+    /**
+     * @param $parser
+     * @param string $tag
+     * @param $attr
+     */
     function tag_open($parser, $tag, $attr) {
-        $this->currentTag = $tag;
         $this->_currentTagContents = '';
+        $this->_currentTag = $tag;
+
         switch($tag) {
             case 'methodCall':
             case 'methodResponse':
@@ -186,7 +272,7 @@
                 $this->messageType = $tag;
                 break;
             /* Deal with stacks of arrays and structs */
-            case 'data':    // data is to all intents and puposes more interesting than array
+            case 'data': // data is to all intents and purposes more interesting than array
                 $this->_arraystructstypes[] = 'array';
                 $this->_arraystructs[] = array();
                 break;
@@ -197,50 +283,53 @@
         }
         $this->_lastseen = $tag;
     }
+
+    /**
+     * @param $parser
+     * @param string $cdata
+     */
     function cdata($parser, $cdata) {
         $this->_currentTagContents .= $cdata;
     }
+
+    /**
+     * @param $parser
+     * @param $tag
+     */
     function tag_close($parser, $tag) {
+        $value = null;
         $valueFlag = false;
         switch($tag) {
             case 'int':
             case 'i4':
-                $value = (int)trim($this->_currentTagContents);
-                $this->_currentTagContents = '';
+                $value = (int) trim($this->_currentTagContents);
                 $valueFlag = true;
                 break;
             case 'double':
-                $value = (double)trim($this->_currentTagContents);
-                $this->_currentTagContents = '';
+                $value = (double) trim($this->_currentTagContents);
                 $valueFlag = true;
                 break;
             case 'string':
-                $value = (string)$this->_currentTagContents;
-                $this->_currentTagContents = '';
+                $value = (string) $this->_currentTagContents;
                 $valueFlag = true;
                 break;
             case 'dateTime.iso8601':
                 $value = new IXR_Date(trim($this->_currentTagContents));
-                // $value = $iso->getTimestamp();
-                $this->_currentTagContents = '';
                 $valueFlag = true;
                 break;
             case 'value':
                 // "If no type is indicated, the type is string."
-                if($this->_lastseen == 'value'){
-                    $value = (string)$this->_currentTagContents;
-                    $this->_currentTagContents = '';
+                if($this->_lastseen == 'value') {
+                    $value = (string) $this->_currentTagContents;
                     $valueFlag = true;
                 }
                 break;
             case 'boolean':
-                $value = (boolean)trim($this->_currentTagContents);
-                $this->_currentTagContents = '';
+                $value = (boolean) trim($this->_currentTagContents);
                 $valueFlag = true;
                 break;
             case 'base64':
                 $value = base64_decode($this->_currentTagContents);
-                $this->_currentTagContents = '';
                 $valueFlag = true;
                 break;
             /* Deal with stacks of arrays and structs */
@@ -255,75 +344,94 @@
                 break;
             case 'name':
                 $this->_currentStructName[] = trim($this->_currentTagContents);
-                $this->_currentTagContents = '';
                 break;
             case 'methodName':
                 $this->methodName = trim($this->_currentTagContents);
-                $this->_currentTagContents = '';
                 break;
         }
-        if ($valueFlag) {
-            /*
-            if (!is_array($value) && !is_object($value)) {
-                $value = trim($value);
-            }
-            */
-            if (count($this->_arraystructs) > 0) {
+
+        if($valueFlag) {
+            if(count($this->_arraystructs) > 0) {
                 // Add value to struct or array
-                if ($this->_arraystructstypes[count($this->_arraystructstypes)-1] == 'struct') {
+                if($this->_arraystructstypes[count($this->_arraystructstypes) - 1] == 'struct') {
                     // Add to struct
-                    $this->_arraystructs[count($this->_arraystructs)-1][$this->_currentStructName[count($this->_currentStructName)-1]] = $value;
+                    $this->_arraystructs[count($this->_arraystructs) - 1][$this->_currentStructName[count($this->_currentStructName) - 1]] = $value;
                 } else {
                     // Add to array
-                    $this->_arraystructs[count($this->_arraystructs)-1][] = $value;
+                    $this->_arraystructs[count($this->_arraystructs) - 1][] = $value;
                 }
             } else {
-                // Just add as a paramater
+                // Just add as a parameter
                 $this->params[] = $value;
             }
         }
+        $this->_currentTagContents = '';
         $this->_lastseen = $tag;
     }
 }
 
-
+/**
+ * IXR_Server
+ *
+ * @package IXR
+ * @since 1.5
+ */
 class IXR_Server {
     var $data;
+    /** @var array */
     var $callbacks = array();
     var $message;
+    /** @var array */
     var $capabilities;
-    function IXR_Server($callbacks = false, $data = false) {
+
+    /**
+     * @param array|bool $callbacks
+     * @param bool $data
+     * @param bool $wait
+     */
+    function __construct($callbacks = false, $data = false, $wait = false) {
         $this->setCapabilities();
-        if ($callbacks) {
+        if($callbacks) {
             $this->callbacks = $callbacks;
         }
         $this->setCallbacks();
-        $this->serve($data);
+
+        if(!$wait) {
+            $this->serve($data);
+        }
     }
+
+    /**
+     * @param bool|string $data
+     */
     function serve($data = false) {
-        if (!$data) {
+        if(!$data) {
 
             $postData = trim(http_get_raw_post_data());
-            if (!$postData) {
+            if(!$postData) {
+                header('Content-Type: text/plain'); // merged from WP #9093
                 die('XML-RPC server accepts POST requests only.');
             }
             $data = $postData;
         }
         $this->message = new IXR_Message($data);
-        if (!$this->message->parse()) {
+        if(!$this->message->parse()) {
             $this->error(-32700, 'parse error. not well formed');
         }
-        if ($this->message->messageType != 'methodCall') {
+        if($this->message->messageType != 'methodCall') {
             $this->error(-32600, 'server error. invalid xml-rpc. not conforming to spec. Request must be a methodCall');
         }
         $result = $this->call($this->message->methodName, $this->message->params);
+
         // Is the result an error?
-        if (is_a($result, 'IXR_Error')) {
+        if(is_a($result, 'IXR_Error')) {
             $this->error($result);
         }
+
         // Encode the result
         $r = new IXR_Value($result);
         $resultxml = $r->getXml();
+
         // Create the XML
         $xml = <<<EOD
 <methodResponse>
@@ -340,16 +448,23 @@
         // Send it
         $this->output($xml);
     }
+
+    /**
+     * @param string $methodname
+     * @param array $args
+     * @return IXR_Error|mixed
+     */
     function call($methodname, $args) {
-        if (!$this->hasMethod($methodname)) {
-            return new IXR_Error(-32601, 'server error. requested method '.$methodname.' does not exist.');
+        if(!$this->hasMethod($methodname)) {
+            return new IXR_Error(-32601, 'server error. requested method ' . $methodname . ' does not exist.');
         }
         $method = $this->callbacks[$methodname];
+
         // Perform the callback and send the response
 
         # Removed for DokuWiki to have a more consistent interface
         #        if (count($args) == 1) {
-        #            // If only one paramater just send that instead of the whole array
+        #            // If only one parameter just send that instead of the whole array
         #            $args = $args[0];
         #        }
 
@@ -359,16 +474,16 @@
         $args = (array) $args;
 
         // Are we dealing with a function or a method?
-        if (substr($method, 0, 5) == 'this:') {
+        if(is_string($method) && substr($method, 0, 5) == 'this:') {
             // It's a class method - check it exists
             $method = substr($method, 5);
-            if (!method_exists($this, $method)) {
-                return new IXR_Error(-32601, 'server error. requested class method "'.$method.'" does not exist.');
+            if(!method_exists($this, $method)) {
+                return new IXR_Error(-32601, 'server error. requested class method "' . $method . '" does not exist.');
             }
             // Call the method
             #$result = $this->$method($args);
-            $result = call_user_func_array(array(&$this,$method),$args);
-        } elseif (substr($method, 0, 7) == 'plugin:') {
+            $result = call_user_func_array(array(&$this, $method), $args);
+        } elseif(substr($method, 0, 7) == 'plugin:') {
             list($pluginname, $callback) = explode(':', substr($method, 7), 2);
             if(!plugin_isdisabled($pluginname)) {
                 $plugin = plugin_load('action', $pluginname);
@@ -378,31 +493,49 @@
             }
         } else {
             // It's a function - does it exist?
-            if (!function_exists($method)) {
-                return new IXR_Error(-32601, 'server error. requested function "'.$method.'" does not exist.');
+            if(is_array($method)) {
+                if(!is_callable(array($method[0], $method[1]))) {
+                    return new IXR_Error(-32601, 'server error. requested object method "' . $method[1] . '" does not exist.');
+                }
+            } else if(!function_exists($method)) {
+                return new IXR_Error(-32601, 'server error. requested function "' . $method . '" does not exist.');
             }
+
             // Call the function
-            #$result = $method($args);
-            $result = call_user_func_array($method,$args);
+            $result = call_user_func($method, $args);
         }
         return $result;
     }
 
+    /**
+     * @param int $error
+     * @param string|bool $message
+     */
     function error($error, $message = false) {
         // Accepts either an error object or an error code and message
-        if ($message && !is_object($error)) {
+        if($message && !is_object($error)) {
             $error = new IXR_Error($error, $message);
         }
         $this->output($error->getXml());
     }
+
+    /**
+     * @param string $xml
+     */
     function output($xml) {
         header('Content-Type: text/xml; charset=utf-8');
         echo '<?xml version="1.0"?>', "\n", $xml;
         exit;
     }
+
+    /**
+     * @param string $method
+     * @return bool
+     */
     function hasMethod($method) {
         return in_array($method, array_keys($this->callbacks));
     }
+
     function setCapabilities() {
         // Initialises capabilities array
         $this->capabilities = array(
@@ -420,31 +553,45 @@
             ),
         );
     }
+
+    /**
+     * @return mixed
+     */
     function getCapabilities() {
         return $this->capabilities;
     }
+
     function setCallbacks() {
         $this->callbacks['system.getCapabilities'] = 'this:getCapabilities';
         $this->callbacks['system.listMethods'] = 'this:listMethods';
         $this->callbacks['system.multicall'] = 'this:multiCall';
     }
+
+    /**
+     * @return array
+     */
     function listMethods() {
         // Returns a list of methods - uses array_reverse to ensure user defined
         // methods are listed before server defined methods
         return array_reverse(array_keys($this->callbacks));
     }
+
+    /**
+     * @param array $methodcalls
+     * @return array
+     */
     function multiCall($methodcalls) {
         // See http://www.xmlrpc.com/discuss/msgReader$1208
         $return = array();
-        foreach ($methodcalls as $call) {
+        foreach($methodcalls as $call) {
             $method = $call['methodName'];
             $params = $call['params'];
-            if ($method == 'system.multicall') {
+            if($method == 'system.multicall') {
                 $result = new IXR_Error(-32800, 'Recursive calls to system.multicall are forbidden');
             } else {
                 $result = $this->call($method, $params);
             }
-            if (is_a($result, 'IXR_Error')) {
+            if(is_a($result, 'IXR_Error')) {
                 $return[] = array(
                     'faultCode' => $result->code,
                     'faultString' => $result->message
@@ -457,11 +604,25 @@
     }
 }
 
+/**
+ * IXR_Request
+ *
+ * @package IXR
+ * @since 1.5
+ */
 class IXR_Request {
+    /** @var string */
     var $method;
+    /** @var array */
     var $args;
+    /** @var string */
     var $xml;
-    function IXR_Request($method, $args) {
+
+    /**
+     * @param string $method
+     * @param array $args
+     */
+    function __construct($method, $args) {
         $this->method = $method;
         $this->args = $args;
         $this->xml = <<<EOD
@@ -471,7 +632,7 @@
 <params>
 
 EOD;
-        foreach ($this->args as $arg) {
+        foreach($this->args as $arg) {
             $this->xml .= '<param><value>';
             $v = new IXR_Value($arg);
             $this->xml .= $v->getXml();
@@ -479,15 +640,28 @@
         }
         $this->xml .= '</params></methodCall>';
     }
+
+    /**
+     * @return int
+     */
     function getLength() {
         return strlen($this->xml);
     }
+
+    /**
+     * @return string
+     */
     function getXml() {
         return $this->xml;
     }
 }
 
 /**
+ * IXR_Client
+ *
+ * @package IXR
+ * @since 1.5
+ *
  * Changed for DokuWiki to use DokuHTTPClient
  *
  * This should be compatible to the original class, but uses DokuWiki's
@@ -498,19 +672,34 @@
  */
 class IXR_Client extends DokuHTTPClient {
     var $posturl = '';
+    /** @var IXR_Message|bool */
     var $message = false;
+
+    // Storage place for an error message
+    /** @var IXR_Error|bool */
     var $xmlerror = false;
 
-    function IXR_Client($server, $path = false, $port = 80) {
+    /**
+     * @param string $server
+     * @param string|bool $path
+     * @param int $port
+     * @param int $timeout
+     */
+    function __construct($server, $path = false, $port = 80, $timeout = 15) {
         parent::__construct();
-        if (!$path) {
+        if(!$path) {
             // Assume we have been given a URL instead
             $this->posturl = $server;
-        }else{
-            $this->posturl = 'http://'.$server.':'.$port.$path;
+        } else {
+            $this->posturl = 'http://' . $server . ':' . $port . $path;
         }
+        $this->timeout = $timeout;
     }
 
+    /**
+     * parameters: method and arguments
+     * @return bool success or error
+     */
     function query() {
         $args = func_get_args();
         $method = array_shift($args);
@@ -518,55 +707,87 @@
         $xml = $request->getXml();
 
         $this->headers['Content-Type'] = 'text/xml';
-        if(!$this->sendRequest($this->posturl,$xml,'POST')){
-            $this->xmlerror = new IXR_Error(-32300, 'transport error - '.$this->error);
+        if(!$this->sendRequest($this->posturl, $xml, 'POST')) {
+            $this->xmlerror = new IXR_Error(-32300, 'transport error - ' . $this->error);
             return false;
         }
 
         // Check HTTP Response code
-        if($this->status < 200 || $this->status > 206){
-            $this->xmlerror = new IXR_Error(-32300, 'transport error - HTTP status '.$this->status);
+        if($this->status < 200 || $this->status > 206) {
+            $this->xmlerror = new IXR_Error(-32300, 'transport error - HTTP status ' . $this->status);