Added missing header to Makefile.am.

The non _T are deprecated.

Signed-off-by: Rosen Penev <rosenp@gmail.com>

.clang-format

@@ -0,0 +1,33 @@
+---
+BasedOnStyle: LLVM
+Standard: c++14
+
+AllowShortFunctionsOnASingleLine: All
+AllowShortLambdasOnASingleLine: All
+AlwaysBreakAfterReturnType: TopLevelDefinitions
+BinPackArguments: false
+BinPackParameters: false
+BreakConstructorInitializers: AfterColon
+BreakStringLiterals: false
+ColumnLimit: 0
+ContinuationIndentWidth: 2
+IndentCaseLabels: false
+IndentWidth: 2
+PenaltyReturnTypeOnItsOwnLine: 130
+PointerAlignment: Left
+
+AlignEscapedNewlines: Right
+AlignConsecutiveDeclarations:
+  Enabled: true
+  AcrossEmptyLines: true
+  AcrossComments: false
+AlignConsecutiveMacros:
+  Enabled: true
+AlignConsecutiveAssignments:
+  Enabled: true
+
+IncludeCategories:
+  - Regex: "^(config|globals)\\.h"
+    Priority: -1
+  - Regex: "^torrent/.*"
+    Priority: 1

.clang-tidy

@@ -0,0 +1,16 @@
+---
+Checks: '-*,readability-identifier-naming'
+FormatStyle: 'file'
+CheckOptions:
+  - key: readability-identifier-naming.LocalVariableCase
+    value: lower_case
+  - key: readability-identifier-naming.ParameterCase
+    value: lower_case
+  - key: readability-identifier-naming.FunctionCase
+    value: lower_case
+  - key: readability-identifier-naming.PrivateMemberPrefix
+    value: m_
+  - key: readability-identifier-naming.PrivateMemberCase
+    value: lower_case
+  - key: readability-identifier-naming.ClassConstantCase
+    value: lower_case

.dir-locals.el

@@ -0,0 +1,7 @@
+;;; Directory Local Variables
+;;; For more information see (info "(emacs) Directory Variables")
+
+((c++-mode
+  (flycheck-clang-language-standard . "c++11")
+  (flycheck-gcc-language-standard . "c++11")))
+

.github/FUNDING.yml

@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github: [rakshasa]
+patreon: rtorrent
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+custom: ['https://rakshasa.github.io/rtorrent/donate.html']

.github/workflows/post-static-analysis.yml

@@ -0,0 +1,96 @@
+# Secure workflow with access to repository secrets and GitHub token for posting analysis results
+name: Post the static analysis results
+
+on:
+  workflow_run:
+    workflows: [ "Static analysis" ]
+    types: [ completed ]
+
+jobs:
+  clang-tidy-results:
+    # Trigger the job only if the previous (insecure) workflow completed successfully
+    if: ${{ github.event.workflow_run.event == 'pull_request' && github.event.workflow_run.conclusion == 'success' }}
+    runs-on: ubuntu-22.04
+    permissions:
+      pull-requests: write
+      # OPTIONAL: auto-closing conversations requires the `contents` permission
+      contents: write
+    steps:
+    - name: Sleep for 30 seconds
+      run: sleep 30s
+      shell: bash
+    - name: Download analysis results
+      uses: actions/github-script@v7
+      with:
+        script: |
+          const artifacts = await github.rest.actions.listWorkflowRunArtifacts({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              run_id: ${{ github.event.workflow_run.id }},
+          });
+          const matchArtifact = artifacts.data.artifacts.filter((artifact) => {
+              return artifact.name == "clang-tidy-result"
+          })[0];
+          const download = await github.rest.actions.downloadArtifact({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              artifact_id: matchArtifact.id,
+              archive_format: "zip",
+          });
+          const fs = require("fs");
+          fs.writeFileSync("${{ github.workspace }}/clang-tidy-result.zip", Buffer.from(download.data));
+    - name: Extract analysis results
+      run: |
+        mkdir clang-tidy-result
+        unzip -j clang-tidy-result.zip -d clang-tidy-result
+    - name: Set environment variables
+      uses: actions/github-script@v7
+      with:
+        script: |
+          const assert = require("node:assert").strict;
+          const fs = require("fs");
+          function exportVar(varName, fileName, regEx) {
+              const val = fs.readFileSync("${{ github.workspace }}/clang-tidy-result/" + fileName, {
+                  encoding: "ascii"
+              }).trimEnd();
+              assert.ok(regEx.test(val), "Invalid value format for " + varName);
+              core.exportVariable(varName, val);
+          }
+          exportVar("PR_ID", "pr-id.txt", /^[0-9]+$/);
+          exportVar("PR_HEAD_REPO", "pr-head-repo.txt", /^[-./0-9A-Z_a-z]+$/);
+          exportVar("PR_HEAD_SHA", "pr-head-sha.txt", /^[0-9A-Fa-f]+$/);
+    - uses: actions/checkout@v4
+      with:
+        repository: ${{ env.PR_HEAD_REPO }}
+        ref: ${{ env.PR_HEAD_SHA }}
+        persist-credentials: false
+    - name: Redownload analysis results
+      uses: actions/github-script@v7
+      with:
+        script: |
+          const artifacts = await github.rest.actions.listWorkflowRunArtifacts({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              run_id: ${{ github.event.workflow_run.id }},
+          });
+          const matchArtifact = artifacts.data.artifacts.filter((artifact) => {
+              return artifact.name == "clang-tidy-result"
+          })[0];
+          const download = await github.rest.actions.downloadArtifact({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              artifact_id: matchArtifact.id,
+              archive_format: "zip",
+          });
+          const fs = require("fs");
+          fs.writeFileSync("${{ github.workspace }}/clang-tidy-result.zip", Buffer.from(download.data));
+    - name: Extract analysis results
+      run: |
+        mkdir clang-tidy-result
+        unzip -j clang-tidy-result.zip -d clang-tidy-result
+    - name: Run clang-tidy-pr-comments action
+      uses: platisd/clang-tidy-pr-comments@v1
+      with:
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        clang_tidy_fixes: clang-tidy-result/fixes.yml
+        pull_request_id: ${{ env.PR_ID }}

.github/workflows/static-analysis.yml

@@ -0,0 +1,80 @@
+name: Static analysis
+
+on: pull_request
+
+jobs:
+
+  clang-tidy:
+    runs-on: ubuntu-22.04
+
+    steps:
+    - name: Update Packages
+      run: |
+        sudo apt-get update
+    - name: Fetch libtorrent
+      run: |
+        git clone https://github.com/rakshasa/libtorrent
+    - name: Build libtorrent
+      run: |
+        cd libtorrent
+        libtoolize
+        aclocal -I scripts
+        autoconf -i
+        autoheader
+        automake --add-missing
+        ./configure
+        make
+        sudo make install
+        cd ..
+        rm -rf libtorrent
+    - uses: actions/checkout@v4
+      with:
+        ref: ${{ github.event.pull_request.head.sha }}
+        fetch-depth: 0
+    - name: Fetch base branch
+      run: |
+        git remote add upstream "https://github.com/${{ github.event.pull_request.base.repo.full_name }}"
+        git fetch --no-tags --no-recurse-submodules upstream "${{ github.event.pull_request.base.ref }}"
+    - name: Install Dependencies
+      run: |
+        sudo apt-get install -y bear clang-tidy libcurl4-openssl-dev
+    - name: Configure Project
+      run: |
+        libtoolize
+        aclocal -I scripts
+        autoconf -i
+        autoheader
+        automake --add-missing
+        ./configure
+    - name: Prepare compile_commands.json
+      run: |
+        bear -- make
+    - name: Create results directory
+      run: |
+        mkdir clang-tidy-result
+    - name: Analyze
+      run: |
+        git diff -U0 "$(git merge-base HEAD "upstream/${{ github.event.pull_request.base.ref }}")" | clang-tidy-diff -p1 -path build -export-fixes clang-tidy-result/fixes.yml "-extra-arg=-include/${PWD}/config.h"
+    - name: Save PR metadata
+      run: |
+        echo "${{ github.event.number }}" > clang-tidy-result/pr-id.txt
+        echo "${{ github.event.pull_request.head.repo.full_name }}" > clang-tidy-result/pr-head-repo.txt
+        echo "${{ github.event.pull_request.head.sha }}" > clang-tidy-result/pr-head-sha.txt
+    - uses: actions/upload-artifact@v4
+      with:
+        name: clang-tidy-result
+        path: clang-tidy-result/
+    # - name: Run clang-tidy-pr-comments action
+    #   uses: platisd/clang-tidy-pr-comments@v1
+    #   with:
+    #     # The GitHub token (or a personal access token)
+    #     github_token: ${{ secrets.GITHUB_TOKEN }}
+    #     # The path to the clang-tidy fixes generated previously
+    #     clang_tidy_fixes: clang-tidy-result/fixes.yml
+    #     # Optionally set to true if you want the Action to request
+    #     # changes in case warnings are found
+    #     request_changes: true
+    #     # Optionally set the number of comments per review
+    #     # to avoid GitHub API timeouts for heavily loaded
+    #     # pull requests
+    #     suggestions_per_comment: 10

.github/workflows/unit-tests.yml

@@ -0,0 +1,56 @@
+name: Static analysis
+
+on: pull_request
+
+jobs:
+
+  unit-tests:
+    runs-on: ubuntu-22.04
+
+    steps:
+    - name: Update Packages
+      run: |
+        sudo apt-get update
+    - name: Fetch libtorrent
+      run: |
+        git clone https://github.com/rakshasa/libtorrent
+    - name: Build libtorrent
+      run: |
+        cd libtorrent
+        libtoolize
+        aclocal -I scripts
+        autoconf -i
+        autoheader
+        automake --add-missing
+        ./configure
+        make
+        sudo make install
+        cd ..
+        rm -rf libtorrent
+    - uses: actions/checkout@v4
+      with:
+        ref: ${{ github.event.pull_request.head.sha }}
+        fetch-depth: 0
+    - name: Fetch base branch
+      run: |
+        git remote add upstream "https://github.com/${{ github.event.pull_request.base.repo.full_name }}"
+        git fetch --no-tags --no-recurse-submodules upstream "${{ github.event.pull_request.base.ref }}"
+    - name: Install Dependencies
+      run: |
+        sudo apt-get install -y \
+          libcppunit-dev \
+          libcurl4-openssl-dev
+    - name: Configure Project
+      run: |
+        libtoolize
+        aclocal -I scripts
+        autoconf -i
+        autoheader
+        automake --add-missing
+        ./configure
+    - name: Build Project
+      run: |
+        make
+    - name: Run Unit Tests
+      run: |
+        make check

.gitignore

@@ -0,0 +1,72 @@
+# Compiled source #
+###################
+*.o
+*.lo
+*.a
+*.la
+*.so
+*.in
+*.sub
+*.pc
+*.orig
+*.rej
+
+# Autoconf files #
+##################
+
+.deps
+.libs
+Makefile
+aclocal.m4
+ar-lib
+autom4te.cache
+compile
+config.h
+config.guess
+config.status
+confdefs.h
+conftest.dir
+configure
+depcomp
+install-sh
+libtool
+ltmain.sh
+missing
+stamp-h1
+
+src/rtorrent
+scripts/libtool.m4
+scripts/lt*.m4
+
+# Editor poo #
+##############
+.#*
+\#*#
+*~
+
+# Packages #
+############
+# it's better to unpack these files and commit the raw source
+# git has its own built in compression methods
+*.gz
+*.tar
+*.zip
+
+# Logs and databases #
+######################
+*.log
+
+# OS generated files #
+######################
+.DS_Store?
+.dirstamp
+ehthumbs.db
+Icon?
+Thumbs.db
+TAGS
+
+# rTorrent specific files
+###########################
+src/rtorrent
+test/rtorrent_Test*
+test-driver

.travis.yml

@@ -0,0 +1,85 @@
+language: cpp
+
+env:
+  global:
+    - MAKEFLAGS="-j 12"
+
+matrix:
+  include:
+  - compiler: clang
+    env: COMPILER=clang++ SKIP_CHECK=true
+  - compiler: clang
+    env: COMPILER=clang++
+    addons:
+      apt:
+        packages:
+        - libcppunit-dev
+  - compiler: clang
+    env: COMPILER=clang++-3.6
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-precise-3.6
+        packages:
+        - clang-3.6
+        - libcppunit-dev
+  - compiler: clang
+    env: COMPILER=clang++-3.7
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-precise-3.7
+        packages:
+        - clang-3.7
+        - libcppunit-dev
+  - compiler: clang
+    env: COMPILER=clang++-3.8
+    addons:
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        - llvm-toolchain-precise-3.8
+        packages:
+        - clang-3.8
+        - libcppunit-dev
+  - compiler: gcc
+    env: COMPILER=g++-4.7 SKIP_CHECK=true
+    addons:
+      apt:
+        sources: ubuntu-toolchain-r-test
+        packages:
+        - g++-4.7
+  - compiler: gcc
+    env: COMPILER=g++-4.7
+    addons:
+      apt:
+        sources: ubuntu-toolchain-r-test
+        packages:
+        - g++-4.7
+        - libcppunit-dev
+  - compiler: gcc
+    env: COMPILER=g++-4.8
+    addons:
+      apt:
+        sources: ubuntu-toolchain-r-test
+        packages:
+        - g++-4.8
+        - libcppunit-dev
+
+# TODO: Use the same branch name if libtorrent has it.
+before_install:
+ - git clone https://github.com/rakshasa/libtorrent.git
+ - |
+   pushd libtorrent \
+   && (git checkout ${TRAVIS_BRANCH} || true) \
+   && ./autogen.sh \
+   && CXX="$COMPILER" ./configure --prefix=/usr \
+   && make \
+   && sudo make install \
+   && popd
+
+script:
+- ./autogen.sh && CXX="$COMPILER" ./configure && make
+- if [ ! $SKIP_CHECK ]; then make check; fi

AUTHORS

@@ -0,0 +1 @@
+Jari Sundell <sundell.software@gmail.com>

CNAME

@@ -1 +0,0 @@
-rtorrent.net

COPYING

@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year  name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

INSTALL

@@ -0,0 +1,368 @@
+Installation Instructions
+*************************
+
+   Copyright (C) 1994-1996, 1999-2002, 2004-2016 Free Software
+Foundation, Inc.
+
+   Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.  This file is offered as-is,
+without warranty of any kind.
+
+Basic Installation
+==================
+
+   Briefly, the shell command './configure && make && make install'
+should configure, build, and install this package.  The following
+more-detailed instructions are generic; see the 'README' file for
+instructions specific to this package.  Some packages provide this
+'INSTALL' file but do not implement all of the features documented
+below.  The lack of an optional feature in a given package is not
+necessarily a bug.  More recommendations for GNU packages can be found
+in *note Makefile Conventions: (standards)Makefile Conventions.
+
+   The 'configure' shell script attempts to guess correct values for
+various system-dependent variables used during compilation.  It uses
+those values to create a 'Makefile' in each directory of the package.
+It may also create one or more '.h' files containing system-dependent
+definitions.  Finally, it creates a shell script 'config.status' that
+you can run in the future to recreate the current configuration, and a
+file 'config.log' containing compiler output (useful mainly for
+debugging 'configure').
+
+   It can also use an optional file (typically called 'config.cache' and
+enabled with '--cache-file=config.cache' or simply '-C') that saves the
+results of its tests to speed up reconfiguring.  Caching is disabled by
+default to prevent problems with accidental use of stale cache files.
+
+   If you need to do unusual things to compile the package, please try
+to figure out how 'configure' could check whether to do them, and mail
+diffs or instructions to the address given in the 'README' so they can
+be considered for the next release.  If you are using the cache, and at
+some point 'config.cache' contains results you don't want to keep, you
+may remove or edit it.
+
+   The file 'configure.ac' (or 'configure.in') is used to create
+'configure' by a program called 'autoconf'.  You need 'configure.ac' if
+you want to change it or regenerate 'configure' using a newer version of
+'autoconf'.
+
+   The simplest way to compile this package is:
+
+  1. 'cd' to the directory containing the package's source code and type
+     './configure' to configure the package for your system.
+
+     Running 'configure' might take a while.  While running, it prints
+     some messages telling which features it is checking for.
+
+  2. Type 'make' to compile the package.
+
+  3. Optionally, type 'make check' to run any self-tests that come with
+     the package, generally using the just-built uninstalled binaries.
+
+  4. Type 'make install' to install the programs and any data files and
+     documentation.  When installing into a prefix owned by root, it is
+     recommended that the package be configured and built as a regular
+     user, and only the 'make install' phase executed with root
+     privileges.
+
+  5. Optionally, type 'make installcheck' to repeat any self-tests, but
+     this time using the binaries in their final installed location.
+     This target does not install anything.  Running this target as a
+     regular user, particularly if the prior 'make install' required
+     root privileges, verifies that the installation completed
+     correctly.
+
+  6. You can remove the program binaries and object files from the
+     source code directory by typing 'make clean'.  To also remove the
+     files that 'configure' created (so you can compile the package for
+     a different kind of computer), type 'make distclean'.  There is
+     also a 'make maintainer-clean' target, but that is intended mainly
+     for the package's developers.  If you use it, you may have to get
+     all sorts of other programs in order to regenerate files that came
+     with the distribution.
+
+  7. Often, you can also type 'make uninstall' to remove the installed
+     files again.  In practice, not all packages have tested that
+     uninstallation works correctly, even though it is required by the
+     GNU Coding Standards.
+
+  8. Some packages, particularly those that use Automake, provide 'make
+     distcheck', which can by used by developers to test that all other
+     targets like 'make install' and 'make uninstall' work correctly.
+     This target is generally not run by end users.
+
+Compilers and Options
+=====================
+
+   Some systems require unusual options for compilation or linking that
+the 'configure' script does not know about.  Run './configure --help'
+for details on some of the pertinent environment variables.
+
+   You can give 'configure' initial values for configuration parameters
+by setting variables in the command line or in the environment.  Here is
+an example:
+
+     ./configure CC=c99 CFLAGS=-g LIBS=-lposix
+
+   *Note Defining Variables::, for more details.
+
+Compiling For Multiple Architectures
+====================================
+
+   You can compile the package for more than one kind of computer at the
+same time, by placing the object files for each architecture in their
+own directory.  To do this, you can use GNU 'make'.  'cd' to the
+directory where you want the object files and executables to go and run
+the 'configure' script.  'configure' automatically checks for the source
+code in the directory that 'configure' is in and in '..'.  This is known
+as a "VPATH" build.
+
+   With a non-GNU 'make', it is safer to compile the package for one
+architecture at a time in the source code directory.  After you have
+installed the package for one architecture, use 'make distclean' before
+reconfiguring for another architecture.
+
+   On MacOS X 10.5 and later systems, you can create libraries and
+executables that work on multiple system types--known as "fat" or
+"universal" binaries--by specifying multiple '-arch' options to the
+compiler but only a single '-arch' option to the preprocessor.  Like
+this:
+
+     ./configure CC="gcc -arch i386 -arch x86_64 -arch ppc -arch ppc64" \
+                 CXX="g++ -arch i386 -arch x86_64 -arch ppc -arch ppc64" \
+                 CPP="gcc -E" CXXCPP="g++ -E"
+
+   This is not guaranteed to produce working output in all cases, you
+may have to build one architecture at a time and combine the results
+using the 'lipo' tool if you have problems.
+
+Installation Names
+==================
+
+   By default, 'make install' installs the package's commands under
+'/usr/local/bin', include files under '/usr/local/include', etc.  You
+can specify an installation prefix other than '/usr/local' by giving
+'configure' the option '--prefix=PREFIX', where PREFIX must be an
+absolute file name.
+
+   You can specify separate installation prefixes for
+architecture-specific files and architecture-independent files.  If you
+pass the option '--exec-prefix=PREFIX' to 'configure', the package uses
+PREFIX as the prefix for installing programs and libraries.
+Documentation and other data files still use the regular prefix.
+
+   In addition, if you use an unusual directory layout you can give
+options like '--bindir=DIR' to specify different values for particular
+kinds of files.  Run 'configure --help' for a list of the directories
+you can set and what kinds of files go in them.  In general, the default
+for these options is expressed in terms of '${prefix}', so that
+specifying just '--prefix' will affect all of the other directory
+specifications that were not explicitly provided.
+
+   The most portable way to affect installation locations is to pass the
+correct locations to 'configure'; however, many packages provide one or
+both of the following shortcuts of passing variable assignments to the
+'make install' command line to change installation locations without
+having to reconfigure or recompile.
+
+   The first method involves providing an override variable for each
+affected directory.  For example, 'make install
+prefix=/alternate/directory' will choose an alternate location for all
+directory configuration variables that were expressed in terms of
+'${prefix}'.  Any directories that were specified during 'configure',
+but not in terms of '${prefix}', must each be overridden at install time
+for the entire installation to be relocated.  The approach of makefile
+variable overrides for each directory variable is required by the GNU
+Coding Standards, and ideally causes no recompilation.  However, some
+platforms have known limitations with the semantics of shared libraries
+that end up requiring recompilation when using this method, particularly
+noticeable in packages that use GNU Libtool.
+
+   The second method involves providing the 'DESTDIR' variable.  For
+example, 'make install DESTDIR=/alternate/directory' will prepend
+'/alternate/directory' before all installation names.  The approach of
+'DESTDIR' overrides is not required by the GNU Coding Standards, and
+does not work on platforms that have drive letters.  On the other hand,
+it does better at avoiding recompilation issues, and works well even
+when some directory options were not specified in terms of '${prefix}'
+at 'configure' time.
+
+Optional Features
+=================
+
+   If the package supports it, you can cause programs to be installed
+with an extra prefix or suffix on their names by giving 'configure' the
+option '--program-prefix=PREFIX' or '--program-suffix=SUFFIX'.
+
+   Some packages pay attention to '--enable-FEATURE' options to
+'configure', where FEATURE indicates an optional part of the package.
+They may also pay attention to '--with-PACKAGE' options, where PACKAGE
+is something like 'gnu-as' or 'x' (for the X Window System).  The
+'README' should mention any '--enable-' and '--with-' options that the
+package recognizes.
+
+   For packages that use the X Window System, 'configure' can usually
+find the X include and library files automatically, but if it doesn't,
+you can use the 'configure' options '--x-includes=DIR' and
+'--x-libraries=DIR' to specify their locations.
+
+   Some packages offer the ability to configure how verbose the
+execution of 'make' will be.  For these packages, running './configure
+--enable-silent-rules' sets the default to minimal output, which can be
+overridden with 'make V=1'; while running './configure
+--disable-silent-rules' sets the default to verbose, which can be
+overridden with 'make V=0'.
+
+Particular systems
+==================
+
+   On HP-UX, the default C compiler is not ANSI C compatible.  If GNU CC
+is not installed, it is recommended to use the following options in
+order to use an ANSI C compiler:
+
+     ./configure CC="cc -Ae -D_XOPEN_SOURCE=500"
+
+and if that doesn't work, install pre-built binaries of GCC for HP-UX.
+
+   HP-UX 'make' updates targets which have the same time stamps as their
+prerequisites, which makes it generally unusable when shipped generated
+files such as 'configure' are involved.  Use GNU 'make' instead.
+
+   On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot
+parse its '<wchar.h>' header file.  The option '-nodtk' can be used as a
+workaround.  If GNU CC is not installed, it is therefore recommended to
+try
+
+     ./configure CC="cc"
+
+and if that doesn't work, try
+
+     ./configure CC="cc -nodtk"
+
+   On Solaris, don't put '/usr/ucb' early in your 'PATH'.  This
+directory contains several dysfunctional programs; working variants of
+these programs are available in '/usr/bin'.  So, if you need '/usr/ucb'
+in your 'PATH', put it _after_ '/usr/bin'.
+
+   On Haiku, software installed for all users goes in '/boot/common',
+not '/usr/local'.  It is recommended to use the following options:
+
+     ./configure --prefix=/boot/common
+
+Specifying the System Type
+==========================
+
+   There may be some features 'configure' cannot figure out
+automatically, but needs to determine by the type of machine the package
+will run on.  Usually, assuming the package is built to be run on the
+_same_ architectures, 'configure' can figure that out, but if it prints
+a message saying it cannot guess the machine type, give it the
+'--build=TYPE' option.  TYPE can either be a short name for the system
+type, such as 'sun4', or a canonical name which has the form:
+
+     CPU-COMPANY-SYSTEM
+
+where SYSTEM can have one of these forms:
+
+     OS
+     KERNEL-OS
+
+   See the file 'config.sub' for the possible values of each field.  If
+'config.sub' isn't included in this package, then this package doesn't
+need to know the machine type.
+
+   If you are _building_ compiler tools for cross-compiling, you should
+use the option '--target=TYPE' to select the type of system they will
+produce code for.
+
+   If you want to _use_ a cross compiler, that generates code for a
+platform different from the build platform, you should specify the
+"host" platform (i.e., that on which the generated programs will
+eventually be run) with '--host=TYPE'.
+
+Sharing Defaults
+================
+
+   If you want to set default values for 'configure' scripts to share,
+you can create a site shell script called 'config.site' that gives
+default values for variables like 'CC', 'cache_file', and 'prefix'.
+'configure' looks for 'PREFIX/share/config.site' if it exists, then
+'PREFIX/etc/config.site' if it exists.  Or, you can set the
+'CONFIG_SITE' environment variable to the location of the site script.
+A warning: not all 'configure' scripts look for a site script.
+
+Defining Variables
+==================
+
+   Variables not defined in a site shell script can be set in the
+environment passed to 'configure'.  However, some packages may run
+configure again during the build, and the customized values of these
+variables may be lost.  In order to avoid this problem, you should set
+them in the 'configure' command line, using 'VAR=value'.  For example:
+
+     ./configure CC=/usr/local2/bin/gcc
+
+causes the specified 'gcc' to be used as the C compiler (unless it is
+overridden in the site shell script).
+
+Unfortunately, this technique does not work for 'CONFIG_SHELL' due to an
+Autoconf limitation.  Until the limitation is lifted, you can use this
+workaround:
+
+     CONFIG_SHELL=/bin/bash ./configure CONFIG_SHELL=/bin/bash
+
+'configure' Invocation
+======================
+
+   'configure' recognizes the following options to control how it
+operates.
+
+'--help'
+'-h'
+     Print a summary of all of the options to 'configure', and exit.
+
+'--help=short'
+'--help=recursive'
+     Print a summary of the options unique to this package's
+     'configure', and exit.  The 'short' variant lists options used only
+     in the top level, while the 'recursive' variant lists options also
+     present in any nested packages.
+
+'--version'
+'-V'
+     Print the version of Autoconf used to generate the 'configure'
+     script, and exit.
+
+'--cache-file=FILE'
+     Enable the cache: use and save the results of the tests in FILE,
+     traditionally 'config.cache'.  FILE defaults to '/dev/null' to
+     disable caching.
+
+'--config-cache'
+'-C'
+     Alias for '--cache-file=config.cache'.
+
+'--quiet'
+'--silent'
+'-q'
+     Do not print messages saying which checks are being made.  To
+     suppress all normal output, redirect it to '/dev/null' (any error
+     messages will still be shown).
+
+'--srcdir=DIR'
+     Look for the package's source code in directory DIR.  Usually
+     'configure' can determine that directory automatically.
+
+'--prefix=DIR'
+     Use DIR as the installation prefix.  *note Installation Names:: for
+     more details, including other options available for fine-tuning the
+     installation locations.
+
+'--no-create'
+'-n'
+     Run the configure checks, but stop before creating any output
+     files.
+
+'configure' also accepts some other, not widely useful, options.  Run
+'configure --help' for more details.

Makefile.am

@@ -0,0 +1,23 @@
+SUBDIRS = \
+	doc \
+	src \
+	test
+
+EXTRA_DIST= \
+	rtorrent.lua \
+	rak/address_info.h \
+	rak/algorithm.h \
+	rak/error_number.h \
+	rak/file_stat.h \
+	rak/fs_stat.h \
+	rak/path.h \
+	rak/partial_queue.h \
+	rak/regex.h \
+	rak/socket_address.h \
+	rak/string_manip.h \
+	rak/unordered_vector.h \
+	scripts/checks.m4 \
+	scripts/common.m4 \
+	scripts/attributes.m4
+
+ACLOCAL_AMFLAGS = -I scripts

README

@@ -0,0 +1,41 @@
+BUILDING
+
+ Run "aclocal -I scripts && autoconf -i && autoheader && automake --add-missing"
+to generate the configure scripts if necessary. The man page "doc/rtorrent.1"
+must be generated with "docbook2man rtorrent.1.xml" if it is missing.
+
+ Note that rtorrent follows the development of libtorrent closely, and
+thus the versions must be in sync. This should not be nessesary in the
+future, when the library API stabilizes.
+
+USAGE
+
+ See the man page or website for instructions.
+
+LICENSE
+
+ GNU GPL, see COPYING. "libtorrent/src/utils/sha_fast.{cc,h}" is
+originally from the Mozilla NSS and is under a triple license; MPL,
+LGPL and GPL. An exception to non-NSS code has been added for linking
+to OpenSSL as requested by Debian, though the author considers that
+library to be part of the Operative System and thus linking is allowed
+according to the GPL.
+
+ Use whatever fits your purpose, the code required to compile with
+Mozilla's NSS implementation of SHA1 has been retained and can be
+compiled if the user wishes to avoid using OpenSSL.
+
+DEPENDENCIES
+
+  libcurl >= 7.12.0
+  ncurses
+
+CONTACT
+
+ Jari Sundell
+
+ Skomakerveien 33
+ 3185 Skoppum, NORWAY
+
+ Send bug reports, suggestions and patches to
+<sundell.software@gmail.com> or to the mailinglist.

README.md

@@ -1,4 +1,6 @@
-RTorrent
+[![Donate](https://rakshasa.github.io/rtorrent/donate_paypal_green.svg)](https://paypal.me/jarisundelljp)
+
+RTorrent BitTorrent Client
 ========
 
 Introduction
@@ -6,19 +8,17 @@ Introduction
 
 To learn how to use rTorrent visit the [Wiki](https://github.com/rakshasa/rtorrent/wiki).
 
-[Donate](https://rakshasa.github.io/rtorrent/donate.html) to help fund the development of this client.
-
 Stable
 ------
 
- * [libtorrent-0.16.11.tar.gz](https://github.com/rakshasa/rtorrent-archive/raw/master/libtorrent-0.16.11.tar.gz)
- * [rtorrent-0.16.11.tar.gz](https://github.com/rakshasa/rtorrent-archive/raw/master/rtorrent-0.16.11.tar.gz)
+ * [https://github.com/rakshasa/rtorrent-archive/raw/master/libtorrent-0.13.8.tar.gz](https://github.com/rakshasa/rtorrent-archive/raw/master/libtorrent-0.13.8.tar.gz)
+ * [https://github.com/rakshasa/rtorrent-archive/raw/master/rtorrent-0.9.8.tar.gz](https://github.com/rakshasa/rtorrent-archive/raw/master/rtorrent-0.9.8.tar.gz)
 
-Development
------------
+Unstable
+------
 
- * [libtorrent-0.16.13.tar.gz](https://github.com/rakshasa/rtorrent-archive/raw/master/libtorrent-0.16.13.tar.gz)
- * [rtorrent-0.16.13.tar.gz](https://github.com/rakshasa/rtorrent-archive/raw/master/rtorrent-0.16.13.tar.gz)
+ * [https://github.com/rakshasa/rtorrent-archive/raw/master/libtorrent-0.14.0.tar.gz](https://github.com/rakshasa/rtorrent-archive/raw/master/libtorrent-0.14.0.tar.gz)
+ * [https://github.com/rakshasa/rtorrent-archive/raw/master/rtorrent-0.10.0.tar.gz](https://github.com/rakshasa/rtorrent-archive/raw/master/rtorrent-0.10.0.tar.gz)
 
 Related Projects
 ----------------
@@ -36,4 +36,5 @@ Donate to rTorrent development
  * Litecoin: LdyaVR67LBnTf6mAT4QJnjSG2Zk67qxmfQ
  * Cardano: addr1qytaslmqmk6dspltw06sp0zf83dh09u79j49ceh5y26zdcccgq4ph7nmx6kgmzeldauj43254ey97f3x4xw49d86aguqwfhlte
 
+
 Help keep rTorrent development going by donating to its creator.

_config.yml

@@ -1,8 +0,0 @@
-title: Rtorrent
-description: rTorrent BitTorrent client
-google_analytics: 
-show_downloads: true
-theme: jekyll-theme-minimal
-
-gems:
-  - jekyll-mentions

configure.ac

@@ -0,0 +1,91 @@
+m4_pattern_allow([PKG_CHECK_EXISTS])
+
+AC_INIT([rtorrent],[0.15.4],[sundell.software@gmail.com])
+
+AC_CONFIG_HEADERS([config.h])
+AC_CONFIG_MACRO_DIRS([scripts])
+AM_INIT_AUTOMAKE([foreign subdir-objects])
+AM_PROG_AR
+
+LT_INIT
+
+AC_PROG_CXX
+AC_DEFINE([API_VERSION], [14], [api version])
+
+# Filter out unwanted flags added by autoconf on some systems, e.g. MacOS.
+TORRENT_REMOVE_UNWANTED(CXX, $CXX, -std=c++11 -std=gnu++11)
+
+AX_CXX_COMPILE_STDCXX([17], [noext], [mandatory])
+
+AC_SYS_LARGEFILE
+
+RAK_CHECK_CFLAGS
+RAK_CHECK_CXXFLAGS
+RAK_ENABLE_DEBUG
+RAK_ENABLE_EXTRA_DEBUG
+RAK_ENABLE_WERROR
+
+TORRENT_DISABLE_IPV6
+
+TORRENT_ENABLE_ARCH
+TORRENT_WITH_SYSROOT
+
+TORRENT_WITHOUT_VARIABLE_FDSET
+TORRENT_WITHOUT_STATVFS
+TORRENT_WITHOUT_STATFS
+
+AC_ARG_ENABLE(execinfo,
+  AS_HELP_STRING([--disable-execinfo],
+    [disable libexecinfo [[default=enable]]]),
+  [
+    if test "$enableval" = "yes"; then
+      AX_EXECINFO
+    fi
+  ],[
+    AX_EXECINFO
+  ])
+
+AX_PTHREAD([], AC_MSG_ERROR([requires pthread]))
+AX_WITH_CURSES
+
+if test "x$ax_cv_ncursesw" != xyes && test "x$ax_cv_ncurses" != xyes; then
+  AC_MSG_ERROR([requires either NcursesW or Ncurses library])
+fi
+
+PKG_CHECK_MODULES([LIBCURL], [libcurl],, [LIBCURL_CHECK_CONFIG])
+PKG_CHECK_MODULES([CPPUNIT], [cppunit],, [no_cppunit="yes"])
+PKG_CHECK_MODULES([DEPENDENCIES], [libtorrent >= 0.15.4])
+
+AC_LANG_PUSH(C++)
+TORRENT_WITH_XMLRPC_C
+AC_LANG_POP(C++)
+
+TORRENT_WITH_LUA
+TORRENT_WITH_TINYXML2
+
+if test ${with_xmlrpc_c+y} && test ${with_xmlrpc_tinyxml2+y}; then
+  AC_MSG_ERROR([--with-xmlrpc-c and --with-xmlrpc-tinyxml2 cannot be used together. Please choose only one])
+fi
+
+AC_DEFINE(HAVE_CONFIG_H, 1, true if config.h was included)
+AC_DEFINE(USER_AGENT, [std::string(PACKAGE "/" VERSION "/") + torrent::version()], Http user agent)
+
+AC_CHECK_FUNCS(posix_memalign)
+
+dnl Only update global build variables immediately before generating the output,
+dnl to avoid affecting the global build environment for other autoconf checks.
+LIBS="$PTHREAD_LIBS $CURSES_LIB $CURSES_LIBS $LIBCURL $LIBCURL_LIBS $DEPENDENCIES_LIBS $LIBS"
+CFLAGS="$CFLAGS $PTHREAD_CFLAGS $LIBCURL_CPPFLAGS $LIBCURL_CFLAGS $DEPENDENCIES_CFLAGS $CURSES_CFLAGS"
+CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS $LIBCURL_CPPFLAGS $LIBCURL_CFLAGS $DEPENDENCIES_CFLAGS $CURSES_CFLAGS"
+
+TORRENT_CHECK_CACHELINE()
+TORRENT_CHECK_POPCOUNT()
+
+AC_CONFIG_FILES([
+  Makefile
+  doc/Makefile
+  src/Makefile
+  test/Makefile
+])
+
+AC_OUTPUT

confirmation.md

@@ -1,4 +0,0 @@
-Reddit
-======
-
-Yes, I'm 'rasatsu'.

doc/Makefile.am

@@ -0,0 +1,2 @@
+EXTRA_DIST= \
+	rtorrent.rc

doc/debugging

@@ -0,0 +1,11 @@
+=== Dumping core files on mac ==
+
+ulimit -c unlimited
+sysctl kern.corefile
+
+
+schedule = log_vmmap,5,600,"execute_nothrow=/Users/rakshasa/trunk/rtorrent/doc/log_vmmap.sh,\"$cat=/Users/rakshasa/Downloads/session/vmmap.system.,$system.pid="; log.vmmap.dump=\"$cat=/Users/rakshasa/Downloads/session/vmmap.rtorrent.,$system.pid=\""
+
+log.vmmap.dump="$cat=/Users/rakshasa/Downloads/session/vmmap.rtorrent.,$system.pid="
+
+print="$cat=/Users/rakshasa/Downloads/session/vmmap.rtorrent.,$system.pid="

doc/faq.xml

@@ -0,0 +1,106 @@
+<!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook V4.1//EN">
+
+<article>
+  <title>rTorrent Frequently Asked Questions</title>
+
+  <para>
+    This is the user FAQ for Rakshasa's BitTorrent client. RTorrent is
+    an ncurses based client that uses libTorrent and is written in
+    C++. Efficiency and good code is the main goal of both projects.
+  </para>
+
+  <qandaset>
+    <qandaentry>
+      <question><para>
+        How do I add new torrents while the client is running?
+      </para></question>
+      <answer><para>
+        Use the backspace key to enter file input mode. The bottom
+        line will change into a prompt which allows you to enter URL's
+        or file paths to torrents. File name completion and directory
+        listing is supported with the tab key.
+      </para></answer>
+    </qandaentry>
+
+    <qandaentry>
+      <question><para>
+        I got the message "Could not create download, failed to parse the bencoded data" when adding a torrent, what does it mean?
+      </para></question>
+      <answer><para>
+        The torrent data the library received was not a valid torrent
+        file. If this was a direct http download, try downloading the
+        torrent file and add it manually. This usually happens when
+        the torrent link uses some form of redirection that libcurl
+        does not automatically redirect. If the failure still happens,
+        make sure the file is infact an uncorrupted torrent.
+      </para></answer>
+    </qandaentry>
+
+    <qandaentry>
+      <question><para>
+        How does the session feature work?
+      </para></question>
+      <answer><para>
+        When you start the client you can use the "-s" switch to
+        specify a session directory. The client will save all
+        currently running torrents in the session directory and fast
+        resume data will be written when the client exits. Upon
+        restarting the client it will resume all the torrents in the
+        session directory.
+      </para></answer>
+    </qandaentry>
+
+    <qandaentry>
+      <question><para>
+        How do i query the tracker for more peers?
+      </para></question>
+      <answer><para>
+        Go into the download view screen and press 't' to initiate a
+        new tracker request. If the tracker requires a minimum timeout
+        between requests you can override this by using the capital
+        'T'. Don't abuse this feature.
+      </para></answer>
+    </qandaentry>
+
+    <qandaentry>
+      <question><para>
+        Why do I sometimes need to press ctrl-Q twice to exit the client?
+      </para></question>
+      <answer><para>
+        The first time you press ctrl-q you initiate the
+        shutdown. This causes rTorrent to send a stop message to the
+        trackers of each torrent, and if the tracker is slow it might
+        take more than a few seconds or until the requests time
+        out. The second time ctrl-q is pressed forces the client to
+        shutdown.
+      </para></answer>
+    </qandaentry>
+
+    <qandaentry>
+      <question><para>
+        It doesn't help how much i press ctrl-q, it still won't quit.
+      </para></question>
+      <answer><para>
+        Perhaps your terminal sends a different key-code to the
+        application. There's no configuration files for keys yet, so
+        modify rtorrent/src/ui/root.cc:56 to use whatever key you want
+        for quitting.
+      </para></answer>
+    </qandaentry>
+
+    <qandaentry>
+      <question><para>
+        When I try downloading a torrent the client aborts (SIGABRT), what should I do?
+      </para></question>
+      <answer><para>
+        Make sure you arn't using "-fomit-frame-pointer" when
+        compiling libtorrent and rtorrent, this is known to produce
+        bad code for C++ exception handling. If this doesn't help, run
+        the client in gdb and use "bt -20" to get a backtrace. Send
+        this with a bug report.
+      </para></answer>
+    </qandaentry>
+
+  </qandaset>
+
+</article>

doc/log_proc_vmmap.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+cat /proc/$PPID/maps > $1

doc/log_rtorrent.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+args=($@)
+echo "${args[@]:1}" >> $1

doc/log_stats.plot

@@ -0,0 +1,149 @@
+#/bin/bash
+gnuplot << EOF
+# 1)  system.time_seconds=
+#
+# 2)  throttle.global_up.rate
+# 3)  throttle.global_up.total
+# 4)  throttle.global_down.rate
+# 5)  throttle.global_down.total
+#
+# 6)  pieces.memory.current
+# 7)  pieces.memory.sync_queue
+# 8)  pieces.memory.block_count
+# 9)  pieces.stats.total_size
+# 10) pieces.hash.queue_size
+#
+# file.append = (cat,/foo/bandwidth_stats.,(system.pid)),"timestamp","\"upload rate\"","\"upload total\"","\"download rate\"","\"download total\"","\"memory usage\"","\"sync queue\"","\"block count\"","\"total size\"","\"hash queue size\""
+# schedule = log_bandwidth_stats,5,10,((file.append,((cat,/foo/bandwidth_stats.,((system.pid)))),((system.time_seconds)),((throttle.global_up.rate)),((throttle.global_up.total)),((throttle.global_down.rate)),((throttle.global_down.total)),((pieces.memory.current)),((pieces.memory.sync_queue)),((pieces.memory.block_count)),((pieces.stats.total_size)),((pieces.hash.queue_size))))
+#
+# 1) system.time_seconds
+#
+# 2) throttle.unchoked_uploads
+# 3) throttle.unchoked_downloads
+# 4) network.open_sockets
+#
+# 5) view.size,leeching
+# 6) view.size,seeding
+# 7) view.size,active
+#
+# file.append = (cat,/foo/peer_stats.,(system.pid)),"timestamp","\"upload unchoked\"","\"download unchoked\"","\"open sockets\"","leeching","seeding","active"
+# schedule = log_peer_stats,5,10,((file.append,((cat,/foo/peer_stats.,((system.pid)))),((system.time_seconds)),((throttle.unchoked_uploads)),((throttle.unchoked_downloads)),((network.open_sockets)),((view.size,leeching)),((view.size,seeding)),((view.size,active))))
+#
+# Choke groups:
+#
+# file.append = (cat,/foo/choke_group_stats.,(system.pid)),"timestamp",\
+# "\"default up unchoked\"","\"default up queued\"","\"default up rate\"",\
+# "\"default down unchoked\"","\"default down queued\"","\"default down rate\"","\"default torrents\"",\
+# "\"leech up unchoked\"","\"leech up queued\"","\"leech up rate\"",\
+# "\"leech down unchoked\"","\"leech down queued\"","\"leech down rate\"","\"leech torrents\"",\
+# "\"seed boost up unchoked\"","\"seed boost up queued\"","\"seed boost up rate\"",\
+# "\"seed boost down unchoked\"","\"seed boost down queued\"","\"seed boost down rate\"","\"seed boost torrents\"",\
+# "\"seed up unchoked\"","\"seed up queued\"","\"seed up rate\"",\
+# "\"seed down unchoked\"","\"seed down queued\"","\"seed down rate\"","\"seed torrents\""
+#
+# schedule = log_choke_group_stats,5,10,((file.append,((cat,/foo/choke_group_stats.,((system.pid)))),((system.time_seconds)),\
+# ((choke_group.up.unchoked,0)),((choke_group.up.queued,0)),((choke_group.up.rate,0)),((choke_group.down.unchoked,0)),((choke_group.down.queued,0)),((choke_group.down.rate,0)),((choke_group.size,0)),\
+# ((choke_group.up.unchoked,1)),((choke_group.up.queued,1)),((choke_group.up.rate,1)),((choke_group.down.unchoked,1)),((choke_group.down.queued,1)),((choke_group.down.rate,1)),((choke_group.size,1)),\
+# ((choke_group.up.unchoked,2)),((choke_group.up.queued,2)),((choke_group.up.rate,2)),((choke_group.down.unchoked,2)),((choke_group.down.queued,2)),((choke_group.down.rate,2)),((choke_group.size,2)),\
+# ((choke_group.up.unchoked,3)),((choke_group.up.queued,3)),((choke_group.up.rate,3)),((choke_group.down.unchoked,3)),((choke_group.down.queued,3)),((choke_group.down.rate,3)),((choke_group.size,3)) ))
+#
+# Mincore stats:
+#
+# file.append = (cat,/foo/mincore_stats.,(system.pid)),"timestamp","\"incore cont. /10s\"","\"not incore cont. /10s\"","\"incore new /10s\"","\"not incore new /10s\"","\"incore break /10s\"","\"sync success /10s\"","\"sync failed /10s\"","\"sync not synced /10s\"","\"sync not deallocated /10s\"","\"alloc failed /10s\"","\"allocate velocity /10s\"","\"deallocate velocity /10s\""
+# log.libtorrent = mincore_stats,(cat,"/foo/mincore_stats.",(system.pid))
+
+
+set terminal png size 1024,768 enhanced
+#set terminal png size 2*1024,768 enhanced
+set xdata time
+set timefmt "%s"
+set format x "%H:%M"
+set format y2 "%.0f"
+set y2tics
+set autoscale xfix
+set key autotitle columnhead
+
+set output "output_$1_sockets.png"
+plot "peer_stats.$1" using 1:7 smooth sbezier with lines lw 4,\
+     "peer_stats.$1" using 1:5 smooth sbezier with lines lw 4,\
+     "peer_stats.$1" using 1:6 smooth sbezier with lines lw 4,\
+     "<awk '{x=1000; if (\$4 < 1000) x=\$4; print \$1,x}' peer_stats.$1" using 1:2 smooth sbezier with lines title "open sockets" lw 2 axis x1y2,\
+     "peer_stats.$1" using 1:2 smooth sbezier with lines lw 2 axis x1y2,\
+     "peer_stats.$1" using 1:3 smooth sbezier with lines lw 2 axis x1y2
+
+set output "output_$1_groups.png"
+plot "choke_group_stats.$1" \
+        using 1:8     smooth sbezier with lines lw 4,\
+     "" using 1:8+7*1 smooth sbezier with lines lw 4,\
+     "" using 1:8+7*2 smooth sbezier with lines lw 4,\
+     "" using 1:8+7*3 smooth sbezier with lines lw 4\
+
+
+set format y "%.0s %cb"
+
+set output "output_$1_bandwidth.png"
+plot "bandwidth_stats.$1" using 1:2 smooth sbezier with lines lw 4,\
+     "bandwidth_stats.$1" using 1:4 smooth sbezier with lines lw 4,\
+     "choke_group_stats.$1" using 1:4+7*1 smooth sbezier with lines lw 3,\
+     "choke_group_stats.$1" using 1:7+7*1 smooth sbezier with lines lw 3,\
+     "choke_group_stats.$1" using 1:4+7*2 smooth sbezier with lines lw 3,\
+     "choke_group_stats.$1" using 1:4+7*3 smooth sbezier with lines lw 3,\
+     "peer_stats.$1" using 1:2 smooth sbezier with lines lw 2 axis x1y2,\
+     "peer_stats.$1" using 1:3 smooth sbezier with lines lw 2 axis x1y2
+
+set output "output_$1_memory.png"
+plot "bandwidth_stats.$1" using 1:6 smooth sbezier with lines lw 4 axis x1y1,\
+     "peer_stats.$1" using 1:2 smooth sbezier with lines lw 2 axis x1y2,\
+     "peer_stats.$1" using 1:3 smooth sbezier with lines lw 2 axis x1y2
+
+#set yrange [0:3900000000.0]
+#set y2range [0:2000]
+
+set output "output_$1_pieces.png"
+plot "bandwidth_stats.$1" using 1:6   smooth sbezier with lines lw 4 axis x1y1,\
+     "bandwidth_stats.$1" using 1:7   smooth sbezier with lines lw 4 axis x1y1,\
+     "<awk '{x=\$12*10; print \$1,x}' mincore_stats.$1" using 1:2 smooth sbezier with lines lw 4 title 'alloc /100s' axis x1y1,\
+     "<awk '{x=\$13*10; print \$1,x}' mincore_stats.$1" using 1:2 smooth sbezier with lines lw 4 title 'dealloc /100s' axis x1y1,\
+     "mincore_stats.$1"   using 1:7   smooth sbezier with lines lw 2 axis x1y2,\
+     "mincore_stats.$1"   using 1:8   smooth sbezier with lines lw 2 axis x1y2,\
+     "mincore_stats.$1"   using 1:11  smooth sbezier with lines lw 2 axis x1y2,\
+     "<awk '{x=\$8/10; print \$1,x}'  bandwidth_stats.$1" using 1:2 smooth sbezier with lines lw 2 title 'block count /10' axis x1y2,\
+     "bandwidth_stats.$1" using 1:10  smooth sbezier with lines lw 2 axis x1y2
+
+#set yrange [*:*]
+#set y2range [*:*]
+
+set format y2 "%.0s %cb"
+set output "output_$1_torrents.png"
+plot "bandwidth_stats.$1" using 1:6 smooth sbezier with lines lw 4 axis x1y1,\
+     "bandwidth_stats.$1" using 1:9 smooth sbezier with lines lw 2 axis x1y2
+
+set format y "%.0f"
+set format y2 "%.0f"
+
+set output "output_$1_incore.png"
+#plot "bandwidth_stats.$1" using 1:(0) smooth sbezier with lines,
+plot \
+     "mincore_stats.$1" using 1:2 smooth sbezier with lines lw 2 axis x1y1,\
+     "mincore_stats.$1" using 1:3 smooth sbezier with lines lw 4 axis x1y2,\
+     "mincore_stats.$1" using 1:4 smooth sbezier with lines lw 2 axis x1y1,\
+     "mincore_stats.$1" using 1:5 smooth sbezier with lines lw 4 axis x1y2
+
+#
+# Updated:
+#
+
+set output "output_$1_choke.png"
+set style histogram columnstacked
+
+plot "choke_group_stats.$1" \
+        using 1:2+7*1 smooth sbezier with lines lw 2 axis x1y2,\
+     "" using 1:3+7*1 smooth sbezier with lines lw 2 axis x1y2,\
+     "" using 1:5+7*1 smooth sbezier with lines lw 2 axis x1y2,\
+     "" using 1:6+7*1 smooth sbezier with lines lw 2 axis x1y2,\
+     "" using 1:2+7*2 smooth sbezier with lines lw 2 axis x1y2,\
+     "" using 1:3+7*2 smooth sbezier with lines lw 2 axis x1y2,\
+     "" using 1:2+7*3 smooth sbezier with lines lw 2 axis x1y2,\
+     "" using 1:3+7*3 smooth sbezier with lines lw 2 axis x1y2
+
+EOF

doc/log_vmmap.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+vmmap -interleaved $PPID > $1

doc/manual/choke_groups.md

@@ -0,0 +1,28 @@
+# Choke Groups
+
+## Settings
+
+    choke_group.insert = "leech_fast"
+
+Create a new group named "leech_fast", accessible by the string or
+index / reverse index according to order of insertion. E.g. '-1'
+refers to the last inserted choke group, while 0 refers to the first.
+
+All commands that applies to a group requires the first argument to be
+the index, reverse index or the group name.
+
+    choke_group.tracker.mode.set = -1,"aggressive"
+
+Set the tracker mode for torrents in this group.
+
+    choke_group.up.heuristics.set = -1,"upload_leech_experimental"
+    choke_group.down.heuristics.set = -1,"download_leech"
+
+Set the heuristics used when deciding on which peers to choke and
+unchoke. Use "strings.choke_heuristics{,.upload,.download}" to get a
+list of the available heuristics.
+
+    choke_group.up.max.set = -1,250
+    choke_group.down.max.set = -1,500
+
+Set the max total number of unchoked peers for all torrents in this choke group.

doc/manual/ip_filtering.md

@@ -0,0 +1,64 @@
+# IP filtering
+
+## Introduction
+
+## Make a new ip table
+
+    ip_tables.insert_table = <table_name>
+
+Create a new empty table with the name ’table\_name’, with the default
+value returned being $0$.
+
+There is currently no use of the generic ip tables commands.
+
+## Add a new address block
+
+    ip_tables.add_address = <table_name>, 10.0.0.0/8, <value>
+
+Set <value\> for all addresses in the address block, overwriting prior
+values.
+
+## Add a new address block
+
+    ip_tables.load = <table_name>, ~/foo.txt, <value>
+
+Set <value\> for all addresses in the file ’foo.txt’ separated by
+newline, similar to ’add\_address’.
+
+## Get value for address
+
+    ip_tables.get = <table_name>, 10.10.10.10
+
+Returns the value set for an address, or the address block it belongs
+to. The default is $0$.
+
+## Size of data structures
+
+    ip_tables.size_data = <table_name>
+
+Returns the size in bytes of all data structures for this table,
+excluding the root class object itself. Note that the in-memory table is
+dynamically consolidated, as such memory use will always be based on
+actual fragmentation.
+
+The table is a b-tree with 1024 nodes per branch.
+
+## IPv4 filtering table
+
+    ipv4_filter.add_address = 10.0.0.0/8, unwanted
+    ipv4_filter.add_address = 11.0.0.0/8, preferred
+    ipv4_filter.load = ~/filters.txt, unwanted
+    ipv4_filter.get = 10.10.10.10
+    ipv4_filter.size_data =
+
+The main ip filter, currently supporting ’unwanted’ (do not allow
+connections) and ’preferred’ (currently used only in private code).
+
+## Constants
+
+    strings.ip_filter =
+    =>
+    { "unwanted",  PeerInfo::flag_unwanted },
+    { "preferred", PeerInfo::flag_preferred },
+
+Constants used by ipv4\_filter values.

doc/manual/ip_filtering.tex

@@ -0,0 +1,85 @@
+\section{IP filtering}
+
+\subsection{Introduction}
+
+\subsection{Make a new ip table}
+
+\begin{verbatim}
+ip_tables.insert_table = <table_name>
+\end{verbatim}
+
+Create a new empty table with the name 'table\_name', with the default
+value returned being $0$.
+
+There is currently no use of the generic ip tables commands.
+
+
+\subsection{Add a new address block}
+
+\begin{verbatim}
+ip_tables.add_address = <table_name>, 10.0.0.0/8, <value>
+\end{verbatim}
+
+Set <value> for all addresses in the address block, overwriting prior
+values.
+
+
+\subsection{Add a new address block}
+
+\begin{verbatim}
+ip_tables.load = <table_name>, ~/foo.txt, <value>
+\end{verbatim}
+
+Set <value> for all addresses in the file 'foo.txt' separated by
+newline, similar to 'add\_address'.
+
+
+\subsection{Get value for address}
+
+\begin{verbatim}
+ip_tables.get = <table_name>, 10.10.10.10
+\end{verbatim}
+
+Returns the value set for an address, or the address block it belongs
+to. The default is $0$.
+
+
+\subsection{Size of data structures}
+
+\begin{verbatim}
+ip_tables.size_data = <table_name>
+\end{verbatim}
+
+Returns the size in bytes of all data structures for this table,
+excluding the root class object itself. Note that the in-memory table
+is dynamically consolidated, as such memory use will always be based
+on actual fragmentation.
+
+The table is a b-tree with 1024 nodes per branch.
+
+
+\subsection{IPv4 filtering table}
+
+\begin{verbatim}
+ipv4_filter.add_address = 10.0.0.0/8, unwanted
+ipv4_filter.add_address = 11.0.0.0/8, preferred
+ipv4_filter.load = ~/filters.txt, unwanted
+ipv4_filter.get = 10.10.10.10
+ipv4_filter.size_data =
+\end{verbatim}
+
+The main ip filter, currently supporting 'unwanted' (do not allow
+connections) and 'preferred' (currently used only in private code).
+
+
+
+\subsection{Constants}
+
+\begin{verbatim}
+strings.ip_filter =
+=>
+{ "unwanted",  PeerInfo::flag_unwanted },
+{ "preferred", PeerInfo::flag_preferred },
+\end{verbatim}
+
+Constants used by ipv4_filter values.

doc/manual/logging.md

@@ -0,0 +1,50 @@
+# Logging
+
+## Opening log files
+
+    # log.open_file = "log name", "file path"
+
+    log.open_file = "rtorrent.log", (cat,/tmp/rtorrent.log.,(system.pid))  
+
+A newly opened log file is not connected to any logging events.
+
+Some control over formatting will be provided at a later date.
+
+## Adding outputs to events
+
+    # log.add_output = "logging event", "log name"
+
+    log.add_output = "info", "rtorrent.log"
+
+    log.add_output = "dht_debug", "tracker.log"
+    log.add_output = "tracker_debug", "tracker.log"
+
+Each log handle can be added to multiple different logging events.
+
+## Logging events
+
+    "critical"
+    "error"
+    "warn"
+    "notice"
+    "info"
+    "debug"
+
+The above events receive logging events from all the sub-groups
+displayed below, and each event also reciving events from the event
+above in importance.
+
+Thus some high-volume sub-group events such as “tracker\_debug” are not
+part of “debug” and every “warn” event will receive events from “error”,
+“critical”.
+
+    "connection_*"
+    "dht_*"
+    "peer_*"
+    "rpc_*"
+    "storage_*"
+    "thread_*"
+    "tracker_*"
+    "torrent_*"
+
+All sub-groups have events from “critical” to “debug” defined.

doc/manual/logging.tex

@@ -0,0 +1,61 @@
+\section{Logging}
+
+\subsection{Opening log files}
+
+\begin{verbatim}
+# log.open_file = "log name", "file path"
+
+log.open_file = "rtorrent.log", (cat,/tmp/rtorrent.log.,(system.pid))  
+\end{verbatim}
+
+A newly opened log file is not connected to any logging events.
+
+Some control over formatting will be provided at a later date.
+
+
+\subsection{Adding outputs to events}
+
+\begin{verbatim}
+# log.add_output = "logging event", "log name"
+
+log.add_output = "info", "rtorrent.log"
+
+log.add_output = "dht_debug", "tracker.log"
+log.add_output = "tracker_debug", "tracker.log"
+\end{verbatim}
+
+Each log handle can be added to multiple different logging events.
+
+
+\subsection{Logging events}
+
+\begin{verbatim}
+"critical"
+"error"
+"warn"
+"notice"
+"info"
+"debug"
+\end{verbatim}
+
+The above events receive logging events from all the sub-groups
+displayed below, and each event also reciving events from the event
+above in importance.
+
+Thus some high-volume sub-group events such as ``tracker\_debug'' are
+not part of ``debug'' and every ``warn'' event will receive events
+from ``error'', ``critical''.
+
+\begin{verbatim}
+"connection_*"
+"dht_*"
+"peer_*"
+"rpc_*"
+"storage_*"
+"thread_*"
+"tracker_*"
+"torrent_*"
+\end{verbatim}
+
+All sub-groups have events from ``critical'' to ``debug'' defined.
+

doc/old/rtorrent.1

@@ -0,0 +1,559 @@
+.\" This manpage has been automatically generated by docbook2man 
+.\" from a DocBook document.  This tool can be found at:
+.\" <http://shell.ipoline.com/~elmert/comp/docbook2X/> 
+.\" Please send any bug reports, improvements, comments, patches, 
+.\" etc. to Steve Cheng <steve@ggi-project.org>.
+.TH "RTORRENT" "1" "14 May 2009" "BitTorrent client for ncurses" ""
+
+.SH NAME
+rtorrent \- a BitTorrent client for ncurses
+.SH SYNOPSIS
+
+\fBrtorrent\fR [ \fB-h\fR ] [ \fB-n\fR ] [ \fB-o key1=opt1,...\fR ] [ \fB-O key=opt\fR ] [ \fBURL | FILE\fR\fI ...\fR ]
+
+.SH "DESCRIPTION"
+.PP
+\fBrtorrent\fR is a BitTorrent client for ncurses, using
+the \fBlibtorrent\fR library. The client and library is
+written in C++ with emphasis on speed and efficiency, while delivering
+equivalent features to those found in GUI based clients in an ncurses
+client.
+.PP
+Most of the options below have their own default unit in addition to
+supporting B, K, M and G suffixes.
+.SH "KEYBOARD CONTROL"
+.PP
+.SS "GLOBAL KEYS"
+.TP
+\fB^q\fR
+Initiate shutdown, press again to force the shutdown and
+skip sending the stop signal to trackers.
+.TP
+\fBup | down | left | right arrow keys\fR
+.TP
+\fB^P | ^N | ^B | ^F\fR
+Select entries or change windows. The right arrow key or ^F is often
+used for viewing details about the selected entry, while the left
+arrow key or ^B often returns to the previous screen.
+.TP
+\fBa | s | d\fR
+Increase the upload throttle by 1/5/50 KB.
+.TP
+\fBA | S | D\fR
+Increase the download throttle by 1/5/50 KB.
+.TP
+\fBz | x | c\fR
+Decrease the upload throttle by 1/5/50 KB.
+.TP
+\fBZ | X | C\fR
+Decrease the download throttle by 1/5/50 KB.
+.SS "MAIN VIEW KEYS"
+.TP
+\fB->\fR
+View download.
+.TP
+\fB0 - 9\fR
+Change view.
+.TP
+\fB^S\fR
+Start download.
+.TP
+\fB^D\fR
+Stop an active download, or remove a stopped download.
+.TP
+\fB^K\fR
+Close a torrent and its files.
+.TP
+\fB^E\fR
+Set the 'create/resize queued' flags on all files in a torrent. This
+is necessary if the underlying files in a torrent have been deleted or
+truncated, and thus rtorrent must recreate them.
+.TP
+\fB^R\fR
+Initiate hash check of torrent.
+.TP
+\fB^O\fR
+Change the destination directory of the download. The torrent must be
+closed.
+.TP
+\fB^X\fR
+Call commands or change settings.
+.TP
+\fB^B\fR
+Set download to perform initial seeding. Only use when
+you are the first and only seeder so far for the download.
+.TP
+\fB+ | -\fR
+Change the priority of the download.
+.TP
+\fBbackspace\fR
+Add torrent using an URL or file path. Use
+\fBtab\fR to view directory content and do
+auto-complete.
+.TP
+\fBl\fR
+View log. Exit by pressing the space-bar.
+.TP
+\fBU\fR
+Delete the file the torrent is tied to, and clear the association.
+.TP
+\fBI\fR
+Toggle whether torrent ignores ratio settings.
+.TP
+\fBF\fR
+Add a temporary name based regex filter to the current view.
+.SS "DOWNLOAD VIEW KEYS"
+.TP
+\fB->\fR
+View torrent file list. Use the space-bar to change the file priority
+and \fB*\fR to change the priority of all
+files. Use \fB/\fR to collapse the directories. OUTDATED
+.TP
+\fB1 | 2\fR
+Adjust max uploads.
+.TP
+\fB3 | 4\fR
+Adjust min peers.
+.TP
+\fB5 | 6\fR
+Adjust max peers.
+.TP
+\fBu\fR
+Display transfering blocks.
+.TP
+\fBi\fR
+Display chunk rarity.
+.TP
+\fBo\fR
+Display the tracker list. Cycle the trackers in a group with the
+space-bar.
+.TP
+\fBp\fR
+View peer and torrent information.
+.TP
+\fBt | T\fR
+Initiate tracker request. Use capital T to force the request, ignoring
+the "min interval" set by the tracker.
+.TP
+\fBk\fR
+Disconnect peer.
+.TP
+\fB*\fR
+Choke/Snub peer.
+.SH "OPTIONS"
+.TP
+\fB-b \fIa.b.c.d\fB\fR
+Bind listening socket and outgoing connections to this network
+interface address.
+.TP
+\fB-d \fIdirectory\fB\fR
+Set the default download directory. Defaults to "./".
+.TP
+\fB-h\fR
+Display help and exit.
+.TP
+\fB-i \fIa.b.c.d\fB\fR
+Set the address reported to the tracker.
+.TP
+\fB-n\fR
+Don't load ~/.rtorrent.rc on startup.
+.TP
+\fB-o key1=opt1,...\fR
+.TP
+\fB-O key=opt\fR
+Set any number of options, see the SETTINGS section. The options given
+here override the resource files. Use capital \fB-O\fR
+to allow comma in the option.
+.TP
+\fB-p \fIa-b\fB\fR
+Try to open a listening port in the range \fBa\fR up to
+and including \fBb\fR\&.
+.TP
+\fB-s \fIdirectory\fB\fR
+Session management will be enabled and the torrent files for all open
+downloads will be stored in this directory. Only one instance of
+rtorrent should be used with each session directory, though at the
+moment no locking is done. An empty string will disable the session
+directory.
+.SH "GENERAL SETTINGS"
+.PP
+.TP
+\fBbind = \fIa.b.c.d\fB\fR
+Bind listening socket and outgoing connections to this network
+interface address.
+.TP
+\fBip = \fIa.b.c.d\fB\fR
+.TP
+\fBip = \fIhostname\fB\fR
+Set the address reported to the tracker.
+.TP
+\fBport_range = \fIa-b\fB\fR
+Try to open a listening port in the range \fBa\fR up to
+and including \fBb\fR\&.
+.TP
+\fBport_random = \fIyes | no\fB\fR
+Open the listening port at a random position in the port range.
+.TP
+\fBcheck_hash = \fIyes | no\fB\fR
+Perform hash check on torrents that have finished downloading.
+.TP
+\fBdirectory = \fIdirectory\fB\fR
+Set the default download directory. Defaults to "./".
+.TP
+\fBsession = \fIdirectory\fB\fR
+Session management will be enabled and the torrent files for all open
+downloads will be stored in this directory. Only one instance of
+rtorrent can be used per session directory. An empty string will
+disable the session directory.
+.TP
+\fBhttp_proxy = \fIurl\fB\fR
+Use a http proxy. Use an empty string to disable.
+.TP
+\fBencoding_list = \fIencoding\fB\fR
+Add a preferred filename encoding to the list. The encodings are
+attempted in the order they are inserted, if none match the torrent
+default is used.
+.TP
+\fBencryption = \fIoption\fB,\fI\&...\fB\fR
+Set how rtorrent should deal with encrypted Bittorrent connections. By
+default, encryption is disabled, equivalent to specifying the option
+\fBnone\fR\&. Alternatively, any number of the following
+options may be specified:
+
+\fBallow_incoming\fR (allow incoming encrypted connections), 
+\fBtry_outgoing\fR (use encryption for outgoing connections),
+\fBrequire\fR (disable unencrypted handshakes), 
+\fBrequire_RC4\fR (also disable plaintext transmission after the
+initial encrypted handshake),
+\fBenable_retry\fR (if the initial outgoing connection fails, retry
+with encryption turned on if it was off or off if it was on), 
+\fBprefer_plaintext\fR (choose plaintext when peer offers a choice 
+between plaintext transmission and RC4 encryption, otherwise RC4 will be used).
+.TP
+\fBpeer_exchange = \fIyes | no\fB\fR
+Enable/disable peer exchange for torrents that aren't marked private. Disabled by default.
+.TP
+\fBschedule = \fIid\fB,\fIstart\fB,\fIinterval\fB,\fIcommand\fB\fR
+Call \fBcommand\fR every \fBinterval\fR
+seconds, starting from \fBstart\fR\&. An
+\fBinterval\fR of zero calls the task once, while a
+\fBstart\fR of zero calls it immediately. Currently
+\fBcommand\fR is forwarded to the option handler.
+\fBstart\fR and \fBinterval\fR may
+optionally use a time format, \fBdd:hh:mm:ss\fR\&. F.ex to
+start a task every day at \fB18:00\fR, use
+\fB18:00:00,24:00:00\fR\&.
+.TP
+\fBschedule_remove = \fIid\fB\fR
+Delete \fBid\fR from the scheduler.
+.TP
+\fBstart_tied =\fR
+Start torrents that are tied to filenames that have been re-added.
+.TP
+\fBstop_untied =\fR
+.TP
+\fBclose_untied =\fR
+.TP
+\fBremove_untied =\fR
+Stop, close or remove the torrents that are tied to filenames that
+have been deleted. Clear the association with the 'U' key.
+.TP
+\fBclose_low_diskspace = \fIspace\fB\fR
+Close any active torrents on filesystems with less than
+\fBspace\fR diskspace left. Use with
+the \fBschedule\fR option. A default scheduled event
+with id \fBlow_diskspace\fR is set to 500Mb.
+.TP
+\fBload = \fIfile\fB\fR
+.TP
+\fBload_verbose = \fIfile\fB\fR
+.TP
+\fBload_start = \fIfile\fB\fR
+.TP
+\fBload_start_verbose = \fIfile\fB\fR
+Load and possibly start a file, or possibly multiple files by using the
+wild-card "*". This is meant for use with
+\fBschedule\fR, though ensure that the
+\fBstart\fR is non-zero. The loaded file will be tied
+to the filename provided.
+.TP
+\fBimport = \fIfile\fB\fR
+.TP
+\fBtry_import = \fIfile\fB\fR
+Load a resource file. \fBtry_import\fR does not throw
+torrent::input_error exception on bad input.
+.TP
+\fBstop_on_ratio = \fImin_ratio\fB\fR
+.TP
+\fBstop_on_ratio = \fImin_ratio\fB,\fImin_upload\fB\fR
+.TP
+\fBstop_on_ratio = \fImin_ratio\fB,\fImin_upload\fB,\fImax_ratio\fB\fR
+Stop torrents when they reach the given upload ratio
+\fBmin_ratio\fR in percent. If the optional
+\fBmin_upload\fR is given, require a total
+upload amount of this many bytes as well. If the optional
+\fBmax_ratio\fR is given, stop the torrent
+when reaching this ratio regardless of the total upload
+amount. Exclude certain torrent by pressing 
+\fBShift+I\fR in the downlist list.
+Use with the \fBschedule\fR option.
+.TP
+\fBon_insert = \fIid\fB,\fIcommand\fB\fR
+.TP
+\fBon_erase = \fIid\fB,\fIcommand\fB\fR
+.TP
+\fBon_open = \fIid\fB,\fIcommand\fB\fR
+.TP
+\fBon_close = \fIid\fB,\fIcommand\fB\fR
+.TP
+\fBon_start = \fIid\fB,\fIcommand\fB\fR
+.TP
+\fBon_stop = \fIid\fB,\fIcommand\fB\fR
+.TP
+\fBon_hash_queued = \fIid\fB,\fIcommand\fB\fR
+.TP
+\fBon_hash_removed = \fIid\fB,\fIcommand\fB\fR
+.TP
+\fBon_hash_done = \fIid\fB,\fIcommand\fB\fR
+.TP
+\fBon_finished = \fIid\fB,\fIcommand\fB\fR
+Call a command on a download when its state changes. Only a subset of
+commands are available.
+.SH "THROTTLE SETTINGS"
+.TP
+\fBupload_rate = \fIKB\fB\fR
+.TP
+\fBdownload_rate = \fIKB\fB\fR
+Set the maximum global uploand and download rates.
+.TP
+\fBmin_peers = \fIvalue\fB\fR
+.TP
+\fBmax_peers = \fIvalue\fB\fR
+Set the minimum and maximum number of peers to allow in each download.
+.TP
+\fBmin_peers_seed = \fIvalue\fB\fR
+.TP
+\fBmax_peers_seed = \fIvalue\fB\fR
+Set the minimum nad maximum number of peers to allow while seeding, or
+-1 (default) to use max_peers.
+.TP
+\fBmax_uploads = \fIvalue\fB\fR
+Set the maximum number of simultaneous uploads per download.
+.TP
+\fBmax_uploads_div = \fIvalue\fB\fR
+.TP
+\fBmax_downloads_div = \fIvalue\fB\fR
+Change the divider used to calculate the max upload and download slots
+to use when the throttle is changed. Disable by
+setting \fB0\fR\&.
+.TP
+\fBmax_uploads_global = \fIvalue\fB\fR
+.TP
+\fBmax_downloads_global = \fIvalue\fB\fR
+Max upload and download slots allowed. Disable by
+setting \fB0\fR\&.
+.TP
+\fBthrottle_up = \fIname\fB, \fIupload_rate\fB\fR
+.TP
+\fBthrottle_down = \fIname\fB, \fIdownload_rate\fB\fR
+Define secondary throttle and/or set the given upload or download rate. Attach to a download with the d.set_throttle_name=name command
+or switch throttles with Ctrl-T. Download must be stopped when changing throttles. Note that secondary throttles only work if the
+global upload/download is throttled. Setting a download to use the \fBNULL\fR throttle makes the download unthrottled
+even when there is a global throttle. Note that this special case bypasses the global throttle entirely, and as such its rate and
+transfer amounts are not included in the global statistics.
+.TP
+\fBthrottle_ip = \fIname\fB, \fIhost\fB\fR
+.TP
+\fBthrottle_ip = \fIname\fB, \fInetwork/prefix\fB\fR
+.TP
+\fBthrottle_ip = \fIname\fB, \fIstart\fB, \fIend\fB\fR
+Use the given secondary throttle for a host, CIDR network or IP range. All peers with a matching IP will use this throttle instead
+of the global throttle or a custom download throttle. The name may be \fBNULL\fR to make these peers unthrottled, with
+the same caveats as explained above.
+.SH "TRACKER RELATED SETTINGS"
+.PP
+Tracker related settings.
+.TP
+\fBenable_trackers = \fIyes\fB\fR
+Set to \fBno\fR to disable all tracker requests. Useful
+for disabling rtorrent with the \fBschedule\fR command.
+.TP
+\fBtracker_dump = \fIfilename\fB\fR
+Dump tracker requests to \fBfilename\fR, disable by
+supplying an empty string. Only torrents loaded while
+\fBtracker_dump\fR contains a non-empty string will be
+logged at the moment, although disabling it will work as expected.
+.TP
+\fBtracker_numwant = \fInumber\fB\fR
+Set the numwant field sent to the tracker, which indicates how many
+peers we want. A negative value disables this feature.
+.TP
+\fBuse_udp_trackers = \fIyes\fB\fR
+Use UDP trackers. Disable if you are behind a firewall, etc, that does
+not allow connections to UDP trackers.
+.TP
+\fBdht = \fIdisabled|off|auto|on\fB\fR
+Support for querying the distributed hash table (DHT) to find peers for trackerless
+torrents or when all trackers are down. Set to \fBdisable\fR to completely
+disable DHT, \fBoff\fR (default) to enable DHT but to not start the
+DHT server, \fBauto\fR to automatically start and stop the DHT server
+as needed or \fBon\fR for permanently keeping the DHT server running.
+When set to automatic, the DHT server will start up when the first non-private torrent
+is started, and will stop 15-30 minutes after the last non-private torrent is
+stopped (or when rTorrent quits). For DHT to work, a session directory must be set (for
+saving the DHT cache).
+.TP
+\fBdht_port = \fInumber\fB\fR
+Set the UDP listen port for DHT. Defaults to 6881.
+.TP
+\fBdht_add_node = \fIhost[:port]\fB\fR
+Not intended for use in the configuration file but as one-time option in the
+client or on the command line to bootstrap an empty DHT node table. Contacts 
+the given node and attempts to bootstrap from it if it replies.
+The port is optional, with port 6881 being used by default.
+.TP
+\fBhttp_capath = \fIpath\fB\fR
+.TP
+\fBhttp_cacert = \fIfilename\fB\fR
+Set the certificates to use in http requests. See Curl's
+CURLOPT_CAPATH and CURLOPT_CAINFO options for further information.
+.SH "USER-INTERFACE SETTINGS"
+.PP
+Display related settings.
+.TP
+\fBview_add = \fIname\fB\fR
+Create a new view.
+.TP
+\fBview_sort = \fIname\fB\fR
+.TP
+\fBview_sort = \fIname\fB,\fIseconds\fB\fR
+Sort a view according the the criteria set by
+\fBview_sort_current\fR\&. If the optional argument is
+supplied, the view is not sorted if a change happened during the last
+\fBseconds\fR\&. This command is meant to be used with
+\fBschedule\fR\&.
+.TP
+\fBview_sort_new = \fIname\fB,\fI\&...\fB\fR
+.TP
+\fBview_sort_current = \fIname\fB,\fI\&...\fB\fR
+Set the sorting criteria for when new elements inserted or
+\fBview_sort\fR is called. The list can contain any
+number of criteria, including zero, from the following:
+
+\fBname\fR, \fBname_reverse\fR,
+\fBstopped\fR, \fBstarted\fR,
+\fBcomplete\fR, \fBincomplete\fR,
+\fBstate_changed\fR,
+\fBstate_changed_reverse\fR
+.TP
+\fBkey_layout = \fIqwerty|azerty|qwertz|dvorak\fB\fR
+Change the key-bindings.
+.SH "FILE-SYSTEM SETTINGS"
+.PP
+File-system related settings.
+.TP
+\fBmax_file_size = \fIsize\fB\fR
+Set the maximum size a file can have. Disable by
+passing \fB-1\fR\&.
+.TP
+\fBsplit_file_size = \fIsize\fB\fR
+Split files in a torrent larger than \fBsize\fR into
+seperate files. Disable by passing \fB-1\fR\&.
+.TP
+\fBsplit_suffix = \fIstring\fB\fR
+Set the suffix used on split files. Defaults
+to \fB\&.part\fR\&.
+.SH "DOWNLOAD SETTINGS"
+.PP
+Settings that require a download as a target, the options need to be
+called through f.ex \fBon_finished\fR\&.
+.TP
+\fBcreate_link = \fItype\fB,\fIpath\fB,\fIsuffix\fB\fR
+.TP
+\fBdelete_link = \fItype\fB,\fIpath\fB,\fIsuffix\fB\fR
+Create or delete a symbolic link. The link path is the concatenation
+of \fBpath\fR, the result of
+the \fBtype\fR on the download,
+and \fBsuffix\fR\&.
+
+Available types are; \fBbase_path\fR uses the base path
+of the download, \fBbase_filename\fR uses the base
+filename of the download, \fBtied\fR uses the path of
+the file the download is tied to, see \fBstart_tied\fR\&.
+.SH "ADVANCED SETTINGS"
+.PP
+This list contains settings users shouldn't need to touch, some may
+even cause crashes or similar if incorrectly set.
+.TP
+\fBhash_read_ahead = \fIMB\fB\fR
+Configure how far ahead we ask the kernel to read when doing hash
+checking. The hash checker uses madvise(..., MADV_WILLNEED) for the
+requests.
+.TP
+\fBhash_interval = \fIms\fB\fR
+Interval between attempts to check the hash when the chunk is not in
+memory, in milliseconds.
+.TP
+\fBhash_max_tries = \fItries\fB\fR
+Number of attempts to check the hash while using the mincore status,
+before forcing. Overworked systems might need lower values to get a
+decent hash checking rate.
+.TP
+\fBmax_open_files = \fIvalue\fB\fR
+Number of files to simultaneously keep open. LibTorrent dynamically
+opens and closes files as necessary when mapping files to
+memory. Default is based on sysconf(_SC_OPEN_MAX).
+You probably only think you know what this option does, so don't touch
+it.
+.TP
+\fBmax_open_sockets = \fIvalue\fB\fR
+Number of network sockets to simultaneously keep open. This value is
+set to a reasonable value based on \fBsysconf(_SC_OPEN_MAX)\fR\&.
+.TP
+\fBmax_open_http = \fIvalue\fB\fR
+Number of sockets to simultaneously keep open. This value is set
+to \fB32\fR by default.
+.TP
+\fBmax_memory_usage = \fIbytes\fB\fR
+Set the max amount of memory space used to mapping file chunks. This
+may also be set using \fBulimit -m\fR where 3/4 will be
+allocated to file chunks.
+.TP
+\fBsend_buffer_size = \fIvalue\fB\fR
+.TP
+\fBreceive_buffer_size = \fIvalue\fB\fR
+Adjust the send and receive buffer size for socket.
+.TP
+\fBumask = \fI0022\fB\fR
+Set the umask for this process, which is applied to all files created
+by the program.
+.TP
+\fBcwd = \fIdirectory\fB\fR
+Changes the working directory of the process using
+\fBchdir\fR\&.
+.TP
+\fBsession_on_completion = \fIyes\fB\fR
+Controls if the session torrent is saved when a torrent finishes. By
+default on.
+.TP
+\fBsession_lock = \fIyes\fB\fR
+Controls if a lock file is created in the session directory on startup.
+.TP
+\fBsession_save = \fR
+Save the session files for all downloads.
+.TP
+\fBtos = \fIdefault|lowdelay|throughput|reliability|mincost\fB\fR
+.TP
+\fBtos = \fIhex\fB\fR
+Change the TOS of peer connections, by default set to
+\fBthroughput\fR\&. If the option is set to
+\fBdefault\fR then the system default TOS is used. A
+hex value may be used for non-standard settings.
+.TP
+\fBhandshake_log = \fIyes\fB\fR
+Enable logging of the peer handshake. This generates a large number of
+log messages, but may be useful to debug connection problems.
+.SH "AUTHORS"
+.PP
+
+Jari "Rakshasa" Sundell <jaris@ifi.uio.no>

doc/plot/instrumentation_mincore.sh

@@ -0,0 +1,30 @@
+#/bin/bash
+gnuplot << EOF
+
+set terminal png size 1024 * 1, 768 enhanced
+set xdata time
+set timefmt "%s"
+set format x "%H:%M"
+set y2tics
+set autoscale xfix
+set key autotitle columnhead
+
+set format y "%.0f"
+set format y2 "%.0f"
+
+set output "output_$1_incore_sync.png"
+plot \
+     "instrumentation_mincore.log.$1" using 1:6  title 'success'         with lines lw 4 axis x1y1,\
+     "instrumentation_mincore.log.$1" using 1:7  title 'failed'          with lines lw 4 axis x1y1,\
+     "instrumentation_mincore.log.$1" using 1:8  title 'not synced'      with lines lw 4 axis x1y2,\
+     "instrumentation_mincore.log.$1" using 1:9  title 'not deallocated' with lines lw 4 axis x1y2
+
+set format y "%.0g"
+
+set output "output_$1_incore_alloc.png"
+plot \
+     "instrumentation_mincore.log.$1" using 1:12 title 'allocations'     with lines lw 2 axis x1y1,\
+     "instrumentation_mincore.log.$1" using 1:13 title 'deallocations'   with lines lw 4 axis x1y1,\
+     "instrumentation_mincore.log.$1" using 1:10 title 'alloc failed'    with lines lw 2 axis x1y2
+
+EOF

doc/plot/instrumentation_transfers.sh

@@ -0,0 +1,49 @@
+#/bin/bash
+gnuplot << EOF
+
+set terminal png size 1024,768 enhanced
+set xdata time
+set timefmt "%s"
+set format x "%H:%M"
+set y2tics
+set autoscale xfix
+set key autotitle columnhead
+
+# set datafile missing '0'
+
+set format y "%.0f"
+set format y2 "%.0f"
+
+set yrange [0:]
+set y2range [0:]
+
+set output "output_$1_transfer_requests.png"
+plot \
+     "instrumentation_transfers.log.$1" using 1:2  title 'delegated'       with lines lw 4 axis x1y1,\
+     "instrumentation_transfers.log.$1" using 1:3  title 'downloading'     with lines lw 4 axis x1y1,\
+     "instrumentation_transfers.log.$1" using 1:4  title 'finished'        with lines lw 4 axis x1y1,\
+     "instrumentation_transfers.log.$1" using 1:5  title 'skipped'         with lines lw 2 axis x1y2,\
+     "instrumentation_transfers.log.$1" using 1:6  title 'unknown'         with lines lw 2 axis x1y2,\
+     "instrumentation_transfers.log.$1" using 1:7  title 'unordered'       with lines lw 2 axis x1y2,\
+     "instrumentation_transfers.log.$1" using 1:19 title 'unaccounted'     with lines lw 2 axis x1y2
+
+set output "output_$1_transfer_queues.png"
+plot \
+     "instrumentation_transfers.log.$1" using 1:8  title 'queue added'       with lines lw 2 axis x1y1,\
+     "instrumentation_transfers.log.$1" using 1:9  title 'queue moved'       with lines lw 2 axis x1y1,\
+     "instrumentation_transfers.log.$1" using 1:10 title 'queue removed'     with lines lw 2 axis x1y1,\
+     "instrumentation_transfers.log.$1" using 1:11 title 'queue total'       with lines lw 4 axis x1y2,\
+     "instrumentation_transfers.log.$1" using 1:12 title 'unordered added'   with lines lw 2 axis x1y1,\
+     "instrumentation_transfers.log.$1" using 1:13 title 'unordered moved'   with lines lw 2 axis x1y1,\
+     "instrumentation_transfers.log.$1" using 1:14 title 'unordered removed' with lines lw 2 axis x1y1,\
+     "instrumentation_transfers.log.$1" using 1:15 title 'unordered total'   with lines lw 4 axis x1y2,\
+     "instrumentation_transfers.log.$1" using 1:16 title 'stalled added'     with lines lw 2 axis x1y1,\
+     "instrumentation_transfers.log.$1" using 1:17 title 'stalled moved'     with lines lw 2 axis x1y1,\
+     "instrumentation_transfers.log.$1" using 1:18 title 'stalled removed'   with lines lw 2 axis x1y1,\
+     "instrumentation_transfers.log.$1" using 1:19 title 'stalled total'     with lines lw 4 axis x1y2,\
+     "instrumentation_transfers.log.$1" using 1:20 title 'choked added'      with lines lw 2 axis x1y1,\
+     "instrumentation_transfers.log.$1" using 1:21 title 'choked moved'      with lines lw 2 axis x1y1,\
+     "instrumentation_transfers.log.$1" using 1:22 title 'choked removed'    with lines lw 2 axis x1y1,\
+     "instrumentation_transfers.log.$1" using 1:23 title 'choked total'      with lines lw 4 axis x1y2
+
+EOF

doc/rtorrent.rc

@@ -0,0 +1,132 @@
+#############################################################################
+# This is an (old) example resource file for rTorrent.
+# Copy to ~/.rtorrent.rc and enable/modify the options as needed.
+# Remember to uncomment the options you wish to enable.
+#
+# See 'rtorrent.rc-example' for a newer, basic configuration.
+#
+#   Sample: https://github.com/rakshasa/rtorrent/wiki/CONFIG-Template
+# Complete: https://rtorrent-docs.readthedocs.io/en/latest/cmd-ref.html
+#   Useful: https://rtorrent-docs.readthedocs.io/en/latest/use-cases.html
+#   Manual: https://rtorrent-docs.readthedocs.io/en/latest/
+#  Convert: https://github.com/rakshasa/rtorrent/wiki/rTorrent-0.9-Comprehensive-Command-list-(WIP)
+# Handbook: https://media.readthedocs.org/pdf/rtorrent-docs/latest/rtorrent-docs.pdf
+#     File: https://github.com/rakshasa/rtorrent/blob/master/doc/rtorrent.rc
+#############################################################################
+
+# Maximum and minimum number of peers to connect to per torrent.
+#
+#throttle.min_peers.normal.set = 40
+#throttle.max_peers.normal.set = 100
+
+# Same as above but for seeding completed torrents.
+# "-1" = same as downloading.
+#
+#throttle.min_peers.seed.set = 10
+#throttle.max_peers.seed.set = 50
+
+# Maximum number of simultaneous uploads per torrent.
+#
+#throttle.max_uploads.set = 15
+
+# Global upload and download rate in KiB.
+# "0" for unlimited.
+#
+#throttle.global_down.max_rate.set_kb = 0
+#throttle.global_up.max_rate.set_kb = 0
+
+# Default directory to save the downloaded torrents.
+#
+#directory.default.set = ./
+
+# Default session directory. Make sure you don't run multiple instance
+# of rTorrent using the same session directory. Perhaps using a
+# relative path?
+#
+#session.path.set = ./session
+
+# Watch a directory for new torrents, and stop those that have been
+# deleted.
+#
+#schedule2 = watch_directory,5,5,load.start=./watch/*.torrent
+
+# Close torrents when disk-space is low.
+#
+#schedule2 = low_diskspace,5,60,close_low_diskspace=100M
+
+# The IP address reported to the tracker.
+#
+#network.local_address.set = 127.0.0.1
+#network.local_address.set = rakshasa.no
+
+# The IP address the listening socket and outgoing connections is
+# bound to.
+#
+#network.bind_address.set = 127.0.0.1
+#network.bind_address.set = rakshasa.no
+
+# Port range to use for listening.
+#
+#network.port_range.set = 6890-6999
+
+# Start opening ports at a random position within the port range.
+#
+#network.port_random.set = no
+
+# Set RPC type
+#network.rpc.use_xmlrpc.set = true
+#network.rpc.use_jsonrpc.set = true
+
+# Check hash for finished torrents. Might be useful until the bug is
+# fixed that causes lack of disk-space not to be properly reported.
+#
+#pieces.hash.on_completion.set = no
+
+# Set whether the client should try to connect to UDP trackers.
+#
+#trackers.use_udp.set = yes
+
+# Alternative calls to bind and IP that should handle dynamic IP's.
+#
+#schedule2 = ip_tick,0,1800,ip=rakshasa
+#schedule2 = bind_tick,0,1800,bind=rakshasa
+
+# Encryption options, set to none (default) or any combination of the following:
+# allow_incoming, try_outgoing, require, require_RC4, enable_retry, prefer_plaintext
+#
+# The example value allows incoming encrypted connections, starts unencrypted
+# outgoing connections but retries with encryption if they fail, preferring
+# plain-text to RC4 encryption after the encrypted handshake.
+#
+# protocol.encryption.set = allow_incoming,enable_retry,prefer_plaintext
+
+# Enable DHT support for trackerless torrents or when all trackers are down.
+# May be set to "disable" (completely disable DHT), "off" (do not start DHT),
+# "auto" (start and stop DHT as needed), or "on" (start DHT immediately).
+# The default is "off". For DHT to work, a session directory must be defined.
+#
+# dht.mode.set = auto
+
+# UDP port to use for DHT.
+#
+#dht.port.set = 6881
+
+# Enable peer exchange (for torrents not marked private).
+#
+#protocol.pex.set = yes
+
+# Set download list layout style ("full", "compact").
+#
+#ui.torrent_list.layout.set = "full"
+
+# Run rTorrent as a daemon, controlled via XMLRPC.
+#
+#system.daemon.set = false
+
+# SCGI Connectivity (for alternative rtorrent interfaces, XMLRPC)
+# Use a IP socket with scgi_port, or a Unix socket with scgi_local.
+# schedule can be used to set permissions on the unix socket.
+#
+#network.scgi.open_port = "127.0.0.1:5000"
+#network.scgi.open_local = (cat,(session.path),/rpc.sock)
+#schedule2 = socket_chmod, 0, 0, "execute.nothrow=chmod,770,(cat,(session.path),/rpc.sock)"

doc/rtorrent.rc-example

@@ -0,0 +1,108 @@
+#############################################################################
+# A minimal rTorrent configuration that provides the basic features
+# you want to have in addition to the built-in defaults.
+#
+# See https://github.com/rakshasa/rtorrent/wiki/CONFIG-Template
+# for an up-to-date version.
+#############################################################################
+
+# Instance layout (base paths)
+method.insert = cfg.basedir,  private|const|string, (cat,"/home/USERNAME/rtorrent/")
+method.insert = cfg.download, private|const|string, (cat,(cfg.basedir),"download/")
+method.insert = cfg.logs,     private|const|string, (cat,(cfg.basedir),"log/")
+method.insert = cfg.logfile,  private|const|string, (cat,(cfg.logs),"rtorrent-",(system.time),".log")
+method.insert = cfg.session,  private|const|string, (cat,(cfg.basedir),".session/")
+method.insert = cfg.watch,    private|const|string, (cat,(cfg.basedir),"watch/")
+
+# Create instance directories
+execute.throw = sh, -c, (cat,\
+    "mkdir -p \"",(cfg.download),"\" ",\
+    "\"",(cfg.logs),"\" ",\
+    "\"",(cfg.session),"\" ",\
+    "\"",(cfg.watch),"/load\" ",\
+    "\"",(cfg.watch),"/start\" ")
+
+# Listening port for incoming peer traffic (fixed; you can also randomize it)
+network.port_range.set = 50000-50000
+network.port_random.set = no
+
+# Tracker-less torrent and UDP tracker support
+# (conservative settings for 'private' trackers, change for 'public')
+dht.mode.set = disable
+protocol.pex.set = no
+trackers.use_udp.set = no
+
+# Peer settings
+throttle.max_uploads.set = 100
+throttle.max_uploads.global.set = 250
+
+throttle.min_peers.normal.set = 20
+throttle.max_peers.normal.set = 60
+throttle.min_peers.seed.set = 30
+throttle.max_peers.seed.set = 80
+trackers.numwant.set = 80
+
+protocol.encryption.set = allow_incoming,try_outgoing,enable_retry
+
+# Limits for file handle resources, this is optimized for
+# an `ulimit` of 1024 (a common default). You MUST leave
+# a ceiling of handles reserved for rTorrent's internal needs!
+network.http.max_open.set = 50
+network.max_open_files.set = 600
+network.max_open_sockets.set = 300
+
+# Memory resource usage (increase if you have a large number of items loaded,
+# and/or the available resources to spend)
+pieces.memory.max.set = 1800M
+network.xmlrpc.size_limit.set = 4M
+
+# Basic operational settings (no need to change these)
+session.path.set = (cat, (cfg.session))
+directory.default.set = (cat, (cfg.download))
+log.execute = (cat, (cfg.logs), "execute.log")
+##log.xmlrpc = (cat, (cfg.logs), "xmlrpc.log")
+execute.nothrow = sh, -c, (cat, "echo >",\
+    (session.path), "rtorrent.pid", " ", (system.pid))
+
+# Other operational settings (check & adapt)
+encoding.add = utf8
+system.umask.set = 0027
+system.cwd.set = (directory.default)
+network.http.dns_cache_timeout.set = 25
+schedule2 = monitor_diskspace, 15, 60, ((close_low_diskspace, 1000M))
+##pieces.hash.on_completion.set = no
+##view.sort_current = seeding, greater=d.ratio=
+##keys.layout.set = qwerty
+##network.http.capath.set = "/etc/ssl/certs"
+##network.http.ssl_verify_peer.set = 0
+##network.http.ssl_verify_host.set = 0
+#network.rpc.use_xmlrpc.set = true
+#network.rpc.use_jsonrpc.set = true
+
+# Some additional values and commands
+method.insert = system.startup_time, value|const, (system.time)
+method.insert = d.data_path, simple,\
+    "if=(d.is_multi_file),\
+        (cat, (d.directory), /),\
+        (cat, (d.directory), /, (d.name))"
+method.insert = d.session_file, simple, "cat=(session.path), (d.hash), .torrent"
+
+# Watch directories (add more as you like, but use unique schedule names)
+schedule2 = watch_start, 10, 10, ((load.start_verbose, (cat, (cfg.watch), "start/*.torrent")))
+schedule2 = watch_load, 11, 10, ((load.verbose, (cat, (cfg.watch), "load/*.torrent")))
+
+# Run the rTorrent process as a daemon in the background
+# (and control via XMLRPC sockets)
+#system.daemon.set = true
+#network.scgi.open_local = (cat,(session.path),rtorrent.sock)
+#execute.nothrow = chmod,770,(cat,(session.path),rtorrent.sock)
+
+# Logging:
+#   Levels = critical error warn notice info debug
+#   Groups = connection_* dht_* peer_* rpc_* storage_* thread_* tracker_* torrent_*
+print = (cat, "Logging to ", (cfg.logfile))
+log.open_file = "log", (cfg.logfile)
+log.add_output = "info", "log"
+##log.add_output = "tracker_debug", "log"
+
+### END of rtorrent.rc ###

doc/rtorrent_fast_resume.pl

@@ -0,0 +1,131 @@
+#!/usr/bin/perl
+
+# Perl script to add rTorrent fast resume data to torrent files.
+#
+# Usage:
+# rtorrent_fast_resume.pl [base-directory] < plain.torrent > with_fast_resume.torrent
+# -OR-
+# rtorrent_fast_resume.pl [base-directory] plain.torrent [with_fast_resume.torrent]
+
+use strict;
+use warnings;
+use Convert::Bencode_XS qw(bencode bdecode);
+use File::Spec;  # core module
+use POSIX;       # core module
+
+$/ = undef;
+$| = 1;
+
+# Process ARGV
+my $d = $ARGV[0];
+if ($d and not -d $d) {
+   if (-f $d and -s $d and not $ARGV[2]) {  # missing directory, but has file
+      $ARGV[2] = $ARGV[1];
+      $ARGV[1] = $ARGV[0];
+      $d = '';
+   }
+   else { die "$d is not a directory\n"; }
+}
+$d ||= ".";
+$d .= "/" unless $d =~ m#/$#;
+
+my ($in, $out, $msg);
+my ($in_file, $out_file) = ('', '');
+if ($ARGV[1]) {
+   $in_file = $ARGV[1];
+   open($in, ($ARGV[2] ? '<' : '+<'), $in_file) || die "Cannot open $in_file for input!\n";
+   unless ($ARGV[2]) {
+      $out = $in;
+      $out_file = $in_file;
+   }
+}
+else { $in = *STDIN; }
+if ($ARGV[2]) {
+   $out_file = $ARGV[2];
+   open($out, '>', $out_file) || die "Cannot open $out_file for output!\n";
+   $msg = *STDOUT;
+}
+elsif (!$ARGV[1]) { $out = *STDOUT; }
+$msg //= *STDERR;
+
+print {$msg} "Total input torrent size: ".sprintf('%.2f', (-s $in_file) / 1024)." KB\n" if $in_file;
+print {$msg} "Decoding ".($in_file || 'torrent from standard input')."...";
+my $t = bdecode(scalar <$in>);
+
+die "No info key.\n" unless ref $t eq "HASH" and exists $t->{info};
+my $psize = $t->{info}{"piece length"} or die "No piece length key.\n";
+print {$msg} "done\n\n";
+
+my @files;
+my $tsize = 0;
+if (exists $t->{info}{files}) {
+   print {$msg} "Multi file torrent: $t->{info}{name}\n";
+   for (@{$t->{info}{files}}) {
+      push @files, join "/", $t->{info}{name},@{$_->{path}};
+      $tsize += $_->{length};
+   }
+}
+else {
+   print {$msg} "Single file torrent: $t->{info}{name}\n";
+   @files = ($t->{info}{name});
+   $tsize = $t->{info}{length};
+}
+my $chunks = int(($tsize + $psize - 1) / $psize);
+print {$msg} "Total size: ".sprintf('%.2f', $tsize / 1024**2)." MB; $chunks chunks; ", scalar @files, " files.\n\n";
+
+die "Inconsistent piece information!\n" if $chunks*20 != length $t->{info}{pieces};
+
+print {$msg} "Adding fast resume information...";
+#      flags    => 1+16+
+
+my $pmod = 0;
+$t->{libtorrent_resume}{bitfield} = $chunks;
+foreach my $f (0..$#files) {
+   die "$d$files[$f] not found.\n" unless -e "$d$files[$f]";
+   my $mtime = (stat "$d$files[$f]")[9];
+   
+   # Compute number of chunks per file
+   my $fsize   = (exists $t->{info}{files}) ? $t->{info}{files}[$f]{length} : 1;
+   my $fchunks = ($pmod ? 1 : 0);
+   if ($pmod >= $fsize) { ($fsize, $pmod ) = (0, $pmod-$fsize); }
+   else                 { ($pmod,  $fsize) = (0, $fsize-$pmod); }
+   $fchunks +=      ceil($fsize / $psize);
+   $pmod   ||= $psize - ($fsize % $psize);
+   
+   $t->{libtorrent_resume}{files}[$f] = {
+      priority  => 0,  # Don't download; we already have the file, so don't clobber it!
+      mtime     => $mtime,
+      completed => $fchunks,
+   };
+};
+$t->{libtorrent_resume}{'uncertain_pieces.timestamp'} = time;
+
+# Some extra information to re-enforce the fact that this is a finished torrent
+if (exists $t->{info}{files}) {
+   $d .=  $t->{info}{name};
+}
+
+$t->{rtorrent} = {
+   state          => 1,  # started
+   state_changed  => time,
+   state_counter  => 1,
+   chunks_wanted  => 0,
+   chunks_done    => $chunks,
+   complete       => 1,
+   hashing        => 0,  # Not hashing
+   directory      => File::Spec->file_name_is_absolute($d)        ? $d        : File::Spec->rel2abs($d),
+   ((tied_to_file => File::Spec->file_name_is_absolute($out_file) ? $out_file : File::Spec->rel2abs($out_file)) x!! $out_file),
+   'timestamp.finished' => 0,
+   'timestamp.started'  => time,
+};
+
+print {$msg} "done\n";
+
+print {$msg} "Encoding ".($out_file || 'torrent from standard output')."...";
+seek($out, 0, 0);  # just in case files are the same
+print {$out} bencode($t);
+
+close($in);
+close($out);
+print {$msg} "done\n";
+exit;

doc/scripts/init/rtorrentInitScreen.bash

@@ -0,0 +1,164 @@
+#!/bin/bash
+#############
+###<Notes>###
+#############
+# This script depends on screen.
+# For the stop function to work, you must set an
+# explicit session directory using absolute paths (no, ~ is not absolute) in your rtorrent.rc.
+# If you typically just start rtorrent with just "rtorrent" on the
+# command line, all you need to change is the "user" option.
+# Attach to the screen session as your user with 
+# "screen -dr rtorrent". Change "rtorrent" with srnname option.
+# Licensed under the GPLv2 by lostnihilist: lostnihilist _at_ gmail _dot_ com
+##############
+###</Notes>###
+##############
+
+#######################
+##Start Configuration##
+#######################
+# You can specify your configuration in a different file 
+# (so that it is saved with upgrades, saved in your home directory,
+# or whatever reason you want to)
+# by commenting out/deleting the configuration lines and placing them
+# in a text file (say /home/user/.rtorrent.init.conf) exactly as you would
+# have written them here (you can leave the comments if you desire
+# and then uncommenting the following line correcting the path/filename 
+# for the one you used. note the space after the ".".
+# . /etc/rtorrent.init.conf
+
+
+#Do not put a space on either side of the equal signs e.g.
+# user = user 
+# will not work
+# system user to run as (can only use one)
+user="user"
+
+# system user to run as # not implemented, see d_start for beginning implementation
+# group=$(id -ng "$user")
+
+# the full path to the filename where you store your rtorrent configuration
+# must keep parentheses around the entire statement, quotations around each config file
+config=("$(su -c 'echo $HOME' $user)/.rtorrent.rc")
+# Examples:
+# config=("/home/user/.rtorrent.rc")
+# config=("/home/user/.rtorrent.rc" "/mnt/some/drive/.rtorrent2.rc")
+# config=("/home/user/.rtorrent.rc"
+# "/mnt/some/drive/.rtorrent2.rc"
+# "/mnt/another/drive/.rtorrent3.rc")
+
+# set of options to run with each instance, separated by a new line
+# must keep parentheses around the entire statement
+#if no special options, specify with: ""
+options=("")
+# Examples:
+# starts one instance, sourcing both .rtorrent.rc and .rtorrent2.rc
+# options=("-o import=~/.rtorrent2.rc")
+# starts two instances, ignoring .rtorrent.rc for both, and using
+# .rtorrent2.rc for the first, and .rtorrent3.rc for the second
+# we do not check for valid options
+# options=("-n -o import=~/.rtorrent2.rc" "-n -o import=~/rtorrent3.rc")
+
+# default directory for screen, needs to be an absolute path
+base=$(su -c 'echo $HOME' $user)
+
+# name of screen session
+srnname="rtorrent"
+
+# file to log to (makes for easier debugging if something goes wrong)
+logfile="/var/log/rtorrentInit.log"
+#######################
+###END CONFIGURATION###
+#######################
+
+PATH=/usr/bin:/usr/local/bin:/usr/local/sbin:/sbin:/bin:/usr/sbin
+DESC="rtorrent"
+NAME=rtorrent
+DAEMON=$NAME
+SCRIPTNAME=/etc/init.d/$NAME
+
+checkcnfg() {
+  exists=0
+  for i in `echo "$PATH" | tr ':' '\n'` ; do
+    if [ -f $i/$NAME ] ; then
+      exists=1
+      break
+    fi
+  done
+  if [ $exists -eq 0 ] ; then
+    echo "cannot find $NAME binary in PATH: $PATH" | tee -a "$logfile" >&2
+    exit 3
+  fi
+  for (( i=0 ; i < ${#config[@]} ;  i++ )) ; do
+    if ! [ -r "${config[i]}" ] ; then
+        echo "cannot find readable config ${config[i]}. check that it is there and permissions are appropriate"  | tee -a "$logfile" >&2
+        exit 3
+    fi
+    session=$(getsession "${config[i]}")
+    if ! [ -d "${session}" ] ; then
+        echo "cannot find readable session directory ${session} from config ${config[i]}. check permissions" | tee -a "$logfile" >&2
+        exit 3
+    fi
+  done
+}
+
+d_start() {
+  [ -d "${base}" ] && cd "${base}"
+  stty stop undef && stty start undef
+  su -c "screen -S "${srnname}" -X screen rtorrent ${options} 2>&1 1>/dev/null" ${user} | tee -a "$logfile" >&2
+  # this works for the screen command, but starting rtorrent below adopts screen session gid
+  # even if it is not the screen session we started (e.g. running under an undesirable gid
+  #su -c "screen -ls | grep -sq "\.${srnname}[[:space:]]" " ${user} || su -c "sg \"$group\" -c \"screen -fn -dm -S ${srnname} 2>&1 1>/dev/null\"" ${user} | tee -a "$logfile" >&2
+  for (( i=0 ; i < ${#options[@]} ; i++ )) ;  do
+    sleep 3
+    su -c "screen -S "${srnname}" -X screen rtorrent ${options[i]} 2>&1 1>/dev/null" ${user} | tee -a "$logfile" >&2
+  done
+}
+
+d_stop() {
+  for (( i=0 ; i < ${#config[@]} ; i++ )) ; do
+    session=$(getsession "${config[i]}")
+    if ! [ -s ${session}/rtorrent.lock ] ; then
+        return
+    fi
+    pid=$(cat ${session}/rtorrent.lock | awk -F: '{print($2)}' | sed "s/[^0-9]//g")
+    # make sure the pid doesn't belong to another process
+    if ps -A | grep -sq ${pid}.*rtorrent ; then
+        kill -s INT ${pid}
+    fi
+  done
+}
+
+getsession() { 
+    session=$(cat "$1" | grep "^[[:space:]]*session.path.set[[:space:]]*=" | sed "s/^[[:space:]]*session.path.set[[:space:]]*=[[:space:]]*//" )
+    #session=${session/#~/`getent passwd ${user}|cut -d: -f6`}
+    echo $session
+}
+
+checkcnfg
+
+case "$1" in
+  start)
+    echo -n "Starting $DESC: $NAME"
+    d_start
+    echo "."
+    ;;
+  stop)
+    echo -n "Stopping $DESC: $NAME"
+    d_stop
+    echo "."
+    ;;
+  restart|force-reload)
+    echo -n "Restarting $DESC: $NAME"
+    d_stop
+    sleep 1
+    d_start
+    echo "."
+    ;;
+  *)
+    echo "Usage: $SCRIPTNAME {start|stop|restart|force-reload}" >&2
+    exit 1
+    ;;
+esac
+
+exit 0

doc/scripts/init/rtorrentInitScreen.sh

@@ -0,0 +1,137 @@
+#!/bin/sh
+#############
+###<Notes>###
+#############
+# This script depends on screen.
+# For the stop function to work, you must set an
+# explicit session directory using ABSOLUTE paths (no, ~ is not absolute) in your rtorrent.rc.
+# If you typically just start rtorrent with just "rtorrent" on the
+# command line, all you need to change is the "user" option.
+# Attach to the screen session as your user with 
+# "screen -dr rtorrent". Change "rtorrent" with srnname option.
+# Licensed under the GPLv2 by lostnihilist: lostnihilist _at_ gmail _dot_ com
+##############
+###</Notes>###
+##############
+
+#######################
+##Start Configuration##
+#######################
+# You can specify your configuration in a different file 
+# (so that it is saved with upgrades, saved in your home directory,
+# or whateve reason you want to)
+# by commenting out/deleting the configuration lines and placing them
+# in a text file (say /home/user/.rtorrent.init.conf) exactly as you would
+# have written them here (you can leave the comments if you desire
+# and then uncommenting the following line correcting the path/filename 
+# for the one you used. note the space after the ".".
+# . /etc/rtorrent.init.conf
+
+#Do not put a space on either side of the equal signs e.g.
+# user = user 
+# will not work
+# system user to run as
+user="user"
+
+# the system group to run as, not implemented, see d_start for beginning implementation
+# group=`id -ng "$user"`
+
+# the full path to the filename where you store your rtorrent configuration
+config="`su -c 'echo $HOME' $user`/.rtorrent.rc"
+
+# set of options to run with
+options=""
+
+# default directory for screen, needs to be an absolute path
+base="`su -c 'echo $HOME' $user`"
+
+# name of screen session
+srnname="rtorrent"
+
+# file to log to (makes for easier debugging if something goes wrong)
+logfile="/var/log/rtorrentInit.log"
+#######################
+###END CONFIGURATION###
+#######################
+PATH=/usr/bin:/usr/local/bin:/usr/local/sbin:/sbin:/bin:/usr/sbin
+DESC="rtorrent"
+NAME=rtorrent
+DAEMON=$NAME
+SCRIPTNAME=/etc/init.d/$NAME
+
+checkcnfg() {
+    exists=0
+    for i in `echo "$PATH" | tr ':' '\n'` ; do
+        if [ -f $i/$NAME ] ; then
+            exists=1
+            break
+        fi
+    done
+    if [ $exists -eq 0 ] ; then
+        echo "cannot find rtorrent binary in PATH $PATH" | tee -a "$logfile" >&2
+        exit 3
+    fi
+    if ! [ -r "${config}" ] ; then 
+        echo "cannot find readable config ${config}. check that it is there and permissions are appropriate" | tee -a "$logfile" >&2
+        exit 3 
+    fi 
+    session=`getsession "$config"` 
+    if ! [ -d "${session}" ] ; then
+        echo "cannot find readable session directory ${session} from config ${config}. check permissions" | tee -a "$logfile" >&2
+        exit 3
+    fi
+}
+
+d_start() {
+  [ -d "${base}" ] && cd "${base}"
+  stty stop undef && stty start undef
+  su -c "screen -ls | grep -sq "\.${srnname}[[:space:]]" " ${user} || su -c "screen -dm -S ${srnname} 2>&1 1>/dev/null" ${user} | tee -a "$logfile" >&2
+  # this works for the screen command, but starting rtorrent below adopts screen session gid
+  # even if it is not the screen session we started (e.g. running under an undesirable gid
+  #su -c "screen -ls | grep -sq "\.${srnname}[[:space:]]" " ${user} || su -c "sg \"$group\" -c \"screen -fn -dm -S ${srnname} 2>&1 1>/dev/null\"" ${user} | tee -a "$logfile" >&2
+  su -c "screen -S "${srnname}" -X screen rtorrent ${options} 2>&1 1>/dev/null" ${user} | tee -a "$logfile" >&2
+}
+
+d_stop() {
+    session=`getsession "$config"`
+    if ! [ -s ${session}/rtorrent.lock ] ; then
+        return
+    fi
+    pid=`cat ${session}/rtorrent.lock | awk -F: '{print($2)}' | sed "s/[^0-9]//g"`
+    if ps -A | grep -sq ${pid}.*rtorrent ; then # make sure the pid doesn't belong to another process
+        kill -s INT ${pid}
+    fi
+}
+
+getsession() { 
+    session=`cat "$1" | grep "^[[:space:]]*session.path.set[[:space:]]*=" | sed "s/^[[:space:]]*session.path.set[[:space:]]*=[[:space:]]*//" `
+    echo $session
+}
+
+checkcnfg
+
+case "$1" in
+  start)
+    echo -n "Starting $DESC: $NAME"
+    d_start
+    echo "."
+    ;;
+  stop)
+    echo -n "Stopping $DESC: $NAME"
+    d_stop
+    echo "."
+    ;;
+  restart|force-reload)
+    echo -n "Restarting $DESC: $NAME"
+    d_stop
+    sleep 1
+    d_start
+    echo "."
+    ;;
+  *)
+    echo "Usage: $SCRIPTNAME {start|stop|restart|force-reload}" >&2
+    exit 1
+    ;;
+esac
+
+exit 0

doc/scripts/init/rtorrentInitTmux.bash

@@ -0,0 +1,166 @@
+#!/bin/bash
+### BEGIN INIT INFO
+# Provides:          rtorrent_autostart
+# Required-Start:    $local_fs $remote_fs $network $syslog $netdaemons
+# Required-Stop:     $local_fs $remote_fs
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: rtorrent script using tmux
+# Description:       rtorrent script using tmux
+### END INIT INFO
+
+#############
+###<Notes>###
+#############
+# This script depends on tmux and is based on 'rtorrentInitScreen.sh' script
+# with the following enhancements:
+#  - init script 'start' option can be called without breaking anything
+#  - init script 'status' option can be used in scripts to determine whether rtorrent is running or not
+#  - auto removes damaged/stuck 'rtorrent.lock' file if necessary
+#  - saves session (just in case) before stopping with 'rtxmlrp' if it exists
+#  - provides examples how to script tmux windows
+#
+# For the stop function to work, you must set an explicit session directory
+# using ABSOLUTE paths (no, ~ is not absolute) in your rtorrent.rc and with
+# "sessiondir" option.
+# If you typically just start rtorrent with just "rtorrent" on the
+# command line, all you need to change is the "user" and "sessiondir" option.
+# Attach to the tmux session as your user with
+# "tmux -2u new-session -A -s rtorrent". Change "rtorrent" with "tmuxname" option.
+# Licensed under the GPLv2 by lostnihilist: lostnihilist _at_ gmail _dot_ com
+##############
+###</Notes>###
+##############
+
+#######################
+##Start Configuration##
+#######################
+# You can specify your configuration in a different file.
+# (so that it is saved with upgrades, saved in your home directory,
+# or whatever reason you want to)
+# by commenting out/deleting the configuration lines and placing them
+# in a text file (say /home/user/.rtorrent.init.conf) exactly as you would
+# have written them here (you can leave the comments if you desire
+# and then uncommenting the following line correcting the path/filename.
+# for the one you used. note the space after the ".".
+# . /etc/rtorrent.init.conf
+
+# system user to run as
+user="username"
+
+# default directory for tmux, needs to be an absolute path
+base=$(su -c 'echo $HOME' $user)
+
+# the full path to the filename where you store your rtorrent configuration
+config="$base/.rtorrent.rc"
+
+# the full path to the session directory of rtorrent
+sessiondir="/mnt/Torrents/.rtorrent/.session"
+
+# options to pass to rtorrent; e.g. don't read config from $HOME but load alternate
+#options="-n -O import=$config"
+options=""
+
+# name of tmux session
+tmuxname="rtorrent"
+
+# name of window in tmux session
+tmuxwindowname="rT"
+#######################
+###END CONFIGURATION###
+#######################
+PATH=/usr/bin:/usr/local/bin:/usr/local/sbin:/sbin:/bin:/usr/sbin
+NAME=rtorrent
+DAEMON=$NAME
+SCRIPTNAME=/etc/init.d/$NAME
+RTXMLRPCBIN="$base/bin/rtxmlrpc"
+
+
+checkcnfg() {
+    if [ -z "$(which $DAEMON)" ] ; then
+        echo "Cannot find $DAEMON binary in PATH: $PATH"
+        exit 3
+    fi
+    if ! [ -r "$config" ] ; then
+        echo "Cannot find readable config $config. Check that it is there and permissions are appropriate"
+        exit 3
+    fi
+    if ! [ -d "$sessiondir" ] ; then
+        echo "Cannot find readable session directory $sessiondir from config $config. Check permissions"
+        exit 3
+    fi
+}
+
+
+status() {
+    if [ -e "${sessiondir}/rtorrent.lock" ] ; then
+	pid=`cat ${sessiondir}/rtorrent.lock | awk -F: '{print($2)}' | sed "s/[^0-9]//g"`
+	# make sure the pid isn't empty and doesn't belong to another process : this will match lines containing rtorrent, which grep '[r]torrent' does not!
+	# if there is no process as the 'pid' suggests then delete the stuck "rtorrent.lock" file (to be able to start rtorrent)
+	[[ -n "$pid" ]] && ps aux | grep -sq ${pid}.*[r]torrent && echo -e ${pid} || rm -f "${sessiondir}/rtorrent.lock"
+    fi
+}
+
+
+d_start() {
+    [ -d "$base" ] && cd "$base"
+    # if STDIN is a terminal (we are using interactive mode)
+    [ -t 0 ] && stty stop undef && stty start undef
+    # start the default 2 tmux window (bash and mc) if there isn't tmux session called "tmuxname" option (rtorrent)
+    if ! su -c "tmux ls | grep -sq ${tmuxname}: " $user ; then
+	# 1st window (0): split it into 3 panes, display 'date' in the last one
+	su -c "tmux -2u new-session -d -s ${tmuxname} -n 'shell1'" $user
+	su -c "tmux -2u split-window -v -t ${tmuxname}:0 'bash'" $user
+	su -c "tmux -2u split-window -h -t ${tmuxname}:0 'date; bash'" $user
+	# 2nd window (1): start 'mc' if it exists
+	su -c "tmux -2u new-window -t ${tmuxname}:1 -n 'mc1' 'command which mc && mc ~/; bash'" $user
+    fi
+    # start rtorrent always in the 3rd tmux window (2) if it's not running and leave shell behind to be able to see reason of a crash
+    if [ "$(status)" == "" ]; then
+	su -c "tmux -2u list-panes -t ${tmuxname}:2 &>/dev/null && tmux -2u respawn-pane -t ${tmuxname}:2 -k \"${DAEMON} ${options}; bash\" || tmux -2u new-window -t ${tmuxname}:2 -n ${tmuxwindowname} \"${DAEMON} ${options}; bash\"" $user
+    fi
+}
+
+
+d_stop() {
+    pid=$(status)
+    if [ "$pid" != "" ]; then
+	# save session before stopping explicitly (just in case) if rtxmlrpc util exists then wait for 5 seconds to be able to complete it
+	[ -L "$RTXMLRPCBIN" ] && "$RTXMLRPCBIN" session.save &>/dev/null && sleep 5
+	# INT (2, Interrupt from keyboard): normal shutdown
+	kill -s INT $pid
+    fi
+}
+
+
+checkcnfg
+
+
+case "$1" in
+    start)
+        echo -n "Starting $tmuxwindowname: $NAME"
+        d_start
+        echo "."
+        ;;
+    stop)
+        echo -n "Stopping $tmuxwindowname: $NAME"
+        d_stop
+        echo "."
+        ;;
+    restart|force-reload)
+        echo -n "Restarting $tmuxwindowname: $NAME"
+        d_stop
+        sleep 1
+        d_start
+        echo "."
+        ;;
+    status)
+        status
+        ;;
+    *)
+        echo "Usage: $SCRIPTNAME {start|stop|restart|force-reload|status}" >&2
+        exit 1
+        ;;
+esac
+
+exit 0

doc/scripts/print_option_string.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+PORT_NUMBER=${1:-5001}
+
+echo "Option Strings"
+echo "=============="
+echo
+echo "Introduction"
+echo "------------"
+echo
+echo "Client version: " `xmlrpc2scgi.py -p scgi://127.0.0.1:${PORT_NUMBER} system.client_version`
+echo
+echo "Generated by 'rtorrent/doc/scripts/print_option_string.sh' on `date -u`."
+
+for i in strings.choke_heuristics strings.choke_heuristics.upload strings.choke_heuristics.download strings.connection_type strings.encryption strings.ip_filter strings.ip_tos strings.log_group strings.tracker_event strings.tracker_mode; do
+  echo
+  echo $i
+  echo `echo $i | tr 'a-z_.' '-'`
+  echo
+  echo '```'
+  xmlrpc2scgi.py -p scgi://127.0.0.1:${PORT_NUMBER} $i | tr , '\n' | tr '[' ' ' | tr ']' ' '
+  echo '```'
+done

doc/torrent_data

@@ -0,0 +1,23 @@
+#!/usr/bin/perl
+
+# Perl script to read torrent data
+
+use strict;
+use warnings;
+use Convert::Bencode_XS qw(bdecode);
+use Data::Dumper;
+
+$/ = undef;
+$| = 1;
+
+my $in;
+my $in_file = $ARGV[0];
+if ($in_file) { open($in, '<', $in_file) || die "Cannot open $in_file for input!\n"; }
+else          { $in = *STDIN; }
+
+print "Total input torrent size: ".sprintf('%.2f', (-s $in_file) / 1024)." KB\n" if $in_file;
+print "Decoding ".($in_file || 'torrent from standard input')."...";
+my $t = bdecode(scalar <$in>);
+print "done\n\n";
+
+print Data::Dumper->new([$t], ['*Torrent'])->Indent(1)->Useqq(1)->Quotekeys(0)->Sortkeys(1)->Dump;

donate.md

@@ -1,14 +0,0 @@
-Donate to rTorrent development
-==============================
-
- * [Paypal](https://paypal.me/jarisundellno)
- * [Patreon](https://www.patreon.com/rtorrent)
- * [SubscribeStar](https://www.subscribestar.com/rtorrent)
- * Bitcoin: 1MpmXm5AHtdBoDaLZstJw8nupJJaeKu8V8
- * Ethereum: 0x9AB1e3C3d8a875e870f161b3e9287Db0E6DAfF78
- * Litecoin: LdyaVR67LBnTf6mAT4QJnjSG2Zk67qxmfQ
- * Cardano: addr1qytaslmqmk6dspltw06sp0zf83dh09u79j49ceh5y26zdcccgq4ph7nmx6kgmzeldauj43254ey97f3x4xw49d86aguqwfhlte
-
-Help keep rTorrent development going by donating to its creator.
-
-(Note the old paypal account is defunct, please use the new one when sending donations)

donate_paypal_green.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="96" height="20"><linearGradient id="b" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="a"><rect width="96" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#a)"><path fill="#555" d="M0 0h49v20H0z"/><path fill="#97ca00" d="M49 0h47v20H49z"/><path fill="url(#b)" d="M0 0h96v20H0z"/></g><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="110"> <text x="255" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="390">Donate</text><text x="255" y="140" transform="scale(.1)" textLength="390">Donate</text><text x="715" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="370">PayPal</text><text x="715" y="140" transform="scale(.1)" textLength="370">PayPal</text></g> </svg>

javascripts/main.js

@@ -1 +0,0 @@
-console.log('This would be the main JS file.');

javascripts/scale.fix.js

@@ -1,17 +0,0 @@
-var metas = document.getElementsByTagName('meta');
-var i;
-if (navigator.userAgent.match(/iPhone/i)) {
-  for (i=0; i<metas.length; i++) {
-    if (metas[i].name == "viewport") {
-      metas[i].content = "width=device-width, minimum-scale=1.0, maximum-scale=1.0";
-    }
-  }
-  document.addEventListener("gesturestart", gestureStart, false);
-}
-function gestureStart() {
-  for (i=0; i<metas.length; i++) {
-    if (metas[i].name == "viewport") {
-      metas[i].content = "width=device-width, minimum-scale=0.25, maximum-scale=1.6";
-    }
-  }
-}

rak/address_info.h

@@ -0,0 +1,98 @@
+// rak - Rakshasa's toolbox
+// Copyright (C) 2005-2007, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+// Wrapper for addrinfo with focus on zero-copy conversion to and from
+// the c-type and wrapper.
+//
+// Do use the wrapper on a pre-existing struct addrinfo, cast the
+// pointer rather than the base type.
+
+#ifndef RAK_ADDRESS_INFO_H
+#define RAK_ADDRESS_INFO_H
+
+#include <netdb.h>
+#include <rak/socket_address.h>
+
+namespace rak {
+
+class address_info {
+public:
+  void                clear()                       { std::memset(this, 0, sizeof(address_info)); }
+
+  int                 flags() const                 { return m_addrinfo.ai_flags; }
+  void                set_flags(int f)              { m_addrinfo.ai_flags = f; }
+
+  int                 family() const                { return m_addrinfo.ai_family; }
+  void                set_family(int f)             { m_addrinfo.ai_family = f; }
+
+  int                 socket_type() const           { return m_addrinfo.ai_socktype; }
+  void                set_socket_type(int t)        { m_addrinfo.ai_socktype = t; }
+  
+  int                 protocol() const              { return m_addrinfo.ai_protocol; }
+  void                set_protocol(int p)           { m_addrinfo.ai_protocol = p; }
+  
+  size_t              length() const                { return m_addrinfo.ai_addrlen; }
+
+  socket_address*     address()                     { return reinterpret_cast<socket_address*>(m_addrinfo.ai_addr); }
+
+  addrinfo*           c_addrinfo()                  { return &m_addrinfo; }
+  const addrinfo*     c_addrinfo() const            { return &m_addrinfo; }
+
+  address_info*       next()                        { return reinterpret_cast<address_info*>(m_addrinfo.ai_next); }
+
+  static int          get_address_info(const char* node, int domain, int type, address_info** ai);
+
+  static void         free_address_info(address_info* ai) { ::freeaddrinfo(ai->c_addrinfo()); }
+
+  static const char*  strerror(int err)                   { return gai_strerror(err); }
+
+private:
+  addrinfo            m_addrinfo;
+};
+
+inline int
+address_info::get_address_info(const char* node, int pfamily, int stype, address_info** ai) {
+  address_info hints;
+  hints.clear();
+  hints.set_family(pfamily);
+  hints.set_socket_type(stype);
+  
+  return ::getaddrinfo(node, NULL, hints.c_addrinfo(), reinterpret_cast<addrinfo**>(ai));
+}
+
+}
+
+#endif

rak/algorithm.h

@@ -0,0 +1,198 @@
+// rak - Rakshasa's toolbox
+// Copyright (C) 2005-2007, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+#ifndef RAK_ALGORITHM_H
+#define RAK_ALGORITHM_H
+
+#include <algorithm>
+#include <functional>
+#include <limits>
+
+namespace rak {
+
+template <typename _InputIter, typename _Function>
+_Function
+for_each_pre(_InputIter __first, _InputIter __last, _Function __f) {
+  _InputIter __tmp;
+
+  while (__first != __last) {
+    __tmp = __first++;
+    
+    __f(*__tmp);
+  }
+
+  return __f;
+}
+
+// Return a range with a distance of no more than __distance and
+// between __first and __last, centered on __middle1.
+template <typename _InputIter, typename _Distance>
+std::pair<_InputIter, _InputIter>
+advance_bidirectional(_InputIter __first, _InputIter __middle1, _InputIter __last, _Distance __distance) {
+  _InputIter __middle2 = __middle1;
+
+  do {
+    if (!__distance)
+      break;
+
+    if (__middle2 != __last) {
+      ++__middle2;
+      --__distance;
+
+    } else if (__middle1 == __first) {
+      break;
+    }
+
+    if (!__distance)
+      break;
+
+    if (__middle1 != __first) {
+      --__middle1;
+      --__distance;
+
+    } else if (__middle2 == __last) {
+      break;
+    }
+
+  } while (true);
+
+  return std::make_pair(__middle1, __middle2);
+}
+
+template <typename _InputIter, typename _Distance>
+_InputIter
+advance_forward(_InputIter __first, _InputIter __last, _Distance __distance) {
+  while (__first != __last && __distance != 0) {
+    __first++;
+    __distance--;
+  }
+
+  return __first;
+}
+
+template <typename _InputIter, typename _Distance>
+_InputIter
+advance_backward(_InputIter __first, _InputIter __last, _Distance __distance) {
+  while (__first != __last && __distance != 0) {
+    __first--;
+    __distance--;
+  }
+
+  return __first;
+}
+
+template <typename _Value>
+struct compare_base : public std::function<bool(_Value, _Value)> {
+  bool operator () (const _Value& complete, const _Value& base) const {
+    return !complete.compare(0, base.size(), base);
+  }
+};
+
+// Count the number of elements from the start of the containers to
+// the first inequal element.
+template <typename _InputIter1, typename _InputIter2>
+typename std::iterator_traits<_InputIter1>::difference_type
+count_base(_InputIter1 __first1, _InputIter1 __last1,
+	   _InputIter2 __first2, _InputIter2 __last2) {
+
+  typename std::iterator_traits<_InputIter1>::difference_type __n = 0;
+
+  for ( ;__first1 != __last1 && __first2 != __last2; ++__first1, ++__first2, ++__n)
+    if (*__first1 != *__first2)
+      return __n;
+
+  return __n;
+}
+
+template <typename _Return, typename _InputIter, typename _Ftor>
+_Return
+make_base(_InputIter __first, _InputIter __last, _Ftor __ftor) {
+  if (__first == __last)
+    return "";
+
+  _Return __base = __ftor(*__first++);
+
+  for ( ;__first != __last; ++__first) {
+    typename std::iterator_traits<_InputIter>::difference_type __pos = count_base(__base.begin(), __base.end(),
+										  __ftor(*__first).begin(), __ftor(*__first).end());
+
+    if (__pos < (typename std::iterator_traits<_InputIter>::difference_type)__base.size())
+      __base.resize(__pos);
+  }
+
+  return __base;
+}
+
+template<typename T>
+inline int popcount_wrapper(T t) {
+#if USE_BUILTIN_POPCOUNT
+  return __builtin_popcountll(t);
+#else
+#error __builtin_popcount not found.
+  unsigned int count = 0;
+  
+  while (t) {
+    count += t & 0x1;
+    t >> 1;
+  }
+
+  return count;
+#endif
+}
+
+// Get the median of an unordered set of numbers of arbitrary
+// type by modifing the underlying dataset
+template <typename T = double, typename _InputIter>
+T median(_InputIter __first, _InputIter __last) {
+  T __med;
+
+  unsigned int __size = __last - __first;
+  unsigned int __middle = __size / 2;
+  _InputIter __target1 = __first + __middle;
+  std::nth_element(__first, __target1, __last);
+  __med = *__target1;
+
+  if (__size % 2 == 0) {
+    _InputIter __target2 = std::max_element(__first, __target1);
+    __med = (__med + *__target2) / 2.0;
+  }
+
+  return __med;
+}
+
+}
+
+#endif

rak/error_number.h

@@ -0,0 +1,88 @@
+// rak - Rakshasa's toolbox
+// Copyright (C) 2005-2007, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+#ifndef RAK_ERROR_NUMBER_H
+#define RAK_ERROR_NUMBER_H
+
+#include <cerrno>
+#include <cstring>
+
+namespace rak {
+
+class error_number {
+public:
+  static const int e_access      = EACCES;
+  static const int e_again       = EAGAIN;
+  static const int e_connreset   = ECONNRESET;
+  static const int e_connaborted = ECONNABORTED;
+  static const int e_deadlk      = EDEADLK;
+
+  static const int e_noent       = ENOENT;
+  static const int e_nodev       = ENODEV;
+  static const int e_nomem       = ENOMEM;
+  static const int e_notdir      = ENOTDIR;
+  static const int e_isdir       = EISDIR;
+  
+  static const int e_intr        = EINTR;
+
+  error_number() : m_errno(0) {}
+  error_number(int e) : m_errno(e) {}
+
+  bool                is_valid() const             { return m_errno != 0; }
+
+  int                 value() const                { return m_errno; }
+  const char*         c_str() const                { return std::strerror(m_errno); }
+
+  bool                is_blocked_momentary() const { return m_errno == e_again || m_errno == e_intr; }
+  bool                is_blocked_prolonged() const { return m_errno == e_deadlk; }
+
+  bool                is_closed() const            { return m_errno == e_connreset || m_errno == e_connaborted; }
+
+  bool                is_bad_path() const          { return m_errno == e_noent || m_errno == e_notdir || m_errno == e_access; }
+
+  static error_number current()                    { return errno; }
+  static void         clear_global()               { errno = 0; }
+  static void         set_global(error_number err) { errno = err.m_errno; }
+
+  bool operator == (const error_number& e) const   { return m_errno == e.m_errno; }
+
+private:
+  int                 m_errno;
+};
+
+}
+
+#endif

rak/file_stat.h

@@ -0,0 +1,77 @@
+// rak - Rakshasa's toolbox
+// Copyright (C) 2005-2007, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+#ifndef RAK_FILE_STAT_H
+#define RAK_FILE_STAT_H
+
+#include <string>
+#include <cinttypes>
+#include <sys/stat.h>
+
+namespace rak {
+
+class file_stat {
+public:
+  // Consider storing rak::error_number.
+
+  bool                update(int fd)                        { return fstat(fd, &m_stat) == 0; }
+  bool                update(const char* filename)          { return stat(filename, &m_stat) == 0; }
+  bool                update(const std::string& filename)   { return update(filename.c_str()); }
+
+  bool                update_link(const char* filename)        { return lstat(filename, &m_stat) == 0; }
+  bool                update_link(const std::string& filename) { return update_link(filename.c_str()); }
+
+  bool                is_regular() const                    { return S_ISREG(m_stat.st_mode); }
+  bool                is_directory() const                  { return S_ISDIR(m_stat.st_mode); }
+  bool                is_character() const                  { return S_ISCHR(m_stat.st_mode); }
+  bool                is_block() const                      { return S_ISBLK(m_stat.st_mode); }
+  bool                is_fifo() const                       { return S_ISFIFO(m_stat.st_mode); }
+  bool                is_link() const                       { return S_ISLNK(m_stat.st_mode); }
+  bool                is_socket() const                     { return S_ISSOCK(m_stat.st_mode); }
+
+  off_t               size() const                          { return m_stat.st_size; }
+
+  time_t              access_time() const                   { return m_stat.st_atime; }
+  time_t              change_time() const                   { return m_stat.st_ctime; }
+  time_t              modified_time() const                 { return m_stat.st_mtime; }
+
+private:
+  struct stat         m_stat;
+};
+
+}
+
+#endif

rak/fs_stat.h

@@ -0,0 +1,84 @@
+// rak - Rakshasa's toolbox
+// Copyright (C) 2005-2007, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+#ifndef RAK_FS_STAT_H
+#define RAK_FS_STAT_H
+
+#include <string>
+#include <cinttypes>
+
+#include <rak/error_number.h>
+
+#if HAVE_SYS_VFS_H
+#include <sys/vfs.h>
+#endif
+#if HAVE_SYS_STATVFS_H
+#include <sys/statvfs.h>
+#endif
+#if HAVE_SYS_STATFS_H
+#include <sys/statfs.h>
+#endif
+#if HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+#if HAVE_SYS_MOUNT_H
+#include <sys/mount.h>
+#endif
+
+namespace rak {
+
+class fs_stat {
+public:
+
+  typedef FS_STAT_SIZE_TYPE  blocksize_type;
+  typedef FS_STAT_COUNT_TYPE blockcount_type;
+  typedef FS_STAT_STRUCT     fs_stat_type;
+
+  bool                       update(int fd)                       { return FS_STAT_FD; }
+  bool                       update(const char* fn)               { return FS_STAT_FN; }
+  bool                       update(const std::string& filename)  { return update(filename.c_str()); }
+
+  blocksize_type             blocksize()                          { return FS_STAT_BLOCK_SIZE; }
+  blockcount_type            blocks_avail()                       { return m_stat.f_bavail; }
+  int64_t                    bytes_avail()                        { return (int64_t) blocksize() * m_stat.f_bavail; }
+
+private:
+  fs_stat_type               m_stat;
+};
+
+}
+
+#endif

rak/partial_queue.h

@@ -0,0 +1,199 @@
+// rak - Rakshasa's toolbox
+// Copyright (C) 2005-2007, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+#ifndef RAK_PARTIAL_QUEUE_H
+#define RAK_PARTIAL_QUEUE_H
+
+#include <array>
+#include <cstring>
+#include <stdexcept>
+#include <cinttypes>
+
+namespace rak {
+
+// First step, don't allow overflowing to the next layer. Only disable
+// the above layers for now.
+
+// We also include 0 in a single layer as some chunk may be available
+// only through seeders.
+
+class partial_queue {
+public:
+  typedef uint8_t                         key_type;
+  typedef uint32_t                        mapped_type;
+  typedef uint16_t                        size_type;
+  typedef std::pair<size_type, size_type> size_pair_type;
+
+  static const size_type num_layers = 8;
+
+  partial_queue() : m_data(NULL), m_maxLayerSize(0) {}
+  ~partial_queue() { disable(); }
+
+  bool                is_full() const                         { return m_ceiling == 0; }
+  bool                is_layer_full(size_type l) const        { return m_layers[l].second >= m_maxLayerSize; }
+
+  bool                is_enabled() const                      { return m_data != NULL; }
+
+  // Add check to see if we can add more. Also make it possible to
+  // check how full we are in the lower parts so the caller knows when
+  // he can stop searching.
+  //
+  // Though propably not needed, as we must continue til the first
+  // layer is full.
+
+  size_type           max_size() const                        { return m_maxLayerSize * num_layers; }
+  size_type           max_layer_size() const                  { return m_maxLayerSize; }
+
+  // Must be less that or equal to (max size_type) / num_layers.
+  void                enable(size_type ls);
+  void                disable();
+
+  void                clear();
+
+  // Safe to call while pop'ing and it will not reuse pop'ed indices
+  // so it is guaranteed to reach max_size at some point. This will
+  // ensure that the user needs to refill with new data at regular
+  // intervals.
+  bool                insert(key_type key, mapped_type value);
+
+  // Only call this when pop'ing as it moves the index.
+  bool                prepare_pop();
+
+  mapped_type         pop();
+
+private:
+  partial_queue(const partial_queue&);
+  void operator = (const partial_queue&);
+
+  static size_type    ceiling(size_type layer)                { return (2 << layer) - 1; }
+
+  void                find_non_empty();
+
+  mapped_type*        m_data;
+  size_type           m_maxLayerSize;
+
+  size_type           m_index;
+  size_type           m_ceiling;
+
+  std::array<size_pair_type, num_layers> m_layers;
+};
+
+inline void
+partial_queue::enable(size_type ls) {
+  if (ls == 0)
+    throw std::logic_error("partial_queue::enable(...) ls == 0.");
+
+  delete [] m_data;
+  m_data = new mapped_type[ls * num_layers];
+
+  m_maxLayerSize = ls;
+}
+
+inline void
+partial_queue::disable() {
+  delete [] m_data;
+  m_data = NULL;
+
+  m_maxLayerSize = 0;
+}
+
+inline void
+partial_queue::clear() {
+  if (m_data == NULL)
+    return;
+
+  m_index = 0;
+  m_ceiling = ceiling(num_layers - 1);
+
+  m_layers = {};
+}
+
+inline bool
+partial_queue::insert(key_type key, mapped_type value) {
+  if (key >= m_ceiling)
+    return false;
+
+  size_type idx = 0;
+
+  // Hmm... since we already check the 'm_ceiling' above, we only need
+  // to find the target layer. Could this be calculated directly?
+  while (key >= ceiling(idx))
+    ++idx;
+
+  m_index = std::min(m_index, idx);
+
+  // Currently don't allow overflow.
+  if (is_layer_full(idx))
+    throw std::logic_error("partial_queue::insert(...) layer already full.");
+    //return false;
+
+  m_data[m_maxLayerSize * idx + m_layers[idx].second] = value;
+  m_layers[idx].second++;
+
+  if (is_layer_full(idx))
+    // Set the ceiling to 0 when layer 0 is full so no more values can
+    // be inserted.
+    m_ceiling = idx > 0 ? ceiling(idx - 1) : 0;
+
+  return true;
+}
+
+// is_empty() will iterate to the first layer with un-popped elements
+// and return true, else return false when it reaches a overflowed or
+// the last layer.
+inline bool
+partial_queue::prepare_pop() {
+  while (m_layers[m_index].first == m_layers[m_index].second) {
+    if (is_layer_full(m_index) || m_index + 1 == num_layers)
+      return false;
+
+    m_index++;
+  }
+
+  return true;
+}
+
+inline partial_queue::mapped_type
+partial_queue::pop() {
+  if (m_index >= num_layers || m_layers[m_index].first >= m_layers[m_index].second)
+    throw std::logic_error("partial_queue::pop() bad state.");
+
+  return m_data[m_index * m_maxLayerSize + m_layers[m_index].first++];
+}
+
+}
+
+#endif

rak/path.h

@@ -0,0 +1,107 @@
+// rak - Rakshasa's toolbox
+// Copyright (C) 2005-2007, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+// Various functions for manipulating file paths. Also consider making
+// a directory iterator.
+
+#ifndef RAK_PATH_H
+#define RAK_PATH_H
+
+#include <cstdlib>
+#include <string>
+
+namespace rak {
+
+inline std::string
+path_expand(const std::string& path) {
+  if (path.empty() || path[0] != '~')
+    return path;
+
+  char* home = std::getenv("HOME");
+
+  if (home == NULL)
+    return path;
+  
+  return home + path.substr(1);
+}
+
+// Don't inline this...
+//
+// Same strlcpy as found in *bsd.
+inline size_t
+strlcpy(char *dest, const char *src, size_t size) {
+  size_t n = size;
+  const char* first = src;
+
+  if (n != 0) {
+    while (--n != 0)
+      if ((*dest++ = *src++) == '\0')
+        break;
+  }
+
+  if (n == 0) {
+    if (size != 0)
+      *dest = '\0';
+    
+    while (*src++)
+      ;
+  }
+
+  return src - first - 1;
+}
+
+inline char*
+path_expand(const char* src, char* first, char* last) {
+  if (*src == '~') {
+    char* home = std::getenv("HOME");
+
+    if (home == NULL)
+      return first;
+
+    first += strlcpy(first, home, std::distance(first, last));
+
+    if (first > last)
+      return last;
+
+    src++;
+  }
+
+  return std::min(first + strlcpy(first, src, std::distance(first, last)), last);
+}
+
+}
+
+#endif

rak/regex.h

@@ -0,0 +1,111 @@
+// rak - Rakshasa's toolbox
+// Copyright (C) 2005-2007, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+// This is a hacked up whole string pattern matching. Replace with
+// TR1's regex when that becomes widely available. It is intended for
+// small strings.
+
+#ifndef RAK_REGEX_H
+#define RAK_REGEX_H
+
+#include <sys/types.h>
+
+#include <algorithm>
+#include <functional>
+#include <string>
+#include <list>
+
+namespace rak {
+
+class regex : public std::function<bool (std::string)> {
+public:
+  regex() {}
+  regex(const std::string& p) : m_pattern(p) {}
+
+  const std::string& pattern() const { return m_pattern; }
+
+  bool operator () (const std::string& p) const;
+
+private:
+  std::string m_pattern;
+};
+
+// This isn't optimized, or very clean. A simple hack that should work.
+inline bool
+regex::operator () (const std::string& text) const {
+  if (m_pattern.empty() ||
+      text.empty() ||
+      (m_pattern[0] != '*' && m_pattern[0] != text[0]))
+    return false;
+
+  // Replace with unordered_vector?
+  std::list<unsigned int> paths;
+  paths.push_front(0);
+
+  for (std::string::const_iterator itrText = ++text.begin(), lastText = text.end(); itrText != lastText; ++itrText) {
+    
+    for (std::list<unsigned int>::iterator itrPaths = paths.begin(), lastPaths = paths.end(); itrPaths != lastPaths; ) {
+
+      unsigned int next = *itrPaths + 1;
+
+      if (m_pattern[*itrPaths] != '*')
+	itrPaths = paths.erase(itrPaths);
+      else
+	itrPaths++;
+
+      // When we reach the end of 'm_pattern', we don't have a whole
+      // match of 'text'.
+      if (next == m_pattern.size())
+	continue;
+
+      // Push to the back so that '*' will match zero length strings.
+      if (m_pattern[next] == '*')
+	paths.push_back(next);
+
+      if (m_pattern[next] == *itrText)
+	paths.push_front(next);
+    }
+
+    if (paths.empty())
+      return false;
+  }
+
+  return std::find(paths.begin(), paths.end(), m_pattern.size() - 1) != paths.end();
+}
+
+}
+
+#endif

rak/socket_address.h

@@ -0,0 +1,559 @@
+// rak - Rakshasa's toolbox
+// Copyright (C) 2005-2007, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+// Wrappers for the various sockaddr types with focus on zero-copy
+// casting between the original type and the wrapper class.
+//
+// The default ctor does not initialize any data.
+//
+// _n suffixes indicate that the argument or return value is in
+// network byte order, _h that they are in hardware byte order.
+
+// Add define for inet6 scope id?
+
+#ifndef RAK_SOCKET_ADDRESS_H
+#define RAK_SOCKET_ADDRESS_H
+
+#include <cinttypes>
+#include <cstdint>
+#include <cstring>
+#include <stdexcept>
+#include <string>
+
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+namespace rak {
+
+class socket_address_inet;
+class socket_address_inet6;
+
+class socket_address {
+public:
+  static const sa_family_t af_inet   = AF_INET;
+  static const int         pf_inet   = PF_INET;
+  static const sa_family_t af_inet6  = AF_INET6;
+  static const int         pf_inet6  = PF_INET6;
+  static const sa_family_t af_unspec = AF_UNSPEC;
+  static const int         pf_unspec = PF_UNSPEC;
+
+#ifdef AF_LOCAL
+  static const sa_family_t af_local  = AF_LOCAL;
+  static const int         pf_local  = PF_LOCAL;
+#else
+  static const sa_family_t af_local  = AF_UNIX;
+  static const int         pf_local  = PF_UNIX;
+#endif
+
+  bool                is_any() const;
+  bool                is_valid() const;
+  bool                is_bindable() const;
+  bool                is_address_any() const;
+
+  bool                is_valid_inet_class() const             { return family() == af_inet || family() == af_inet6; }
+
+  void                clear()                                 { std::memset(this, 0, sizeof(socket_address)); set_family(); }
+
+  sa_family_t         family() const                          { return m_sockaddr.sa_family; }
+  void                set_family()                            { m_sockaddr.sa_family = af_unspec; }
+
+  uint16_t            port() const;
+  void                set_port(uint16_t p);
+
+  std::string         address_str() const;
+  bool                address_c_str(char* buf, socklen_t size) const;
+
+  std::string         pretty_address_str() const;
+
+  // Attemts to set it as an inet, then an inet6 address. It will
+  // never set anything but net addresses, no local/unix.
+  bool                set_address_str(const std::string& a)   { return set_address_c_str(a.c_str()); }
+  bool                set_address_c_str(const char* a);
+
+  uint32_t            length() const;
+
+  socket_address_inet*        sa_inet()                       { return reinterpret_cast<socket_address_inet*>(this); }
+  const socket_address_inet*  sa_inet() const                 { return reinterpret_cast<const socket_address_inet*>(this); }
+
+  sockaddr*           c_sockaddr()                            { return &m_sockaddr; }
+  sockaddr_in*        c_sockaddr_inet()                       { return &m_sockaddrInet; }
+
+  const sockaddr*     c_sockaddr() const                      { return &m_sockaddr; }
+  const sockaddr_in*  c_sockaddr_inet() const                 { return &m_sockaddrInet; }
+
+  socket_address_inet6*       sa_inet6()                      { return reinterpret_cast<socket_address_inet6*>(this); }
+  const socket_address_inet6* sa_inet6() const                { return reinterpret_cast<const socket_address_inet6*>(this); }
+
+  sockaddr_in6*       c_sockaddr_inet6()                      { return &m_sockaddrInet6; }
+  const sockaddr_in6* c_sockaddr_inet6() const                { return &m_sockaddrInet6; }
+
+  // Copy a socket address which has the length 'length. Zero out any
+  // extranous bytes and ensure it does not go beyond the size of this
+  // struct.
+  void                copy(const socket_address& src, size_t length);
+  void                copy_sockaddr(const sockaddr* src);
+
+  static socket_address*       cast_from(sockaddr* sa)        { return reinterpret_cast<socket_address*>(sa); }
+  static const socket_address* cast_from(const sockaddr* sa)  { return reinterpret_cast<const socket_address*>(sa); }
+
+  // The different families will be sorted according to the
+  // sa_family_t's numeric value.
+  bool                operator == (const socket_address& rhs) const;
+  bool                operator  < (const socket_address& rhs) const;
+
+  bool                operator == (const sockaddr& rhs) const { return *this == *cast_from(&rhs); }
+  bool                operator == (const sockaddr* rhs) const { return *this == *cast_from(rhs); }
+  bool                operator  < (const sockaddr& rhs) const { return *this == *cast_from(&rhs); }
+  bool                operator  < (const sockaddr* rhs) const { return *this == *cast_from(rhs); }
+
+private:
+  union {
+    sockaddr            m_sockaddr;
+    sockaddr_in         m_sockaddrInet;
+    sockaddr_in6        m_sockaddrInet6;
+  };
+};
+
+// Remember to set the AF_INET.
+
+class socket_address_inet {
+public:
+  bool                is_any() const                          { return is_port_any() && is_address_any(); }
+  bool                is_valid() const                        { return !is_port_any() && !is_address_any(); }
+  bool                is_port_any() const                     { return port() == 0; }
+  bool                is_address_any() const                  { return m_sockaddr.sin_addr.s_addr == htonl(INADDR_ANY); }
+
+  void                clear()                                 { std::memset(this, 0, sizeof(socket_address_inet)); set_family(); }
+
+  uint16_t            port() const                            { return ntohs(m_sockaddr.sin_port); }
+  uint16_t            port_n() const                          { return m_sockaddr.sin_port; }
+  void                set_port(uint16_t p)                    { m_sockaddr.sin_port = htons(p); }
+  void                set_port_n(uint16_t p)                  { m_sockaddr.sin_port = p; }
+
+  // Should address() return the uint32_t?
+  in_addr             address() const                         { return m_sockaddr.sin_addr; }
+  uint32_t            address_h() const                       { return ntohl(m_sockaddr.sin_addr.s_addr); }
+  uint32_t            address_n() const                       { return m_sockaddr.sin_addr.s_addr; }
+  std::string         address_str() const;
+  bool                address_c_str(char* buf, socklen_t size) const;
+
+  void                set_address(in_addr a)                  { m_sockaddr.sin_addr = a; }
+  void                set_address_h(uint32_t a)               { m_sockaddr.sin_addr.s_addr = htonl(a); }
+  void                set_address_n(uint32_t a)               { m_sockaddr.sin_addr.s_addr = a; }
+  bool                set_address_str(const std::string& a)   { return set_address_c_str(a.c_str()); }
+  bool                set_address_c_str(const char* a);
+
+  void                set_address_any()                       { set_port(0); set_address_h(INADDR_ANY); }
+
+  sa_family_t         family() const                          { return m_sockaddr.sin_family; }
+  void                set_family()                            { m_sockaddr.sin_family = AF_INET; }
+
+  sockaddr*           c_sockaddr()                            { return reinterpret_cast<sockaddr*>(&m_sockaddr); }
+  sockaddr_in*        c_sockaddr_inet()                       { return &m_sockaddr; }
+
+  const sockaddr*     c_sockaddr() const                      { return reinterpret_cast<const sockaddr*>(&m_sockaddr); }
+  const sockaddr_in*  c_sockaddr_inet() const                 { return &m_sockaddr; }
+  
+  socket_address_inet6 to_mapped_address() const;
+
+  bool                operator == (const socket_address_inet& rhs) const;
+  bool                operator < (const socket_address_inet& rhs) const;
+
+private:
+  struct sockaddr_in  m_sockaddr;
+};
+
+class socket_address_inet6 {
+public:
+  bool                is_any() const                          { return is_port_any() && is_address_any(); }
+  bool                is_valid() const                        { return !is_port_any() && !is_address_any(); }
+  bool                is_port_any() const                     { return port() == 0; }
+  bool                is_address_any() const                  { return std::memcmp(&m_sockaddr.sin6_addr, &in6addr_any, sizeof(in6_addr)) == 0; }
+
+  void                clear()                                 { std::memset(this, 0, sizeof(socket_address_inet6)); set_family(); }
+
+  uint16_t            port() const                            { return ntohs(m_sockaddr.sin6_port); }
+  uint16_t            port_n() const                          { return m_sockaddr.sin6_port; }
+  void                set_port(uint16_t p)                    { m_sockaddr.sin6_port = htons(p); }
+  void                set_port_n(uint16_t p)                  { m_sockaddr.sin6_port = p; }
+
+  in6_addr            address() const                         { return m_sockaddr.sin6_addr; }
+  const in6_addr*     address_ptr() const                     { return &m_sockaddr.sin6_addr; }
+  std::string         address_str() const;
+  bool                address_c_str(char* buf, socklen_t size) const;
+
+  void                set_address(in6_addr a)                 { m_sockaddr.sin6_addr = a; }
+  bool                set_address_str(const std::string& a)   { return set_address_c_str(a.c_str()); }
+  bool                set_address_c_str(const char* a);
+
+  void                set_address_any()                       { set_port(0); set_address(in6addr_any); }
+
+  std::string         pretty_address_str() const;
+
+  sa_family_t         family() const                          { return m_sockaddr.sin6_family; }
+  void                set_family()                            { m_sockaddr.sin6_family = AF_INET6; }
+
+  sockaddr*           c_sockaddr()                            { return reinterpret_cast<sockaddr*>(&m_sockaddr); }
+  sockaddr_in6*       c_sockaddr_inet6()                      { return &m_sockaddr; }
+
+  const sockaddr*     c_sockaddr() const                      { return reinterpret_cast<const sockaddr*>(&m_sockaddr); }
+  const sockaddr_in6* c_sockaddr_inet6() const                { return &m_sockaddr; }
+
+  socket_address      normalize_address() const;
+
+  bool                operator == (const socket_address_inet6& rhs) const;
+  bool                operator < (const socket_address_inet6& rhs) const;
+
+private:
+  struct sockaddr_in6 m_sockaddr;
+};
+
+inline bool
+socket_address::is_any() const {
+  switch (family()) {
+  case af_inet:
+    return sa_inet()->is_any();
+  case af_inet6:
+    return sa_inet6()->is_any();
+  default:
+    return false;
+  }
+}
+
+inline bool
+socket_address::is_valid() const {
+  switch (family()) {
+  case af_inet:
+    return sa_inet()->is_valid();
+  case af_inet6:
+    return sa_inet6()->is_valid();
+  default:
+    return false;
+  }
+}
+
+inline bool
+socket_address::is_bindable() const {
+  switch (family()) {
+  case af_inet:
+    return !sa_inet()->is_address_any();
+  case af_inet6:
+    return !sa_inet6()->is_address_any();
+  default:
+    return false;
+  }
+}
+
+inline bool
+socket_address::is_address_any() const {
+  switch (family()) {
+  case af_inet:
+    return sa_inet()->is_address_any();
+  case af_inet6:
+    return sa_inet6()->is_address_any();
+  default:
+    return true;
+  }
+}
+
+inline uint16_t
+socket_address::port() const {
+  switch (family()) {
+  case af_inet:
+    return sa_inet()->port();
+  case af_inet6:
+    return sa_inet6()->port();
+  default:
+    return 0;
+  }
+}
+
+inline void
+socket_address::set_port(uint16_t p) {
+  switch (family()) {
+  case af_inet:
+    return sa_inet()->set_port(p);
+  case af_inet6:
+    return sa_inet6()->set_port(p);
+  default:
+    break;
+  }
+}
+
+inline std::string
+socket_address::address_str() const {
+  switch (family()) {
+  case af_inet:
+    return sa_inet()->address_str();
+  case af_inet6:
+    return sa_inet6()->address_str();
+  default:
+    return std::string();
+  }
+}
+
+inline bool
+socket_address::address_c_str(char* buf, socklen_t size) const {
+  switch (family()) {
+  case af_inet:
+    return sa_inet()->address_c_str(buf, size);
+  case af_inet6:
+    return sa_inet6()->address_c_str(buf, size);
+  default:
+    return false;
+  }
+}
+
+inline std::string
+socket_address::pretty_address_str() const {
+  switch (family()) {
+  case af_inet:
+    return sa_inet()->address_str();
+  case af_inet6:
+    return sa_inet6()->pretty_address_str();
+  case af_unspec:
+    return std::string("unspec");
+  default:
+    return std::string("invalid");
+  }
+}
+
+
+inline bool
+socket_address::set_address_c_str(const char* a) {
+  if (sa_inet()->set_address_c_str(a)) {
+    sa_inet()->set_family();
+    return true;
+
+  } else if (sa_inet6()->set_address_c_str(a)) {
+    sa_inet6()->set_family();
+    return true;
+
+  } else {
+    return false;
+  }
+}
+
+// Is the zero length really needed, should we require some length?
+inline uint32_t
+socket_address::length() const {
+  switch(family()) {
+  case af_inet:
+    return sizeof(sockaddr_in);
+  case af_inet6:
+    return sizeof(sockaddr_in6);
+  default:
+    return 0;
+  }      
+}
+
+inline void
+socket_address::copy(const socket_address& src, size_t length) {
+  length = std::min(length, sizeof(socket_address));
+
+  std::memset(this, 0, sizeof(socket_address));
+  std::memcpy(this, &src, length);
+}
+
+inline void
+socket_address::copy_sockaddr(const sockaddr* src) {
+  std::memset(this, 0, sizeof(socket_address));
+  std::memcpy(this, src, socket_address::cast_from(src)->length());
+}
+
+inline bool
+socket_address::operator == (const socket_address& rhs) const {
+  if (family() != rhs.family())
+    return false;
+
+  switch (family()) {
+  case af_inet:
+    return *sa_inet() == *rhs.sa_inet();
+  case af_inet6:
+    return *sa_inet6() == *rhs.sa_inet6();
+  default:
+    throw std::logic_error("socket_address::operator == (rhs) invalid type comparison.");
+  }
+}
+
+inline bool
+socket_address::operator < (const socket_address& rhs) const {
+  if (family() != rhs.family())
+    return family() < rhs.family();
+
+  switch (family()) {
+  case af_inet:
+    return *sa_inet() < *rhs.sa_inet();
+  case af_inet6:
+    return *sa_inet6() < *rhs.sa_inet6();
+  default:
+    throw std::logic_error("socket_address::operator < (rhs) invalid type comparison.");
+  }
+}
+
+inline std::string
+socket_address_inet::address_str() const {
+  char buf[INET_ADDRSTRLEN];
+
+  if (!address_c_str(buf, INET_ADDRSTRLEN))
+    return std::string();
+
+  return std::string(buf);
+}
+
+inline bool
+socket_address_inet::address_c_str(char* buf, socklen_t size) const {
+  return inet_ntop(family(), &m_sockaddr.sin_addr, buf, size);
+}
+
+inline bool
+socket_address_inet::set_address_c_str(const char* a) {
+  return inet_pton(AF_INET, a, &m_sockaddr.sin_addr);
+}
+
+inline socket_address_inet6
+socket_address_inet::to_mapped_address() const {
+  uint32_t addr32[4];
+  addr32[0] = 0;
+  addr32[1] = 0;
+  addr32[2] = htonl(0xffff);
+  addr32[3] = m_sockaddr.sin_addr.s_addr;
+  
+  socket_address_inet6 sa;
+  sa.clear();
+  sa.set_address(*reinterpret_cast<in6_addr *>(addr32));
+  sa.set_port_n(m_sockaddr.sin_port);
+  return sa;
+}
+
+inline bool
+socket_address_inet::operator == (const socket_address_inet& rhs) const {
+  return
+    m_sockaddr.sin_addr.s_addr == rhs.m_sockaddr.sin_addr.s_addr &&
+    m_sockaddr.sin_port == rhs.m_sockaddr.sin_port;
+}
+
+inline bool
+socket_address_inet::operator < (const socket_address_inet& rhs) const {
+  return
+    m_sockaddr.sin_addr.s_addr < rhs.m_sockaddr.sin_addr.s_addr ||
+    (m_sockaddr.sin_addr.s_addr == rhs.m_sockaddr.sin_addr.s_addr &&
+     m_sockaddr.sin_port < rhs.m_sockaddr.sin_port);
+}
+
+inline std::string
+socket_address_inet6::address_str() const {
+  char buf[INET6_ADDRSTRLEN];
+
+  if (!address_c_str(buf, INET6_ADDRSTRLEN))
+    return std::string();
+
+  return std::string(buf);
+}
+
+inline bool
+socket_address_inet6::address_c_str(char* buf, socklen_t size) const {
+  return inet_ntop(family(), &m_sockaddr.sin6_addr, buf, size);
+}
+
+inline bool
+socket_address_inet6::set_address_c_str(const char* a) {
+  return inet_pton(AF_INET6, a, &m_sockaddr.sin6_addr);
+}
+
+inline std::string
+socket_address_inet6::pretty_address_str() const {
+  char buf[INET6_ADDRSTRLEN + 2 + 6];
+
+  if (inet_ntop(family(), &m_sockaddr.sin6_addr, buf + 1, INET6_ADDRSTRLEN) == NULL)
+    return std::string();
+
+  buf[0] = '[';
+
+  char* last_char = (char*)std::memchr(buf + 1, 0, INET6_ADDRSTRLEN);
+
+  // TODO: Throw exception here.
+
+  if (last_char == NULL || last_char >= buf + 1 + INET6_ADDRSTRLEN)
+    throw std::logic_error("inet_ntop for inet6 returned bad buffer");
+
+  *(last_char++) = ']';
+
+  if (!is_port_any()) {
+    if (snprintf(last_char, 7, ":%" PRIu16, port()) == -1)
+      return std::string("error"); // TODO: Throw here.
+
+  } else {
+    *last_char = '\0';
+  }
+
+  return std::string(buf);
+}
+
+inline socket_address
+socket_address_inet6::normalize_address() const {
+  const uint32_t *addr32 = reinterpret_cast<const uint32_t *>(m_sockaddr.sin6_addr.s6_addr);
+  if (addr32[0] == 0 && addr32[1] == 0 && addr32[2] == htonl(0xffff)) {
+    socket_address addr4;
+    addr4.sa_inet()->set_family();
+    addr4.sa_inet()->set_address_n(addr32[3]);
+    addr4.sa_inet()->set_port_n(m_sockaddr.sin6_port);
+    return addr4;
+  }
+  return *reinterpret_cast<const socket_address*>(this);
+}
+
+inline bool
+socket_address_inet6::operator == (const socket_address_inet6& rhs) const {
+  return
+    memcmp(&m_sockaddr.sin6_addr, &rhs.m_sockaddr.sin6_addr, sizeof(in6_addr)) == 0 &&
+    m_sockaddr.sin6_port == rhs.m_sockaddr.sin6_port;
+}
+
+inline bool
+socket_address_inet6::operator < (const socket_address_inet6& rhs) const {
+  int addr_comp = memcmp(&m_sockaddr.sin6_addr, &rhs.m_sockaddr.sin6_addr, sizeof(in6_addr));
+  return
+    addr_comp < 0 ||
+    (addr_comp == 0 ||
+     m_sockaddr.sin6_port < rhs.m_sockaddr.sin6_port);
+}
+
+}
+
+#endif

rak/string_manip.h

@@ -0,0 +1,427 @@
+// rak - Rakshasa's toolbox
+// Copyright (C) 2005-2007, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+#ifndef RAK_STRING_MANIP_H
+#define RAK_STRING_MANIP_H
+
+#include <algorithm>
+#include <cctype>
+#include <climits>
+#include <cstdlib>
+#include <functional>
+#include <iterator>
+#include <locale>
+#include <random>
+
+
+namespace rak {
+
+// Use these trim functions until n1872 is widely supported.
+
+template <typename Sequence>
+Sequence trim_begin(const Sequence& seq) {
+  if (seq.empty() || !std::isspace(*seq.begin()))
+    return seq;
+
+  typename Sequence::size_type pos = 0;
+
+  while (pos != seq.length() && std::isspace(seq[pos]))
+    pos++;
+
+  return seq.substr(pos, seq.length() - pos);
+}
+
+template <typename Sequence>
+Sequence trim_end(const Sequence& seq) {
+  if (seq.empty() || !std::isspace(*(--seq.end())))
+    return seq;
+
+  typename Sequence::size_type pos = seq.size();
+
+  while (pos != 0 && std::isspace(seq[pos - 1]))
+    pos--;
+
+  return seq.substr(0, pos);
+}
+
+template <typename Sequence>
+Sequence trim(const Sequence& seq) {
+  return trim_begin(trim_end(seq));
+}
+
+template <typename Sequence>
+Sequence trim_begin_classic(const Sequence& seq) {
+  if (seq.empty() || !std::isspace(*seq.begin(), std::locale::classic()))
+    return seq;
+
+  typename Sequence::size_type pos = 0;
+
+  while (pos != seq.length() && std::isspace(seq[pos], std::locale::classic()))
+    pos++;
+
+  return seq.substr(pos, seq.length() - pos);
+}
+
+template <typename Sequence>
+Sequence trim_end_classic(const Sequence& seq) {
+  if (seq.empty() || !std::isspace(*(--seq.end()), std::locale::classic()))
+    return seq;
+
+  typename Sequence::size_type pos = seq.size();
+
+  while (pos != 0 && std::isspace(seq[pos - 1], std::locale::classic()))
+    pos--;
+
+  return seq.substr(0, pos);
+}
+
+template <typename Sequence>
+Sequence trim_classic(const Sequence& seq) {
+  return trim_begin_classic(trim_end_classic(seq));
+}
+
+// Consider rewritting such that m_seq is replaced by first/last.
+template <typename Sequence>
+class split_iterator_t {
+public:
+  typedef typename Sequence::const_iterator const_iterator;
+  typedef typename Sequence::value_type     value_type;
+
+  split_iterator_t() {}
+
+  split_iterator_t(const Sequence& seq, value_type delim) :
+    m_seq(&seq),
+    m_delim(delim),
+    m_pos(seq.begin()),
+    m_next(std::find(seq.begin(), seq.end(), delim)) {
+  }
+
+  Sequence operator * () { return Sequence(m_pos, m_next); }
+
+  split_iterator_t& operator ++ () {
+    m_pos = m_next;
+
+    if (m_pos == m_seq->end())
+      return *this;
+
+    m_pos++;
+    m_next = std::find(m_pos, m_seq->end(), m_delim);
+
+    return *this;
+  }
+
+  bool operator == (const split_iterator_t&) const { return m_pos == m_seq->end(); }
+  bool operator != (const split_iterator_t&) const { return m_pos != m_seq->end(); }
+
+private:
+  const Sequence* m_seq;
+  value_type      m_delim;
+  const_iterator  m_pos;
+  const_iterator  m_next;
+};
+
+template <typename Sequence>
+inline split_iterator_t<Sequence>
+split_iterator(const Sequence& seq, typename Sequence::value_type delim) {
+  return split_iterator_t<Sequence>(seq, delim);
+}
+
+template <typename Sequence>
+inline split_iterator_t<Sequence>
+split_iterator(const Sequence&) {
+  return split_iterator_t<Sequence>();
+}
+
+// Could optimize this abit.
+inline char
+hexchar_to_value(char c) {
+  if (c >= '0' && c <= '9')
+    return c - '0';
+
+  else if (c >= 'A' && c <= 'F')
+    return 10 + c - 'A';
+    
+  else
+    return 10 + c - 'a';
+}
+
+template <int pos, typename Value>
+inline char
+value_to_hexchar(Value v) {
+  v >>= pos * 4;
+  v &= 0xf;
+
+  if (v < 0xA)
+    return '0' + v;
+  else
+    return 'A' + v - 0xA;
+}
+
+template <typename InputIterator, typename OutputIterator> 
+OutputIterator
+copy_escape_html(InputIterator first, InputIterator last, OutputIterator dest) {
+  while (first != last) {
+    if (std::isalpha(*first, std::locale::classic()) ||
+        std::isdigit(*first, std::locale::classic()) ||
+        *first == '-') {
+      *(dest++) = *first;
+
+    } else {
+      *(dest++) = '%';
+      *(dest++) = value_to_hexchar<1>(*first);
+      *(dest++) = value_to_hexchar<0>(*first);
+    }
+
+    ++first;
+  }
+
+  return dest;
+}
+
+template <typename InputIterator, typename OutputIterator> 
+OutputIterator
+copy_escape_html(InputIterator first1, InputIterator last1, OutputIterator first2, OutputIterator last2) {
+  while (first1 != last1) {
+    if (std::isalpha(*first1, std::locale::classic()) ||
+        std::isdigit(*first1, std::locale::classic()) ||
+        *first1 == '-') {
+      if (first2 == last2) break; else *(first2++) = *first1;
+
+    } else {
+      if (first2 == last2) break; else *(first2++) = '%';
+      if (first2 == last2) break; else *(first2++) = value_to_hexchar<1>(*first1);
+      if (first2 == last2) break; else *(first2++) = value_to_hexchar<0>(*first1);
+    }
+
+    ++first1;
+  }
+
+  return first2;
+}
+
+template <typename Iterator>
+inline std::string
+copy_escape_html(Iterator first, Iterator last) {
+  std::string dest;
+  copy_escape_html(first, last, std::back_inserter(dest));
+
+  return dest;
+}
+
+template <typename Sequence>
+inline Sequence
+copy_escape_html(const Sequence& src) {
+  Sequence dest;
+  copy_escape_html(src.begin(), src.end(), std::back_inserter(dest));
+
+  return dest;
+}
+
+template <typename Sequence>
+inline std::string
+copy_escape_html_str(const Sequence& src) {
+  std::string dest;
+  copy_escape_html(src.begin(), src.end(), std::back_inserter(dest));
+
+  return dest;
+}
+
+// Consider support for larger than char type.
+template <typename InputIterator, typename OutputIterator> 
+OutputIterator
+transform_hex(InputIterator first, InputIterator last, OutputIterator dest) {
+  while (first != last) {
+    *(dest++) = value_to_hexchar<1>(*first);
+    *(dest++) = value_to_hexchar<0>(*first);
+
+    ++first;
+  }
+
+  return dest;
+}
+
+template <typename InputIterator, typename OutputIterator> 
+OutputIterator
+transform_hex(InputIterator first1, InputIterator last1, OutputIterator first2, OutputIterator last2) {
+  while (first1 != last1) {
+    if (first2 == last2) break; else *(first2++) = value_to_hexchar<1>(*first1);
+    if (first2 == last2) break; else *(first2++) = value_to_hexchar<0>(*first1);
+
+    ++first1;
+  }
+
+  return first2;
+}
+
+template <typename Sequence>
+inline Sequence
+transform_hex(const Sequence& src) {
+  Sequence dest;
+  transform_hex(src.begin(), src.end(), std::back_inserter(dest));
+
+  return dest;
+}
+
+template <typename Iterator>
+inline std::string
+transform_hex(Iterator first, Iterator last) {
+  std::string dest;
+  transform_hex(first, last, std::back_inserter(dest));
+
+  return dest;
+}
+
+template <typename Sequence>
+inline std::string
+transform_hex_str(const Sequence& seq) {
+  std::string dest;
+  transform_hex(seq.begin(), seq.end(), std::back_inserter(dest));
+
+  return dest;
+}
+
+template <typename Sequence>
+Sequence
+generate_random(size_t length) {
+  std::random_device rd;
+  std::mt19937 mt(rd());
+  using bytes_randomizer = std::independent_bits_engine<std::mt19937, CHAR_BIT, uint8_t>;
+  bytes_randomizer bytes(mt);
+  Sequence s;
+  s.reserve(length);
+  std::generate_n(std::back_inserter(s), length, std::ref(bytes));
+  return s;
+}
+
+template <typename Iterator>
+inline bool
+is_all_alpha(Iterator first, Iterator last) {
+  while (first != last)
+    if (!std::isalpha(*first++, std::locale::classic()))
+      return false;
+
+  return true;
+}
+
+template <typename Sequence>
+inline bool
+is_all_alpha(const Sequence& src) {
+  return is_all_alpha(src.begin(), src.end());
+}
+
+template <typename Iterator>
+inline bool
+is_all_alnum(Iterator first, Iterator last) {
+  while (first != last)
+    if (!std::isalnum(*first++, std::locale::classic()))
+      return false;
+
+  return true;
+}
+
+template <typename Sequence>
+inline bool
+is_all_alnum(const Sequence& src) {
+  return is_all_alnum(src.begin(), src.end());
+}
+
+template <typename Iterator>
+inline bool
+is_all_name(Iterator first, Iterator last) {
+  while (first != last) {
+    if (!std::isalnum(*first, std::locale::classic()) && *first != '_')
+      return false;
+
+    first++;
+  }
+
+  return true;
+}
+
+template <typename Sequence>
+inline bool
+is_all_name(const Sequence& src) {
+  return is_all_name(src.begin(), src.end());
+}
+
+template <typename Iterator>
+std::string
+sanitize(Iterator first, Iterator last) {
+  std::string dest;
+  for (; first != last; ++first) {
+    if (std::isprint(*first) && *first != '\r' && *first != '\n' && *first != '\t')
+      dest += *first;
+    else
+      dest += " ";
+  }
+
+  return dest;
+}
+
+template <typename Sequence>
+std::string
+sanitize(const Sequence& src) {
+    return trim(sanitize(src.begin(), src.end()));
+}
+
+template <typename Iterator>
+std::string striptags(Iterator first, Iterator last) {
+  bool copychar = true;
+  std::string dest;
+
+  for (; first != last; ++first) {
+    if (std::isprint(*first) && *first == '<') {
+      copychar = false;
+    } else if (std::isprint(*first) && *first == '>') {
+      copychar = true;
+      continue;
+    }
+
+    if (copychar)
+      dest += *first;
+  }
+
+  return dest;
+}
+
+template <typename Sequence>
+std::string striptags(const Sequence& src) {
+    return striptags(src.begin(), src.end());
+}
+
+}
+
+#endif

rak/unordered_vector.h

@@ -0,0 +1,109 @@
+// rak - Rakshasa's toolbox
+// Copyright (C) 2005-2007, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+#ifndef RAK_UNORDERED_VECTOR_H
+#define RAK_UNORDERED_VECTOR_H
+
+#include <vector>
+
+namespace rak {
+
+template <typename _Tp>
+class unordered_vector : private std::vector<_Tp> {
+public:
+  typedef std::vector<_Tp> Base;
+  
+  typedef typename Base::value_type value_type;
+  typedef typename Base::pointer pointer;
+  typedef typename Base::const_pointer const_pointer;
+  typedef typename Base::reference reference;
+  typedef typename Base::const_reference const_reference;
+  typedef typename Base::size_type size_type;
+  typedef typename Base::difference_type difference_type;
+  typedef typename Base::allocator_type allocator_type;
+
+  typedef typename Base::iterator iterator;
+  typedef typename Base::reverse_iterator reverse_iterator;
+  typedef typename Base::const_iterator const_iterator;
+  typedef typename Base::const_reverse_iterator const_reverse_iterator;
+
+  using Base::clear;
+  using Base::empty;
+  using Base::size;
+  using Base::reserve;
+
+  using Base::front;
+  using Base::back;
+  using Base::begin;
+  using Base::end;
+  using Base::rbegin;
+  using Base::rend;
+
+  using Base::push_back;
+  using Base::pop_back;
+
+  // Use the range erase function, the single element erase gets
+  // overloaded.
+  using Base::erase;
+
+  iterator            insert(iterator position, const value_type& x);
+  iterator            erase(iterator position);
+
+private:
+};
+
+template <typename _Tp>
+typename unordered_vector<_Tp>::iterator
+unordered_vector<_Tp>::insert(iterator position, const value_type& x) {
+  Base::push_back(x);
+
+  return --end();
+}
+
+template <typename _Tp>
+typename unordered_vector<_Tp>::iterator
+unordered_vector<_Tp>::erase(iterator position) {
+  // We don't need to check if position == end - 1 since we then copy
+  // to the position we pop later.
+  *position = Base::back();
+  Base::pop_back();
+
+  return position;
+}    
+
+}
+
+#endif

rtorrent.lua

@@ -0,0 +1,42 @@
+-- the "rtorrent" table is passed in by the C++ code, modify and
+-- return it for loading.
+local args = {...}
+local rtorrent = args[1]
+
+-- Autocall
+-- Allows syntax like `rtorrent.autocall.system.hostname()`
+local mt = {}
+function mt.__call (t, ...)
+   name = table.concat(rawget(t, "__namestack"), ".")
+   success, ret = pcall(rtorrent.call, name, ...)
+   if not success then error(name..": "..ret, 2) end
+   return ret
+end
+function mt.__index (t, key)
+   ns = rawget(t, "__namestack") or {}
+   table.insert(ns, key)
+   return setmetatable({__namestack=ns}, mt)
+end
+rtorrent["autocall"] = setmetatable({}, mt)
+
+-- Autocall-config Same as autocall, but passes an empty first target
+-- implicitly, for syntax like `rtorrent.autocall_config.session.directory.set("/tmp/")`
+local mt = {}
+function mt.__call (t, ...)
+   name = table.concat(rawget(t, "__namestack"), ".")
+   success, ret = pcall(rtorrent.call, name, "", ...)
+   if not success then error(name..": "..ret, 2) end
+   return ret
+end
+function mt.__index (t, key)
+   ns = rawget(t, "__namestack")
+   if ns == nil then
+      if _G[key] ~= nil then return _G[key] end
+      ns = {}
+   end
+   table.insert(ns, key)
+   return setmetatable({__namestack=ns}, mt)
+end
+rtorrent["autocall_config"] = setmetatable({}, mt)
+
+return rtorrent

scripts/attributes.m4

@@ -0,0 +1,131 @@
+# Functions to check for attributes support in compiler
+
+AC_DEFUN([CC_ATTRIBUTE_CONSTRUCTOR], [
+	AC_CACHE_CHECK([if compiler supports __attribute__((constructor))],
+		[cc_cv_attribute_constructor],
+		[AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+			void ctor() __attribute__((constructor));
+			void ctor() { };
+			])],
+			[cc_cv_attribute_constructor=yes],
+			[cc_cv_attribute_constructor=no])
+		])
+	
+	if test "x$cc_cv_attribute_constructor" = "xyes"; then
+		AC_DEFINE([SUPPORT_ATTRIBUTE_CONSTRUCTOR], 1, [Define this if the compiler supports the constructor attribute])
+		$1
+	else
+		true
+		$2
+	fi
+])
+
+AC_DEFUN([CC_ATTRIBUTE_FORMAT], [
+	AC_CACHE_CHECK([if compiler supports __attribute__((format(printf, n, n)))],
+		[cc_cv_attribute_format],
+		[AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+			void __attribute__((format(printf, 1, 2))) printflike(const char *fmt, ...) { }
+			])],
+			[cc_cv_attribute_format=yes],
+			[cc_cv_attribute_format=no])
+		])
+	
+	if test "x$cc_cv_attribute_format" = "xyes"; then
+		AC_DEFINE([SUPPORT_ATTRIBUTE_FORMAT], 1, [Define this if the compiler supports the format attribute])
+		$1
+	else
+		true
+		$2
+	fi
+])
+
+AC_DEFUN([CC_ATTRIBUTE_INTERNAL], [
+	AC_CACHE_CHECK([if compiler supports __attribute__((visibility("internal")))],
+		[cc_cv_attribute_internal],
+		[AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+			void __attribute__((visibility("internal"))) internal_function() { }
+			])],
+			[cc_cv_attribute_internal=yes],
+			[cc_cv_attribute_internal=no])
+		])
+	
+	if test "x$cc_cv_attribute_internal" = "xyes"; then
+		AC_DEFINE([SUPPORT_ATTRIBUTE_INTERNAL], 1, [Define this if the compiler supports the internal visibility attribute])
+		$1
+	else
+		true
+		$2
+	fi
+])
+
+AC_DEFUN([CC_ATTRIBUTE_VISIBILITY], [
+        AC_LANG_PUSH(C++)
+
+        tmp_CXXFLAGS=$CXXFLAGS
+        CXXFLAGS="$CXXFLAGS -fvisibility=hidden"
+
+	AC_CACHE_CHECK([if compiler supports __attribute__((visibility("default")))],
+		[cc_cv_attribute_visibility],
+		[AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+			void __attribute__((visibility("default"))) visibility_function() { }
+			])],
+			[cc_cv_attribute_visibility=yes],
+			[cc_cv_attribute_visibility=no])
+		])
+	
+        CXXFLAGS=$tmp_CXXFLAGS
+        AC_LANG_POP(C++)
+
+	if test "x$cc_cv_attribute_visibility" = "xyes"; then
+		AC_DEFINE([SUPPORT_ATTRIBUTE_VISIBILITY], 1, [Define this if the compiler supports the visibility attributes.])
+                CXXFLAGS="$CXXFLAGS -fvisibility=hidden"
+		$1
+	else
+                true
+		$2
+	fi
+
+])
+
+AC_DEFUN([CC_ATTRIBUTE_NONNULL], [
+	AC_CACHE_CHECK([if compiler supports __attribute__((nonnull()))],
+		[cc_cv_attribute_nonnull],
+		[AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+			void some_function(void *foo, void *bar) __attribute__((nonnull()));
+			void some_function(void *foo, void *bar) { }
+			])],
+			[cc_cv_attribute_nonnull=yes],
+			[cc_cv_attribute_nonnull=no])
+		])
+	
+	if test "x$cc_cv_attribute_nonnull" = "xyes"; then
+		AC_DEFINE([SUPPORT_ATTRIBUTE_NONNULL], 1, [Define this if the compiler supports the nonnull attribute])
+		$1
+	else
+		true
+		$2
+	fi
+])
+
+AC_DEFUN([CC_FUNC_EXPECT], [
+	AC_CACHE_CHECK([if compiler has __builtin_expect function],
+		[cc_cv_func_expect],
+		[AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+			int some_function()
+			{
+				int a = 3;
+				return (int)__builtin_expect(a, 3);
+			}
+			])],
+			[cc_cv_func_expect=yes],
+			[cc_cv_func_expect=no])
+		])
+	
+	if test "x$cc_cv_func_expect" = "xyes"; then
+		AC_DEFINE([SUPPORT__BUILTIN_EXPECT], 1, [Define this if the compiler supports __builtin_expect() function])
+		$1
+	else
+		true
+		$2
+	fi
+])

scripts/ax_check_zlib.m4

@@ -0,0 +1,141 @@
+# ===========================================================================
+#      https://www.gnu.org/software/autoconf-archive/ax_check_zlib.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_CHECK_ZLIB([action-if-found], [action-if-not-found])
+#
+# DESCRIPTION
+#
+#   This macro searches for an installed zlib library. If nothing was
+#   specified when calling configure, it searches first in /usr/local and
+#   then in /usr, /opt/local and /sw. If the --with-zlib=DIR is specified,
+#   it will try to find it in DIR/include/zlib.h and DIR/lib/libz.a. If
+#   --without-zlib is specified, the library is not searched at all.
+#
+#   If either the header file (zlib.h) or the library (libz) is not found,
+#   shell commands 'action-if-not-found' is run. If 'action-if-not-found' is
+#   not specified, the configuration exits on error, asking for a valid zlib
+#   installation directory or --without-zlib.
+#
+#   If both header file and library are found, shell commands
+#   'action-if-found' is run. If 'action-if-found' is not specified, the
+#   default action appends '-I${ZLIB_HOME}/include' to CPFLAGS, appends
+#   '-L$ZLIB_HOME}/lib' to LDFLAGS, prepends '-lz' to LIBS, and calls
+#   AC_DEFINE(HAVE_LIBZ). You should use autoheader to include a definition
+#   for this symbol in a config.h file. Sample usage in a C/C++ source is as
+#   follows:
+#
+#     #ifdef HAVE_LIBZ
+#     #include <zlib.h>
+#     #endif /* HAVE_LIBZ */
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Loic Dachary <loic@senga.org>
+#   Copyright (c) 2010 Bastien Chevreux <bach@chevreux.org>
+#
+#   This program is free software; you can redistribute it and/or modify it
+#   under the terms of the GNU General Public License as published by the
+#   Free Software Foundation; either version 2 of the License, or (at your
+#   option) any later version.
+#
+#   This program is distributed in the hope that it will be useful, but
+#   WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+#   Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program. If not, see <https://www.gnu.org/licenses/>.
+#
+#   As a special exception, the respective Autoconf Macro's copyright owner
+#   gives unlimited permission to copy, distribute and modify the configure
+#   scripts that are the output of Autoconf when processing the Macro. You
+#   need not follow the terms of the GNU General Public License when using
+#   or distributing such scripts, even though portions of the text of the
+#   Macro appear in them. The GNU General Public License (GPL) does govern
+#   all other use of the material that constitutes the Autoconf Macro.
+#
+#   This special exception to the GPL applies to versions of the Autoconf
+#   Macro released by the Autoconf Archive. When you make and distribute a
+#   modified version of the Autoconf Macro, you may extend this special
+#   exception to the GPL to apply to your modified version as well.
+
+#serial 16
+
+AU_ALIAS([CHECK_ZLIB], [AX_CHECK_ZLIB])
+AC_DEFUN([AX_CHECK_ZLIB],
+#
+# Handle user hints
+#
+[AC_MSG_CHECKING(if zlib is wanted)
+zlib_places="/usr/local /usr /opt/local /sw"
+AC_ARG_WITH([zlib],
+[  --with-zlib=DIR         root directory path of zlib installation @<:@defaults to
+                          /usr/local or /usr if not found in /usr/local@:>@
+  --without-zlib          to disable zlib usage completely],
+[if test "$withval" != no ; then
+  AC_MSG_RESULT(yes)
+  if test -d "$withval"
+  then
+    zlib_places="$withval $zlib_places"
+  else
+    AC_MSG_WARN([Sorry, $withval does not exist, checking usual places])
+  fi
+else
+  zlib_places=
+  AC_MSG_RESULT(no)
+fi],
+[AC_MSG_RESULT(yes)])
+
+#
+# Locate zlib, if wanted
+#
+if test -n "${zlib_places}"
+then
+	# check the user supplied or any other more or less 'standard' place:
+	#   Most UNIX systems      : /usr/local and /usr
+	#   MacPorts / Fink on OSX : /opt/local respectively /sw
+	for ZLIB_HOME in ${zlib_places} ; do
+	  if test -f "${ZLIB_HOME}/include/zlib.h"; then break; fi
+	  ZLIB_HOME=""
+	done
+
+  ZLIB_OLD_LDFLAGS=$LDFLAGS
+  ZLIB_OLD_CPPFLAGS=$CPPFLAGS
+  if test -n "${ZLIB_HOME}"; then
+        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
+        CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
+  fi
+  AC_LANG_PUSH([C])
+  AC_CHECK_LIB([z], [inflateEnd], [zlib_cv_libz=yes], [zlib_cv_libz=no])
+  AC_CHECK_HEADER([zlib.h], [zlib_cv_zlib_h=yes], [zlib_cv_zlib_h=no])
+  AC_LANG_POP([C])
+  if test "$zlib_cv_libz" = "yes" && test "$zlib_cv_zlib_h" = "yes"
+  then
+    #
+    # If both library and header were found, action-if-found
+    #
+    m4_ifblank([$1],[
+                CPPFLAGS="$CPPFLAGS -I${ZLIB_HOME}/include"
+                LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
+                LIBS="-lz $LIBS"
+                AC_DEFINE([HAVE_LIBZ], [1],
+                          [Define to 1 if you have `z' library (-lz)])
+               ],[
+                # Restore variables
+                LDFLAGS="$ZLIB_OLD_LDFLAGS"
+                CPPFLAGS="$ZLIB_OLD_CPPFLAGS"
+                $1
+               ])
+  else
+    #
+    # If either header or library was not found, action-if-not-found
+    #
+    m4_default([$2],[
+                AC_MSG_ERROR([either specify a valid zlib installation with --with-zlib=DIR or disable zlib usage with --without-zlib])
+                ])
+  fi
+fi
+])

scripts/ax_cxx_compile_stdcxx.m4

@@ -0,0 +1,962 @@
+# ===========================================================================
+#  https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional])
+#
+# DESCRIPTION
+#
+#   Check for baseline language coverage in the compiler for the specified
+#   version of the C++ standard.  If necessary, add switches to CXX and
+#   CXXCPP to enable support.  VERSION may be '11' (for the C++11 standard)
+#   or '14' (for the C++14 standard).
+#
+#   The second argument, if specified, indicates whether you insist on an
+#   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
+#   -std=c++11).  If neither is specified, you get whatever works, with
+#   preference for no added switch, and then for an extended mode.
+#
+#   The third argument, if specified 'mandatory' or if left unspecified,
+#   indicates that baseline support for the specified C++ standard is
+#   required and that the macro should error out if no mode with that
+#   support is found.  If specified 'optional', then configuration proceeds
+#   regardless, after defining HAVE_CXX${VERSION} if and only if a
+#   supporting mode is found.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
+#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
+#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
+#   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
+#   Copyright (c) 2015 Paul Norman <penorman@mac.com>
+#   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
+#   Copyright (c) 2016, 2018 Krzesimir Nowak <qdlacz@gmail.com>
+#   Copyright (c) 2019 Enji Cooper <yaneurabeya@gmail.com>
+#   Copyright (c) 2020 Jason Merrill <jason@redhat.com>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved.  This file is offered as-is, without any
+#   warranty.
+
+#serial 12
+
+dnl  This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro
+dnl  (serial version number 13).
+
+AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
+  m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"],
+        [$1], [14], [ax_cxx_compile_alternatives="14 1y"],
+        [$1], [17], [ax_cxx_compile_alternatives="17 1z"],
+        [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl
+  m4_if([$2], [], [],
+        [$2], [ext], [],
+        [$2], [noext], [],
+        [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl
+  m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true],
+        [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true],
+        [$3], [optional], [ax_cxx_compile_cxx$1_required=false],
+        [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])])
+  AC_LANG_PUSH([C++])dnl
+  ac_success=no
+
+  m4_if([$2], [], [dnl
+    AC_CACHE_CHECK(whether $CXX supports C++$1 features by default,
+		   ax_cv_cxx_compile_cxx$1,
+      [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+        [ax_cv_cxx_compile_cxx$1=yes],
+        [ax_cv_cxx_compile_cxx$1=no])])
+    if test x$ax_cv_cxx_compile_cxx$1 = xyes; then
+      ac_success=yes
+    fi])
+
+  m4_if([$2], [noext], [], [dnl
+  if test x$ac_success = xno; then
+    for alternative in ${ax_cxx_compile_alternatives}; do
+      switch="-std=gnu++${alternative}"
+      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
+      AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
+                     $cachevar,
+        [ac_save_CXX="$CXX"
+         CXX="$CXX $switch"
+         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+          [eval $cachevar=yes],
+          [eval $cachevar=no])
+         CXX="$ac_save_CXX"])
+      if eval test x\$$cachevar = xyes; then
+        CXX="$CXX $switch"
+        if test -n "$CXXCPP" ; then
+          CXXCPP="$CXXCPP $switch"
+        fi
+        ac_success=yes
+        break
+      fi
+    done
+  fi])
+
+  m4_if([$2], [ext], [], [dnl
+  if test x$ac_success = xno; then
+    dnl HP's aCC needs +std=c++11 according to:
+    dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf
+    dnl Cray's crayCC needs "-h std=c++11"
+    for alternative in ${ax_cxx_compile_alternatives}; do
+      for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do
+        cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
+        AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
+                       $cachevar,
+          [ac_save_CXX="$CXX"
+           CXX="$CXX $switch"
+           AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
+            [eval $cachevar=yes],
+            [eval $cachevar=no])
+           CXX="$ac_save_CXX"])
+        if eval test x\$$cachevar = xyes; then
+          CXX="$CXX $switch"
+          if test -n "$CXXCPP" ; then
+            CXXCPP="$CXXCPP $switch"
+          fi
+          ac_success=yes
+          break
+        fi
+      done
+      if test x$ac_success = xyes; then
+        break
+      fi
+    done
+  fi])
+  AC_LANG_POP([C++])
+  if test x$ax_cxx_compile_cxx$1_required = xtrue; then
+    if test x$ac_success = xno; then
+      AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.])
+    fi
+  fi
+  if test x$ac_success = xno; then
+    HAVE_CXX$1=0
+    AC_MSG_NOTICE([No compiler with C++$1 support was found])
+  else
+    HAVE_CXX$1=1
+    AC_DEFINE(HAVE_CXX$1,1,
+              [define if the compiler supports basic C++$1 syntax])
+  fi
+  AC_SUBST(HAVE_CXX$1)
+])
+
+
+dnl  Test body for checking C++11 support
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11],
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+)
+
+
+dnl  Test body for checking C++14 support
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14],
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
+)
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17],
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_17
+)
+
+dnl  Tests for new features in C++11
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[
+
+// If the compiler admits that it is not ready for C++11, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201103L
+
+#error "This is not a C++11 compiler"
+
+#else
+
+namespace cxx11
+{
+
+  namespace test_static_assert
+  {
+
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+  }
+
+  namespace test_final_override
+  {
+
+    struct Base
+    {
+      virtual ~Base() {}
+      virtual void f() {}
+    };
+
+    struct Derived : public Base
+    {
+      virtual ~Derived() override {}
+      virtual void f() override {}
+    };
+
+  }
+
+  namespace test_double_right_angle_brackets
+  {
+
+    template < typename T >
+    struct check {};
+
+    typedef check<void> single_type;
+    typedef check<check<void>> double_type;
+    typedef check<check<check<void>>> triple_type;
+    typedef check<check<check<check<void>>>> quadruple_type;
+
+  }
+
+  namespace test_decltype
+  {
+
+    int
+    f()
+    {
+      int a = 1;
+      decltype(a) b = 2;
+      return a + b;
+    }
+
+  }
+
+  namespace test_type_deduction
+  {
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static const bool value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static const bool value = true;
+    };
+
+    template < typename T1, typename T2 >
+    auto
+    add(T1 a1, T2 a2) -> decltype(a1 + a2)
+    {
+      return a1 + a2;
+    }
+
+    int
+    test(const int c, volatile int v)
+    {
+      static_assert(is_same<int, decltype(0)>::value == true, "");
+      static_assert(is_same<int, decltype(c)>::value == false, "");
+      static_assert(is_same<int, decltype(v)>::value == false, "");
+      auto ac = c;
+      auto av = v;
+      auto sumi = ac + av + 'x';
+      auto sumf = ac + av + 1.0;
+      static_assert(is_same<int, decltype(ac)>::value == true, "");
+      static_assert(is_same<int, decltype(av)>::value == true, "");
+      static_assert(is_same<int, decltype(sumi)>::value == true, "");
+      static_assert(is_same<int, decltype(sumf)>::value == false, "");
+      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
+      return (sumf > 0.0) ? sumi : add(c, v);
+    }
+
+  }
+
+  namespace test_noexcept
+  {
+
+    int f() { return 0; }
+    int g() noexcept { return 0; }
+
+    static_assert(noexcept(f()) == false, "");
+    static_assert(noexcept(g()) == true, "");
+
+  }
+
+  namespace test_constexpr
+  {
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
+    {
+      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
+    }
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c(const CharT *const s) noexcept
+    {
+      return strlen_c_r(s, 0UL);
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("1") == 1UL, "");
+    static_assert(strlen_c("example") == 7UL, "");
+    static_assert(strlen_c("another\0example") == 7UL, "");
+
+  }
+
+  namespace test_rvalue_references
+  {
+
+    template < int N >
+    struct answer
+    {
+      static constexpr int value = N;
+    };
+
+    answer<1> f(int&)       { return answer<1>(); }
+    answer<2> f(const int&) { return answer<2>(); }
+    answer<3> f(int&&)      { return answer<3>(); }
+
+    void
+    test()
+    {
+      int i = 0;
+      const int c = 0;
+      static_assert(decltype(f(i))::value == 1, "");
+      static_assert(decltype(f(c))::value == 2, "");
+      static_assert(decltype(f(0))::value == 3, "");
+    }
+
+  }
+
+  namespace test_uniform_initialization
+  {
+
+    struct test
+    {
+      static const int zero {};
+      static const int one {1};
+    };
+
+    static_assert(test::zero == 0, "");
+    static_assert(test::one == 1, "");
+
+  }
+
+  namespace test_lambdas
+  {
+
+    void
+    test1()
+    {
+      auto lambda1 = [](){};
+      auto lambda2 = lambda1;
+      lambda1();
+      lambda2();
+    }
+
+    int
+    test2()
+    {
+      auto a = [](int i, int j){ return i + j; }(1, 2);
+      auto b = []() -> int { return '0'; }();
+      auto c = [=](){ return a + b; }();
+      auto d = [&](){ return c; }();
+      auto e = [a, &b](int x) mutable {
+        const auto identity = [](int y){ return y; };
+        for (auto i = 0; i < a; ++i)
+          a += b--;
+        return x + identity(a + b);
+      }(0);
+      return a + b + c + d + e;
+    }
+
+    int
+    test3()
+    {
+      const auto nullary = [](){ return 0; };
+      const auto unary = [](int x){ return x; };
+      using nullary_t = decltype(nullary);
+      using unary_t = decltype(unary);
+      const auto higher1st = [](nullary_t f){ return f(); };
+      const auto higher2nd = [unary](nullary_t f1){
+        return [unary, f1](unary_t f2){ return f2(unary(f1())); };
+      };
+      return higher1st(nullary) + higher2nd(nullary)(unary);
+    }
+
+  }
+
+  namespace test_variadic_templates
+  {
+
+    template <int...>
+    struct sum;
+
+    template <int N0, int... N1toN>
+    struct sum<N0, N1toN...>
+    {
+      static constexpr auto value = N0 + sum<N1toN...>::value;
+    };
+
+    template <>
+    struct sum<>
+    {
+      static constexpr auto value = 0;
+    };
+
+    static_assert(sum<>::value == 0, "");
+    static_assert(sum<1>::value == 1, "");
+    static_assert(sum<23>::value == 23, "");
+    static_assert(sum<1, 2>::value == 3, "");
+    static_assert(sum<5, 5, 11>::value == 21, "");
+    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
+
+  }
+
+  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
+  // because of this.
+  namespace test_template_alias_sfinae
+  {
+
+    struct foo {};
+
+    template<typename T>
+    using member = typename T::member_type;
+
+    template<typename T>
+    void func(...) {}
+
+    template<typename T>
+    void func(member<T>*) {}
+
+    void test();
+
+    void test() { func<foo>(0); }
+
+  }
+
+}  // namespace cxx11
+
+#endif  // __cplusplus >= 201103L
+
+]])
+
+
+dnl  Tests for new features in C++14
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[
+
+// If the compiler admits that it is not ready for C++14, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201402L
+
+#error "This is not a C++14 compiler"
+
+#else
+
+namespace cxx14
+{
+
+  namespace test_polymorphic_lambdas
+  {
+
+    int
+    test()
+    {
+      const auto lambda = [](auto&&... args){
+        const auto istiny = [](auto x){
+          return (sizeof(x) == 1UL) ? 1 : 0;
+        };
+        const int aretiny[] = { istiny(args)... };
+        return aretiny[0];
+      };
+      return lambda(1, 1L, 1.0f, '1');
+    }
+
+  }
+
+  namespace test_binary_literals
+  {
+
+    constexpr auto ivii = 0b0000000000101010;
+    static_assert(ivii == 42, "wrong value");
+
+  }
+
+  namespace test_generalized_constexpr
+  {
+
+    template < typename CharT >
+    constexpr unsigned long
+    strlen_c(const CharT *const s) noexcept
+    {
+      auto length = 0UL;
+      for (auto p = s; *p; ++p)
+        ++length;
+      return length;
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("x") == 1UL, "");
+    static_assert(strlen_c("test") == 4UL, "");
+    static_assert(strlen_c("another\0test") == 7UL, "");
+
+  }
+
+  namespace test_lambda_init_capture
+  {
+
+    int
+    test()
+    {
+      auto x = 0;
+      const auto lambda1 = [a = x](int b){ return a + b; };
+      const auto lambda2 = [a = lambda1(x)](){ return a; };
+      return lambda2();
+    }
+
+  }
+
+  namespace test_digit_separators
+  {
+
+    constexpr auto ten_million = 100'000'000;
+    static_assert(ten_million == 100000000, "");
+
+  }
+
+  namespace test_return_type_deduction
+  {
+
+    auto f(int& x) { return x; }
+    decltype(auto) g(int& x) { return x; }
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static constexpr auto value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static constexpr auto value = true;
+    };
+
+    int
+    test()
+    {
+      auto x = 0;
+      static_assert(is_same<int, decltype(f(x))>::value, "");
+      static_assert(is_same<int&, decltype(g(x))>::value, "");
+      return x;
+    }
+
+  }
+
+}  // namespace cxx14
+
+#endif  // __cplusplus >= 201402L
+
+]])
+
+
+dnl  Tests for new features in C++17
+
+m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[
+
+// If the compiler admits that it is not ready for C++17, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201703L
+
+#error "This is not a C++17 compiler"
+
+#else
+
+#include <initializer_list>
+#include <utility>
+#include <type_traits>
+
+namespace cxx17
+{
+
+  namespace test_constexpr_lambdas
+  {
+
+    constexpr int foo = [](){return 42;}();
+
+  }
+
+  namespace test::nested_namespace::definitions
+  {
+
+  }
+
+  namespace test_fold_expression
+  {
+
+    template<typename... Args>
+    int multiply(Args... args)
+    {
+      return (args * ... * 1);
+    }
+
+    template<typename... Args>
+    bool all(Args... args)
+    {
+      return (args && ...);
+    }
+
+  }
+
+  namespace test_extended_static_assert
+  {
+
+    static_assert (true);
+
+  }
+
+  namespace test_auto_brace_init_list
+  {
+
+    auto foo = {5};
+    auto bar {5};
+
+    static_assert(std::is_same<std::initializer_list<int>, decltype(foo)>::value);
+    static_assert(std::is_same<int, decltype(bar)>::value);
+  }
+
+  namespace test_typename_in_template_template_parameter
+  {
+
+    template<template<typename> typename X> struct D;
+
+  }
+
+  namespace test_fallthrough_nodiscard_maybe_unused_attributes
+  {
+
+    int f1()
+    {
+      return 42;
+    }
+
+    [[nodiscard]] int f2()
+    {
+      [[maybe_unused]] auto unused = f1();
+
+      switch (f1())
+      {
+      case 17:
+        f1();
+        [[fallthrough]];
+      case 42:
+        f1();
+      }
+      return f1();
+    }
+
+  }
+
+  namespace test_extended_aggregate_initialization
+  {
+
+    struct base1
+    {
+      int b1, b2 = 42;
+    };
+
+    struct base2
+    {
+      base2() {
+        b3 = 42;
+      }
+      int b3;
+    };
+
+    struct derived : base1, base2
+    {
+        int d;
+    };
+
+    derived d1 {{1, 2}, {}, 4};  // full initialization
+    derived d2 {{}, {}, 4};      // value-initialized bases
+
+  }
+
+  namespace test_general_range_based_for_loop
+  {
+
+    struct iter
+    {
+      int i;
+
+      int& operator* ()
+      {
+        return i;
+      }
+
+      const int& operator* () const
+      {
+        return i;
+      }
+
+      iter& operator++()
+      {
+        ++i;
+        return *this;
+      }
+    };
+
+    struct sentinel
+    {
+      int i;
+    };
+
+    bool operator== (const iter& i, const sentinel& s)
+    {
+      return i.i == s.i;
+    }
+
+    bool operator!= (const iter& i, const sentinel& s)
+    {
+      return !(i == s);
+    }
+
+    struct range
+    {
+      iter begin() const
+      {
+        return {0};
+      }
+
+      sentinel end() const
+      {
+        return {5};
+      }
+    };
+
+    void f()
+    {
+      range r {};
+
+      for (auto i : r)
+      {
+        [[maybe_unused]] auto v = i;
+      }
+    }
+
+  }
+
+  namespace test_lambda_capture_asterisk_this_by_value
+  {
+
+    struct t
+    {
+      int i;
+      int foo()
+      {
+        return [*this]()
+        {
+          return i;
+        }();
+      }
+    };
+
+  }
+
+  namespace test_enum_class_construction
+  {
+
+    enum class byte : unsigned char
+    {};
+
+    byte foo {42};
+
+  }
+
+  namespace test_constexpr_if
+  {
+
+    template <bool cond>
+    int f ()
+    {
+      if constexpr(cond)
+      {
+        return 13;
+      }
+      else
+      {
+        return 42;
+      }
+    }
+
+  }
+
+  namespace test_selection_statement_with_initializer
+  {
+
+    int f()
+    {
+      return 13;
+    }
+
+    int f2()
+    {
+      if (auto i = f(); i > 0)
+      {
+        return 3;
+      }
+
+      switch (auto i = f(); i + 4)
+      {
+      case 17:
+        return 2;
+
+      default:
+        return 1;
+      }
+    }
+
+  }
+
+  namespace test_template_argument_deduction_for_class_templates
+  {
+
+    template <typename T1, typename T2>
+    struct pair
+    {
+      pair (T1 p1, T2 p2)
+        : m1 {p1},
+          m2 {p2}
+      {}
+
+      T1 m1;
+      T2 m2;
+    };
+
+    void f()
+    {
+      [[maybe_unused]] auto p = pair{13, 42u};
+    }
+
+  }
+
+  namespace test_non_type_auto_template_parameters
+  {
+
+    template <auto n>
+    struct B
+    {};
+
+    B<5> b1;
+    B<'a'> b2;
+
+  }
+
+  namespace test_structured_bindings
+  {
+
+    int arr[2] = { 1, 2 };
+    std::pair<int, int> pr = { 1, 2 };
+
+    auto f1() -> int(&)[2]
+    {
+      return arr;
+    }
+
+    auto f2() -> std::pair<int, int>&
+    {
+      return pr;
+    }
+
+    struct S
+    {
+      int x1 : 2;
+      volatile double y1;
+    };
+
+    S f3()
+    {
+      return {};
+    }
+
+    auto [ x1, y1 ] = f1();
+    auto& [ xr1, yr1 ] = f1();
+    auto [ x2, y2 ] = f2();
+    auto& [ xr2, yr2 ] = f2();
+    const auto [ x3, y3 ] = f3();
+
+  }
+
+  namespace test_exception_spec_type_system
+  {
+
+    struct Good {};
+    struct Bad {};
+
+    void g1() noexcept;
+    void g2();
+
+    template<typename T>
+    Bad
+    f(T*, T*);
+
+    template<typename T1, typename T2>
+    Good
+    f(T1*, T2*);
+
+    static_assert (std::is_same_v<Good, decltype(f(g1, g2))>);
+
+  }
+
+  namespace test_inline_variables
+  {
+
+    template<class T> void f(T)
+    {}
+
+    template<class T> inline T g(T)
+    {
+      return T{};
+    }
+
+    template<> inline void f<>(int)
+    {}
+
+    template<> int g<>(int)
+    {
+      return 5;
+    }
+
+  }
+
+}  // namespace cxx17
+
+#endif  // __cplusplus < 201703L
+
+]])

scripts/ax_execinfo.m4

@@ -0,0 +1,67 @@
+# ===========================================================================
+#       https://www.gnu.org/software/autoconf-archive/ax_execinfo.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_EXECINFO([ACTION-IF-EXECINFO-H-IS-FOUND], [ACTION-IF-EXECINFO-H-IS-NOT-FOUND], [ADDITIONAL-TYPES-LIST])
+#
+# DESCRIPTION
+#
+#   Checks for execinfo.h header and if the len parameter/return type can be
+#   found from a list, also define backtrace_size_t to that type.
+#
+#   By default the list of types to try contains int and size_t, but should
+#   some yet undiscovered system use e.g. unsigned, the 3rd argument can be
+#   used for extensions. I'd like to hear of further suggestions.
+#
+#   Executes ACTION-IF-EXECINFO-H-IS-FOUND when present and the execinfo.h
+#   header is found or ACTION-IF-EXECINFO-H-IS-NOT-FOUND in case the header
+#   seems unavailable.
+#
+#   Also adds -lexecinfo to LIBS on BSD if needed.
+#
+# LICENSE
+#
+#   Copyright (c) 2014 Thomas Jahns <jahns@dkrz.de>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 2
+
+AC_DEFUN([AX_EXECINFO],
+  [AC_CHECK_HEADERS([execinfo.h])
+   AS_IF([test x"$ac_cv_header_execinfo_h" = xyes],
+     [AC_CACHE_CHECK([size parameter type for backtrace()],
+	[ax_cv_proto_backtrace_type],
+	[AC_LANG_PUSH([C])
+	 for ax_cv_proto_backtrace_type in size_t int m4_ifnblank([$3],[$3 ])none; do
+	   AS_IF([test "${ax_cv_proto_backtrace_type}" = none],
+	     [ax_cv_proto_backtrace_type= ; break])
+	   AC_COMPILE_IFELSE([AC_LANG_PROGRAM([
+#include <execinfo.h>
+extern
+${ax_cv_proto_backtrace_type} backtrace(void **addrlist, ${ax_cv_proto_backtrace_type} len);
+char **backtrace_symbols(void *const *buffer, ${ax_cv_proto_backtrace_type} size);
+])],
+	   [break])
+	 done
+	 AC_LANG_POP([C])])])
+   AS_IF([test x${ax_cv_proto_backtrace_type} != x],
+     [AC_DEFINE_UNQUOTED([backtrace_size_t], [$ax_cv_proto_backtrace_type],
+        [Defined to return type of backtrace().])])
+   AC_SEARCH_LIBS([backtrace],[execinfo])
+   AS_IF([test x"${ax_cv_proto_backtrace_type}" != x -a x"$ac_cv_header_execinfo_h" = xyes -a x"$ac_cv_search_backtrace" != xno],
+     [AC_DEFINE([HAVE_BACKTRACE],[1],
+        [Defined if backtrace() could be fully identified.])
+     ]m4_ifnblank([$1],[$1
+]),m4_ifnblank([$2],[$2
+]))])
+dnl
+dnl Local Variables:
+dnl mode: autoconf
+dnl End:
+dnl

scripts/ax_lua.m4

@@ -0,0 +1,661 @@
+# ===========================================================================
+#          https://www.gnu.org/software/autoconf-archive/ax_lua.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_PROG_LUA[([MINIMUM-VERSION], [TOO-BIG-VERSION], [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])]
+#   AX_LUA_HEADERS[([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])]
+#   AX_LUA_LIBS[([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])]
+#   AX_LUA_READLINE[([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])]
+#
+# DESCRIPTION
+#
+#   Detect a Lua interpreter, optionally specifying a minimum and maximum
+#   version number. Set up important Lua paths, such as the directories in
+#   which to install scripts and modules (shared libraries).
+#
+#   Also detect Lua headers and libraries. The Lua version contained in the
+#   header is checked to match the Lua interpreter version exactly. When
+#   searching for Lua libraries, the version number is used as a suffix.
+#   This is done with the goal of supporting multiple Lua installs (5.1,
+#   5.2, and 5.3 side-by-side).
+#
+#   A note on compatibility with previous versions: This file has been
+#   mostly rewritten for serial 18. Most developers should be able to use
+#   these macros without needing to modify configure.ac. Care has been taken
+#   to preserve each macro's behavior, but there are some differences:
+#
+#   1) AX_WITH_LUA is deprecated; it now expands to the exact same thing as
+#   AX_PROG_LUA with no arguments.
+#
+#   2) AX_LUA_HEADERS now checks that the version number defined in lua.h
+#   matches the interpreter version. AX_LUA_HEADERS_VERSION is therefore
+#   unnecessary, so it is deprecated and does not expand to anything.
+#
+#   3) The configure flag --with-lua-suffix no longer exists; the user
+#   should instead specify the LUA precious variable on the command line.
+#   See the AX_PROG_LUA description for details.
+#
+#   Please read the macro descriptions below for more information.
+#
+#   This file was inspired by Andrew Dalke's and James Henstridge's
+#   python.m4 and Tom Payne's, Matthieu Moy's, and Reuben Thomas's ax_lua.m4
+#   (serial 17). Basically, this file is a mash-up of those two files. I
+#   like to think it combines the best of the two!
+#
+#   AX_PROG_LUA: Search for the Lua interpreter, and set up important Lua
+#   paths. Adds precious variable LUA, which may contain the path of the Lua
+#   interpreter. If LUA is blank, the user's path is searched for an
+#   suitable interpreter.
+#
+#   If MINIMUM-VERSION is supplied, then only Lua interpreters with a
+#   version number greater or equal to MINIMUM-VERSION will be accepted. If
+#   TOO-BIG-VERSION is also supplied, then only Lua interpreters with a
+#   version number greater or equal to MINIMUM-VERSION and less than
+#   TOO-BIG-VERSION will be accepted.
+#
+#   The Lua version number, LUA_VERSION, is found from the interpreter, and
+#   substituted. LUA_PLATFORM is also found, but not currently supported (no
+#   standard representation).
+#
+#   Finally, the macro finds four paths:
+#
+#     luadir             Directory to install Lua scripts.
+#     pkgluadir          $luadir/$PACKAGE
+#     luaexecdir         Directory to install Lua modules.
+#     pkgluaexecdir      $luaexecdir/$PACKAGE
+#
+#   These paths are found based on $prefix, $exec_prefix, Lua's
+#   package.path, and package.cpath. The first path of package.path
+#   beginning with $prefix is selected as luadir. The first path of
+#   package.cpath beginning with $exec_prefix is used as luaexecdir. This
+#   should work on all reasonable Lua installations. If a path cannot be
+#   determined, a default path is used. Of course, the user can override
+#   these later when invoking make.
+#
+#     luadir             Default: $prefix/share/lua/$LUA_VERSION
+#     luaexecdir         Default: $exec_prefix/lib/lua/$LUA_VERSION
+#
+#   These directories can be used by Automake as install destinations. The
+#   variable name minus 'dir' needs to be used as a prefix to the
+#   appropriate Automake primary, e.g. lua_SCRIPS or luaexec_LIBRARIES.
+#
+#   If an acceptable Lua interpreter is found, then ACTION-IF-FOUND is
+#   performed, otherwise ACTION-IF-NOT-FOUND is preformed. If ACTION-IF-NOT-
+#   FOUND is blank, then it will default to printing an error. To prevent
+#   the default behavior, give ':' as an action.
+#
+#   AX_LUA_HEADERS: Search for Lua headers. Requires that AX_PROG_LUA be
+#   expanded before this macro. Adds precious variable LUA_INCLUDE, which
+#   may contain Lua specific include flags, e.g. -I/usr/include/lua5.1. If
+#   LUA_INCLUDE is blank, then this macro will attempt to find suitable
+#   flags.
+#
+#   LUA_INCLUDE can be used by Automake to compile Lua modules or
+#   executables with embedded interpreters. The *_CPPFLAGS variables should
+#   be used for this purpose, e.g. myprog_CPPFLAGS = $(LUA_INCLUDE).
+#
+#   This macro searches for the header lua.h (and others). The search is
+#   performed with a combination of CPPFLAGS, CPATH, etc, and LUA_INCLUDE.
+#   If the search is unsuccessful, then some common directories are tried.
+#   If the headers are then found, then LUA_INCLUDE is set accordingly.
+#
+#   The paths automatically searched are:
+#
+#     * /usr/include/luaX.Y
+#     * /usr/include/lua/X.Y
+#     * /usr/include/luaXY
+#     * /usr/local/include/luaX.Y
+#     * /usr/local/include/lua-X.Y
+#     * /usr/local/include/lua/X.Y
+#     * /usr/local/include/luaXY
+#
+#   (Where X.Y is the Lua version number, e.g. 5.1.)
+#
+#   The Lua version number found in the headers is always checked to match
+#   the Lua interpreter's version number. Lua headers with mismatched
+#   version numbers are not accepted.
+#
+#   If headers are found, then ACTION-IF-FOUND is performed, otherwise
+#   ACTION-IF-NOT-FOUND is performed. If ACTION-IF-NOT-FOUND is blank, then
+#   it will default to printing an error. To prevent the default behavior,
+#   set the action to ':'.
+#
+#   AX_LUA_LIBS: Search for Lua libraries. Requires that AX_PROG_LUA be
+#   expanded before this macro. Adds precious variable LUA_LIB, which may
+#   contain Lua specific linker flags, e.g. -llua5.1. If LUA_LIB is blank,
+#   then this macro will attempt to find suitable flags.
+#
+#   LUA_LIB can be used by Automake to link Lua modules or executables with
+#   embedded interpreters. The *_LIBADD and *_LDADD variables should be used
+#   for this purpose, e.g. mymod_LIBADD = $(LUA_LIB).
+#
+#   This macro searches for the Lua library. More technically, it searches
+#   for a library containing the function lua_load. The search is performed
+#   with a combination of LIBS, LIBRARY_PATH, and LUA_LIB.
+#
+#   If the search determines that some linker flags are missing, then those
+#   flags will be added to LUA_LIB.
+#
+#   If libraries are found, then ACTION-IF-FOUND is performed, otherwise
+#   ACTION-IF-NOT-FOUND is performed. If ACTION-IF-NOT-FOUND is blank, then
+#   it will default to printing an error. To prevent the default behavior,
+#   set the action to ':'.
+#
+#   AX_LUA_READLINE: Search for readline headers and libraries. Requires the
+#   AX_LIB_READLINE macro, which is provided by ax_lib_readline.m4 from the
+#   Autoconf Archive.
+#
+#   If a readline compatible library is found, then ACTION-IF-FOUND is
+#   performed, otherwise ACTION-IF-NOT-FOUND is performed.
+#
+# LICENSE
+#
+#   Copyright (c) 2015 Reuben Thomas <rrt@sc3d.org>
+#   Copyright (c) 2014 Tim Perkins <tprk77@gmail.com>
+#
+#   This program is free software: you can redistribute it and/or modify it
+#   under the terms of the GNU General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   This program is distributed in the hope that it will be useful, but
+#   WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+#   Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program. If not, see <https://www.gnu.org/licenses/>.
+#
+#   As a special exception, the respective Autoconf Macro's copyright owner
+#   gives unlimited permission to copy, distribute and modify the configure
+#   scripts that are the output of Autoconf when processing the Macro. You
+#   need not follow the terms of the GNU General Public License when using
+#   or distributing such scripts, even though portions of the text of the
+#   Macro appear in them. The GNU General Public License (GPL) does govern
+#   all other use of the material that constitutes the Autoconf Macro.
+#
+#   This special exception to the GPL applies to versions of the Autoconf
+#   Macro released by the Autoconf Archive. When you make and distribute a
+#   modified version of the Autoconf Macro, you may extend this special
+#   exception to the GPL to apply to your modified version as well.
+
+#serial 42
+
+dnl =========================================================================
+dnl AX_PROG_LUA([MINIMUM-VERSION], [TOO-BIG-VERSION],
+dnl             [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+dnl =========================================================================
+AC_DEFUN([AX_PROG_LUA],
+[
+  dnl Check for required tools.
+  AC_REQUIRE([AC_PROG_GREP])
+  AC_REQUIRE([AC_PROG_SED])
+
+  dnl Make LUA a precious variable.
+  AC_ARG_VAR([LUA], [The Lua interpreter, e.g. /usr/bin/lua5.1])
+
+  dnl Find a Lua interpreter.
+  m4_define_default([_AX_LUA_INTERPRETER_LIST],
+    [lua lua5.3 lua53 lua5.2 lua52 lua5.1 lua51 lua50])
+
+  m4_if([$1], [],
+  [ dnl No version check is needed. Find any Lua interpreter.
+    AS_IF([test "x$LUA" = 'x'],
+      [AC_PATH_PROGS([LUA], [_AX_LUA_INTERPRETER_LIST], [:])])
+    ax_display_LUA='lua'
+
+    AS_IF([test "x$LUA" != 'x:'],
+      [ dnl At least check if this is a Lua interpreter.
+        AC_MSG_CHECKING([if $LUA is a Lua interpreter])
+        _AX_LUA_CHK_IS_INTRP([$LUA],
+          [AC_MSG_RESULT([yes])],
+          [ AC_MSG_RESULT([no])
+            AC_MSG_ERROR([not a Lua interpreter])
+          ])
+      ])
+  ],
+  [ dnl A version check is needed.
+    AS_IF([test "x$LUA" != 'x'],
+    [ dnl Check if this is a Lua interpreter.
+      AC_MSG_CHECKING([if $LUA is a Lua interpreter])
+      _AX_LUA_CHK_IS_INTRP([$LUA],
+        [AC_MSG_RESULT([yes])],
+        [ AC_MSG_RESULT([no])
+          AC_MSG_ERROR([not a Lua interpreter])
+        ])
+      dnl Check the version.
+      m4_if([$2], [],
+        [_ax_check_text="whether $LUA version >= $1"],
+        [_ax_check_text="whether $LUA version >= $1, < $2"])
+      AC_MSG_CHECKING([$_ax_check_text])
+      _AX_LUA_CHK_VER([$LUA], [$1], [$2],
+        [AC_MSG_RESULT([yes])],
+        [ AC_MSG_RESULT([no])
+          AC_MSG_ERROR([version is out of range for specified LUA])])
+      ax_display_LUA=$LUA
+    ],
+    [ dnl Try each interpreter until we find one that satisfies VERSION.
+      m4_if([$2], [],
+        [_ax_check_text="for a Lua interpreter with version >= $1"],
+        [_ax_check_text="for a Lua interpreter with version >= $1, < $2"])
+      AC_CACHE_CHECK([$_ax_check_text],
+        [ax_cv_pathless_LUA],
+        [ for ax_cv_pathless_LUA in _AX_LUA_INTERPRETER_LIST none; do
+            test "x$ax_cv_pathless_LUA" = 'xnone' && break
+            _AX_LUA_CHK_IS_INTRP([$ax_cv_pathless_LUA], [], [continue])
+            _AX_LUA_CHK_VER([$ax_cv_pathless_LUA], [$1], [$2], [break])
+          done
+        ])
+      dnl Set $LUA to the absolute path of $ax_cv_pathless_LUA.
+      AS_IF([test "x$ax_cv_pathless_LUA" = 'xnone'],
+        [LUA=':'],
+        [AC_PATH_PROG([LUA], [$ax_cv_pathless_LUA])])
+      ax_display_LUA=$ax_cv_pathless_LUA
+    ])
+  ])
+
+  AS_IF([test "x$LUA" = 'x:'],
+  [ dnl Run any user-specified action, or abort.
+    m4_default([$4], [AC_MSG_ERROR([cannot find suitable Lua interpreter])])
+  ],
+  [ dnl Query Lua for its version number.
+    AC_CACHE_CHECK([for $ax_display_LUA version],
+      [ax_cv_lua_version],
+      [ dnl Get the interpreter version in X.Y format. This should work for
+        dnl interpreters version 5.0 and beyond.
+        ax_cv_lua_version=[`$LUA -e '
+          -- return a version number in X.Y format
+          local _, _, ver = string.find(_VERSION, "^Lua (%d+%.%d+)")
+          print(ver)'`]
+      ])
+    AS_IF([test "x$ax_cv_lua_version" = 'x'],
+      [AC_MSG_ERROR([invalid Lua version number])])
+    AC_SUBST([LUA_VERSION], [$ax_cv_lua_version])
+    AC_SUBST([LUA_SHORT_VERSION], [`echo "$LUA_VERSION" | $SED 's|\.||'`])
+
+    dnl The following check is not supported:
+    dnl At times (like when building shared libraries) you may want to know
+    dnl which OS platform Lua thinks this is.
+    AC_CACHE_CHECK([for $ax_display_LUA platform],
+      [ax_cv_lua_platform],
+      [ax_cv_lua_platform=[`$LUA -e 'print("unknown")'`]])
+    AC_SUBST([LUA_PLATFORM], [$ax_cv_lua_platform])
+
+    dnl Use the values of $prefix and $exec_prefix for the corresponding
+    dnl values of LUA_PREFIX and LUA_EXEC_PREFIX. These are made distinct
+    dnl variables so they can be overridden if need be. However, the general
+    dnl consensus is that you shouldn't need this ability.
+    AC_SUBST([LUA_PREFIX], ['${prefix}'])
+    AC_SUBST([LUA_EXEC_PREFIX], ['${exec_prefix}'])
+
+    dnl Lua provides no way to query the script directory, and instead
+    dnl provides LUA_PATH. However, we should be able to make a safe educated
+    dnl guess. If the built-in search path contains a directory which is
+    dnl prefixed by $prefix, then we can store scripts there. The first
+    dnl matching path will be used.
+    AC_CACHE_CHECK([for $ax_display_LUA script directory],
+      [ax_cv_lua_luadir],
+      [ AS_IF([test "x$prefix" = 'xNONE'],
+          [ax_lua_prefix=$ac_default_prefix],
+          [ax_lua_prefix=$prefix])
+
+        dnl Initialize to the default path.
+        ax_cv_lua_luadir="$LUA_PREFIX/share/lua/$LUA_VERSION"
+
+        dnl Try to find a path with the prefix.
+        _AX_LUA_FND_PRFX_PTH([$LUA], [$ax_lua_prefix], [script])
+        AS_IF([test "x$ax_lua_prefixed_path" != 'x'],
+        [ dnl Fix the prefix.
+          _ax_strip_prefix=`echo "$ax_lua_prefix" | $SED 's|.|.|g'`
+          ax_cv_lua_luadir=`echo "$ax_lua_prefixed_path" | \
+            $SED "s|^$_ax_strip_prefix|$LUA_PREFIX|"`
+        ])
+      ])
+    AC_SUBST([luadir], [$ax_cv_lua_luadir])
+    AC_SUBST([pkgluadir], [\${luadir}/$PACKAGE])
+
+    dnl Lua provides no way to query the module directory, and instead
+    dnl provides LUA_PATH. However, we should be able to make a safe educated
+    dnl guess. If the built-in search path contains a directory which is
+    dnl prefixed by $exec_prefix, then we can store modules there. The first
+    dnl matching path will be used.
+    AC_CACHE_CHECK([for $ax_display_LUA module directory],
+      [ax_cv_lua_luaexecdir],
+      [ AS_IF([test "x$exec_prefix" = 'xNONE'],
+          [ax_lua_exec_prefix=$ax_lua_prefix],
+          [ax_lua_exec_prefix=$exec_prefix])
+
+        dnl Initialize to the default path.
+        ax_cv_lua_luaexecdir="$LUA_EXEC_PREFIX/lib/lua/$LUA_VERSION"
+
+        dnl Try to find a path with the prefix.
+        _AX_LUA_FND_PRFX_PTH([$LUA],
+          [$ax_lua_exec_prefix], [module])
+        AS_IF([test "x$ax_lua_prefixed_path" != 'x'],
+        [ dnl Fix the prefix.
+          _ax_strip_prefix=`echo "$ax_lua_exec_prefix" | $SED 's|.|.|g'`
+          ax_cv_lua_luaexecdir=`echo "$ax_lua_prefixed_path" | \
+            $SED "s|^$_ax_strip_prefix|$LUA_EXEC_PREFIX|"`
+        ])
+      ])
+    AC_SUBST([luaexecdir], [$ax_cv_lua_luaexecdir])
+    AC_SUBST([pkgluaexecdir], [\${luaexecdir}/$PACKAGE])
+
+    dnl Run any user specified action.
+    $3
+  ])
+])
+
+dnl AX_WITH_LUA is now the same thing as AX_PROG_LUA.
+AC_DEFUN([AX_WITH_LUA],
+[
+  AC_MSG_WARN([[$0 is deprecated, please use AX_PROG_LUA instead]])
+  AX_PROG_LUA
+])
+
+
+dnl =========================================================================
+dnl _AX_LUA_CHK_IS_INTRP(PROG, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
+dnl =========================================================================
+AC_DEFUN([_AX_LUA_CHK_IS_INTRP],
+[
+  dnl A minimal Lua factorial to prove this is an interpreter. This should work
+  dnl for Lua interpreters version 5.0 and beyond.
+  _ax_lua_factorial=[`$1 2>/dev/null -e '
+    -- a simple factorial
+    function fact (n)
+      if n == 0 then
+        return 1
+      else
+        return n * fact(n-1)
+      end
+    end
+    print("fact(5) is " .. fact(5))'`]
+  AS_IF([test "$_ax_lua_factorial" = 'fact(5) is 120'],
+    [$2], [$3])
+])
+
+
+dnl =========================================================================
+dnl _AX_LUA_CHK_VER(PROG, MINIMUM-VERSION, [TOO-BIG-VERSION],
+dnl                 [ACTION-IF-TRUE], [ACTION-IF-FALSE])
+dnl =========================================================================
+AC_DEFUN([_AX_LUA_CHK_VER],
+[
+  dnl Check that the Lua version is within the bounds. Only the major and minor
+  dnl version numbers are considered. This should work for Lua interpreters
+  dnl version 5.0 and beyond.
+  _ax_lua_good_version=[`$1 -e '
+    -- a script to compare versions
+    function verstr2num(verstr)
+      local _, _, majorver, minorver = string.find(verstr, "^(%d+)%.(%d+)")
+      if majorver and minorver then
+        return tonumber(majorver) * 100 + tonumber(minorver)
+      end
+    end
+    local minver = verstr2num("$2")
+    local _, _, trimver = string.find(_VERSION, "^Lua (.*)")
+    local ver = verstr2num(trimver)
+    local maxver = verstr2num("$3") or 1e9
+    if minver <= ver and ver < maxver then
+      print("yes")
+    else
+      print("no")
+    end'`]
+    AS_IF([test "x$_ax_lua_good_version" = "xyes"],
+      [$4], [$5])
+])
+
+
+dnl =========================================================================
+dnl _AX_LUA_FND_PRFX_PTH(PROG, PREFIX, SCRIPT-OR-MODULE-DIR)
+dnl =========================================================================
+AC_DEFUN([_AX_LUA_FND_PRFX_PTH],
+[
+  dnl Get the script or module directory by querying the Lua interpreter,
+  dnl filtering on the given prefix, and selecting the shallowest path. If no
+  dnl path is found matching the prefix, the result will be an empty string.
+  dnl The third argument determines the type of search, it can be 'script' or
+  dnl 'module'. Supplying 'script' will perform the search with package.path
+  dnl and LUA_PATH, and supplying 'module' will search with package.cpath and
+  dnl LUA_CPATH. This is done for compatibility with Lua 5.0.
+
+  ax_lua_prefixed_path=[`$1 -e '
+    -- get the path based on search type
+    local searchtype = "$3"
+    local paths = ""
+    if searchtype == "script" then
+      paths = (package and package.path) or LUA_PATH
+    elseif searchtype == "module" then
+      paths = (package and package.cpath) or LUA_CPATH
+    end
+    -- search for the prefix
+    local prefix = "'$2'"
+    local minpath = ""
+    local mindepth = 1e9
+    string.gsub(paths, "(@<:@^;@:>@+)",
+      function (path)
+        path = string.gsub(path, "%?.*$", "")
+        path = string.gsub(path, "/@<:@^/@:>@*$", "")
+        if string.find(path, prefix) then
+          local depth = string.len(string.gsub(path, "@<:@^/@:>@", ""))
+          if depth < mindepth then
+            minpath = path
+            mindepth = depth
+          end
+        end
+      end)
+    print(minpath)'`]
+])
+
+
+dnl =========================================================================
+dnl AX_LUA_HEADERS([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+dnl =========================================================================
+AC_DEFUN([AX_LUA_HEADERS],
+[
+  dnl Check for LUA_VERSION.
+  AC_MSG_CHECKING([if LUA_VERSION is defined])
+  AS_IF([test "x$LUA_VERSION" != 'x'],
+    [AC_MSG_RESULT([yes])],
+    [ AC_MSG_RESULT([no])
+      AC_MSG_ERROR([cannot check Lua headers without knowing LUA_VERSION])
+    ])
+
+  dnl Make LUA_INCLUDE a precious variable.
+  AC_ARG_VAR([LUA_INCLUDE], [The Lua includes, e.g. -I/usr/include/lua5.1])
+
+  dnl Some default directories to search.
+  LUA_SHORT_VERSION=`echo "$LUA_VERSION" | $SED 's|\.||'`
+  m4_define_default([_AX_LUA_INCLUDE_LIST],
+    [ /usr/include/lua$LUA_VERSION \
+      /usr/include/lua-$LUA_VERSION \
+      /usr/include/lua/$LUA_VERSION \
+      /usr/include/lua$LUA_SHORT_VERSION \
+      /usr/local/include/lua$LUA_VERSION \
+      /usr/local/include/lua-$LUA_VERSION \
+      /usr/local/include/lua/$LUA_VERSION \
+      /usr/local/include/lua$LUA_SHORT_VERSION \
+    ])
+
+  dnl Try to find the headers.
+  _ax_lua_saved_cppflags=$CPPFLAGS
+  CPPFLAGS="$CPPFLAGS $LUA_INCLUDE"
+  AC_CHECK_HEADERS([lua.h lualib.h lauxlib.h luaconf.h])
+  CPPFLAGS=$_ax_lua_saved_cppflags
+
+  dnl Try some other directories if LUA_INCLUDE was not set.
+  AS_IF([test "x$LUA_INCLUDE" = 'x' &&
+         test "x$ac_cv_header_lua_h" != 'xyes'],
+    [ dnl Try some common include paths.
+      for _ax_include_path in _AX_LUA_INCLUDE_LIST; do
+        test ! -d "$_ax_include_path" && continue
+
+        AC_MSG_CHECKING([for Lua headers in])
+        AC_MSG_RESULT([$_ax_include_path])
+
+        AS_UNSET([ac_cv_header_lua_h])
+        AS_UNSET([ac_cv_header_lualib_h])
+        AS_UNSET([ac_cv_header_lauxlib_h])
+        AS_UNSET([ac_cv_header_luaconf_h])
+
+        _ax_lua_saved_cppflags=$CPPFLAGS
+        CPPFLAGS="$CPPFLAGS -I$_ax_include_path"
+        AC_CHECK_HEADERS([lua.h lualib.h lauxlib.h luaconf.h])
+        CPPFLAGS=$_ax_lua_saved_cppflags
+
+        AS_IF([test "x$ac_cv_header_lua_h" = 'xyes'],
+          [ LUA_INCLUDE="-I$_ax_include_path"
+            break
+          ])
+      done
+    ])
+
+  AS_IF([test "x$ac_cv_header_lua_h" = 'xyes'],
+    [ dnl Make a program to print LUA_VERSION defined in the header.
+      dnl TODO It would be really nice if we could do this without compiling a
+      dnl program, then it would work when cross compiling. But I'm not sure how
+      dnl to do this reliably. For now, assume versions match when cross compiling.
+
+      AS_IF([test "x$cross_compiling" != 'xyes'],
+        [ AC_CACHE_CHECK([for Lua header version],
+            [ax_cv_lua_header_version],
+            [ _ax_lua_saved_cppflags=$CPPFLAGS
+              CPPFLAGS="$CPPFLAGS $LUA_INCLUDE"
+              AC_COMPUTE_INT(ax_cv_lua_header_version_major,[LUA_VERSION_NUM/100],[AC_INCLUDES_DEFAULT
+#include <lua.h>
+],[ax_cv_lua_header_version_major=unknown])
+              AC_COMPUTE_INT(ax_cv_lua_header_version_minor,[LUA_VERSION_NUM%100],[AC_INCLUDES_DEFAULT
+#include <lua.h>
+],[ax_cv_lua_header_version_minor=unknown])
+              AS_IF([test "x$ax_cv_lua_header_version_major" = xunknown || test "x$ax_cv_lua_header_version_minor" = xunknown],[
+                ax_cv_lua_header_version=unknown
+              ],[
+                ax_cv_lua_header_version="$ax_cv_lua_header_version_major.$ax_cv_lua_header_version_minor"
+              ])
+              CPPFLAGS=$_ax_lua_saved_cppflags
+            ])
+
+          dnl Compare this to the previously found LUA_VERSION.
+          AC_MSG_CHECKING([if Lua header version matches $LUA_VERSION])
+          AS_IF([test "x$ax_cv_lua_header_version" = "x$LUA_VERSION"],
+            [ AC_MSG_RESULT([yes])
+              ax_header_version_match='yes'
+            ],
+            [ AC_MSG_RESULT([no])
+              ax_header_version_match='no'
+            ])
+        ],
+        [ AC_MSG_WARN([cross compiling so assuming header version number matches])
+          ax_header_version_match='yes'
+        ])
+    ])
+
+  dnl Was LUA_INCLUDE specified?
+  AS_IF([test "x$ax_header_version_match" != 'xyes' &&
+         test "x$LUA_INCLUDE" != 'x'],
+    [AC_MSG_ERROR([cannot find headers for specified LUA_INCLUDE])])
+
+  dnl Test the final result and run user code.
+  AS_IF([test "x$ax_header_version_match" = 'xyes'], [$1],
+    [m4_default([$2], [AC_MSG_ERROR([cannot find Lua includes])])])
+])
+
+dnl AX_LUA_HEADERS_VERSION no longer exists, use AX_LUA_HEADERS.
+AC_DEFUN([AX_LUA_HEADERS_VERSION],
+[
+  AC_MSG_WARN([[$0 is deprecated, please use AX_LUA_HEADERS instead]])
+])
+
+
+dnl =========================================================================
+dnl AX_LUA_LIBS([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+dnl =========================================================================
+AC_DEFUN([AX_LUA_LIBS],
+[
+  dnl TODO Should this macro also check various -L flags?
+
+  dnl Check for LUA_VERSION.
+  AC_MSG_CHECKING([if LUA_VERSION is defined])
+  AS_IF([test "x$LUA_VERSION" != 'x'],
+    [AC_MSG_RESULT([yes])],
+    [ AC_MSG_RESULT([no])
+      AC_MSG_ERROR([cannot check Lua libs without knowing LUA_VERSION])
+    ])
+
+  dnl Make LUA_LIB a precious variable.
+  AC_ARG_VAR([LUA_LIB], [The Lua library, e.g. -llua5.1])
+
+  AS_IF([test "x$LUA_LIB" != 'x'],
+  [ dnl Check that LUA_LIBS works.
+    _ax_lua_saved_libs=$LIBS
+    LIBS="$LIBS $LUA_LIB"
+    AC_SEARCH_LIBS([lua_load], [],
+      [_ax_found_lua_libs='yes'],
+      [_ax_found_lua_libs='no'])
+    LIBS=$_ax_lua_saved_libs
+
+    dnl Check the result.
+    AS_IF([test "x$_ax_found_lua_libs" != 'xyes'],
+      [AC_MSG_ERROR([cannot find libs for specified LUA_LIB])])
+  ],
+  [ dnl First search for extra libs.
+    _ax_lua_extra_libs=''
+
+    _ax_lua_saved_libs=$LIBS
+    LIBS="$LIBS $LUA_LIB"
+    AC_SEARCH_LIBS([exp], [m])
+    AC_SEARCH_LIBS([dlopen], [dl])
+    LIBS=$_ax_lua_saved_libs
+
+    AS_IF([test "x$ac_cv_search_exp" != 'xno' &&
+           test "x$ac_cv_search_exp" != 'xnone required'],
+      [_ax_lua_extra_libs="$_ax_lua_extra_libs $ac_cv_search_exp"])
+
+    AS_IF([test "x$ac_cv_search_dlopen" != 'xno' &&
+           test "x$ac_cv_search_dlopen" != 'xnone required'],
+      [_ax_lua_extra_libs="$_ax_lua_extra_libs $ac_cv_search_dlopen"])
+
+    dnl Try to find the Lua libs.
+    _ax_lua_saved_libs=$LIBS
+    LIBS="$LIBS $LUA_LIB"
+    AC_SEARCH_LIBS([lua_load],
+      [ lua$LUA_VERSION \
+        lua$LUA_SHORT_VERSION \
+        lua-$LUA_VERSION \
+        lua-$LUA_SHORT_VERSION \
+        :liblua-$LUA_VERSION.so.0 \
+        :liblua-$LUA_SHORT_VERSION.so.0 \
+        lua \
+      ],
+      [_ax_found_lua_libs='yes'],
+      [_ax_found_lua_libs='no'],
+      [$_ax_lua_extra_libs])
+    LIBS=$_ax_lua_saved_libs
+
+    AS_IF([test "x$ac_cv_search_lua_load" != 'xno' &&
+           test "x$ac_cv_search_lua_load" != 'xnone required'],
+      [LUA_LIB="$ac_cv_search_lua_load $_ax_lua_extra_libs"])
+  ])
+
+  dnl Test the result and run user code.
+  AS_IF([test "x$_ax_found_lua_libs" = 'xyes'], [$1],
+    [m4_default([$2], [AC_MSG_ERROR([cannot find Lua libs])])])
+])
+
+
+dnl =========================================================================
+dnl AX_LUA_READLINE([ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+dnl =========================================================================
+AC_DEFUN([AX_LUA_READLINE],
+[
+  AX_LIB_READLINE
+  AS_IF([test "x$ac_cv_header_readline_readline_h" != 'x' &&
+         test "x$ac_cv_header_readline_history_h" != 'x'],
+    [ LUA_LIBS_CFLAGS="-DLUA_USE_READLINE $LUA_LIBS_CFLAGS"
+      $1
+    ],
+    [$2])
+])

scripts/ax_pthread.m4

@@ -0,0 +1,522 @@
+# ===========================================================================
+#        https://www.gnu.org/software/autoconf-archive/ax_pthread.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+#
+# DESCRIPTION
+#
+#   This macro figures out how to build C programs using POSIX threads. It
+#   sets the PTHREAD_LIBS output variable to the threads library and linker
+#   flags, and the PTHREAD_CFLAGS output variable to any special C compiler
+#   flags that are needed. (The user can also force certain compiler
+#   flags/libs to be tested by setting these environment variables.)
+#
+#   Also sets PTHREAD_CC and PTHREAD_CXX to any special C compiler that is
+#   needed for multi-threaded programs (defaults to the value of CC
+#   respectively CXX otherwise). (This is necessary on e.g. AIX to use the
+#   special cc_r/CC_r compiler alias.)
+#
+#   NOTE: You are assumed to not only compile your program with these flags,
+#   but also to link with them as well. For example, you might link with
+#   $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS
+#   $PTHREAD_CXX $CXXFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS
+#
+#   If you are only building threaded programs, you may wish to use these
+#   variables in your default LIBS, CFLAGS, and CC:
+#
+#     LIBS="$PTHREAD_LIBS $LIBS"
+#     CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+#     CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS"
+#     CC="$PTHREAD_CC"
+#     CXX="$PTHREAD_CXX"
+#
+#   In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant
+#   has a nonstandard name, this macro defines PTHREAD_CREATE_JOINABLE to
+#   that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX).
+#
+#   Also HAVE_PTHREAD_PRIO_INHERIT is defined if pthread is found and the
+#   PTHREAD_PRIO_INHERIT symbol is defined when compiling with
+#   PTHREAD_CFLAGS.
+#
+#   ACTION-IF-FOUND is a list of shell commands to run if a threads library
+#   is found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it
+#   is not found. If ACTION-IF-FOUND is not specified, the default action
+#   will define HAVE_PTHREAD.
+#
+#   Please let the authors know if this macro fails on any platform, or if
+#   you have any other suggestions or comments. This macro was based on work
+#   by SGJ on autoconf scripts for FFTW (http://www.fftw.org/) (with help
+#   from M. Frigo), as well as ac_pthread and hb_pthread macros posted by
+#   Alejandro Forero Cuervo to the autoconf macro repository. We are also
+#   grateful for the helpful feedback of numerous users.
+#
+#   Updated for Autoconf 2.68 by Daniel Richard G.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
+#   Copyright (c) 2011 Daniel Richard G. <skunk@iSKUNK.ORG>
+#   Copyright (c) 2019 Marc Stevens <marc.stevens@cwi.nl>
+#
+#   This program is free software: you can redistribute it and/or modify it
+#   under the terms of the GNU General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   This program is distributed in the hope that it will be useful, but
+#   WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+#   Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program. If not, see <https://www.gnu.org/licenses/>.
+#
+#   As a special exception, the respective Autoconf Macro's copyright owner
+#   gives unlimited permission to copy, distribute and modify the configure
+#   scripts that are the output of Autoconf when processing the Macro. You
+#   need not follow the terms of the GNU General Public License when using
+#   or distributing such scripts, even though portions of the text of the
+#   Macro appear in them. The GNU General Public License (GPL) does govern
+#   all other use of the material that constitutes the Autoconf Macro.
+#
+#   This special exception to the GPL applies to versions of the Autoconf
+#   Macro released by the Autoconf Archive. When you make and distribute a
+#   modified version of the Autoconf Macro, you may extend this special
+#   exception to the GPL to apply to your modified version as well.
+
+#serial 31
+
+AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD])
+AC_DEFUN([AX_PTHREAD], [
+AC_REQUIRE([AC_CANONICAL_HOST])
+AC_REQUIRE([AC_PROG_CC])
+AC_REQUIRE([AC_PROG_SED])
+AC_LANG_PUSH([C])
+ax_pthread_ok=no
+
+# We used to check for pthread.h first, but this fails if pthread.h
+# requires special compiler flags (e.g. on Tru64 or Sequent).
+# It gets checked for in the link test anyway.
+
+# First of all, check if the user has set any of the PTHREAD_LIBS,
+# etcetera environment variables, and if threads linking works using
+# them:
+if test "x$PTHREAD_CFLAGS$PTHREAD_LIBS" != "x"; then
+        ax_pthread_save_CC="$CC"
+        ax_pthread_save_CFLAGS="$CFLAGS"
+        ax_pthread_save_LIBS="$LIBS"
+        AS_IF([test "x$PTHREAD_CC" != "x"], [CC="$PTHREAD_CC"])
+        AS_IF([test "x$PTHREAD_CXX" != "x"], [CXX="$PTHREAD_CXX"])
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        AC_MSG_CHECKING([for pthread_join using $CC $PTHREAD_CFLAGS $PTHREAD_LIBS])
+        AC_LINK_IFELSE([AC_LANG_CALL([], [pthread_join])], [ax_pthread_ok=yes])
+        AC_MSG_RESULT([$ax_pthread_ok])
+        if test "x$ax_pthread_ok" = "xno"; then
+                PTHREAD_LIBS=""
+                PTHREAD_CFLAGS=""
+        fi
+        CC="$ax_pthread_save_CC"
+        CFLAGS="$ax_pthread_save_CFLAGS"
+        LIBS="$ax_pthread_save_LIBS"
+fi
+
+# We must check for the threads library under a number of different
+# names; the ordering is very important because some systems
+# (e.g. DEC) have both -lpthread and -lpthreads, where one of the
+# libraries is broken (non-POSIX).
+
+# Create a list of thread flags to try. Items with a "," contain both
+# C compiler flags (before ",") and linker flags (after ","). Other items
+# starting with a "-" are C compiler flags, and remaining items are
+# library names, except for "none" which indicates that we try without
+# any flags at all, and "pthread-config" which is a program returning
+# the flags for the Pth emulation library.
+
+ax_pthread_flags="pthreads none -Kthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"
+
+# The ordering *is* (sometimes) important.  Some notes on the
+# individual items follow:
+
+# pthreads: AIX (must check this before -lpthread)
+# none: in case threads are in libc; should be tried before -Kthread and
+#       other compiler flags to prevent continual compiler warnings
+# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
+# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads), Tru64
+#           (Note: HP C rejects this with "bad form for `-t' option")
+# -pthreads: Solaris/gcc (Note: HP C also rejects)
+# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
+#      doesn't hurt to check since this sometimes defines pthreads and
+#      -D_REENTRANT too), HP C (must be checked before -lpthread, which
+#      is present but should not be used directly; and before -mthreads,
+#      because the compiler interprets this as "-mt" + "-hreads")
+# -mthreads: Mingw32/gcc, Lynx/gcc
+# pthread: Linux, etcetera
+# --thread-safe: KAI C++
+# pthread-config: use pthread-config program (for GNU Pth library)
+
+case $host_os in
+
+        freebsd*)
+
+        # -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
+        # lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
+
+        ax_pthread_flags="-kthread lthread $ax_pthread_flags"
+        ;;
+
+        hpux*)
+
+        # From the cc(1) man page: "[-mt] Sets various -D flags to enable
+        # multi-threading and also sets -lpthread."
+
+        ax_pthread_flags="-mt -pthread pthread $ax_pthread_flags"
+        ;;
+
+        openedition*)
+
+        # IBM z/OS requires a feature-test macro to be defined in order to
+        # enable POSIX threads at all, so give the user a hint if this is
+        # not set. (We don't define these ourselves, as they can affect
+        # other portions of the system API in unpredictable ways.)
+
+        AC_EGREP_CPP([AX_PTHREAD_ZOS_MISSING],
+            [
+#            if !defined(_OPEN_THREADS) && !defined(_UNIX03_THREADS)
+             AX_PTHREAD_ZOS_MISSING
+#            endif
+            ],
+            [AC_MSG_WARN([IBM z/OS requires -D_OPEN_THREADS or -D_UNIX03_THREADS to enable pthreads support.])])
+        ;;
+
+        solaris*)
+
+        # On Solaris (at least, for some versions), libc contains stubbed
+        # (non-functional) versions of the pthreads routines, so link-based
+        # tests will erroneously succeed. (N.B.: The stubs are missing
+        # pthread_cleanup_push, or rather a function called by this macro,
+        # so we could check for that, but who knows whether they'll stub
+        # that too in a future libc.)  So we'll check first for the
+        # standard Solaris way of linking pthreads (-mt -lpthread).
+
+        ax_pthread_flags="-mt,-lpthread pthread $ax_pthread_flags"
+        ;;
+esac
+
+# Are we compiling with Clang?
+
+AC_CACHE_CHECK([whether $CC is Clang],
+    [ax_cv_PTHREAD_CLANG],
+    [ax_cv_PTHREAD_CLANG=no
+     # Note that Autoconf sets GCC=yes for Clang as well as GCC
+     if test "x$GCC" = "xyes"; then
+        AC_EGREP_CPP([AX_PTHREAD_CC_IS_CLANG],
+            [/* Note: Clang 2.7 lacks __clang_[a-z]+__ */
+#            if defined(__clang__) && defined(__llvm__)
+             AX_PTHREAD_CC_IS_CLANG
+#            endif
+            ],
+            [ax_cv_PTHREAD_CLANG=yes])
+     fi
+    ])
+ax_pthread_clang="$ax_cv_PTHREAD_CLANG"
+
+
+# GCC generally uses -pthread, or -pthreads on some platforms (e.g. SPARC)
+
+# Note that for GCC and Clang -pthread generally implies -lpthread,
+# except when -nostdlib is passed.
+# This is problematic using libtool to build C++ shared libraries with pthread:
+# [1] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=25460
+# [2] https://bugzilla.redhat.com/show_bug.cgi?id=661333
+# [3] https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=468555
+# To solve this, first try -pthread together with -lpthread for GCC
+
+AS_IF([test "x$GCC" = "xyes"],
+      [ax_pthread_flags="-pthread,-lpthread -pthread -pthreads $ax_pthread_flags"])
+
+# Clang takes -pthread (never supported any other flag), but we'll try with -lpthread first
+
+AS_IF([test "x$ax_pthread_clang" = "xyes"],
+      [ax_pthread_flags="-pthread,-lpthread -pthread"])
+
+
+# The presence of a feature test macro requesting re-entrant function
+# definitions is, on some systems, a strong hint that pthreads support is
+# correctly enabled
+
+case $host_os in
+        darwin* | hpux* | linux* | osf* | solaris*)
+        ax_pthread_check_macro="_REENTRANT"
+        ;;
+
+        aix*)
+        ax_pthread_check_macro="_THREAD_SAFE"
+        ;;
+
+        *)
+        ax_pthread_check_macro="--"
+        ;;
+esac
+AS_IF([test "x$ax_pthread_check_macro" = "x--"],
+      [ax_pthread_check_cond=0],
+      [ax_pthread_check_cond="!defined($ax_pthread_check_macro)"])
+
+
+if test "x$ax_pthread_ok" = "xno"; then
+for ax_pthread_try_flag in $ax_pthread_flags; do
+
+        case $ax_pthread_try_flag in
+                none)
+                AC_MSG_CHECKING([whether pthreads work without any flags])
+                ;;
+
+                *,*)
+                PTHREAD_CFLAGS=`echo $ax_pthread_try_flag | sed "s/^\(.*\),\(.*\)$/\1/"`
+                PTHREAD_LIBS=`echo $ax_pthread_try_flag | sed "s/^\(.*\),\(.*\)$/\2/"`
+                AC_MSG_CHECKING([whether pthreads work with "$PTHREAD_CFLAGS" and "$PTHREAD_LIBS"])
+                ;;
+
+                -*)
+                AC_MSG_CHECKING([whether pthreads work with $ax_pthread_try_flag])
+                PTHREAD_CFLAGS="$ax_pthread_try_flag"
+                ;;
+
+                pthread-config)
+                AC_CHECK_PROG([ax_pthread_config], [pthread-config], [yes], [no])
+                AS_IF([test "x$ax_pthread_config" = "xno"], [continue])
+                PTHREAD_CFLAGS="`pthread-config --cflags`"
+                PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
+                ;;
+
+                *)
+                AC_MSG_CHECKING([for the pthreads library -l$ax_pthread_try_flag])
+                PTHREAD_LIBS="-l$ax_pthread_try_flag"
+                ;;
+        esac
+
+        ax_pthread_save_CFLAGS="$CFLAGS"
+        ax_pthread_save_LIBS="$LIBS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+
+        # Check for various functions.  We must include pthread.h,
+        # since some functions may be macros.  (On the Sequent, we
+        # need a special flag -Kthread to make this header compile.)
+        # We check for pthread_join because it is in -lpthread on IRIX
+        # while pthread_create is in libc.  We check for pthread_attr_init
+        # due to DEC craziness with -lpthreads.  We check for
+        # pthread_cleanup_push because it is one of the few pthread
+        # functions on Solaris that doesn't have a non-functional libc stub.
+        # We try pthread_create on general principles.
+
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>
+#                       if $ax_pthread_check_cond
+#                        error "$ax_pthread_check_macro must be defined"
+#                       endif
+                        static void *some_global = NULL;
+                        static void routine(void *a)
+                          {
+                             /* To avoid any unused-parameter or
+                                unused-but-set-parameter warning.  */
+                             some_global = a;
+                          }
+                        static void *start_routine(void *a) { return a; }],
+                       [pthread_t th; pthread_attr_t attr;
+                        pthread_create(&th, 0, start_routine, 0);
+                        pthread_join(th, 0);
+                        pthread_attr_init(&attr);
+                        pthread_cleanup_push(routine, 0);
+                        pthread_cleanup_pop(0) /* ; */])],
+            [ax_pthread_ok=yes],
+            [])
+
+        CFLAGS="$ax_pthread_save_CFLAGS"
+        LIBS="$ax_pthread_save_LIBS"
+
+        AC_MSG_RESULT([$ax_pthread_ok])
+        AS_IF([test "x$ax_pthread_ok" = "xyes"], [break])
+
+        PTHREAD_LIBS=""
+        PTHREAD_CFLAGS=""
+done
+fi
+
+
+# Clang needs special handling, because older versions handle the -pthread
+# option in a rather... idiosyncratic way
+
+if test "x$ax_pthread_clang" = "xyes"; then
+
+        # Clang takes -pthread; it has never supported any other flag
+
+        # (Note 1: This will need to be revisited if a system that Clang
+        # supports has POSIX threads in a separate library.  This tends not
+        # to be the way of modern systems, but it's conceivable.)
+
+        # (Note 2: On some systems, notably Darwin, -pthread is not needed
+        # to get POSIX threads support; the API is always present and
+        # active.  We could reasonably leave PTHREAD_CFLAGS empty.  But
+        # -pthread does define _REENTRANT, and while the Darwin headers
+        # ignore this macro, third-party headers might not.)
+
+        # However, older versions of Clang make a point of warning the user
+        # that, in an invocation where only linking and no compilation is
+        # taking place, the -pthread option has no effect ("argument unused
+        # during compilation").  They expect -pthread to be passed in only
+        # when source code is being compiled.
+        #
+        # Problem is, this is at odds with the way Automake and most other
+        # C build frameworks function, which is that the same flags used in
+        # compilation (CFLAGS) are also used in linking.  Many systems
+        # supported by AX_PTHREAD require exactly this for POSIX threads
+        # support, and in fact it is often not straightforward to specify a
+        # flag that is used only in the compilation phase and not in
+        # linking.  Such a scenario is extremely rare in practice.
+        #
+        # Even though use of the -pthread flag in linking would only print
+        # a warning, this can be a nuisance for well-run software projects
+        # that build with -Werror.  So if the active version of Clang has
+        # this misfeature, we search for an option to squash it.
+
+        AC_CACHE_CHECK([whether Clang needs flag to prevent "argument unused" warning when linking with -pthread],
+            [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG],
+            [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG=unknown
+             # Create an alternate version of $ac_link that compiles and
+             # links in two steps (.c -> .o, .o -> exe) instead of one
+             # (.c -> exe), because the warning occurs only in the second
+             # step
+             ax_pthread_save_ac_link="$ac_link"
+             ax_pthread_sed='s/conftest\.\$ac_ext/conftest.$ac_objext/g'
+             ax_pthread_link_step=`AS_ECHO(["$ac_link"]) | sed "$ax_pthread_sed"`
+             ax_pthread_2step_ac_link="($ac_compile) && (echo ==== >&5) && ($ax_pthread_link_step)"
+             ax_pthread_save_CFLAGS="$CFLAGS"
+             for ax_pthread_try in '' -Qunused-arguments -Wno-unused-command-line-argument unknown; do
+                AS_IF([test "x$ax_pthread_try" = "xunknown"], [break])
+                CFLAGS="-Werror -Wunknown-warning-option $ax_pthread_try -pthread $ax_pthread_save_CFLAGS"
+                ac_link="$ax_pthread_save_ac_link"
+                AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])],
+                    [ac_link="$ax_pthread_2step_ac_link"
+                     AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])],
+                         [break])
+                    ])
+             done
+             ac_link="$ax_pthread_save_ac_link"
+             CFLAGS="$ax_pthread_save_CFLAGS"
+             AS_IF([test "x$ax_pthread_try" = "x"], [ax_pthread_try=no])
+             ax_cv_PTHREAD_CLANG_NO_WARN_FLAG="$ax_pthread_try"
+            ])
+
+        case "$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" in
+                no | unknown) ;;
+                *) PTHREAD_CFLAGS="$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG $PTHREAD_CFLAGS" ;;
+        esac
+
+fi # $ax_pthread_clang = yes
+
+
+
+# Various other checks:
+if test "x$ax_pthread_ok" = "xyes"; then
+        ax_pthread_save_CFLAGS="$CFLAGS"
+        ax_pthread_save_LIBS="$LIBS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+
+        # Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
+        AC_CACHE_CHECK([for joinable pthread attribute],
+            [ax_cv_PTHREAD_JOINABLE_ATTR],
+            [ax_cv_PTHREAD_JOINABLE_ATTR=unknown
+             for ax_pthread_attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
+                 AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>],
+                                                 [int attr = $ax_pthread_attr; return attr /* ; */])],
+                                [ax_cv_PTHREAD_JOINABLE_ATTR=$ax_pthread_attr; break],
+                                [])
+             done
+            ])
+        AS_IF([test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xunknown" && \
+               test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xPTHREAD_CREATE_JOINABLE" && \
+               test "x$ax_pthread_joinable_attr_defined" != "xyes"],
+              [AC_DEFINE_UNQUOTED([PTHREAD_CREATE_JOINABLE],
+                                  [$ax_cv_PTHREAD_JOINABLE_ATTR],
+                                  [Define to necessary symbol if this constant
+                                   uses a non-standard name on your system.])
+               ax_pthread_joinable_attr_defined=yes
+              ])
+
+        AC_CACHE_CHECK([whether more special flags are required for pthreads],
+            [ax_cv_PTHREAD_SPECIAL_FLAGS],
+            [ax_cv_PTHREAD_SPECIAL_FLAGS=no
+             case $host_os in
+             solaris*)
+             ax_cv_PTHREAD_SPECIAL_FLAGS="-D_POSIX_PTHREAD_SEMANTICS"
+             ;;
+             esac
+            ])
+        AS_IF([test "x$ax_cv_PTHREAD_SPECIAL_FLAGS" != "xno" && \
+               test "x$ax_pthread_special_flags_added" != "xyes"],
+              [PTHREAD_CFLAGS="$ax_cv_PTHREAD_SPECIAL_FLAGS $PTHREAD_CFLAGS"
+               ax_pthread_special_flags_added=yes])
+
+        AC_CACHE_CHECK([for PTHREAD_PRIO_INHERIT],
+            [ax_cv_PTHREAD_PRIO_INHERIT],
+            [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <pthread.h>]],
+                                             [[int i = PTHREAD_PRIO_INHERIT;
+                                               return i;]])],
+                            [ax_cv_PTHREAD_PRIO_INHERIT=yes],
+                            [ax_cv_PTHREAD_PRIO_INHERIT=no])
+            ])
+        AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes" && \
+               test "x$ax_pthread_prio_inherit_defined" != "xyes"],
+              [AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], [1], [Have PTHREAD_PRIO_INHERIT.])
+               ax_pthread_prio_inherit_defined=yes
+              ])
+
+        CFLAGS="$ax_pthread_save_CFLAGS"
+        LIBS="$ax_pthread_save_LIBS"
+
+        # More AIX lossage: compile with *_r variant
+        if test "x$GCC" != "xyes"; then
+            case $host_os in
+                aix*)
+                AS_CASE(["x/$CC"],
+                    [x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6],
+                    [#handle absolute path differently from PATH based program lookup
+                     AS_CASE(["x$CC"],
+                         [x/*],
+                         [
+			   AS_IF([AS_EXECUTABLE_P([${CC}_r])],[PTHREAD_CC="${CC}_r"])
+			   AS_IF([test "x${CXX}" != "x"], [AS_IF([AS_EXECUTABLE_P([${CXX}_r])],[PTHREAD_CXX="${CXX}_r"])])
+			 ],
+                         [
+			   AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC])
+			   AS_IF([test "x${CXX}" != "x"], [AC_CHECK_PROGS([PTHREAD_CXX],[${CXX}_r],[$CXX])])
+			 ]
+                     )
+                    ])
+                ;;
+            esac
+        fi
+fi
+
+test -n "$PTHREAD_CC" || PTHREAD_CC="$CC"
+test -n "$PTHREAD_CXX" || PTHREAD_CXX="$CXX"
+
+AC_SUBST([PTHREAD_LIBS])
+AC_SUBST([PTHREAD_CFLAGS])
+AC_SUBST([PTHREAD_CC])
+AC_SUBST([PTHREAD_CXX])
+
+# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
+if test "x$ax_pthread_ok" = "xyes"; then
+        ifelse([$1],,[AC_DEFINE([HAVE_PTHREAD],[1],[Define if you have POSIX threads libraries and header files.])],[$1])
+        :
+else
+        ax_pthread_ok=no
+        $2
+fi
+AC_LANG_POP
+])dnl AX_PTHREAD

scripts/ax_require_defined.m4

@@ -0,0 +1,37 @@
+# ===========================================================================
+#    https://www.gnu.org/software/autoconf-archive/ax_require_defined.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_REQUIRE_DEFINED(MACRO)
+#
+# DESCRIPTION
+#
+#   AX_REQUIRE_DEFINED is a simple helper for making sure other macros have
+#   been defined and thus are available for use.  This avoids random issues
+#   where a macro isn't expanded.  Instead the configure script emits a
+#   non-fatal:
+#
+#     ./configure: line 1673: AX_CFLAGS_WARN_ALL: command not found
+#
+#   It's like AC_REQUIRE except it doesn't expand the required macro.
+#
+#   Here's an example:
+#
+#     AX_REQUIRE_DEFINED([AX_CHECK_LINK_FLAG])
+#
+# LICENSE
+#
+#   Copyright (c) 2014 Mike Frysinger <vapier@gentoo.org>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 2
+
+AC_DEFUN([AX_REQUIRE_DEFINED], [dnl
+  m4_ifndef([$1], [m4_fatal([macro ]$1[ is not defined; is a m4 file missing?])])
+])dnl AX_REQUIRE_DEFINED

scripts/ax_with_curses.m4

@@ -0,0 +1,582 @@
+# ===========================================================================
+#      https://www.gnu.org/software/autoconf-archive/ax_with_curses.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_WITH_CURSES
+#
+# DESCRIPTION
+#
+#   This macro checks whether a SysV or X/Open-compatible Curses library is
+#   present, along with the associated header file.  The NcursesW
+#   (wide-character) library is searched for first, followed by Ncurses,
+#   then the system-default plain Curses.  The first library found is the
+#   one returned. Finding libraries will first be attempted by using
+#   pkg-config, and should the pkg-config files not be available, will
+#   fallback to combinations of known flags itself.
+#
+#   The following options are understood: --with-ncursesw, --with-ncurses,
+#   --without-ncursesw, --without-ncurses.  The "--with" options force the
+#   macro to use that particular library, terminating with an error if not
+#   found.  The "--without" options simply skip the check for that library.
+#   The effect on the search pattern is:
+#
+#     (no options)                           - NcursesW, Ncurses, Curses
+#     --with-ncurses     --with-ncursesw     - NcursesW only [*]
+#     --without-ncurses  --with-ncursesw     - NcursesW only [*]
+#                        --with-ncursesw     - NcursesW only [*]
+#     --with-ncurses     --without-ncursesw  - Ncurses only [*]
+#     --with-ncurses                         - NcursesW, Ncurses [**]
+#     --without-ncurses  --without-ncursesw  - Curses only
+#                        --without-ncursesw  - Ncurses, Curses
+#     --without-ncurses                      - NcursesW, Curses
+#
+#   [*]  If the library is not found, abort the configure script.
+#
+#   [**] If the second library (Ncurses) is not found, abort configure.
+#
+#   The following preprocessor symbols may be defined by this macro if the
+#   appropriate conditions are met:
+#
+#     HAVE_CURSES             - if any SysV or X/Open Curses library found
+#     HAVE_CURSES_ENHANCED    - if library supports X/Open Enhanced functions
+#     HAVE_CURSES_COLOR       - if library supports color (enhanced functions)
+#     HAVE_CURSES_OBSOLETE    - if library supports certain obsolete features
+#     HAVE_NCURSESW           - if NcursesW (wide char) library is to be used
+#     HAVE_NCURSES            - if the Ncurses library is to be used
+#
+#     HAVE_CURSES_H           - if <curses.h> is present and should be used
+#     HAVE_NCURSESW_H         - if <ncursesw.h> should be used
+#     HAVE_NCURSES_H          - if <ncurses.h> should be used
+#     HAVE_NCURSESW_CURSES_H  - if <ncursesw/curses.h> should be used
+#     HAVE_NCURSES_CURSES_H   - if <ncurses/curses.h> should be used
+#
+#   (These preprocessor symbols are discussed later in this document.)
+#
+#   The following output variables are defined by this macro; they are
+#   precious and may be overridden on the ./configure command line:
+#
+#     CURSES_LIBS  - library to add to xxx_LDADD
+#     CURSES_CFLAGS  - include paths to add to xxx_CPPFLAGS
+#
+#   In previous versions of this macro, the flags CURSES_LIB and
+#   CURSES_CPPFLAGS were defined. These have been renamed, in keeping with
+#   AX_WITH_CURSES's close bigger brother, PKG_CHECK_MODULES, which should
+#   eventually supersede the use of AX_WITH_CURSES. Neither the library
+#   listed in CURSES_LIBS, nor the flags in CURSES_CFLAGS are added to LIBS,
+#   respectively CPPFLAGS, by default. You need to add both to the
+#   appropriate xxx_LDADD/xxx_CPPFLAGS line in your Makefile.am. For
+#   example:
+#
+#     prog_LDADD = @CURSES_LIBS@
+#     prog_CPPFLAGS = @CURSES_CFLAGS@
+#
+#   If CURSES_LIBS is set on the configure command line (such as by running
+#   "./configure CURSES_LIBS=-lmycurses"), then the only header searched for
+#   is <curses.h>. If the user needs to specify an alternative path for a
+#   library (such as for a non-standard NcurseW), the user should use the
+#   LDFLAGS variable.
+#
+#   The following shell variables may be defined by this macro:
+#
+#     ax_cv_curses           - set to "yes" if any Curses library found
+#     ax_cv_curses_enhanced  - set to "yes" if Enhanced functions present
+#     ax_cv_curses_color     - set to "yes" if color functions present
+#     ax_cv_curses_obsolete  - set to "yes" if obsolete features present
+#
+#     ax_cv_ncursesw      - set to "yes" if NcursesW library found
+#     ax_cv_ncurses       - set to "yes" if Ncurses library found
+#     ax_cv_plaincurses   - set to "yes" if plain Curses library found
+#     ax_cv_curses_which  - set to "ncursesw", "ncurses", "plaincurses" or "no"
+#
+#   These variables can be used in your configure.ac to determine the level
+#   of support you need from the Curses library.  For example, if you must
+#   have either Ncurses or NcursesW, you could include:
+#
+#     AX_WITH_CURSES
+#     if test "x$ax_cv_ncursesw" != xyes && test "x$ax_cv_ncurses" != xyes; then
+#         AC_MSG_ERROR([requires either NcursesW or Ncurses library])
+#     fi
+#
+#   If any Curses library will do (but one must be present and must support
+#   color), you could use:
+#
+#     AX_WITH_CURSES
+#     if test "x$ax_cv_curses" != xyes || test "x$ax_cv_curses_color" != xyes; then
+#         AC_MSG_ERROR([requires an X/Open-compatible Curses library with color])
+#     fi
+#
+#   Certain preprocessor symbols and shell variables defined by this macro
+#   can be used to determine various features of the Curses library.  In
+#   particular, HAVE_CURSES and ax_cv_curses are defined if the Curses
+#   library found conforms to the traditional SysV and/or X/Open Base Curses
+#   definition.  Any working Curses library conforms to this level.
+#
+#   HAVE_CURSES_ENHANCED and ax_cv_curses_enhanced are defined if the
+#   library supports the X/Open Enhanced Curses definition.  In particular,
+#   the wide-character types attr_t, cchar_t and wint_t, the functions
+#   wattr_set() and wget_wch() and the macros WA_NORMAL and _XOPEN_CURSES
+#   are checked.  The Ncurses library does NOT conform to this definition,
+#   although NcursesW does.
+#
+#   HAVE_CURSES_COLOR and ax_cv_curses_color are defined if the library
+#   supports color functions and macros such as COLOR_PAIR, A_COLOR,
+#   COLOR_WHITE, COLOR_RED and init_pair().  These are NOT part of the
+#   X/Open Base Curses definition, but are part of the Enhanced set of
+#   functions.  The Ncurses library DOES support these functions, as does
+#   NcursesW.
+#
+#   HAVE_CURSES_OBSOLETE and ax_cv_curses_obsolete are defined if the
+#   library supports certain features present in SysV and BSD Curses but not
+#   defined in the X/Open definition.  In particular, the functions
+#   getattrs(), getcurx() and getmaxx() are checked.
+#
+#   To use the HAVE_xxx_H preprocessor symbols, insert the following into
+#   your system.h (or equivalent) header file:
+#
+#     #if defined HAVE_NCURSESW_CURSES_H
+#     #  include <ncursesw/curses.h>
+#     #elif defined HAVE_NCURSESW_H
+#     #  include <ncursesw.h>
+#     #elif defined HAVE_NCURSES_CURSES_H
+#     #  include <ncurses/curses.h>
+#     #elif defined HAVE_NCURSES_H
+#     #  include <ncurses.h>
+#     #elif defined HAVE_CURSES_H
+#     #  include <curses.h>
+#     #else
+#     #  error "SysV or X/Open-compatible Curses header file required"
+#     #endif
+#
+#   For previous users of this macro: you should not need to change anything
+#   in your configure.ac or Makefile.am, as the previous (serial 10)
+#   semantics are still valid.  However, you should update your system.h (or
+#   equivalent) header file to the fragment shown above. You are encouraged
+#   also to make use of the extended functionality provided by this version
+#   of AX_WITH_CURSES, as well as in the additional macros
+#   AX_WITH_CURSES_PANEL, AX_WITH_CURSES_MENU and AX_WITH_CURSES_FORM.
+#
+# LICENSE
+#
+#   Copyright (c) 2009 Mark Pulford <mark@kyne.com.au>
+#   Copyright (c) 2009 Damian Pietras <daper@daper.net>
+#   Copyright (c) 2012 Reuben Thomas <rrt@sc3d.org>
+#   Copyright (c) 2011 John Zaitseff <J.Zaitseff@zap.org.au>
+#
+#   This program is free software: you can redistribute it and/or modify it
+#   under the terms of the GNU General Public License as published by the
+#   Free Software Foundation, either version 3 of the License, or (at your
+#   option) any later version.
+#
+#   This program is distributed in the hope that it will be useful, but
+#   WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+#   Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License along
+#   with this program. If not, see <https://www.gnu.org/licenses/>.
+#
+#   As a special exception, the respective Autoconf Macro's copyright owner
+#   gives unlimited permission to copy, distribute and modify the configure
+#   scripts that are the output of Autoconf when processing the Macro. You
+#   need not follow the terms of the GNU General Public License when using
+#   or distributing such scripts, even though portions of the text of the
+#   Macro appear in them. The GNU General Public License (GPL) does govern
+#   all other use of the material that constitutes the Autoconf Macro.
+#
+#   This special exception to the GPL applies to versions of the Autoconf
+#   Macro released by the Autoconf Archive. When you make and distribute a
+#   modified version of the Autoconf Macro, you may extend this special
+#   exception to the GPL to apply to your modified version as well.
+
+#serial 18
+
+# internal function to factorize common code that is used by both ncurses
+# and ncursesw
+AC_DEFUN([_FIND_CURSES_FLAGS], [
+    AC_MSG_CHECKING([for $1 via pkg-config])
+
+    AX_REQUIRE_DEFINED([PKG_CHECK_EXISTS])
+    _PKG_CONFIG([_ax_cv_$1_libs], [libs], [$1])
+    _PKG_CONFIG([_ax_cv_$1_cppflags], [cflags], [$1])
+
+    AS_IF([test "x$pkg_failed" = "xyes" || test "x$pkg_failed" = "xuntried"],[
+        AC_MSG_RESULT([no])
+        # No suitable .pc file found, have to find flags via fallback
+        AC_CACHE_CHECK([for $1 via fallback], [ax_cv_$1], [
+            AS_ECHO()
+            pkg_cv__ax_cv_$1_libs="-l$1"
+            pkg_cv__ax_cv_$1_cppflags="-D_GNU_SOURCE $CURSES_CFLAGS"
+            LIBS="$ax_saved_LIBS $pkg_cv__ax_cv_$1_libs"
+            CPPFLAGS="$ax_saved_CPPFLAGS $pkg_cv__ax_cv_$1_cppflags"
+
+            AC_MSG_CHECKING([for initscr() with $pkg_cv__ax_cv_$1_libs])
+            AC_LINK_IFELSE([AC_LANG_CALL([], [initscr])],
+                [
+                    AC_MSG_RESULT([yes])
+                    AC_MSG_CHECKING([for nodelay() with $pkg_cv__ax_cv_$1_libs])
+                    AC_LINK_IFELSE([AC_LANG_CALL([], [nodelay])],[
+                        ax_cv_$1=yes
+                        ],[
+                        AC_MSG_RESULT([no])
+                        m4_if(
+                            [$1],[ncursesw],[pkg_cv__ax_cv_$1_libs="$pkg_cv__ax_cv_$1_libs -ltinfow"],
+                            [$1],[ncurses],[pkg_cv__ax_cv_$1_libs="$pkg_cv__ax_cv_$1_libs -ltinfo"]
+                        )
+                        LIBS="$ax_saved_LIBS $pkg_cv__ax_cv_$1_libs"
+
+                        AC_MSG_CHECKING([for nodelay() with $pkg_cv__ax_cv_$1_libs])
+                        AC_LINK_IFELSE([AC_LANG_CALL([], [nodelay])],[
+                            ax_cv_$1=yes
+                            ],[
+                            ax_cv_$1=no
+                        ])
+                    ])
+                ],[
+                    ax_cv_$1=no
+            ])
+        ])
+        ],[
+        AC_MSG_RESULT([yes])
+        # Found .pc file, using its information
+        LIBS="$ax_saved_LIBS $pkg_cv__ax_cv_$1_libs"
+        CPPFLAGS="$ax_saved_CPPFLAGS $pkg_cv__ax_cv_$1_cppflags"
+        ax_cv_$1=yes
+    ])
+])
+
+AU_ALIAS([MP_WITH_CURSES], [AX_WITH_CURSES])
+AC_DEFUN([AX_WITH_CURSES], [
+    AC_ARG_VAR([CURSES_LIBS], [linker library for Curses, e.g. -lcurses])
+    AC_ARG_VAR([CURSES_CFLAGS], [preprocessor flags for Curses, e.g. -I/usr/include/ncursesw])
+    AC_ARG_WITH([ncurses], [AS_HELP_STRING([--with-ncurses],
+        [force the use of Ncurses or NcursesW])],
+        [], [with_ncurses=check])
+    AC_ARG_WITH([ncursesw], [AS_HELP_STRING([--without-ncursesw],
+        [do not use NcursesW (wide character support)])],
+        [], [with_ncursesw=check])
+
+    ax_saved_LIBS=$LIBS
+    ax_saved_CPPFLAGS=$CPPFLAGS
+
+    AS_IF([test "x$with_ncurses" = xyes || test "x$with_ncursesw" = xyes],
+        [ax_with_plaincurses=no], [ax_with_plaincurses=check])
+
+    ax_cv_curses_which=no
+
+    # Test for NcursesW
+    AS_IF([test "x$CURSES_LIBS" = x && test "x$with_ncursesw" != xno], [
+        _FIND_CURSES_FLAGS([ncursesw])
+
+        AS_IF([test "x$ax_cv_ncursesw" = xno && test "x$with_ncursesw" = xyes], [
+            AC_MSG_ERROR([--with-ncursesw specified but could not find NcursesW library])
+        ])
+
+        AS_IF([test "x$ax_cv_ncursesw" = xyes], [
+            ax_cv_curses=yes
+            ax_cv_curses_which=ncursesw
+            CURSES_LIBS="$pkg_cv__ax_cv_ncursesw_libs"
+            CURSES_CFLAGS="$pkg_cv__ax_cv_ncursesw_cppflags"
+            AC_DEFINE([HAVE_NCURSESW], [1], [Define to 1 if the NcursesW library is present])
+            AC_DEFINE([HAVE_CURSES],   [1], [Define to 1 if a SysV or X/Open compatible Curses library is present])
+
+            AC_CACHE_CHECK([for working ncursesw/curses.h], [ax_cv_header_ncursesw_curses_h], [
+                AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+                        @%:@define _XOPEN_SOURCE_EXTENDED 1
+                        @%:@include <ncursesw/curses.h>
+                    ]], [[
+                        chtype a = A_BOLD;
+                        int b = KEY_LEFT;
+                        chtype c = COLOR_PAIR(1) & A_COLOR;
+                        attr_t d = WA_NORMAL;
+                        cchar_t e;
+                        wint_t f;
+                        int g = getattrs(stdscr);
+                        int h = getcurx(stdscr) + getmaxx(stdscr);
+                        initscr();
+                        init_pair(1, COLOR_WHITE, COLOR_RED);
+                        wattr_set(stdscr, d, 0, NULL);
+                        wget_wch(stdscr, &f);
+                    ]])],
+                    [ax_cv_header_ncursesw_curses_h=yes],
+                    [ax_cv_header_ncursesw_curses_h=no])
+            ])
+            AS_IF([test "x$ax_cv_header_ncursesw_curses_h" = xyes], [
+                ax_cv_curses_enhanced=yes
+                ax_cv_curses_color=yes
+                ax_cv_curses_obsolete=yes
+                AC_DEFINE([HAVE_CURSES_ENHANCED],   [1], [Define to 1 if library supports X/Open Enhanced functions])
+                AC_DEFINE([HAVE_CURSES_COLOR],      [1], [Define to 1 if library supports color (enhanced functions)])
+                AC_DEFINE([HAVE_CURSES_OBSOLETE],   [1], [Define to 1 if library supports certain obsolete features])
+                AC_DEFINE([HAVE_NCURSESW_CURSES_H], [1], [Define to 1 if <ncursesw/curses.h> is present])
+            ])
+
+            AC_CACHE_CHECK([for working ncursesw.h], [ax_cv_header_ncursesw_h], [
+                AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+                        @%:@define _XOPEN_SOURCE_EXTENDED 1
+                        @%:@include <ncursesw.h>
+                    ]], [[
+                        chtype a = A_BOLD;
+                        int b = KEY_LEFT;
+                        chtype c = COLOR_PAIR(1) & A_COLOR;
+                        attr_t d = WA_NORMAL;
+                        cchar_t e;
+                        wint_t f;
+                        int g = getattrs(stdscr);
+                        int h = getcurx(stdscr) + getmaxx(stdscr);
+                        initscr();
+                        init_pair(1, COLOR_WHITE, COLOR_RED);
+                        wattr_set(stdscr, d, 0, NULL);
+                        wget_wch(stdscr, &f);
+                    ]])],
+                    [ax_cv_header_ncursesw_h=yes],
+                    [ax_cv_header_ncursesw_h=no])
+            ])
+            AS_IF([test "x$ax_cv_header_ncursesw_h" = xyes], [
+                ax_cv_curses_enhanced=yes
+                ax_cv_curses_color=yes
+                ax_cv_curses_obsolete=yes
+                AC_DEFINE([HAVE_CURSES_ENHANCED], [1], [Define to 1 if library supports X/Open Enhanced functions])
+                AC_DEFINE([HAVE_CURSES_COLOR],    [1], [Define to 1 if library supports color (enhanced functions)])
+                AC_DEFINE([HAVE_CURSES_OBSOLETE], [1], [Define to 1 if library supports certain obsolete features])
+                AC_DEFINE([HAVE_NCURSESW_H],      [1], [Define to 1 if <ncursesw.h> is present])
+            ])
+
+            AC_CACHE_CHECK([for working ncurses.h], [ax_cv_header_ncurses_h_with_ncursesw], [
+                AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+                        @%:@define _XOPEN_SOURCE_EXTENDED 1
+                        @%:@include <ncurses.h>
+                    ]], [[
+                        chtype a = A_BOLD;
+                        int b = KEY_LEFT;
+                        chtype c = COLOR_PAIR(1) & A_COLOR;
+                        attr_t d = WA_NORMAL;
+                        cchar_t e;
+                        wint_t f;
+                        int g = getattrs(stdscr);
+                        int h = getcurx(stdscr) + getmaxx(stdscr);
+                        initscr();
+                        init_pair(1, COLOR_WHITE, COLOR_RED);
+                        wattr_set(stdscr, d, 0, NULL);
+                        wget_wch(stdscr, &f);
+                    ]])],
+                    [ax_cv_header_ncurses_h_with_ncursesw=yes],
+                    [ax_cv_header_ncurses_h_with_ncursesw=no])
+            ])
+            AS_IF([test "x$ax_cv_header_ncurses_h_with_ncursesw" = xyes], [
+                ax_cv_curses_enhanced=yes
+                ax_cv_curses_color=yes
+                ax_cv_curses_obsolete=yes
+                AC_DEFINE([HAVE_CURSES_ENHANCED], [1], [Define to 1 if library supports X/Open Enhanced functions])
+                AC_DEFINE([HAVE_CURSES_COLOR],    [1], [Define to 1 if library supports color (enhanced functions)])
+                AC_DEFINE([HAVE_CURSES_OBSOLETE], [1], [Define to 1 if library supports certain obsolete features])
+                AC_DEFINE([HAVE_NCURSES_H],       [1], [Define to 1 if <ncurses.h> is present])
+            ])
+
+            AS_IF([test "x$ax_cv_header_ncursesw_curses_h" = xno && test "x$ax_cv_header_ncursesw_h" = xno && test "x$ax_cv_header_ncurses_h_with_ncursesw" = xno], [
+                AC_MSG_WARN([could not find a working ncursesw/curses.h, ncursesw.h or ncurses.h])
+            ])
+        ])
+    ])
+    unset pkg_cv__ax_cv_ncursesw_libs
+    unset pkg_cv__ax_cv_ncursesw_cppflags
+
+    # Test for Ncurses
+    AS_IF([test "x$CURSES_LIBS" = x && test "x$with_ncurses" != xno && test "x$ax_cv_curses_which" = xno], [
+        _FIND_CURSES_FLAGS([ncurses])
+
+        AS_IF([test "x$ax_cv_ncurses" = xno && test "x$with_ncurses" = xyes], [
+            AC_MSG_ERROR([--with-ncurses specified but could not find Ncurses library])
+        ])
+
+        AS_IF([test "x$ax_cv_ncurses" = xyes], [
+            ax_cv_curses=yes
+            ax_cv_curses_which=ncurses
+            CURSES_LIBS="$pkg_cv__ax_cv_ncurses_libs"
+            CURSES_CFLAGS="$pkg_cv__ax_cv_ncurses_cppflags"
+            AC_DEFINE([HAVE_NCURSES], [1], [Define to 1 if the Ncurses library is present])
+            AC_DEFINE([HAVE_CURSES],  [1], [Define to 1 if a SysV or X/Open compatible Curses library is present])
+
+            AC_CACHE_CHECK([for working ncurses/curses.h], [ax_cv_header_ncurses_curses_h], [
+                AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+                        @%:@include <ncurses/curses.h>
+                    ]], [[
+                        chtype a = A_BOLD;
+                        int b = KEY_LEFT;
+                        chtype c = COLOR_PAIR(1) & A_COLOR;
+                        int g = getattrs(stdscr);
+                        int h = getcurx(stdscr) + getmaxx(stdscr);
+                        initscr();
+                        init_pair(1, COLOR_WHITE, COLOR_RED);
+                    ]])],
+                    [ax_cv_header_ncurses_curses_h=yes],
+                    [ax_cv_header_ncurses_curses_h=no])
+            ])
+            AS_IF([test "x$ax_cv_header_ncurses_curses_h" = xyes], [
+                ax_cv_curses_color=yes
+                ax_cv_curses_obsolete=yes
+                AC_DEFINE([HAVE_CURSES_COLOR],     [1], [Define to 1 if library supports color (enhanced functions)])
+                AC_DEFINE([HAVE_CURSES_OBSOLETE],  [1], [Define to 1 if library supports certain obsolete features])
+                AC_DEFINE([HAVE_NCURSES_CURSES_H], [1], [Define to 1 if <ncurses/curses.h> is present])
+            ])
+
+            AC_CACHE_CHECK([for working ncurses.h], [ax_cv_header_ncurses_h], [
+                AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+                        @%:@include <ncurses.h>
+                    ]], [[
+                        chtype a = A_BOLD;
+                        int b = KEY_LEFT;
+                        chtype c = COLOR_PAIR(1) & A_COLOR;
+                        int g = getattrs(stdscr);
+                        int h = getcurx(stdscr) + getmaxx(stdscr);
+                        initscr();
+                        init_pair(1, COLOR_WHITE, COLOR_RED);
+                    ]])],
+                    [ax_cv_header_ncurses_h=yes],
+                    [ax_cv_header_ncurses_h=no])
+            ])
+            AS_IF([test "x$ax_cv_header_ncurses_h" = xyes], [
+                ax_cv_curses_color=yes
+                ax_cv_curses_obsolete=yes
+                AC_DEFINE([HAVE_CURSES_COLOR],    [1], [Define to 1 if library supports color (enhanced functions)])
+                AC_DEFINE([HAVE_CURSES_OBSOLETE], [1], [Define to 1 if library supports certain obsolete features])
+                AC_DEFINE([HAVE_NCURSES_H],       [1], [Define to 1 if <ncurses.h> is present])
+            ])
+
+            AS_IF([test "x$ax_cv_header_ncurses_curses_h" = xno && test "x$ax_cv_header_ncurses_h" = xno], [
+                AC_MSG_WARN([could not find a working ncurses/curses.h or ncurses.h])
+            ])
+        ])
+    ])
+    unset pkg_cv__ax_cv_ncurses_libs
+    unset pkg_cv__ax_cv_ncurses_cppflags
+
+    # Test for plain Curses (or if CURSES_LIBS was set by user)
+    AS_IF([test "x$with_plaincurses" != xno && test "x$ax_cv_curses_which" = xno], [
+        AS_IF([test "x$CURSES_LIBS" != x], [
+            LIBS="$ax_saved_LIBS $CURSES_LIBS"
+        ], [
+            LIBS="$ax_saved_LIBS -lcurses"
+        ])
+
+        AC_CACHE_CHECK([for Curses library], [ax_cv_plaincurses], [
+            AC_LINK_IFELSE([AC_LANG_CALL([], [initscr])],
+                [ax_cv_plaincurses=yes], [ax_cv_plaincurses=no])
+        ])
+
+        AS_IF([test "x$ax_cv_plaincurses" = xyes], [
+            ax_cv_curses=yes
+            ax_cv_curses_which=plaincurses
+            AS_IF([test "x$CURSES_LIBS" = x], [
+                CURSES_LIBS="-lcurses"
+            ])
+            AC_DEFINE([HAVE_CURSES], [1], [Define to 1 if a SysV or X/Open compatible Curses library is present])
+
+            # Check for base conformance (and header file)
+
+            AC_CACHE_CHECK([for working curses.h], [ax_cv_header_curses_h], [
+                AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+                        @%:@include <curses.h>
+                    ]], [[
+                        chtype a = A_BOLD;
+                        int b = KEY_LEFT;
+                        initscr();
+                    ]])],
+                    [ax_cv_header_curses_h=yes],
+                    [ax_cv_header_curses_h=no])
+            ])
+            AS_IF([test "x$ax_cv_header_curses_h" = xyes], [
+                AC_DEFINE([HAVE_CURSES_H], [1], [Define to 1 if <curses.h> is present])
+
+                # Check for X/Open Enhanced conformance
+
+                AC_CACHE_CHECK([for X/Open Enhanced Curses conformance], [ax_cv_plaincurses_enhanced], [
+                    AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+                            @%:@define _XOPEN_SOURCE_EXTENDED 1
+                            @%:@include <curses.h>
+                            @%:@ifndef _XOPEN_CURSES
+                            @%:@error "this Curses library is not enhanced"
+                            "this Curses library is not enhanced"
+                            @%:@endif
+                        ]], [[
+                            chtype a = A_BOLD;
+                            int b = KEY_LEFT;
+                            chtype c = COLOR_PAIR(1) & A_COLOR;
+                            attr_t d = WA_NORMAL;
+                            cchar_t e;
+                            wint_t f;
+                            initscr();
+                            init_pair(1, COLOR_WHITE, COLOR_RED);
+                            wattr_set(stdscr, d, 0, NULL);
+                            wget_wch(stdscr, &f);
+                        ]])],
+                        [ax_cv_plaincurses_enhanced=yes],
+                        [ax_cv_plaincurses_enhanced=no])
+                ])
+                AS_IF([test "x$ax_cv_plaincurses_enhanced" = xyes], [
+                    ax_cv_curses_enhanced=yes
+                    ax_cv_curses_color=yes
+                    AC_DEFINE([HAVE_CURSES_ENHANCED], [1], [Define to 1 if library supports X/Open Enhanced functions])
+                    AC_DEFINE([HAVE_CURSES_COLOR],    [1], [Define to 1 if library supports color (enhanced functions)])
+                ])
+
+                # Check for color functions
+
+                AC_CACHE_CHECK([for Curses color functions], [ax_cv_plaincurses_color], [
+                    AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+                        @%:@define _XOPEN_SOURCE_EXTENDED 1
+                        @%:@include <curses.h>
+                        ]], [[
+                            chtype a = A_BOLD;
+                            int b = KEY_LEFT;
+                            chtype c = COLOR_PAIR(1) & A_COLOR;
+                            initscr();
+                            init_pair(1, COLOR_WHITE, COLOR_RED);
+                        ]])],
+                        [ax_cv_plaincurses_color=yes],
+                        [ax_cv_plaincurses_color=no])
+                ])
+                AS_IF([test "x$ax_cv_plaincurses_color" = xyes], [
+                    ax_cv_curses_color=yes
+                    AC_DEFINE([HAVE_CURSES_COLOR], [1], [Define to 1 if library supports color (enhanced functions)])
+                ])
+
+                # Check for obsolete functions
+
+                AC_CACHE_CHECK([for obsolete Curses functions], [ax_cv_plaincurses_obsolete], [
+                AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+                        @%:@include <curses.h>
+                    ]], [[
+                        chtype a = A_BOLD;
+                        int b = KEY_LEFT;
+                        int g = getattrs(stdscr);
+                        int h = getcurx(stdscr) + getmaxx(stdscr);
+                        initscr();
+                    ]])],
+                    [ax_cv_plaincurses_obsolete=yes],
+                    [ax_cv_plaincurses_obsolete=no])
+                ])
+                AS_IF([test "x$ax_cv_plaincurses_obsolete" = xyes], [
+                    ax_cv_curses_obsolete=yes
+                    AC_DEFINE([HAVE_CURSES_OBSOLETE], [1], [Define to 1 if library supports certain obsolete features])
+                ])
+            ])
+
+            AS_IF([test "x$ax_cv_header_curses_h" = xno], [
+                AC_MSG_WARN([could not find a working curses.h])
+            ])
+        ])
+    ])
+
+    AS_IF([test "x$ax_cv_curses"          != xyes], [ax_cv_curses=no])
+    AS_IF([test "x$ax_cv_curses_enhanced" != xyes], [ax_cv_curses_enhanced=no])
+    AS_IF([test "x$ax_cv_curses_color"    != xyes], [ax_cv_curses_color=no])
+    AS_IF([test "x$ax_cv_curses_obsolete" != xyes], [ax_cv_curses_obsolete=no])
+
+    LIBS=$ax_saved_LIBS
+    CPPFLAGS=$ax_saved_CPPFLAGS
+
+    unset ax_saved_LIBS
+    unset ax_saved_CPPFLAGS
+])dnl

scripts/checks.m4

@@ -0,0 +1,487 @@
+AC_DEFUN([TORRENT_CHECK_XFS], [
+  AC_MSG_CHECKING(for XFS support)
+
+  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+      #include <xfs/libxfs.h>
+      #include <sys/ioctl.h>
+      int main() {
+        struct xfs_flock64 l;
+        ioctl(0, XFS_IOC_RESVSP64, &l);
+        return 0;
+      }
+      ])],
+    [
+      AC_DEFINE(USE_XFS, 1, Use XFS filesystem stuff.)
+      AC_MSG_RESULT(yes)
+    ], [
+      AC_MSG_RESULT(no)
+    ])
+])
+
+
+AC_DEFUN([TORRENT_WITHOUT_XFS], [
+  AC_ARG_WITH(xfs,
+    AS_HELP_STRING([--without-xfs],[do not check for XFS filesystem support]),
+    [
+       if test "$withval" = "yes"; then
+        TORRENT_CHECK_XFS
+      fi
+    ], [
+        TORRENT_CHECK_XFS
+    ])
+])
+
+
+AC_DEFUN([TORRENT_WITH_XFS], [
+  AC_ARG_WITH(xfs,
+    AS_HELP_STRING([--with-xfs],[check for XFS filesystem support]),
+    [
+      if test "$withval" = "yes"; then
+        TORRENT_CHECK_XFS
+      fi
+    ])
+])
+
+
+AC_DEFUN([TORRENT_CHECK_EPOLL], [
+  AC_MSG_CHECKING(for epoll support)
+
+  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+      #include <sys/epoll.h>
+      int main() {
+        int fd = epoll_create(100);
+        return 0;
+      }
+      ])],
+    [
+      AC_DEFINE(USE_EPOLL, 1, Use epoll.)
+      AC_MSG_RESULT(yes)
+    ], [
+      AC_MSG_RESULT(no)
+    ])
+])
+
+AC_DEFUN([TORRENT_WITHOUT_EPOLL], [
+  AC_ARG_WITH(epoll,
+    AS_HELP_STRING([--without-epoll],[do not check for epoll support]),
+    [
+      if test "$withval" = "yes"; then
+        TORRENT_CHECK_EPOLL
+      fi
+    ], [
+        TORRENT_CHECK_EPOLL
+    ])
+])
+
+
+AC_DEFUN([TORRENT_CHECK_KQUEUE], [
+  AC_MSG_CHECKING(for kqueue support)
+
+  AC_LINK_IFELSE([AC_LANG_SOURCE([
+      #include <sys/time.h>  /* Because OpenBSD's sys/event.h fails to compile otherwise. Yeah... */
+      #include <sys/event.h>
+      int main() {
+        int fd = kqueue();
+        return 0;
+      }
+      ])],
+    [
+      AC_DEFINE(USE_KQUEUE, 1, Use kqueue.)
+      AC_MSG_RESULT(yes)
+    ], [
+      AC_MSG_RESULT(no)
+    ])
+])
+
+
+AC_DEFUN([TORRENT_WITH_KQUEUE], [
+  AC_ARG_WITH(kqueue,
+    AS_HELP_STRING([--with-kqueue],[enable kqueue [[default=no]]]),
+    [
+        if test "$withval" = "yes"; then
+          TORRENT_CHECK_KQUEUE
+        fi
+    ])
+])
+
+
+AC_DEFUN([TORRENT_WITHOUT_KQUEUE], [
+  AC_ARG_WITH(kqueue,
+    AS_HELP_STRING([--without-kqueue],[do not check for kqueue support]),
+    [
+      if test "$withval" = "yes"; then
+        TORRENT_CHECK_KQUEUE
+      fi
+    ], [
+        TORRENT_CHECK_KQUEUE
+    ])
+])
+
+
+AC_DEFUN([TORRENT_WITHOUT_VARIABLE_FDSET], [
+  AC_ARG_WITH(variable-fdset,
+    AS_HELP_STRING([--without-variable-fdset],[do not use non-portable variable sized fd_set's]),
+    [
+      if test "$withval" = "yes"; then
+        AC_DEFINE(USE_VARIABLE_FDSET, 1, defined when we allow the use of fd_set's of any size)
+      fi
+    ], [
+      AC_DEFINE(USE_VARIABLE_FDSET, 1, defined when we allow the use of fd_set's of any size)
+    ])
+])
+
+
+AC_DEFUN([TORRENT_CHECK_FALLOCATE], [
+  AC_MSG_CHECKING(for fallocate)
+
+  AC_LINK_IFELSE([AC_LANG_PROGRAM([[#define _GNU_SOURCE
+               #include <fcntl.h>
+              ]], [[ fallocate(0, FALLOC_FL_KEEP_SIZE, 0, 0); return 0;
+              ]])],[
+      AC_DEFINE(HAVE_FALLOCATE, 1, Linux's fallocate supported.)
+      AC_MSG_RESULT(yes)
+    ],[
+      AC_MSG_RESULT(no)
+    ])
+])
+
+
+AC_DEFUN([TORRENT_CHECK_POSIX_FALLOCATE], [
+  AC_MSG_CHECKING(for posix_fallocate)
+
+  AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include <fcntl.h>
+              ]], [[ posix_fallocate(0, 0, 0);
+              ]])],[
+      AC_DEFINE(USE_POSIX_FALLOCATE, 1, posix_fallocate supported.)
+      AC_MSG_RESULT(yes)
+    ],[
+      AC_MSG_RESULT(no)
+    ])
+])
+
+
+AC_DEFUN([TORRENT_WITH_POSIX_FALLOCATE], [
+  AC_ARG_WITH(posix-fallocate,
+    AS_HELP_STRING([--with-posix-fallocate],[check for and use posix_fallocate to allocate files]),
+    [
+      if test "$withval" = "yes"; then
+        TORRENT_CHECK_POSIX_FALLOCATE
+      fi
+    ])
+])
+
+AC_DEFUN([TORRENT_CHECK_STATVFS], [
+  AC_CHECK_HEADERS(sys/vfs.h sys/statvfs.h sys/statfs.h)
+
+  AC_MSG_CHECKING(for statvfs)
+
+  AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+      #if HAVE_SYS_VFS_H
+      #include <sys/vfs.h>
+      #endif
+      #if HAVE_SYS_STATVFS_H
+      #include <sys/statvfs.h>
+      #endif
+      #if HAVE_SYS_STATFS_H
+      #include <sys/statfs.h>
+      #endif
+    ]], [[
+      struct statvfs s; fsblkcnt_t c;
+      statvfs("", &s);
+      fstatvfs(0, &s);
+    ]])],[
+      AC_DEFINE(FS_STAT_FD, [fstatvfs(fd, &m_stat) == 0], Function to determine filesystem stats from fd)
+      AC_DEFINE(FS_STAT_FN, [statvfs(fn, &m_stat) == 0], Function to determine filesystem stats from filename)
+      AC_DEFINE(FS_STAT_STRUCT, [struct statvfs], Type of second argument to statfs function)
+      AC_DEFINE(FS_STAT_SIZE_TYPE, [unsigned long], Type of block size member in stat struct)
+      AC_DEFINE(FS_STAT_COUNT_TYPE, [fsblkcnt_t], Type of block count member in stat struct)
+      AC_DEFINE(FS_STAT_BLOCK_SIZE, [(m_stat.f_frsize)], Determine the block size)
+      AC_MSG_RESULT(ok)
+      have_stat_vfs=yes
+    ],[
+      AC_MSG_RESULT(no)
+      have_stat_vfs=no
+    ])
+])
+
+AC_DEFUN([TORRENT_CHECK_STATFS], [
+  AC_CHECK_HEADERS(sys/statfs.h sys/param.h sys/mount.h)
+
+  AC_MSG_CHECKING(for statfs)
+
+  AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+      #if HAVE_SYS_STATFS_H
+      #include <sys/statfs.h>
+      #endif
+      #if HAVE_SYS_PARAM_H
+      #include <sys/param.h>
+      #endif
+      #if HAVE_SYS_MOUNT_H
+      #include <sys/mount.h>
+      #endif
+    ]], [[
+      struct statfs s;
+      statfs("", &s);
+      fstatfs(0, &s);
+    ]])],[
+      AC_DEFINE(FS_STAT_FD, [fstatfs(fd, &m_stat) == 0], Function to determine filesystem stats from fd)
+      AC_DEFINE(FS_STAT_FN, [statfs(fn, &m_stat) == 0], Function to determine filesystem stats from filename)
+      AC_DEFINE(FS_STAT_STRUCT, [struct statfs], Type of second argument to statfs function)
+      AC_DEFINE(FS_STAT_SIZE_TYPE, [long], Type of block size member in stat struct)
+      AC_DEFINE(FS_STAT_COUNT_TYPE, [long], Type of block count member in stat struct)
+      AC_DEFINE(FS_STAT_BLOCK_SIZE, [(m_stat.f_bsize)], Determine the block size)
+      AC_MSG_RESULT(ok)
+      have_stat_vfs=yes
+    ],[
+      AC_MSG_RESULT(no)
+      have_stat_vfs=no
+    ])
+])
+
+AC_DEFUN([TORRENT_DISABLED_STATFS], [
+      AC_DEFINE(FS_STAT_FD, [(errno = ENOSYS) == 0], Function to determine filesystem stats from fd)
+      AC_DEFINE(FS_STAT_FN, [(errno = ENOSYS) == 0], Function to determine filesystem stats from filename)
+      AC_DEFINE(FS_STAT_STRUCT, [struct {blocksize_type  f_bsize; blockcount_type f_bavail;}], Type of second argument to statfs function)
+      AC_DEFINE(FS_STAT_SIZE_TYPE, [int], Type of block size member in stat struct)
+      AC_DEFINE(FS_STAT_COUNT_TYPE, [int], Type of block count member in stat struct)
+      AC_DEFINE(FS_STAT_BLOCK_SIZE, [(4096)], Determine the block size)
+      AC_MSG_RESULT(No filesystem stats available)
+])
+
+AC_DEFUN([TORRENT_WITHOUT_STATVFS], [
+  AC_ARG_WITH(statvfs,
+    AS_HELP_STRING([--without-statvfs],[don't try to use statvfs to find free diskspace]),
+    [
+      if test "$withval" = "yes"; then
+        TORRENT_CHECK_STATVFS
+      else
+        have_stat_vfs=no
+      fi
+    ],
+    [
+      TORRENT_CHECK_STATVFS
+    ])
+])
+
+AC_DEFUN([TORRENT_WITHOUT_STATFS], [
+  AC_ARG_WITH(statfs,
+    AS_HELP_STRING([--without-statfs],[don't try to use statfs to find free diskspace]),
+    [
+      if test "$have_stat_vfs" = "no"; then
+        if test "$withval" = "yes"; then
+          TORRENT_CHECK_STATFS
+        else
+          TORRENT_DISABLED_STATFS
+        fi
+      fi
+    ],
+    [
+      if test "$have_stat_vfs" = "no"; then
+        TORRENT_CHECK_STATFS
+        if test "$have_stat_vfs" = "no"; then
+          TORRENT_DISABLED_STATFS
+        fi
+      fi
+    ])
+])
+
+AC_DEFUN([TORRENT_WITH_ADDRESS_SPACE], [
+  AC_ARG_WITH(address-space,
+    AS_HELP_STRING([--with-address-space=MB],[change the default address space size [[default=1024mb]]]),
+    [
+      if test ! -z $withval -a "$withval" != "yes" -a "$withval" != "no"; then
+        AC_DEFINE_UNQUOTED(DEFAULT_ADDRESS_SPACE_SIZE, [$withval])
+      else
+        AC_MSG_ERROR(--with-address-space requires a parameter.)
+      fi
+    ],
+    [
+      AC_CHECK_SIZEOF(long)
+
+      if test $ac_cv_sizeof_long = 8; then
+        AC_DEFINE(DEFAULT_ADDRESS_SPACE_SIZE, 4096, Default address space size.)
+      else
+        AC_DEFINE(DEFAULT_ADDRESS_SPACE_SIZE, 1024, Default address space size.)
+      fi
+    ])
+])
+
+AC_DEFUN([TORRENT_WITH_FASTCGI], [
+  AC_ARG_WITH(fastcgi,
+    AS_HELP_STRING([--with-fastcgi=PATH],[enable FastCGI RPC support (DO NOT USE)]),
+    [
+      AC_MSG_CHECKING([for FastCGI (DO NOT USE)])
+
+      if test "$withval" = "no"; then
+        AC_MSG_RESULT(no)
+
+      elif test "$withval" = "yes"; then
+        CXXFLAGS="$CXXFLAGS"
+	LIBS="$LIBS -lfcgi"        
+
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([[ #include <fcgiapp.h>
+        ]], [[ FCGX_Init(); ]])],[
+          AC_MSG_RESULT(ok)
+        ],[
+          AC_MSG_RESULT(not found)
+          AC_MSG_ERROR(Could not compile FastCGI test.)
+        ])
+
+        AC_DEFINE(HAVE_FASTCGI, 1, Support for FastCGI.)
+
+      else
+        CXXFLAGS="$CXXFLAGS -I$withval/include"
+	LIBS="$LIBS -lfcgi -L$withval/lib"
+
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([[ #include <fcgiapp.h>
+        ]], [[ FCGX_Init(); ]])],[
+          AC_MSG_RESULT(ok)
+        ],[
+          AC_MSG_RESULT(not found)
+          AC_MSG_ERROR(Could not compile FastCGI test.)
+        ])
+
+        AC_DEFINE(HAVE_FASTCGI, 1, Support for FastCGI.)
+      fi
+    ])
+])
+
+
+AC_DEFUN([TORRENT_WITH_XMLRPC_C], [
+  AC_MSG_CHECKING(for XMLRPC-C)
+
+  AC_ARG_WITH(xmlrpc-c,
+    AS_HELP_STRING([--with-xmlrpc-c=PATH],[enable XMLRPC-C support]),
+  [
+    if test "$withval" = "no"; then
+      AC_MSG_RESULT(no)
+
+    else
+      if test "$withval" = "yes"; then
+        xmlrpc_cc_prg="xmlrpc-c-config"
+      else
+        xmlrpc_cc_prg="$withval"
+      fi
+
+      if eval $xmlrpc_cc_prg --version 2>/dev/null >/dev/null; then
+        CXXFLAGS="$CXXFLAGS `$xmlrpc_cc_prg --cflags server-util`"
+        LIBS="$LIBS `$xmlrpc_cc_prg server-util --libs`"
+
+        AC_LINK_IFELSE([AC_LANG_PROGRAM([[ #include <xmlrpc-c/server.h>
+        ]], [[ xmlrpc_registry_new(NULL); ]])],[
+          AC_MSG_RESULT(ok)
+        ],[
+          AC_MSG_RESULT(failed)
+          AC_MSG_ERROR(Could not compile XMLRPC-C test.)
+        ])
+
+        AC_DEFINE(HAVE_XMLRPC_C, 1, Support for XMLRPC-C.)
+
+      else
+        AC_MSG_RESULT(failed)
+        AC_MSG_ERROR(Could not compile XMLRPC-C test.)
+      fi
+    fi
+
+  ],[
+    AC_MSG_RESULT(ignored)
+  ])
+])
+
+AC_DEFUN([TORRENT_WITH_TINYXML2], [
+  AC_MSG_CHECKING(for tinyxml2)
+
+  AC_ARG_WITH(xmlrpc-tinyxml2,
+    AS_HELP_STRING([--with-xmlrpc-tinyxml2],[enable XMLRPC support via tinyxml2]),
+  [
+    AC_MSG_RESULT(yes)
+    AC_DEFINE(HAVE_XMLRPC_TINYXML2, 1, Support for XMLRPC via tinyxml2.)
+  ],[
+    AC_MSG_RESULT(ignored)
+  ])
+])
+
+AC_DEFUN([TORRENT_WITH_LUA], [
+  AC_ARG_WITH(lua,
+    AS_HELP_STRING([--with-lua],[enable LUA support]),
+  [
+    if test "$withval" = "no"; then
+      AC_MSG_RESULT(no)
+    else
+      AX_PROG_LUA
+      AX_LUA_LIBS
+      AX_LUA_HEADERS
+      AC_DEFINE(HAVE_LUA, 1, Use LUA.)
+      LIBS="$LIBS $LUA_LIB"
+      CXXFLAGS="$CXXFLAGS $LUA_INCLUDE"
+    fi
+  ],[
+    AC_MSG_RESULT(ignored)
+  ])
+])
+
+AC_DEFUN([TORRENT_WITH_INOTIFY], [
+  AC_LANG_PUSH(C++)
+
+  AC_CHECK_HEADERS([sys/inotify.h mcheck.h])
+  AC_MSG_CHECKING([whether sys/inotify.h actually works])
+
+  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+      #include <sys/inotify.h>
+      int main(int,const char**) { return (-1 == inotify_init()); }])
+    ],[
+     AC_DEFINE(HAVE_INOTIFY, 1, [sys/inotify.h exists and works correctly])
+     AC_MSG_RESULT(yes)],
+    [AC_MSG_RESULT(failed)]
+  )
+
+  AC_LANG_POP(C++)
+])
+
+AC_DEFUN([TORRENT_CHECK_PTHREAD_SETNAME_NP], [
+  AC_CHECK_HEADERS(pthread.h)
+
+  AC_MSG_CHECKING(for pthread_setname_np type)
+
+  AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+    #include <pthread.h>
+    #include <sys/types.h>
+  ]], [[
+    pthread_t t;
+    pthread_setname_np(t, "foo");
+  ]])],[
+    AC_DEFINE(HAS_PTHREAD_SETNAME_NP_GENERIC, 1, The function to set pthread name has a pthread_t argumet.)
+    AC_MSG_RESULT(generic)
+  ],[
+    AC_LINK_IFELSE([AC_LANG_PROGRAM([[
+      #include <pthread.h>
+      #include <sys/types.h>
+    ]],[[
+      pthread_t t;
+      pthread_setname_np("foo");
+    ]])],[
+      AC_DEFINE(HAS_PTHREAD_SETNAME_NP_DARWIN, 1, The function to set pthread name has no pthread argument.)
+      AC_MSG_RESULT(darwin)
+    ],[
+      AC_MSG_RESULT(no)
+    ])
+  ])
+])
+
+AC_DEFUN([TORRENT_DISABLE_PTHREAD_SETNAME_NP], [
+  AC_MSG_CHECKING([for pthread_setname_no])
+
+  AC_ARG_ENABLE(pthread-setname-np,
+    AS_HELP_STRING([--disable-pthread-setname-np],[disable pthread_setname_np]),
+    [
+      if test "$enableval" = "no"; then
+        AC_MSG_RESULT(disabled)
+      else
+        AC_MSG_RESULT(checking)
+        TORRENT_CHECK_PTHREAD_SETNAME_NP
+      fi
+    ], [
+      TORRENT_CHECK_PTHREAD_SETNAME_NP
+    ]
+  )
+])

scripts/common.m4

@@ -0,0 +1,256 @@
+AC_DEFUN([TORRENT_WITH_SYSROOT], [
+  AC_ARG_WITH(sysroot,
+    AS_HELP_STRING([--with-sysroot=PATH],
+      [compile and link with a specific sysroot]),
+    [
+      AC_MSG_CHECKING(for sysroot)
+
+      if test "$withval" = "no"; then
+        AC_MSG_RESULT(no)
+
+      elif test "$withval" = "yes"; then
+        AC_MSG_RESULT(not a path)
+        AC_MSG_ERROR(The sysroot option must point to a directory, like f.ex "/Developer/SDKs/MacOSX10.4u.sdk".)
+      else
+        AC_MSG_RESULT($withval)
+
+        CXXFLAGS="$CXXFLAGS -isysroot $withval"
+        LDFLAGS="$LDFLAGS -Wl,-syslibroot,$withval"
+      fi
+    ])
+])
+
+
+AC_DEFUN([TORRENT_REMOVE_UNWANTED],
+[
+  values_to_check=`for i in $2; do echo $i; done`
+  unwanted_values=`for i in $3; do echo $i; done`
+  if test -z "${unwanted_values}"; then
+    $1="$2"
+  else
+    result=`echo "${values_to_check}" | $GREP -Fvx -- "${unwanted_values}" | $GREP -v '^$'`
+    $1=$(echo "$result" | tr -d '\n')
+  fi
+])
+
+
+AC_DEFUN([TORRENT_ENABLE_ARCH], [
+  AC_ARG_ENABLE(arch,
+    AS_HELP_STRING([--enable-arch=ARCH],
+      [comma seprated list of architectures to compile for]),
+    [
+      AC_MSG_CHECKING(for target architectures)
+
+      if test "$enableval" = "yes"; then
+        AC_MSG_ERROR(no arch supplied)
+
+      elif test "$enableval" = "no"; then
+        AC_MSG_RESULT(using default)
+
+      else
+        AC_MSG_RESULT($enableval)
+
+        for i in `IFS=,; echo $enableval`; do
+          CFLAGS="$CFLAGS -march=$i"
+          CXXFLAGS="$CXXFLAGS -march=$i"
+          LDFLAGS="$LDFLAGS -march=$i"
+        done
+      fi
+    ])
+])
+
+
+AC_DEFUN([TORRENT_MINCORE_SIGNEDNESS], [
+  AC_LANG_PUSH(C++)
+  AC_MSG_CHECKING(signedness of mincore parameter)
+
+  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+      #include <sys/types.h>
+      #include <sys/mman.h>
+      #include <unistd.h>
+      void f() { mincore((char*)0, 0, (unsigned char*)0); }
+      ])],
+    [
+      AC_DEFINE(USE_MINCORE, 1, Use mincore)
+      AC_DEFINE(USE_MINCORE_UNSIGNED, 1, use unsigned char* in mincore)
+      AC_MSG_RESULT(unsigned)
+    ],
+    [
+      AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+          #include <sys/types.h>
+          #include <sys/mman.h>
+          #include <unistd.h>
+          void f() { mincore((char*)0, 0, (char*)0); }
+          ])],
+        [
+          AC_DEFINE(USE_MINCORE, 1, Use mincore)
+          AC_DEFINE(USE_MINCORE_UNSIGNED, 0, use char* in mincore)
+          AC_MSG_RESULT(signed)
+        ],
+        [
+          AC_MSG_ERROR([failed, do *not* attempt fix this with --disable-mincore unless you are running Win32.])
+      ])
+  ])
+
+  AC_LANG_POP(C++)
+])
+
+AC_DEFUN([TORRENT_MINCORE], [
+  AC_ARG_ENABLE(mincore,
+    AS_HELP_STRING([--disable-mincore],
+      [disable mincore check [[default=enable]]]),
+    [
+      if test "$enableval" = "yes"; then
+        TORRENT_MINCORE_SIGNEDNESS()
+      else
+	AC_MSG_CHECKING(for mincore)
+	AC_MSG_RESULT(disabled)
+      fi
+    ],[
+        TORRENT_MINCORE_SIGNEDNESS()
+    ])
+])
+
+AC_DEFUN([TORRENT_CHECK_MADVISE], [
+  AC_MSG_CHECKING(for madvise)
+
+  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+      #include <sys/types.h>
+      #include <sys/mman.h>
+      void f() { static char test@<:@1024@:>@; madvise((void *)test, sizeof(test), MADV_NORMAL); }
+      ])],
+    [
+      AC_MSG_RESULT(yes)
+      AC_DEFINE(USE_MADVISE, 1, Use madvise)
+    ], [
+      AC_MSG_RESULT(no)
+  ])
+])
+
+AC_DEFUN([TORRENT_CHECK_POSIX_FADVISE], [
+  AC_MSG_CHECKING(for posix_fadvise)
+
+  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+      #include <fcntl.h>
+      void f() { posix_fadvise(0, 0, 0, POSIX_FADV_RANDOM); }
+      ])],
+    [
+      AC_MSG_RESULT(yes)
+      AC_DEFINE(USE_POSIX_FADVISE, 1, Use posix_fadvise)
+    ], [
+      AC_MSG_RESULT(no)
+  ])
+])
+
+AC_DEFUN([TORRENT_CHECK_POPCOUNT], [
+  AC_MSG_CHECKING(for __builtin_popcount)
+
+  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+      int f() { return __builtin_popcount(0); }
+    ])],
+    [
+      AC_MSG_RESULT(yes)
+      AC_DEFINE(USE_BUILTIN_POPCOUNT, 1, Use __builtin_popcount.)
+    ], [
+      AC_MSG_RESULT(no)
+  ])
+])
+
+AC_DEFUN([TORRENT_CHECK_CACHELINE], [
+  AC_MSG_CHECKING(for cacheline)
+
+  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+      #include <stdlib.h>
+          #include <linux/cache.h>
+          void* vptr __cacheline_aligned;
+          void f() { posix_memalign(&vptr, SMP_CACHE_BYTES, 42); }
+      ])],
+    [
+      AC_MSG_RESULT(found builtin)
+dnl   Need to fix this so that it uses the stuff defined by the system.
+
+      AC_DEFINE(LT_SMP_CACHE_BYTES, 128, Largest L1 cache size we know of should work on all archs.)
+    ], [
+      AC_MSG_RESULT(using default 128 bytes)
+      AC_DEFINE(LT_SMP_CACHE_BYTES, 128, Largest L1 cache size we know of should work on all archs.)
+  ])
+])
+
+AC_DEFUN([TORRENT_CHECK_ALIGNED], [
+  AC_MSG_CHECKING(the byte alignment)
+
+  AC_RUN_IFELSE([AC_LANG_SOURCE([
+      #include <inttypes.h>
+      int main() {
+        char buf@<:@8@:>@ = { 0, 0, 0, 0, 1, 0, 0, 0 };
+	int i;
+        for (i = 1; i < 4; ++i)
+	  if (*(uint32_t*)(buf + i) == 0) return -1;
+	return 0;
+	}
+      ])],
+    [
+      AC_MSG_RESULT(none needed)
+    ], [
+      AC_DEFINE(USE_ALIGNED, 1, Require byte alignment)
+      AC_MSG_RESULT(required)
+  ])
+])
+
+
+AC_DEFUN([TORRENT_ENABLE_ALIGNED], [
+  AC_ARG_ENABLE(aligned,
+    AS_HELP_STRING([--enable-aligned],
+      [enable alignment safe code [[default=check]]]),
+    [
+        if test "$enableval" = "yes"; then
+          AC_DEFINE(USE_ALIGNED, 1, Require byte alignment)
+        fi
+    ],[
+        TORRENT_CHECK_ALIGNED
+  ])
+])
+
+
+AC_DEFUN([TORRENT_DISABLE_INSTRUMENTATION], [
+  AC_MSG_CHECKING([if instrumentation should be included])
+
+  AC_ARG_ENABLE(instrumentation,
+    AS_HELP_STRING([--disable-instrumentation],
+      [disable instrumentation [[default=enabled]]]),
+    [
+      if test "$enableval" = "yes"; then
+        AC_DEFINE(LT_INSTRUMENTATION, 1, enable instrumentation)
+	AC_MSG_RESULT(yes)
+      else
+	AC_MSG_RESULT(no)
+      fi
+    ],[
+      AC_DEFINE(LT_INSTRUMENTATION, 1, enable instrumentation)
+      AC_MSG_RESULT(yes)
+    ])
+])
+
+
+AC_DEFUN([TORRENT_ENABLE_INTERRUPT_SOCKET], [
+  AC_ARG_ENABLE(interrupt-socket,
+    AS_HELP_STRING([--enable-interrupt-socket],
+      [enable interrupt socket [[default=no]]]),
+    [
+      if test "$enableval" = "yes"; then
+        AC_DEFINE(USE_INTERRUPT_SOCKET, 1, Use interrupt socket instead of pthread_kill)
+      fi
+    ]
+  )
+])
+
+AC_DEFUN([TORRENT_DISABLE_IPV6], [
+  AC_ARG_ENABLE(ipv6,
+    AS_HELP_STRING([--enable-ipv6],
+      [enable ipv6 [[default=no]]]),
+    [
+        if test "$enableval" = "yes"; then
+            AC_DEFINE(RAK_USE_INET6, 1, enable ipv6 stuff)
+        fi
+    ])
+])

scripts/rak_compiler.m4

@@ -0,0 +1,63 @@
+AC_DEFUN([RAK_CHECK_CFLAGS], [
+
+  AC_MSG_CHECKING([for user-defined CFLAGS])
+
+  if test "$CFLAGS" = ""; then
+    unset CFLAGS
+    AC_MSG_RESULT([undefined])
+  else
+    AC_MSG_RESULT([user-defined "$CFLAGS"])
+  fi
+])
+
+
+AC_DEFUN([RAK_CHECK_CXXFLAGS], [
+
+  AC_MSG_CHECKING([for user-defined CXXFLAGS])
+
+  if test "$CXXFLAGS" = ""; then
+    unset CXXFLAGS
+    AC_MSG_RESULT([undefined])
+  else
+    AC_MSG_RESULT([user-defined "$CXXFLAGS"])
+  fi
+])
+
+
+AC_DEFUN([RAK_ENABLE_DEBUG], [
+  AC_ARG_ENABLE(debug,
+    AS_HELP_STRING([--enable-debug],[enable debug information [[default=yes]]]),
+    [
+        if test "$enableval" = "yes"; then
+            CXXFLAGS="$CXXFLAGS -g -DDEBUG"
+        else
+            CXXFLAGS="$CXXFLAGS -DNDEBUG"
+        fi
+    ],[
+        CXXFLAGS="$CXXFLAGS -g -DDEBUG"
+    ])
+])
+
+
+AC_DEFUN([RAK_ENABLE_WERROR], [
+  AC_ARG_ENABLE(werror,
+    AS_HELP_STRING([--enable-werror],[enable the -Werror and -Wall flags [[default -Wall only]]]),
+    [
+        if test "$enableval" = "yes"; then
+           CXXFLAGS="$CXXFLAGS -Werror -Wall"
+        fi
+    ],[
+        CXXFLAGS="$CXXFLAGS -Wall"
+    ])
+])
+
+
+AC_DEFUN([RAK_ENABLE_EXTRA_DEBUG], [
+  AC_ARG_ENABLE(extra-debug,
+    AS_HELP_STRING([--enable-extra-debug],[enable extra debugging checks [[default=no]]]),
+    [
+        if test "$enableval" = "yes"; then
+            AC_DEFINE(USE_EXTRA_DEBUG, 1, Enable extra debugging checks.)
+        fi
+    ])
+])

scripts/ssl.m4

@@ -0,0 +1,38 @@
+AC_DEFUN([TORRENT_CHECK_OPENSSL],
+  [
+    PKG_CHECK_MODULES(OPENSSL, libcrypto,
+      CXXFLAGS="$CXXFLAGS $OPENSSL_CFLAGS";
+      LIBS="$LIBS $OPENSSL_LIBS")
+
+    AC_DEFINE(USE_OPENSSL, 1, Using OpenSSL.)
+    AC_DEFINE(USE_OPENSSL_SHA, 1, Using OpenSSL's SHA1 implementation.)
+  ]
+)
+
+AC_DEFUN([TORRENT_ARG_OPENSSL],
+  [
+    AC_ARG_ENABLE(openssl,
+      [  --disable-openssl       Don't use OpenSSL's SHA1 implementation.],
+      [
+        if test "$enableval" = "yes"; then
+          TORRENT_CHECK_OPENSSL
+        else
+          AC_DEFINE(USE_NSS_SHA, 1, Using Mozilla's SHA1 implementation.)
+        fi
+      ],[
+        TORRENT_CHECK_OPENSSL
+      ])
+  ]
+)
+
+AC_DEFUN([TORRENT_ARG_CYRUS_RC4],
+  [
+    AC_ARG_ENABLE(cyrus-rc4,
+      [  --enable-cyrus-rc4=PFX  Use Cyrus RC4 implementation.],
+      [
+        CXXFLAGS="$CXXFLAGS -I${enableval}/include";
+        LIBS="$LIBS -lrc4 -L${enableval}/lib"
+        AC_DEFINE(USE_CYRUS_RC4, 1, Using Cyrus RC4 implementation.)
+      ])
+  ]
+)

src/Makefile.am

@@ -0,0 +1,205 @@
+noinst_LIBRARIES = libsub_root.a
+bin_PROGRAMS = rtorrent
+
+rtorrent_LDADD = libsub_root.a @PTHREAD_LIBS@
+rtorrent_SOURCES = main.cc
+
+libsub_root_a_SOURCES = \
+	core/curl_get.cc \
+	core/curl_get.h \
+	core/curl_socket.cc \
+	core/curl_socket.h \
+	core/curl_stack.cc \
+	core/curl_stack.h \
+	core/dht_manager.cc \
+	core/dht_manager.h \
+	core/download.cc \
+	core/download.h \
+	core/download_factory.cc \
+	core/download_factory.h \
+	core/download_list.cc \
+	core/download_list.h \
+	core/download_slot_map.h \
+	core/download_store.cc \
+	core/download_store.h \
+	core/http_queue.cc \
+	core/http_queue.h \
+	core/manager.cc \
+	core/manager.h \
+	core/range_map.h \
+	core/view.cc \
+	core/view.h \
+	core/view_manager.cc \
+	core/view_manager.h \
+	\
+	display/attributes.h \
+	display/canvas.cc \
+	display/canvas.h \
+	display/color_map.h \
+	display/frame.cc \
+	display/frame.h \
+	display/manager.cc \
+	display/manager.h \
+	display/utils.cc \
+	display/utils.h \
+	display/text_element.h \
+	display/text_element_list.cc \
+	display/text_element_list.h \
+	display/text_element_string.cc \
+	display/text_element_string.h \
+	display/text_element_value.cc \
+	display/text_element_value.h \
+	display/window.cc \
+	display/window.h \
+	display/window_download_chunks_seen.cc \
+	display/window_download_chunks_seen.h \
+	display/window_download_list.cc \
+	display/window_download_list.h \
+	display/window_download_statusbar.cc \
+	display/window_download_statusbar.h \
+	display/window_download_transfer_list.cc \
+	display/window_download_transfer_list.h \
+	display/window_file_list.cc \
+	display/window_file_list.h \
+	display/window_http_queue.cc \
+	display/window_http_queue.h \
+	display/window_input.cc \
+	display/window_input.h \
+	display/window_log.cc \
+	display/window_log.h \
+	display/window_log_complete.cc \
+	display/window_log_complete.h \
+	display/window_peer_list.cc \
+	display/window_peer_list.h \
+	display/window_statusbar.cc \
+	display/window_statusbar.h \
+	display/window_string_list.cc \
+	display/window_string_list.h \
+	display/window_text.cc \
+	display/window_text.h \
+	display/window_title.cc \
+	display/window_title.h \
+	display/window_tracker_list.cc \
+	display/window_tracker_list.h \
+	\
+	input/bindings.cc \
+	input/bindings.h \
+	input/input_event.cc \
+	input/input_event.h \
+	input/manager.cc \
+	input/manager.h \
+	input/path_input.cc \
+	input/path_input.h \
+	input/text_input.cc \
+	input/text_input.h \
+	\
+	rpc/command.h \
+	rpc/command.cc \
+	rpc/command_impl.h \
+	rpc/command_map.cc \
+	rpc/command_map.h \
+	rpc/command_scheduler.cc \
+	rpc/command_scheduler.h \
+	rpc/command_scheduler_item.cc \
+	rpc/command_scheduler_item.h \
+	rpc/exec_file.cc \
+	rpc/exec_file.h \
+	rpc/fixed_key.h \
+	rpc/ip_table_list.h \
+	rpc/lua.h \
+	rpc/lua.cc \
+	rpc/jsonrpc.cc \
+	rpc/jsonrpc.h \
+	rpc/rpc_manager.cc \
+	rpc/rpc_manager.h \
+	rpc/object_storage.cc \
+	rpc/object_storage.h \
+	rpc/parse.cc \
+	rpc/parse.h \
+	rpc/parse_commands.cc \
+	rpc/parse_commands.h \
+	rpc/parse_options.cc \
+	rpc/parse_options.h \
+	rpc/scgi.cc \
+	rpc/scgi.h \
+	rpc/scgi_task.cc \
+	rpc/scgi_task.h \
+	rpc/xmlrpc.h \
+	rpc/xmlrpc.cc \
+	rpc/xmlrpc_c.cc \
+	rpc/xmlrpc_tinyxml2.cc \
+	rpc/tinyxml2/tinyxml2.h \
+	rpc/tinyxml2/tinyxml2.cc \
+	rpc/nlohmann/json.h \
+	\
+	ui/download.cc \
+	ui/download.h \
+	ui/download_list.cc \
+	ui/download_list.h \
+	ui/element_base.h \
+	ui/element_base.cc \
+	ui/element_chunks_seen.cc \
+	ui/element_chunks_seen.h \
+	ui/element_download_list.cc \
+	ui/element_download_list.h \
+	ui/element_file_list.cc \
+	ui/element_file_list.h \
+	ui/element_log_complete.cc \
+	ui/element_log_complete.h \
+	ui/element_menu.cc \
+	ui/element_menu.h \
+	ui/element_peer_list.cc \
+	ui/element_peer_list.h \
+	ui/element_string_list.cc \
+	ui/element_string_list.h \
+	ui/element_text.cc \
+	ui/element_text.h \
+	ui/element_tracker_list.cc \
+	ui/element_tracker_list.h \
+	ui/element_transfer_list.cc \
+	ui/element_transfer_list.h \
+	ui/root.cc \
+	ui/root.h \
+	\
+	utils/base64.cc \
+	utils/base64.h \
+	utils/directory.cc \
+	utils/directory.h \
+	utils/file_status_cache.cc \
+	utils/file_status_cache.h \
+	utils/functional.h \
+	utils/list_focus.h \
+	utils/lockfile.cc \
+	utils/lockfile.h \
+	utils/socket_fd.cc \
+	utils/socket_fd.h \
+	\
+	command_download.cc \
+	command_dynamic.cc \
+	command_events.cc \
+	command_file.cc \
+	command_ip.cc \
+	command_helpers.cc \
+	command_helpers.h \
+	command_groups.cc \
+	command_local.cc \
+	command_logging.cc \
+	command_network.cc \
+	command_peer.cc \
+	command_throttle.cc \
+	command_tracker.cc \
+	command_scheduler.cc \
+	command_ui.cc \
+	control.cc \
+	control.h \
+	globals.cc \
+	globals.h \
+	option_parser.cc \
+	option_parser.h \
+	signal_handler.cc \
+	signal_handler.h \
+	thread_worker.cc \
+	thread_worker.h
+
+
+AM_CPPFLAGS = -I$(srcdir) -I$(top_srcdir)

src/command_download.cc

@@ -0,0 +1,881 @@
+#include "config.h"
+
+#include <cassert>
+#include <cstdio>
+#include <functional>
+#include <netdb.h>
+#include <unistd.h>
+#include <rak/file_stat.h>
+#include <rak/error_number.h>
+#include <rak/path.h>
+#include <rak/socket_address.h>
+#include <rak/string_manip.h>
+#include <rak/regex.h>
+#include <torrent/rate.h>
+#include <torrent/throttle.h>
+#include <torrent/tracker/tracker.h>
+#include <torrent/connection_manager.h>
+#include <torrent/data/download_data.h>
+#include <torrent/data/file.h>
+#include <torrent/data/file_list.h>
+#include <torrent/download/resource_manager.h>
+#include <torrent/net/resolver.h>
+#include <torrent/net/types.h>
+#include <torrent/peer/connection_list.h>
+#include <torrent/peer/peer_list.h>
+#include <torrent/utils/log.h>
+#include <torrent/utils/option_strings.h>
+
+#include "core/download.h"
+#include "core/download_store.h"
+#include "core/manager.h"
+#include "rpc/parse.h"
+
+#include "globals.h"
+#include "control.h"
+#include "command_helpers.h"
+
+std::string
+retrieve_d_base_path(core::Download* download) {
+  if (download->file_list()->is_multi_file())
+    return download->file_list()->frozen_root_dir();
+  else
+    return download->file_list()->empty() ? std::string() : download->file_list()->at(0)->frozen_path();
+}
+
+std::string
+retrieve_d_base_filename(core::Download* download) {
+  const std::string* base;
+
+  if (download->file_list()->is_multi_file())
+    base = &download->file_list()->frozen_root_dir();
+  else
+    base = &download->file_list()->at(0)->frozen_path();
+
+  std::string::size_type split = base->rfind('/');
+
+  if (split == std::string::npos)
+    return *base;
+  else
+    return base->substr(split + 1);
+}
+
+torrent::Object
+apply_d_change_link(core::Download* download, const torrent::Object::list_type& args, int changeType) {
+  if (args.size() != 3)
+    throw torrent::input_error("Wrong argument count.");
+
+  torrent::Object::list_const_iterator itr = args.begin();
+
+  const std::string& type    = (itr++)->as_string();
+  const std::string& prefix  = (itr++)->as_string();
+  const std::string& postfix = (itr++)->as_string();
+
+  if (type.empty())
+    throw torrent::input_error("Invalid arguments.");
+
+  std::string target;
+  std::string link;
+
+  if (type == "base_path") {
+    target = rpc::call_command_string("d.base_path", rpc::make_target(download));
+    link = rak::path_expand(prefix + rpc::call_command_string("d.base_path", rpc::make_target(download)) + postfix);
+
+  } else if (type == "base_filename") {
+    target = rpc::call_command_string("d.base_path", rpc::make_target(download));
+    link = rak::path_expand(prefix + rpc::call_command_string("d.base_filename", rpc::make_target(download)) + postfix);
+
+//   } else if (type == "directory_path") {
+//     target = rpc::call_command_string("d.directory", rpc::make_target(download));
+//     link = rak::path_expand(prefix + rpc::call_command_string("d.base_path", rpc::make_target(download)) + postfix);
+
+  } else if (type == "tied") {
+    link = rak::path_expand(rpc::call_command_string("d.tied_to_file", rpc::make_target(download)));
+
+    if (link.empty())
+      return torrent::Object();
+
+    link = rak::path_expand(prefix + link + postfix);
+    target = rpc::call_command_string("d.base_path", rpc::make_target(download));
+
+  } else {
+    throw torrent::input_error("Unknown type argument.");
+  }
+
+  switch (changeType) {
+  case 0:
+    if (symlink(target.c_str(), link.c_str()) == -1){
+      lt_log_print(torrent::LOG_TORRENT_WARN, "create_link failed: %s",
+                   rak::error_number::current().c_str());
+    }
+    break;
+
+  case 1:
+  {
+    rak::file_stat fileStat;
+    rak::error_number::clear_global();
+
+    if (!fileStat.update_link(link) || !fileStat.is_link() ||
+        unlink(link.c_str()) == -1){
+      lt_log_print(torrent::LOG_TORRENT_WARN, "delete_link failed: %s",
+          rak::error_number::current().c_str());
+    }
+    break;
+  }
+  default:
+    break;
+  }
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_d_delete_tied(core::Download* download) {
+  const std::string& tie = rpc::call_command_string("d.tied_to_file", rpc::make_target(download));
+
+  if (tie.empty())
+    return torrent::Object();
+
+  if (::unlink(rak::path_expand(tie).c_str()) == -1)
+    control->core()->push_log_std("Could not unlink tied file: " + std::string(rak::error_number::current().c_str()));
+
+  rpc::call_command("d.tied_to_file.set", std::string(), rpc::make_target(download));
+  return torrent::Object();
+}
+
+void
+apply_d_directory(core::Download* download, const std::string& name) {
+  if (!download->file_list()->is_multi_file())
+    download->set_root_directory(name);
+  else if (name.empty() || *name.rbegin() == '/')
+    download->set_root_directory(name + download->info()->name());
+  else
+    download->set_root_directory(name + "/" + download->info()->name());
+}
+
+torrent::Object
+apply_d_connection_type(core::Download* download, const std::string& name) {
+  torrent::Download::ConnectionType t =
+    (torrent::Download::ConnectionType)torrent::option_find_string(torrent::OPTION_CONNECTION_TYPE, name.c_str());
+
+  download->download()->set_connection_type(t);
+  return torrent::Object();
+}
+
+torrent::Object
+apply_d_choke_heuristics(core::Download* download, const std::string& name, bool is_down) {
+  torrent::Download::HeuristicType t =
+    (torrent::Download::HeuristicType)torrent::option_find_string(torrent::OPTION_CHOKE_HEURISTICS, name.c_str());
+
+  if (is_down)
+    download->download()->set_download_choke_heuristic(t);
+  else
+    download->download()->set_upload_choke_heuristic(t);
+
+  return torrent::Object();
+}
+
+const char*
+retrieve_d_priority_str(core::Download* download) {
+  switch (download->priority()) {
+  case 0:
+    return "off";
+  case 1:
+    return "low";
+  case 2:
+    return "normal";
+  case 3:
+    return "high";
+  default:
+    throw torrent::input_error("Priority out of range.");
+  }
+}
+
+torrent::Object
+retrieve_d_ratio(core::Download* download) {
+  if (download->is_hash_checking())
+    return int64_t();
+
+  int64_t bytesDone = download->download()->bytes_done();
+  int64_t upTotal   = download->info()->up_rate()->total();
+
+  return bytesDone > 0 ? (1000 * upTotal) / bytesDone : 0;
+}
+
+torrent::Object
+apply_d_custom(core::Download* download, const torrent::Object::list_type& args) {
+  torrent::Object::list_const_iterator itr = args.begin();
+
+  if (itr == args.end())
+    throw torrent::bencode_error("Missing key argument.");
+
+  const std::string& key = itr->as_string();
+
+  if (++itr == args.end())
+    throw torrent::bencode_error("Missing value argument.");
+
+  download->bencode()->get_key("rtorrent").
+                       insert_preserve_copy("custom", torrent::Object::create_map()).first->second.
+                       insert_key(key, itr->as_string());
+  return torrent::Object();
+}
+
+torrent::Object
+retrieve_d_custom(core::Download* download, const std::string& key) {
+  try {
+    return download->bencode()->get_key("rtorrent").get_key("custom").get_key_string(key);
+
+  } catch (torrent::bencode_error& e) {
+    return std::string();
+  }
+}
+
+torrent::Object
+retrieve_d_custom_throw(core::Download* download, const std::string& key) {
+  try {
+    return download->bencode()->get_key("rtorrent").get_key("custom").get_key_string(key);
+
+  } catch (torrent::bencode_error& e) {
+    throw torrent::input_error("No such custom value.");
+  }
+}
+
+torrent::Object
+retrieve_d_custom_if_z(core::Download* download, const torrent::Object::list_type& args) {
+  torrent::Object::list_const_iterator itr = args.begin();
+  if (itr == args.end())
+    throw torrent::bencode_error("d.custom.if_z: Missing key argument.");
+  const std::string& key = (itr++)->as_string();
+  if (key.empty())
+    throw torrent::bencode_error("d.custom.if_z: Empty key argument.");
+  if (itr == args.end())
+    throw torrent::bencode_error("d.custom.if_z: Missing default argument.");
+
+  try {
+    const std::string& val = download->bencode()->get_key("rtorrent").get_key("custom").get_key_string(key);
+    return val.empty() ? itr->as_string() : val;
+  } catch (torrent::bencode_error& e) {
+    return itr->as_string();
+  }
+}
+
+torrent::Object
+retrieve_d_custom_map(core::Download* download, bool keys_only, const torrent::Object::list_type& args) {
+  if (args.begin() != args.end())
+    throw torrent::bencode_error("d.custom.keys/items takes no arguments.");
+
+  torrent::Object result = keys_only ? torrent::Object::create_list() : torrent::Object::create_map();
+  torrent::Object::map_type& entries = download->bencode()->get_key("rtorrent").get_key("custom").as_map();
+
+  for (torrent::Object::map_type::const_iterator itr = entries.begin(), last = entries.end(); itr != last; itr++) {
+    if (keys_only) result.as_list().push_back(itr->first);
+    else           result.as_map()[itr->first] = itr->second;
+  }
+
+  return result;
+}
+
+torrent::Object
+retrieve_d_bitfield(core::Download* download) {
+  const torrent::Bitfield* bitField = download->download()->file_list()->bitfield();
+
+  if (bitField->empty())
+    return torrent::Object("");
+
+  return torrent::Object(rak::transform_hex(bitField->begin(), bitField->end()));
+}
+
+void
+apply_d_add_peer(core::Download* download, const std::string& arg) {
+  int port, ret;
+  char dummy;
+  char host[1024];
+
+  if (download->download()->info()->is_private())
+    throw torrent::input_error("Download is private.");
+
+  ret = std::sscanf(arg.c_str(), "[%64[^]]]:%i%c", host, &port, &dummy);
+
+  if (ret < 1)
+    ret = std::sscanf(arg.c_str(), "%1023[^:]:%i%c", host, &port, &dummy);
+
+  if (ret == 1)
+    port = 6881;
+  else if (ret != 2)
+    throw torrent::input_error("Could not parse host.");
+
+  if (port < 1 || port > 65535)
+    throw torrent::input_error("Invalid port number.");
+
+  assert(std::this_thread::get_id() == torrent::main_thread::thread()->thread_id());
+
+  // Currently discarding SOCK_STREAM.
+  torrent::this_thread::resolver()->resolve_preferred(NULL, host, AF_UNSPEC, AF_INET, [download, port](torrent::c_sa_shared_ptr sa, int err) {
+      if (sa == nullptr) {
+        lt_log_print(torrent::LOG_TORRENT_WARN, "could not resolve hostname for added peer: %s", gai_strerror(err));
+        return;
+      }
+
+      download->download()->add_peer(sa.get(), port);
+  });
+}
+
+torrent::Object
+d_chunks_seen(core::Download* download) {
+  const uint8_t* seen = download->download()->chunks_seen();
+
+  if (seen == NULL)
+    return std::string();
+
+  uint32_t size = download->download()->file_list()->size_chunks();
+
+  std::string result;
+  result.resize(size * 2);
+
+  rak::transform_hex((const char*)seen, (const char*)seen + size, result.begin());
+  return result;
+}
+
+torrent::Object
+f_multicall(core::Download* download, const torrent::Object::list_type& args) {
+  if (args.empty())
+    throw torrent::input_error("Too few arguments.");
+
+  // We ignore the first arg for now, but it will be used for
+  // selecting what files to include.
+
+  // Add some pre-parsing of the commands, so we don't spend time
+  // parsing and searching command map for every single call.
+  torrent::Object             resultRaw = torrent::Object::create_list();
+  torrent::Object::list_type& result = resultRaw.as_list();
+  std::vector<rak::regex>     regex_list;
+
+  bool use_regex = true;
+
+  if (args.front().is_list())
+    std::transform(args.front().as_list().begin(), args.front().as_list().end(),
+                   std::back_inserter(regex_list),
+                   std::bind(&torrent::Object::as_string_c, std::placeholders::_1));
+  else if (args.front().is_string() && !args.front().as_string().empty())
+    regex_list.push_back(args.front().as_string());
+  else
+    use_regex = false;
+
+  for (torrent::FileList::const_iterator itr = download->file_list()->begin(), last = download->file_list()->end(); itr != last; itr++) {
+    if (use_regex &&
+        std::find_if(regex_list.begin(), regex_list.end(),
+                     std::bind(&rak::regex::operator(), std::placeholders::_1, (*itr)->path()->as_string())) == regex_list.end())
+      continue;
+
+    torrent::Object::list_type& row = result.insert(result.end(), torrent::Object::create_list())->as_list();
+
+    for (torrent::Object::list_const_iterator cItr = ++args.begin(); cItr != args.end(); cItr++) {
+      const std::string& cmd = cItr->as_string();
+      row.push_back(rpc::parse_command(rpc::make_target(itr->get()), cmd.c_str(), cmd.c_str() + cmd.size()).first);
+    }
+  }
+
+  return resultRaw;
+}
+
+torrent::Object
+t_multicall(core::Download* download, const torrent::Object::list_type& args) {
+  if (args.empty())
+    throw torrent::input_error("Too few arguments.");
+
+  // We ignore the first arg for now, but it will be used for
+  // selecting what files to include.
+
+  // Add some pre-parsing of the commands, so we don't spend time
+  // parsing and searching command map for every single call.
+  torrent::Object             result_raw = torrent::Object::create_list();
+  torrent::Object::list_type& result     = result_raw.as_list();
+
+  for (uint32_t idx = 0, last = download->tracker_list_size(); idx < last; idx++) {
+    auto& row = result.insert(result.end(), torrent::Object::create_list())->as_list();
+    auto  tracker = download->tracker_controller().at(idx);
+
+    if (!tracker.is_valid())
+      continue;
+
+    for (torrent::Object::list_const_iterator cItr = ++args.begin(); cItr != args.end(); cItr++) {
+      const std::string& cmd = cItr->as_string();
+
+      row.push_back(rpc::parse_command(rpc::make_target(&tracker), cmd.c_str(), cmd.c_str() + cmd.size()).first);
+    }
+  }
+
+  return result_raw;
+}
+
+torrent::Object
+p_multicall(core::Download* download, const torrent::Object::list_type& args) {
+  if (args.empty())
+    throw torrent::input_error("Too few arguments.");
+
+  // We ignore the first arg for now, but it will be used for
+  // selecting what files to include.
+
+  // Add some pre-parsing of the commands, so we don't spend time
+  // parsing and searching command map for every single call.
+  torrent::Object             resultRaw = torrent::Object::create_list();
+  torrent::Object::list_type& result = resultRaw.as_list();
+
+  for (torrent::ConnectionList::const_iterator itr = download->connection_list()->begin(), last = download->connection_list()->end();
+       itr != last; itr++) {
+    torrent::Object::list_type& row = result.insert(result.end(), torrent::Object::create_list())->as_list();
+
+    for (torrent::Object::list_const_iterator cItr = ++args.begin(); cItr != args.end(); cItr++) {
+      const std::string& cmd = cItr->as_string();
+
+      row.push_back(rpc::parse_command(rpc::make_target(*itr), cmd.c_str(), cmd.c_str() + cmd.size()).first);
+    }
+  }
+
+  return resultRaw;
+}
+
+torrent::Object
+p_call_target(const torrent::Object::list_type& args) {
+  if (args.empty() || args.begin() + 1 == args.end() || args.begin() + 2 == args.end())
+    throw torrent::input_error("Too few arguments.");
+
+  // We ignore the first arg for now, but it will be used for
+  // selecting what files to include.
+
+  // Add some pre-parsing of the commands, so we don't spend time
+  // parsing and searching command map for every single call.
+  torrent::Object::list_const_iterator itr = args.begin();
+
+  core::Download* download = control->core()->download_list()->find_hex_ptr(itr++->as_string().c_str());
+  const std::string& peer_id = itr++->as_string();
+  const std::string& command_key = itr++->as_string();
+
+  torrent::HashString hash;
+
+  if (peer_id.size() != 40 ||
+      torrent::hash_string_from_hex_c_str(peer_id.c_str(), hash) == peer_id.c_str())
+    throw torrent::input_error("Not a hash string.");
+
+  torrent::ConnectionList::iterator peerItr = download->connection_list()->find(hash.c_str());
+
+  if (peerItr == download->connection_list()->end())
+    throw torrent::input_error("Could not find peer.");
+
+  if (itr == args.end())
+    return rpc::commands.call(command_key.c_str());
+
+  if (itr + 1 == args.end())
+    return rpc::commands.call(command_key.c_str(), *itr);
+
+  return rpc::commands.call(command_key.c_str(), torrent::Object::create_list_range(itr, args.end()));
+}
+
+torrent::Object
+download_tracker_insert(core::Download* download, const torrent::Object::list_type& args) {
+  if (args.size() != 2)
+    throw torrent::input_error("Wrong argument count.");
+
+  int64_t group;
+
+  if (args.front().is_string())
+    rpc::parse_whole_value_nothrow(args.front().as_string().c_str(), &group);
+  else
+    group = args.front().as_value();
+
+  if (group < 0 || group > 32)
+    throw torrent::input_error("Tracker group number invalid.");
+
+  download->tracker_controller().add_extra_tracker(group, args.back().as_string());
+
+  return torrent::Object();
+}
+
+//
+// New download commands and macros:
+//
+
+torrent::Object&
+download_get_variable(core::Download* download, const char* first_key, const char* second_key = NULL) {
+  if (second_key == NULL)
+    return download->bencode()->get_key(first_key);
+
+  return download->bencode()->get_key(first_key).get_key(second_key);
+}
+
+torrent::Object
+download_set_variable(core::Download* download, const torrent::Object& rawArgs, const char* first_key, const char* second_key = NULL) {
+  if (second_key == NULL)
+    return download->bencode()->get_key(first_key) = torrent::object_create_normal(rawArgs);
+
+  return download->bencode()->get_key(first_key).get_key(second_key) = torrent::object_create_normal(rawArgs);
+}
+
+torrent::Object
+download_set_variable_value(core::Download* download, const torrent::Object::value_type& args,
+                            const char* first_key, const char* second_key = NULL) {
+  if (second_key == NULL)
+    return download->bencode()->get_key(first_key) = args;
+
+  return download->bencode()->get_key(first_key).get_key(second_key) = args;
+}
+
+torrent::Object
+download_set_variable_value_ifz(core::Download* download, const torrent::Object::value_type& args,
+                                const char* first_key, const char* second_key = NULL) {
+  torrent::Object& object = second_key == NULL ?
+    download->bencode()->get_key(first_key) :
+    download->bencode()->get_key(first_key).get_key(second_key);
+
+  if (object.as_value() == 0)
+    object = args;
+
+  return object;
+}
+
+torrent::Object
+download_set_variable_string(core::Download* download, const torrent::Object::string_type& args,
+                             const char* first_key, const char* second_key = NULL) {
+  if (second_key == NULL)
+    return download->bencode()->get_key(first_key) = args;
+
+  return download->bencode()->get_key(first_key).get_key(second_key) = args;
+}
+
+//
+//
+//
+
+torrent::Object
+d_list_push_back(core::Download* download, const torrent::Object& rawArgs, const char* first_key, const char* second_key) {
+  download_get_variable(download, first_key, second_key).as_list().push_back(rawArgs);
+
+  return torrent::Object();
+}
+
+torrent::Object
+d_list_push_back_unique(core::Download* download, const torrent::Object& rawArgs, const char* first_key, const char* second_key) {
+  const torrent::Object& args = (rawArgs.is_list() && !rawArgs.as_list().empty()) ? rawArgs.as_list().front() : rawArgs;
+  torrent::Object::list_type& list = download_get_variable(download, first_key, second_key).as_list();
+
+  if (std::find_if(list.begin(), list.end(), [args](const torrent::Object& obj) { return torrent::object_equal(obj, args); }) == list.end())
+    list.push_back(rawArgs);
+
+  return torrent::Object();
+}
+
+torrent::Object
+d_list_has(core::Download* download, const torrent::Object& rawArgs, const char* first_key, const char* second_key) {
+  const torrent::Object& args = (rawArgs.is_list() && !rawArgs.as_list().empty()) ? rawArgs.as_list().front() : rawArgs;
+  torrent::Object::list_type& list = download_get_variable(download, first_key, second_key).as_list();
+
+  return (int64_t)(std::find_if(list.begin(), list.end(), [args](const torrent::Object& obj) { return torrent::object_equal(obj, args); }) != list.end());
+}
+
+torrent::Object
+d_list_remove(core::Download* download, const torrent::Object& rawArgs, const char* first_key, const char* second_key) {
+  const torrent::Object& args = (rawArgs.is_list() && !rawArgs.as_list().empty()) ? rawArgs.as_list().front() : rawArgs;
+  torrent::Object::list_type& list = download_get_variable(download, first_key, second_key).as_list();
+
+  list.erase(std::remove_if(list.begin(), list.end(), [args](const torrent::Object& obj) { return torrent::object_equal(obj, args); }), list.end());
+
+  return torrent::Object();
+}
+
+#define CMD2_ON_INFO(func) std::bind(&torrent::DownloadInfo::func, std::bind(&core::Download::info, std::placeholders::_1))
+#define CMD2_ON_DATA(func) std::bind(&torrent::download_data::func, std::bind(&core::Download::data, std::placeholders::_1))
+#define CMD2_ON_DL(func) std::bind(&torrent::Download::func, std::bind(&core::Download::download, std::placeholders::_1))
+#define CMD2_ON_FL(func) std::bind(&torrent::FileList::func, std::bind(&core::Download::file_list, std::placeholders::_1))
+
+#define CMD2_BIND_DL std::bind(&core::Download::download, std::placeholders::_1)
+#define CMD2_BIND_CL std::bind(&core::Download::connection_list, std::placeholders::_1)
+#define CMD2_BIND_FL std::bind(&core::Download::file_list, std::placeholders::_1)
+#define CMD2_BIND_PL std::bind(&core::Download::c_peer_list, std::placeholders::_1)
+#define CMD2_BIND_TC std::bind(&core::Download::tracker_controller, std::placeholders::_1)
+
+#define CMD2_BIND_INFO std::bind(&core::Download::info, std::placeholders::_1)
+#define CMD2_BIND_DATA std::bind(&core::Download::data, std::placeholders::_1)
+
+#define CMD2_DL_VAR_VALUE(key, first_key, second_key)                   \
+  CMD2_DL(key, std::bind(&download_get_variable, std::placeholders::_1, first_key, second_key)); \
+  CMD2_DL_VALUE_P(key ".set", std::bind(&download_set_variable_value, \
+                                             std::placeholders::_1, std::placeholders::_2, \
+                                             first_key, second_key));
+
+#define CMD2_DL_VAR_VALUE_PUBLIC(key, first_key, second_key)            \
+  CMD2_DL(key, std::bind(&download_get_variable, std::placeholders::_1, first_key, second_key)); \
+  CMD2_DL_VALUE(key ".set", std::bind(&download_set_variable_value, \
+                                           std::placeholders::_1, std::placeholders::_2, \
+                                           first_key, second_key));
+
+#define CMD2_DL_TIMESTAMP(key, first_key, second_key)                   \
+  CMD2_DL(key, std::bind(&download_get_variable, std::placeholders::_1, first_key, second_key)); \
+  CMD2_DL_VALUE_P(key ".set", std::bind(&download_set_variable_value, \
+                                             std::placeholders::_1, std::placeholders::_2, \
+                                             first_key, second_key)); \
+  CMD2_DL_VALUE_P(key ".set_if_z", std::bind(&download_set_variable_value_ifz, \
+                                             std::placeholders::_1, std::placeholders::_2, \
+                                             first_key, second_key));   \
+
+#define CMD2_DL_VAR_STRING(key, first_key, second_key)                   \
+  CMD2_DL(key, std::bind(&download_get_variable, std::placeholders::_1, first_key, second_key)); \
+  CMD2_DL_STRING_P(key ".set", std::bind(&download_set_variable_string, \
+                                              std::placeholders::_1, std::placeholders::_2, \
+                                              first_key, second_key));
+
+#define CMD2_DL_VAR_STRING_PUBLIC(key, first_key, second_key)                   \
+  CMD2_DL(key, std::bind(&download_get_variable, std::placeholders::_1, first_key, second_key)); \
+  CMD2_DL_STRING(key ".set", std::bind(&download_set_variable_string, \
+                                            std::placeholders::_1, std::placeholders::_2, \
+                                            first_key, second_key));
+
+int64_t            cg_d_group(core::Download* download);
+const std::string& cg_d_group_name(core::Download* download);
+void               cg_d_group_set(core::Download* download, const torrent::Object& arg);
+
+void
+initialize_command_download() {
+  CMD2_DL("d.hash",          std::bind(&rak::transform_hex_str<torrent::HashString>, CMD2_ON_INFO(hash)));
+  CMD2_DL("d.local_id",      std::bind(&rak::transform_hex_str<torrent::HashString>, CMD2_ON_INFO(local_id)));
+  CMD2_DL("d.local_id_html", std::bind(&rak::copy_escape_html_str<torrent::HashString>, CMD2_ON_INFO(local_id)));
+  CMD2_DL("d.bitfield",      std::bind(&retrieve_d_bitfield, std::placeholders::_1));
+  CMD2_DL("d.base_path",     std::bind(&retrieve_d_base_path, std::placeholders::_1));
+  CMD2_DL("d.base_filename", std::bind(&retrieve_d_base_filename, std::placeholders::_1));
+
+  CMD2_DL("d.name",          CMD2_ON_INFO(name));
+  CMD2_DL("d.creation_date", CMD2_ON_INFO(creation_date));
+  CMD2_DL("d.load_date",     CMD2_ON_INFO(load_date));
+
+  //
+  // Network related:
+  //
+
+  CMD2_DL         ("d.up.rate",       std::bind(&torrent::Rate::rate,  CMD2_ON_INFO(up_rate)));
+  CMD2_DL         ("d.up.total",      std::bind(&torrent::Rate::total, CMD2_ON_INFO(up_rate)));
+  CMD2_DL         ("d.down.rate",     std::bind(&torrent::Rate::rate,  CMD2_ON_INFO(down_rate)));
+  CMD2_DL         ("d.down.total",    std::bind(&torrent::Rate::total, CMD2_ON_INFO(down_rate)));
+  CMD2_DL         ("d.skip.rate",     std::bind(&torrent::Rate::rate,  CMD2_ON_INFO(skip_rate)));
+  CMD2_DL         ("d.skip.total",    std::bind(&torrent::Rate::total, CMD2_ON_INFO(skip_rate)));
+
+  CMD2_DL         ("d.peer_exchange",     CMD2_ON_INFO(is_pex_enabled));
+  CMD2_DL_VALUE_V ("d.peer_exchange.set", std::bind(&torrent::Download::set_pex_enabled, CMD2_BIND_DL, std::placeholders::_2));
+
+  CMD2_DL_LIST    ("d.create_link", std::bind(&apply_d_change_link, std::placeholders::_1, std::placeholders::_2, 0));
+  CMD2_DL_LIST    ("d.delete_link", std::bind(&apply_d_change_link, std::placeholders::_1, std::placeholders::_2, 1));
+  CMD2_DL         ("d.delete_tied", std::bind(&apply_d_delete_tied, std::placeholders::_1));
+
+  CMD2_FUNC_SINGLE("d.start",     "d.hashing_failed.set=0 ;view.set_visible=started");
+  CMD2_FUNC_SINGLE("d.stop",      "view.set_visible=stopped");
+  CMD2_FUNC_SINGLE("d.try_start", "branch=\"or={d.hashing_failed=,d.ignore_commands=}\",{},{view.set_visible=started}");
+  CMD2_FUNC_SINGLE("d.try_stop",  "branch=d.ignore_commands=, {}, {view.set_visible=stopped}");
+  CMD2_FUNC_SINGLE("d.try_close", "branch=d.ignore_commands=, {}, {view.set_visible=stopped, d.close=}");
+
+  //
+  // Control functinos:
+  //
+
+  CMD2_DL         ("d.is_open",               CMD2_ON_INFO(is_open));
+  CMD2_DL         ("d.is_active",             CMD2_ON_INFO(is_active));
+  CMD2_DL         ("d.is_hash_checked",       std::bind(&torrent::Download::is_hash_checked, CMD2_BIND_DL));
+  CMD2_DL         ("d.is_hash_checking",      std::bind(&torrent::Download::is_hash_checking, CMD2_BIND_DL));
+  CMD2_DL         ("d.is_multi_file",         std::bind(&torrent::FileList::is_multi_file, CMD2_BIND_FL));
+  CMD2_DL         ("d.is_private",            CMD2_ON_INFO(is_private));
+  CMD2_DL         ("d.is_pex_active",         CMD2_ON_INFO(is_pex_active));
+  CMD2_DL         ("d.is_partially_done",     CMD2_ON_DATA(is_partially_done));
+  CMD2_DL         ("d.is_not_partially_done", CMD2_ON_DATA(is_not_partially_done));
+  CMD2_DL         ("d.is_meta",               CMD2_ON_INFO(is_meta_download));
+
+  CMD2_DL_V       ("d.resume",     std::bind(&core::DownloadList::resume_default, control->core()->download_list(), std::placeholders::_1));
+  CMD2_DL_V       ("d.pause",      std::bind(&core::DownloadList::pause_default, control->core()->download_list(), std::placeholders::_1));
+  CMD2_DL_V       ("d.open",       std::bind(&core::DownloadList::open_throw, control->core()->download_list(), std::placeholders::_1));
+  CMD2_DL_V       ("d.close",      std::bind(&core::DownloadList::close_throw, control->core()->download_list(), std::placeholders::_1));
+  CMD2_DL_V       ("d.close.directly", std::bind(&core::DownloadList::close_directly, control->core()->download_list(), std::placeholders::_1));
+  CMD2_DL_V       ("d.erase",      std::bind(&core::DownloadList::erase_ptr, control->core()->download_list(), std::placeholders::_1));
+  CMD2_DL_V       ("d.check_hash", std::bind(&core::DownloadList::check_hash, control->core()->download_list(), std::placeholders::_1));
+
+  CMD2_DL         ("d.save_resume",       std::bind(&core::DownloadStore::save_resume, control->core()->download_store(), std::placeholders::_1));
+  CMD2_DL         ("d.save_full_session", std::bind(&core::DownloadStore::save_full, control->core()->download_store(), std::placeholders::_1));
+
+  CMD2_DL_V       ("d.update_priorities", CMD2_ON_DL(update_priorities));
+
+  CMD2_DL_STRING_V("add_peer",   std::bind(&apply_d_add_peer, std::placeholders::_1, std::placeholders::_2));
+
+  //
+  // Custom settings:
+  //
+
+  CMD2_DL_STRING("d.custom",       std::bind(&retrieve_d_custom, std::placeholders::_1, std::placeholders::_2));
+  CMD2_DL_STRING("d.custom_throw", std::bind(&retrieve_d_custom_throw, std::placeholders::_1, std::placeholders::_2));
+  CMD2_DL_LIST  ("d.custom.set",   std::bind(&apply_d_custom, std::placeholders::_1, std::placeholders::_2));
+  CMD2_DL_LIST  ("d.custom.if_z",  std::bind(&retrieve_d_custom_if_z, std::placeholders::_1, std::placeholders::_2));
+  CMD2_DL_LIST  ("d.custom.keys",  std::bind(&retrieve_d_custom_map, std::placeholders::_1, true, std::placeholders::_2));
+  CMD2_DL_LIST  ("d.custom.items", std::bind(&retrieve_d_custom_map, std::placeholders::_1, false, std::placeholders::_2));
+
+  CMD2_DL_VAR_STRING_PUBLIC("d.custom1", "rtorrent", "custom1");
+  CMD2_DL_VAR_STRING_PUBLIC("d.custom2", "rtorrent", "custom2");
+  CMD2_DL_VAR_STRING_PUBLIC("d.custom3", "rtorrent", "custom3");
+  CMD2_DL_VAR_STRING_PUBLIC("d.custom4", "rtorrent", "custom4");
+  CMD2_DL_VAR_STRING_PUBLIC("d.custom5", "rtorrent", "custom5");
+
+  // 0 - stopped
+  // 1 - started
+  CMD2_DL_VAR_VALUE("d.state",      "rtorrent", "state");
+  CMD2_DL_VAR_VALUE("d.complete",   "rtorrent", "complete");
+
+  CMD2_FUNC_SINGLE ("d.incomplete", "not=(d.complete)");
+
+  // 0 off
+  // 1 scheduled, being controlled by a download scheduler. Includes a priority.
+  // 3 forced off
+  // 2 forced on
+  CMD2_DL_VAR_VALUE("d.mode", "rtorrent", "mode");
+
+  // 0 - Not hashing
+  // 1 - Normal hashing
+  // 2 - Download finished, hashing
+  // 3 - Rehashing
+  CMD2_DL_VAR_VALUE("d.hashing", "rtorrent", "hashing");
+
+  // 'tied_to_file' is the file the download is associated with, and
+  // can be changed by the user.
+  //
+  // 'loaded_file' is the file this instance of the torrent was loaded
+  // from, and should not be changed.
+  CMD2_DL_VAR_STRING_PUBLIC("d.tied_to_file", "rtorrent", "tied_to_file");
+  CMD2_DL_VAR_STRING("d.loaded_file",  "rtorrent", "loaded_file");
+
+  // The "state_changed" variable is required to be a valid unix time
+  // value, it indicates the last time the torrent changed its state,
+  // resume/pause.
+  CMD2_DL_VAR_VALUE("d.state_changed",          "rtorrent", "state_changed");
+  CMD2_DL_VAR_VALUE("d.state_counter",          "rtorrent", "state_counter");
+  CMD2_DL_VAR_VALUE_PUBLIC("d.ignore_commands", "rtorrent", "ignore_commands");
+
+  CMD2_DL_TIMESTAMP("d.timestamp.started",      "rtorrent", "timestamp.started");
+  CMD2_DL_TIMESTAMP("d.timestamp.finished",     "rtorrent", "timestamp.finished");
+
+  CMD2_DL       ("d.connection_current",     std::bind(&torrent::option_as_string, torrent::OPTION_CONNECTION_TYPE, CMD2_ON_DL(connection_type)));
+  CMD2_DL_STRING("d.connection_current.set", std::bind(&apply_d_connection_type, std::placeholders::_1, std::placeholders::_2));
+
+  CMD2_DL_VAR_STRING("d.connection_leech",      "rtorrent", "connection_leech");
+  CMD2_DL_VAR_STRING("d.connection_seed",       "rtorrent", "connection_seed");
+
+  CMD2_DL       ("d.up.choke_heuristics",       std::bind(&torrent::option_as_string, torrent::OPTION_CHOKE_HEURISTICS, CMD2_ON_DL(upload_choke_heuristic)));
+  CMD2_DL_STRING("d.up.choke_heuristics.set",   std::bind(&apply_d_choke_heuristics, std::placeholders::_1, std::placeholders::_2, false));
+  CMD2_DL       ("d.down.choke_heuristics",     std::bind(&torrent::option_as_string, torrent::OPTION_CHOKE_HEURISTICS, CMD2_ON_DL(download_choke_heuristic)));
+  CMD2_DL_STRING("d.down.choke_heuristics.set", std::bind(&apply_d_choke_heuristics, std::placeholders::_1, std::placeholders::_2, true));
+
+  CMD2_DL_VAR_STRING("d.up.choke_heuristics.leech", "rtorrent", "choke_heuristics.up.leech");
+  CMD2_DL_VAR_STRING("d.up.choke_heuristics.seed",  "rtorrent", "choke_heuristics.up.seed");
+  CMD2_DL_VAR_STRING("d.down.choke_heuristics.leech", "rtorrent", "choke_heuristics.down.leech");
+  CMD2_DL_VAR_STRING("d.down.choke_heuristics.seed",  "rtorrent", "choke_heuristics.down.seed");
+
+  CMD2_DL         ("d.hashing_failed",     std::bind(&core::Download::is_hash_failed, std::placeholders::_1));
+  CMD2_DL_VALUE_V ("d.hashing_failed.set", std::bind(&core::Download::set_hash_failed, std::placeholders::_1, std::placeholders::_2));
+
+  CMD2_DL         ("d.views",                  std::bind(&download_get_variable, std::placeholders::_1, "rtorrent", "views"));
+  CMD2_DL         ("d.views.has",              std::bind(&d_list_has, std::placeholders::_1, std::placeholders::_2, "rtorrent", "views"));
+  CMD2_DL         ("d.views.remove",           std::bind(&d_list_remove, std::placeholders::_1, std::placeholders::_2, "rtorrent", "views"));
+  CMD2_DL         ("d.views.push_back",        std::bind(&d_list_push_back, std::placeholders::_1, std::placeholders::_2, "rtorrent", "views"));
+  CMD2_DL         ("d.views.push_back_unique", std::bind(&d_list_push_back_unique, std::placeholders::_1, std::placeholders::_2, "rtorrent", "views"));
+
+  // This command really needs to be improved, so we have proper
+  // logging support.
+  CMD2_DL         ("d.message",     std::bind(&core::Download::message, std::placeholders::_1));
+  CMD2_DL_STRING_V("d.message.set", std::bind(&core::Download::set_message, std::placeholders::_1, std::placeholders::_2));
+
+  CMD2_DL         ("d.max_file_size",       CMD2_ON_FL(max_file_size));
+  CMD2_DL_VALUE_V ("d.max_file_size.set",   std::bind(&torrent::FileList::set_max_file_size, CMD2_BIND_FL, std::placeholders::_2));
+
+  CMD2_DL         ("d.peers_min",           std::bind(&torrent::ConnectionList::min_size, CMD2_BIND_CL));
+  CMD2_DL_VALUE_V ("d.peers_min.set",       std::bind(&torrent::ConnectionList::set_min_size, CMD2_BIND_CL, std::placeholders::_2));
+  CMD2_DL         ("d.peers_max",           std::bind(&torrent::ConnectionList::max_size, CMD2_BIND_CL));
+  CMD2_DL_VALUE_V ("d.peers_max.set",       std::bind(&torrent::ConnectionList::set_max_size, CMD2_BIND_CL, std::placeholders::_2));
+  CMD2_DL         ("d.uploads_max",         std::bind(&torrent::Download::uploads_max, CMD2_BIND_DL));
+  CMD2_DL_VALUE_V ("d.uploads_max.set",     std::bind(&torrent::Download::set_uploads_max, CMD2_BIND_DL, std::placeholders::_2));
+  CMD2_DL         ("d.uploads_min",         std::bind(&torrent::Download::uploads_min, CMD2_BIND_DL));
+  CMD2_DL_VALUE_V ("d.uploads_min.set",     std::bind(&torrent::Download::set_uploads_min, CMD2_BIND_DL, std::placeholders::_2));
+  CMD2_DL         ("d.downloads_max",         std::bind(&torrent::Download::downloads_max, CMD2_BIND_DL));
+  CMD2_DL_VALUE_V ("d.downloads_max.set",     std::bind(&torrent::Download::set_downloads_max, CMD2_BIND_DL, std::placeholders::_2));
+  CMD2_DL         ("d.downloads_min",         std::bind(&torrent::Download::downloads_min, CMD2_BIND_DL));
+  CMD2_DL_VALUE_V ("d.downloads_min.set",     std::bind(&torrent::Download::set_downloads_min, CMD2_BIND_DL, std::placeholders::_2));
+  CMD2_DL         ("d.peers_connected",     std::bind(&torrent::ConnectionList::size, CMD2_BIND_CL));
+  CMD2_DL         ("d.peers_not_connected", std::bind(&torrent::PeerList::available_list_size, CMD2_BIND_PL));
+
+  CMD2_DL         ("d.peers_complete",      CMD2_ON_DL(peers_complete));
+  CMD2_DL         ("d.peers_accounted",     CMD2_ON_DL(peers_accounted));
+
+  CMD2_DL_V       ("d.disconnect.seeders",        std::bind(&torrent::ConnectionList::erase_seeders, CMD2_BIND_CL));
+
+  CMD2_DL         ("d.accepting_seeders",         CMD2_ON_INFO(is_accepting_seeders));
+  CMD2_DL_V       ("d.accepting_seeders.enable",  std::bind(&torrent::DownloadInfo::public_set_flags,   CMD2_BIND_INFO, torrent::DownloadInfo::flag_accepting_seeders));
+  CMD2_DL_V       ("d.accepting_seeders.disable", std::bind(&torrent::DownloadInfo::public_unset_flags, CMD2_BIND_INFO, torrent::DownloadInfo::flag_accepting_seeders));
+
+  CMD2_DL         ("d.throttle_name",     std::bind(&download_get_variable, std::placeholders::_1, "rtorrent", "throttle_name"));
+  CMD2_DL_STRING_V("d.throttle_name.set", std::bind(&core::Download::set_throttle_name, std::placeholders::_1, std::placeholders::_2));
+
+  CMD2_DL         ("d.bytes_done",     CMD2_ON_DL(bytes_done));
+  CMD2_DL         ("d.ratio",          std::bind(&retrieve_d_ratio, std::placeholders::_1));
+  CMD2_DL         ("d.chunks_hashed",  CMD2_ON_DL(chunks_hashed));
+  CMD2_DL         ("d.free_diskspace", CMD2_ON_FL(free_diskspace));
+
+  CMD2_DL         ("d.size_files",     CMD2_ON_FL(size_files));
+  CMD2_DL         ("d.size_bytes",     CMD2_ON_FL(size_bytes));
+  CMD2_DL         ("d.size_chunks",    CMD2_ON_FL(size_chunks));
+  CMD2_DL         ("d.chunk_size",     CMD2_ON_FL(chunk_size));
+  CMD2_DL         ("d.size_pex",       CMD2_ON_DL(size_pex));
+  CMD2_DL         ("d.max_size_pex",   CMD2_ON_DL(max_size_pex));
+
+  CMD2_DL         ("d.chunks_seen",      std::bind(&d_chunks_seen, std::placeholders::_1));
+
+  CMD2_DL         ("d.completed_bytes",  CMD2_ON_FL(completed_bytes));
+  CMD2_DL         ("d.completed_chunks", CMD2_ON_FL(completed_chunks));
+  CMD2_DL         ("d.left_bytes",       CMD2_ON_FL(left_bytes));
+
+  CMD2_DL         ("d.wanted_chunks",    CMD2_ON_DATA(wanted_chunks));
+
+  // Do not exposre d.tracker_announce.force to regular users.
+  CMD2_DL_V       ("d.tracker_announce",       std::bind(&torrent::Download::manual_request, CMD2_BIND_DL, false));
+  CMD2_DL_V       ("d.tracker_announce.force", std::bind(&torrent::Download::manual_request, CMD2_BIND_DL, true));
+
+  CMD2_DL         ("d.tracker_numwant",      std::bind(&torrent::tracker::TrackerControllerWrapper::numwant, CMD2_BIND_TC));
+  CMD2_DL_VALUE_V ("d.tracker_numwant.set",  std::bind(&torrent::tracker::TrackerControllerWrapper::set_numwant, CMD2_BIND_TC, std::placeholders::_2));
+  // TODO: Deprecate 'd.tracker_focus'.
+  CMD2_DL         ("d.tracker_focus",        std::bind(&core::Download::tracker_list_size, std::placeholders::_1));
+  CMD2_DL         ("d.tracker_size",         std::bind(&core::Download::tracker_list_size, std::placeholders::_1));
+
+  CMD2_DL         ("d.tracker.has_active",            std::bind(&torrent::tracker::TrackerControllerWrapper::has_active_trackers, CMD2_BIND_TC));
+  CMD2_DL         ("d.tracker.has_active_not_scrape", std::bind(&torrent::tracker::TrackerControllerWrapper::has_active_trackers_not_scrape, CMD2_BIND_TC));
+  CMD2_DL         ("d.tracker.has_usable",            std::bind(&torrent::tracker::TrackerControllerWrapper::has_usable_trackers, CMD2_BIND_TC));
+  CMD2_DL_LIST    ("d.tracker.insert",                std::bind(&download_tracker_insert, std::placeholders::_1, std::placeholders::_2));
+  CMD2_DL_VALUE_V ("d.tracker.send_scrape",           [](auto download, uint64_t arg) { download->tracker_controller().scrape_request(arg); });
+
+  CMD2_DL         ("d.directory",          CMD2_ON_FL(root_dir));
+  CMD2_DL_STRING_V("d.directory.set",      std::bind(&apply_d_directory, std::placeholders::_1, std::placeholders::_2));
+  CMD2_DL         ("d.directory_base",     CMD2_ON_FL(root_dir));
+  CMD2_DL_STRING_V("d.directory_base.set", std::bind(&core::Download::set_root_directory, std::placeholders::_1, std::placeholders::_2));
+
+  CMD2_DL         ("d.priority",     std::bind(&core::Download::priority, std::placeholders::_1));
+  CMD2_DL         ("d.priority_str", std::bind(&retrieve_d_priority_str, std::placeholders::_1));
+  CMD2_DL_VALUE_V ("d.priority.set", std::bind(&core::Download::set_priority, std::placeholders::_1, std::placeholders::_2));
+
+  // CMD2_DL         ("d.group",     std::bind(&torrent::resource_manager_entry::group,
+  //                                           std::bind(&torrent::ResourceManager::entry_at, torrent::resource_manager(),
+  //                                                     std::bind(&core::Download::main, std::placeholders::_1))));
+
+  // CMD2_DL_V       ("d.group.set", std::bind(&torrent::ResourceManager::set_group,
+  //                                           torrent::resource_manager(),
+  //                                           std::bind(&torrent::ResourceManager::find_throw, torrent::resource_manager(),
+  //                                                     std::bind(&core::Download::main, std::placeholders::_1)),
+  //                                           CG_GROUP_INDEX()));
+
+  CMD2_DL         ("d.group",      std::bind(&cg_d_group, std::placeholders::_1));
+  CMD2_DL         ("d.group.name", std::bind(&cg_d_group_name, std::placeholders::_1));
+  CMD2_DL_V       ("d.group.set",  std::bind(&cg_d_group_set, std::placeholders::_1, std::placeholders::_2));
+
+  CMD2_DL_LIST    ("f.multicall", std::bind(&f_multicall, std::placeholders::_1, std::placeholders::_2));
+  CMD2_DL_LIST    ("p.multicall", std::bind(&p_multicall, std::placeholders::_1, std::placeholders::_2));
+  CMD2_DL_LIST    ("t.multicall", std::bind(&t_multicall, std::placeholders::_1, std::placeholders::_2));
+
+  CMD2_ANY_LIST   ("p.call_target", std::bind(&p_call_target, std::placeholders::_2));
+}

src/command_dynamic.cc

@@ -0,0 +1,460 @@
+#include "config.h"
+
+#include <algorithm>
+#include <torrent/utils/log.h>
+#include <torrent/utils/option_strings.h>
+
+#include "command_helpers.h"
+#include "control.h"
+#include "globals.h"
+#include "rpc/parse.h"
+#include "rpc/parse_options.h"
+
+static std::vector<std::pair<const char*, int>> object_storage_flags = {
+  {"multi", rpc::object_storage::flag_multi_type},
+  {"simple", rpc::object_storage::flag_function_type},
+  {"value", rpc::object_storage::flag_value_type},
+  {"bool", rpc::object_storage::flag_bool_type},
+  {"string", rpc::object_storage::flag_string_type},
+  {"list", rpc::object_storage::flag_list_type},
+
+  {"static", rpc::object_storage::flag_static},
+  {"private", rpc::object_storage::flag_private},
+  {"const", rpc::object_storage::flag_constant},
+  {"rlookup", rpc::object_storage::flag_rlookup}};
+
+static int
+object_storage_parse_flag(const std::string& flag) {
+  for (auto f : object_storage_flags)
+    if (f.first == flag)
+      return f.second;
+
+  throw torrent::input_error("unknown flag");
+}
+
+std::string
+system_method_generate_command(torrent::Object::list_const_iterator first, torrent::Object::list_const_iterator last) {
+  std::string command;
+
+  while (first != last) {
+    if (!command.empty())
+      command += " ;";
+
+    command += (first++)->as_string();
+  }
+
+  return command;
+}
+
+void
+system_method_generate_command2(torrent::Object* object, torrent::Object::list_const_iterator first, torrent::Object::list_const_iterator last) {
+  if (first == last) {
+    // TODO: Use empty object.
+    *object = "";
+    return;
+  }
+
+  if (first->is_string()) {
+    std::string command;
+
+    while (first != last) {
+      if (!command.empty())
+        command += " ;";
+
+      command += (first++)->as_string();
+    }
+
+    *object = command;
+
+    return;
+  }
+
+  if (first + 1 == last) {
+    if (!first->is_dict_key())
+      throw torrent::input_error("New command of wrong type.");
+
+    *object = *first;
+
+    uint32_t flags = object->flags() & torrent::Object::mask_function;
+    object->unset_flags(torrent::Object::mask_function);
+    object->set_flags((flags >> 1) & torrent::Object::mask_function);
+
+  } else {
+    *object = torrent::Object::create_list();
+
+    while (first != last) {
+      if (!first->is_dict_key())
+        throw torrent::input_error("New command of wrong type.");
+
+      object->as_list().push_back(*first++);
+
+      uint32_t flags = object->as_list().back().flags() & torrent::Object::mask_function;
+      object->as_list().back().unset_flags(torrent::Object::mask_function);
+      object->as_list().back().set_flags((flags >> 1) & torrent::Object::mask_function);
+    }
+  }
+}
+
+// torrent::Object
+// system_method_insert_function(const torrent::Object::list_type& args, int flags) {
+
+// }
+
+// This is only used by tinyxml2, xmlrpc-c intercepts the call internally
+torrent::Object
+system_listMethods() {
+  torrent::Object resultRaw = torrent::Object::create_list();
+  torrent::Object::list_type& result = resultRaw.as_list();
+  result.push_back("system.multicall"); // Handled directly by the XMLRPC code
+  for (auto itr : rpc::commands) {
+    result.push_back(itr.first);
+  }
+  return resultRaw;
+}
+
+torrent::Object
+system_method_insert_object(const torrent::Object::list_type& args, int flags) {
+  if (args.empty())
+    throw torrent::input_error("Invalid argument count.");
+
+  torrent::Object::list_const_iterator itrArgs = args.begin();
+  const std::string&                   raw_key = (itrArgs++)->as_string();
+
+  if (raw_key.empty() ||
+      control->object_storage()->find_raw_string(torrent::raw_string::from_string(raw_key)) != control->object_storage()->end() ||
+      rpc::commands.has(raw_key) || rpc::commands.has(raw_key + ".set"))
+    throw torrent::input_error("Invalid key.");
+
+  torrent::Object value;
+
+  switch (flags & rpc::object_storage::mask_type) {
+  case rpc::object_storage::flag_bool_type:
+  case rpc::object_storage::flag_value_type:
+    value = itrArgs != args.end() ? rpc::convert_to_value(*itrArgs) : int64_t();
+    break;
+  case rpc::object_storage::flag_string_type:
+    value = itrArgs != args.end() ? rpc::convert_to_string(*itrArgs) : "";
+    break;
+  case rpc::object_storage::flag_function_type:
+    system_method_generate_command2(&value, itrArgs, args.end());
+    break;
+  case rpc::object_storage::flag_list_type:
+    break;
+  case rpc::object_storage::flag_multi_type:
+    break;
+  default:
+    throw torrent::input_error("Invalid type.");
+  }
+
+  int cmd_flags = 0;
+
+  if (!(flags & rpc::object_storage::flag_static))
+    cmd_flags |= rpc::CommandMap::flag_modifiable;
+  if (!(flags & rpc::object_storage::flag_private))
+    cmd_flags |= rpc::CommandMap::flag_public_rpc;
+
+  if ((flags & rpc::object_storage::mask_type) == rpc::object_storage::flag_list_type) {
+    torrent::Object             valueList     = torrent::Object::create_list();
+    torrent::Object::list_type& valueListType = valueList.as_list();
+
+    if ((itrArgs)->is_list())
+      valueListType = (itrArgs)->as_list();
+
+    control->object_storage()->insert_str(raw_key, valueList, flags);
+  } else {
+    control->object_storage()->insert_str(raw_key, value, flags);
+  }
+
+  if ((flags & rpc::object_storage::mask_type) == rpc::object_storage::flag_function_type ||
+      (flags & rpc::object_storage::mask_type) == rpc::object_storage::flag_multi_type) {
+
+    rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call<rpc::target_type>>::type>(
+      raw_key,
+      std::bind(&rpc::object_storage::call_function_str, control->object_storage(), raw_key, std::placeholders::_1, std::placeholders::_2),
+      &rpc::command_base_call<rpc::target_type>,
+      cmd_flags,
+      NULL,
+      NULL);
+
+  } else {
+    rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call<rpc::target_type>>::type>(
+      raw_key,
+      std::bind(&rpc::object_storage::get_str, control->object_storage(), raw_key),
+      &rpc::command_base_call<rpc::target_type>,
+      cmd_flags,
+      NULL,
+      NULL);
+  }
+
+  // Not the right argument.
+  // if (flags & rpc::object_storage::flag_rlookup) {
+  //   rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call_string<rpc::target_type> >::type>
+  //     (create_new_key<9>(raw_key, ".rlookup"),
+  //      std::bind(&rpc::object_storage::rlookup_obj_list, control->object_storage(), raw_key),
+  //      &rpc::command_base_call_string<rpc::target_type>,
+  //      cmd_flags, NULL, NULL);
+  // }
+
+  // TODO: Next... Make test class for this.
+
+  //   // Ehm... no proper handling if these throw.
+
+  if (!(flags & rpc::object_storage::flag_constant)) {
+    switch (flags & rpc::object_storage::mask_type) {
+    case rpc::object_storage::flag_bool_type:
+      rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call_value<rpc::target_type>>::type>(
+        raw_key + ".set",
+        std::bind(&rpc::object_storage::set_str_bool, control->object_storage(), raw_key, std::placeholders::_2),
+        &rpc::command_base_call_value<rpc::target_type>,
+        cmd_flags,
+        NULL,
+        NULL);
+      break;
+    case rpc::object_storage::flag_value_type:
+      rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call_value<rpc::target_type>>::type>(
+        raw_key + ".set",
+        std::bind(&rpc::object_storage::set_str_value, control->object_storage(), raw_key, std::placeholders::_2),
+        &rpc::command_base_call_value<rpc::target_type>,
+        cmd_flags,
+        NULL,
+        NULL);
+      break;
+    case rpc::object_storage::flag_string_type:
+      rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call_string<rpc::target_type>>::type>(
+        raw_key + ".set",
+        std::bind(&rpc::object_storage::set_str_string, control->object_storage(), raw_key, std::placeholders::_2),
+        &rpc::command_base_call_string<rpc::target_type>,
+        cmd_flags,
+        NULL,
+        NULL);
+      break;
+    case rpc::object_storage::flag_list_type:
+      rpc::commands.insert_slot<rpc::command_base_is_type<rpc::command_base_call_list<rpc::target_type>>::type>(
+        raw_key + ".set",
+        std::bind(&rpc::object_storage::set_str_list, control->object_storage(), raw_key, std::placeholders::_2),
+        &rpc::command_base_call_list<rpc::target_type>,
+        cmd_flags,
+        NULL,
+        NULL);
+      break;
+    case rpc::object_storage::flag_function_type:
+    case rpc::object_storage::flag_multi_type:
+    default:
+      break;
+    }
+  }
+
+  return torrent::Object();
+}
+
+// method.insert <generic> {name, "simple|private|const", ...}
+// method.insert <generic> {name, "multi|private|const"}
+// method.insert <generic> {name, "value|private|const"}
+// method.insert <generic> {name, "value|private|const", value}
+// method.insert <generic> {name, "bool|private|const"}
+// method.insert <generic> {name, "bool|private|const", bool}
+// method.insert <generic> {name, "string|private|const"}
+// method.insert <generic> {name, "string|private|const", string}
+//
+// Add a new user-defined method called 'name' and any number of
+// lines.
+//
+// TODO: Make a static version of this that doesn't need to be called
+// as a command, and which takes advantage of static const char
+// strings, etc.
+torrent::Object
+system_method_insert(const torrent::Object::list_type& args) {
+  if (args.empty() || ++args.begin() == args.end())
+    throw torrent::input_error("Invalid argument count.");
+
+  torrent::Object::list_const_iterator itrArgs = args.begin();
+  const std::string&                   raw_key  = (itrArgs++)->as_string();
+
+  if (raw_key.empty() || rpc::commands.has(raw_key))
+    throw torrent::input_error("Invalid key.");
+
+  int new_flags = rpc::parse_option_flags(itrArgs->as_string(), std::bind(&object_storage_parse_flag, std::placeholders::_1));
+
+  torrent::Object::list_type new_args;
+  new_args.push_back(raw_key);
+
+  if ((new_flags & rpc::object_storage::flag_function_type) ||
+      (new_flags & rpc::object_storage::flag_multi_type)) {
+    new_args.push_back(system_method_generate_command(++itrArgs, args.end()));
+
+  } else if ((new_flags & rpc::object_storage::flag_value_type) ||
+             (new_flags & rpc::object_storage::flag_bool_type) ||
+             (new_flags & rpc::object_storage::flag_string_type) ||
+             (new_flags & rpc::object_storage::flag_list_type)) {
+    if (++itrArgs != args.end())
+      new_args.insert(new_args.end(), itrArgs, args.end());
+
+  } else {
+    throw torrent::input_error("No object type specified.");
+  }
+
+  return system_method_insert_object(new_args, new_flags);
+}
+
+// method.erase <> {name}
+//
+// Erase a modifiable method called 'name. Trying to remove methods
+// that aren't modifiable, e.g. defined by rtorrent or set to
+// read-only by the user, will result in an error.
+torrent::Object
+system_method_erase(const torrent::Object::string_type& args) {
+  rpc::CommandMap::iterator itr = rpc::commands.find(args.c_str());
+
+  if (itr == rpc::commands.end())
+    return torrent::Object();
+
+  if (!rpc::commands.is_modifiable(itr))
+    throw torrent::input_error("Command not modifiable.");
+
+  rpc::commands.erase(itr);
+
+  return torrent::Object();
+}
+
+torrent::Object
+system_method_redirect(const torrent::Object::list_type& args) {
+  if (args.size() != 2)
+    throw torrent::input_error("Invalid argument count.");
+
+  std::string new_key  = torrent::object_create_string(args.front());
+  std::string dest_key = torrent::object_create_string(args.back());
+
+  rpc::commands.create_redirect(new_key, dest_key, rpc::CommandMap::flag_public_rpc | rpc::CommandMap::flag_modifiable);
+
+  return torrent::Object();
+}
+
+torrent::Object
+system_method_set_function(const torrent::Object::list_type& args) {
+  if (args.empty())
+    throw torrent::input_error("Invalid argument count.");
+
+  rpc::object_storage::iterator itr =
+    control->object_storage()->find_raw_string(torrent::raw_string::from_string(args.front().as_string()));
+
+  if (itr == control->object_storage()->end() || itr->second.flags & rpc::object_storage::flag_constant)
+    throw torrent::input_error("Command is not modifiable.");
+
+  return control->object_storage()->set_str_function(args.front().as_string(),
+                                                     system_method_generate_command(++args.begin(), args.end()));
+}
+
+torrent::Object
+system_method_has_key(const torrent::Object::list_type& args) {
+  if (args.empty() || ++args.begin() == args.end())
+    throw torrent::input_error("Invalid argument count.");
+
+  torrent::Object::list_const_iterator itrArgs = args.begin();
+  const std::string&                   key     = (itrArgs++)->as_string();
+  const std::string&                   cmd_key = (itrArgs++)->as_string();
+
+  return control->object_storage()->has_str_multi_key(key, cmd_key);
+}
+
+torrent::Object
+system_method_set_key(const torrent::Object::list_type& args) {
+  if (args.empty() || ++args.begin() == args.end())
+    throw torrent::input_error("Invalid argument count.");
+
+  torrent::Object::list_const_iterator itrArgs = args.begin();
+  const std::string&                   key     = (itrArgs++)->as_string();
+  const std::string&                   cmd_key = (itrArgs++)->as_string();
+
+  if (itrArgs == args.end()) {
+    control->object_storage()->erase_str_multi_key(key, cmd_key);
+    return torrent::Object();
+  }
+
+  if (itrArgs->is_dict_key() || itrArgs->is_list())
+    control->object_storage()->set_str_multi_key_obj(key.c_str(), cmd_key, *itrArgs);
+  else
+    control->object_storage()->set_str_multi_key(key, cmd_key, system_method_generate_command(itrArgs, args.end()));
+
+  return torrent::Object();
+}
+
+torrent::Object
+system_method_list_keys(const torrent::Object::string_type& args) {
+  const torrent::Object::map_type& multi_cmd = control->object_storage()->get_str(args).as_map();
+
+  torrent::Object                  rawResult = torrent::Object::create_list();
+  torrent::Object::list_type&      result    = rawResult.as_list();
+
+  for (torrent::Object::map_const_iterator itr = multi_cmd.begin(), last = multi_cmd.end(); itr != last; itr++)
+    result.push_back(itr->first);
+
+  return rawResult;
+}
+
+torrent::Object
+cmd_catch(rpc::target_type target, const torrent::Object& args) {
+  try {
+    return rpc::call_object(args, target);
+  } catch (torrent::input_error& e) {
+    lt_log_print(torrent::LOG_WARN, "Caught exception: '%s'.", e.what());
+    return torrent::Object();
+  }
+}
+
+#define CMD2_METHOD_INSERT(key, flags) \
+  CMD2_ANY_LIST(key, std::bind(&system_method_insert_object, std::placeholders::_2, flags));
+
+void
+initialize_command_dynamic() {
+  // clang-format off
+#ifdef HAVE_XMLRPC_TINYXML2
+  CMD2_ANY         ("system.listMethods", std::bind(&system_listMethods)); // only used by tinyxml2
+#endif
+
+  // Keep these for future use when we deprecate more commands.
+  CMD2_VAR_BOOL    ("method.use_deprecated", false);
+  CMD2_VAR_VALUE   ("method.use_intermediate", 0);
+
+  CMD2_ANY_LIST    ("method.insert",             std::bind(&system_method_insert, std::placeholders::_2));
+  CMD2_ANY_LIST    ("method.insert.value",       std::bind(&system_method_insert_object, std::placeholders::_2, rpc::object_storage::flag_value_type));
+  CMD2_ANY_LIST    ("method.insert.bool",        std::bind(&system_method_insert_object, std::placeholders::_2, rpc::object_storage::flag_bool_type));
+  CMD2_ANY_LIST    ("method.insert.string",      std::bind(&system_method_insert_object, std::placeholders::_2, rpc::object_storage::flag_string_type));
+  CMD2_ANY_LIST    ("method.insert.list",        std::bind(&system_method_insert_object, std::placeholders::_2, rpc::object_storage::flag_list_type));
+
+  CMD2_METHOD_INSERT("method.insert.simple",     rpc::object_storage::flag_function_type);
+  CMD2_METHOD_INSERT("method.insert.c_simple",   rpc::object_storage::flag_constant | rpc::object_storage::flag_function_type);
+  CMD2_METHOD_INSERT("method.insert.s_c_simple", rpc::object_storage::flag_static |
+                     rpc::object_storage::flag_constant |rpc::object_storage::flag_function_type);
+
+  CMD2_ANY_STRING  ("method.erase",     std::bind(&system_method_erase, std::placeholders::_2));
+  CMD2_ANY_LIST    ("method.redirect",  std::bind(&system_method_redirect, std::placeholders::_2));
+  CMD2_ANY_STRING  ("method.get",       std::bind(&rpc::object_storage::get_str, control->object_storage(),
+                                                       std::placeholders::_2));
+  CMD2_ANY_LIST    ("method.set",       std::bind(&system_method_set_function, std::placeholders::_2));
+
+  CMD2_ANY_STRING  ("method.const",        std::bind(&rpc::object_storage::has_flag_str, control->object_storage(),
+                                                      std::placeholders::_2, rpc::object_storage::flag_constant));
+  CMD2_ANY_STRING_V("method.const.enable", std::bind(&rpc::object_storage::enable_flag_str, control->object_storage(),
+                                                     std::placeholders::_2, rpc::object_storage::flag_constant));
+
+  CMD2_ANY_LIST    ("method.has_key",   std::bind(&system_method_has_key, std::placeholders::_2));
+  CMD2_ANY_LIST    ("method.set_key",   std::bind(&system_method_set_key, std::placeholders::_2));
+  CMD2_ANY_STRING  ("method.list_keys", std::bind(&system_method_list_keys, std::placeholders::_2));
+
+  CMD2_ANY_STRING  ("method.rlookup",       std::bind(&rpc::object_storage::rlookup_obj_list, control->object_storage(), std::placeholders::_2));
+  CMD2_ANY_STRING_V("method.rlookup.clear", std::bind(&rpc::object_storage::rlookup_clear, control->object_storage(), std::placeholders::_2));
+
+  CMD2_ANY         ("catch", std::bind(&cmd_catch, std::placeholders::_1, std::placeholders::_2));
+
+  CMD2_ANY         ("strings.choke_heuristics",          std::bind(&torrent::option_list_strings, torrent::OPTION_CHOKE_HEURISTICS));
+  CMD2_ANY         ("strings.choke_heuristics.upload",   std::bind(&torrent::option_list_strings, torrent::OPTION_CHOKE_HEURISTICS_UPLOAD));
+  CMD2_ANY         ("strings.choke_heuristics.download", std::bind(&torrent::option_list_strings, torrent::OPTION_CHOKE_HEURISTICS_DOWNLOAD));
+  CMD2_ANY         ("strings.connection_type",           std::bind(&torrent::option_list_strings, torrent::OPTION_CONNECTION_TYPE));
+  CMD2_ANY         ("strings.encryption",                std::bind(&torrent::option_list_strings, torrent::OPTION_ENCRYPTION));
+  CMD2_ANY         ("strings.ip_filter",                 std::bind(&torrent::option_list_strings, torrent::OPTION_IP_FILTER));
+  CMD2_ANY         ("strings.ip_tos",                    std::bind(&torrent::option_list_strings, torrent::OPTION_IP_TOS));
+  CMD2_ANY         ("strings.log_group",                 std::bind(&torrent::option_list_strings, torrent::OPTION_LOG_GROUP));
+  CMD2_ANY         ("strings.tracker_event",             std::bind(&torrent::option_list_strings, torrent::OPTION_TRACKER_EVENT));
+  CMD2_ANY         ("strings.tracker_mode",              std::bind(&torrent::option_list_strings, torrent::OPTION_TRACKER_MODE));
+  // clang-format on
+}

src/command_events.cc

@@ -0,0 +1,351 @@
+#include "config.h"
+
+#include <functional>
+#include <cstdio>
+#include <rak/error_number.h>
+#include <rak/file_stat.h>
+#include <rak/path.h>
+#include <rak/string_manip.h>
+#include <torrent/rate.h>
+#include <torrent/hash_string.h>
+#include <torrent/utils/log.h>
+#include <torrent/utils/directory_events.h>
+
+#include "globals.h"
+#include "control.h"
+#include "command_helpers.h"
+#include "core/download.h"
+#include "core/download_list.h"
+#include "core/manager.h"
+#include "core/view_manager.h"
+#include "rpc/command_scheduler.h"
+#include "rpc/parse.h"
+#include "rpc/parse_commands.h"
+
+torrent::Object
+apply_on_ratio(const torrent::Object& rawArgs) {
+  auto& group_name = rawArgs.as_string();
+  auto  view_itr = control->view_manager()->find(rpc::commands.call("group2." + group_name + ".view", rpc::make_target()).as_string());
+
+  if (view_itr == control->view_manager()->end())
+    throw torrent::input_error("Could not find view.");
+
+  // first argument:  minimum ratio to reach
+  // second argument: minimum upload amount to reach [optional]
+  // third argument:  maximum ratio to reach [optional]
+  int64_t min_ratio  = rpc::commands.call("group2." + group_name + ".ratio.min", rpc::make_target()).as_value();
+  int64_t max_ratio  = rpc::commands.call("group2." + group_name + ".ratio.max", rpc::make_target()).as_value();
+  int64_t min_upload = rpc::commands.call("group2." + group_name + ".ratio.upload", rpc::make_target()).as_value();
+
+  std::vector<core::Download*> downloads;
+
+  for  (auto itr = (*view_itr)->begin_visible(), last = (*view_itr)->end_visible(); itr != last; itr++) {
+    if (!(*itr)->is_seeding() || rpc::call_command_value("d.ignore_commands", rpc::make_target(*itr)) != 0)
+      continue;
+
+    int64_t total_done   = (*itr)->download()->bytes_done();
+    int64_t total_upload = (*itr)->info()->up_rate()->total();
+
+    if (!(total_upload >= min_upload && total_upload * 100 >= total_done * min_ratio) &&
+        !(max_ratio > 0 && total_upload * 100 > total_done * max_ratio))
+      continue;
+
+    downloads.push_back(*itr);
+  }
+
+  auto ratio_command = "group." + group_name + ".ratio.command";
+
+  for (std::vector<core::Download*>::iterator itr = downloads.begin(), last = downloads.end(); itr != last; itr++)
+    rpc::commands.call_catch(ratio_command, rpc::make_target(*itr), torrent::Object(), "Ratio reached, but command failed: ");
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_start_tied() {
+  for (auto itr = control->core()->download_list()->begin(); itr != control->core()->download_list()->end(); ++itr) {
+    if (rpc::call_command_value("d.state", rpc::make_target(*itr)) == 1)
+      continue;
+
+    rak::file_stat fs;
+    const std::string& tied_to_file = rpc::call_command_string("d.tied_to_file", rpc::make_target(*itr));
+
+    if (!tied_to_file.empty() && fs.update(rak::path_expand(tied_to_file)))
+      rpc::parse_command_single(rpc::make_target(*itr), "d.try_start=");
+  }
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_stop_untied() {
+  for (auto itr = control->core()->download_list()->begin(); itr != control->core()->download_list()->end(); ++itr) {
+    if (rpc::call_command_value("d.state", rpc::make_target(*itr)) == 0)
+      continue;
+
+    rak::file_stat fs;
+    const std::string& tied_to_file = rpc::call_command_string("d.tied_to_file", rpc::make_target(*itr));
+
+    if (!tied_to_file.empty() && !fs.update(rak::path_expand(tied_to_file)))
+      rpc::parse_command_single(rpc::make_target(*itr), "d.try_stop=");
+  }
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_close_untied() {
+  for (auto itr = control->core()->download_list()->begin(); itr != control->core()->download_list()->end(); ++itr) {
+    rak::file_stat fs;
+    const std::string& tied_to_file = rpc::call_command_string("d.tied_to_file", rpc::make_target(*itr));
+
+    if (rpc::call_command_value("d.ignore_commands", rpc::make_target(*itr)) == 0 && !tied_to_file.empty() && !fs.update(rak::path_expand(tied_to_file)))
+      rpc::parse_command_single(rpc::make_target(*itr), "d.try_close=");
+  }
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_remove_untied() {
+  for (auto itr = control->core()->download_list()->begin(); itr != control->core()->download_list()->end(); ) {
+    rak::file_stat fs;
+    const std::string& tied_to_file = rpc::call_command_string("d.tied_to_file", rpc::make_target(*itr));
+
+    if (!tied_to_file.empty() && !fs.update(rak::path_expand(tied_to_file))) {
+      // Need to clear tied_to_file so it doesn't try to delete it.
+      rpc::call_command("d.tied_to_file.set", std::string(), rpc::make_target(*itr));
+
+      itr = control->core()->download_list()->erase(itr);
+
+    } else {
+      ++itr;
+    }
+  }
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_schedule(const torrent::Object::list_type& args) {
+  if (args.size() != 4)
+    throw torrent::input_error("Wrong number of arguments.");
+
+  torrent::Object::list_const_iterator itr = args.begin();
+
+  auto& arg1 = (itr++)->as_string();
+  auto& arg2 = (itr++)->as_string();
+  auto& arg3 = (itr++)->as_string();
+
+  control->command_scheduler()->parse(arg1, arg2, arg3, *itr);
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_load(const torrent::Object::list_type& args, int flags) {
+  torrent::Object::list_const_iterator argsItr = args.begin();
+
+  if (argsItr == args.end())
+    throw torrent::input_error("Too few arguments.");
+
+  auto& filename = argsItr->as_string();
+  core::Manager::command_list_type commands;
+
+  while (++argsItr != args.end())
+    commands.push_back(argsItr->as_string());
+
+  control->core()->try_create_download_expand(filename, flags, commands);
+
+  return torrent::Object();
+}
+
+void apply_import(const std::string& path)     { if (!rpc::parse_command_file(path)) throw torrent::input_error("Could not open option file: " + path); }
+void apply_try_import(const std::string& path) { if (!rpc::parse_command_file(path)) control->core()->push_log_std("Could not read resource file: " + path); }
+
+torrent::Object
+apply_close_low_diskspace(int64_t arg, uint32_t skip_priority) {
+  bool closed = false;
+
+  for (auto download : *control->core()->download_list()) {
+    if (!download->is_downloading())
+      continue;
+    if (download->priority() >= skip_priority)
+      continue;
+    if (download->file_list()->free_diskspace() >= (uint64_t)arg)
+      continue;
+
+    control->core()->download_list()->close(download);
+
+    download->set_hash_failed(true);
+    download->set_message(std::string("Low diskspace."));
+
+    closed = true;
+  }
+
+  if (closed)
+    lt_log_print(torrent::LOG_TORRENT_ERROR, "Closed torrents due to low diskspace.");
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_download_list(const torrent::Object::list_type& args) {
+  torrent::Object::list_const_iterator argsItr = args.begin();
+
+  core::ViewManager* viewManager = control->view_manager();
+  core::ViewManager::iterator view_itr;
+
+  if (argsItr != args.end() && !argsItr->as_string().empty())
+    view_itr = viewManager->find((argsItr++)->as_string());
+  else
+    view_itr = viewManager->find("default");
+
+  if (view_itr == viewManager->end())
+    throw torrent::input_error("Could not find view.");
+
+  torrent::Object result = torrent::Object::create_list();
+  torrent::Object::list_type& resultList = result.as_list();
+
+  for (core::View::const_iterator itr = (*view_itr)->begin_visible(), last = (*view_itr)->end_visible(); itr != last; itr++) {
+    const torrent::HashString* hashString = &(*itr)->info()->hash();
+
+    resultList.push_back(rak::transform_hex(hashString->begin(), hashString->end()));
+  }
+
+  return result;
+}
+
+torrent::Object
+d_multicall(const torrent::Object::list_type& args) {
+  if (args.empty())
+    throw torrent::input_error("Too few arguments.");
+
+  core::ViewManager* viewManager = control->view_manager();
+  core::ViewManager::iterator view_itr;
+
+  if (!args.front().as_string().empty())
+    view_itr = viewManager->find(args.front().as_string());
+  else
+    view_itr = viewManager->find("default");
+
+  if (view_itr == viewManager->end())
+    throw torrent::input_error("Could not find view.");
+
+  // Add some pre-parsing of the commands, so we don't spend time
+  // parsing and searching command map for every single call.
+  std::vector<core::Download*> dlist((*view_itr)->size_visible());
+
+  std::copy((*view_itr)->begin_visible(), (*view_itr)->end_visible(), dlist.data());
+
+  torrent::Object             resultRaw = torrent::Object::create_list();
+  torrent::Object::list_type& result = resultRaw.as_list();
+
+  for (auto download : dlist) {
+    torrent::Object::list_type& row = result.insert(result.end(), torrent::Object::create_list())->as_list();
+
+    for (torrent::Object::list_const_iterator cItr = ++args.begin(); cItr != args.end(); cItr++) {
+      auto& cmd = cItr->as_string();
+      row.push_back(rpc::parse_command(rpc::make_target(download), cmd.c_str(), cmd.c_str() + cmd.size()).first);
+    }
+  }
+
+  return resultRaw;
+}
+
+torrent::Object
+d_multicall_filtered(const torrent::Object::list_type& args) {
+  if (args.size() < 2)
+    throw torrent::input_error("d.multicall.filtered requires at least 2 arguments.");
+  torrent::Object::list_const_iterator arg = args.begin();
+
+  // Find the given view
+  core::ViewManager* viewManager = control->view_manager();
+  core::ViewManager::iterator view_itr = viewManager->find(arg->as_string().empty() ? "default" : arg->as_string());
+
+  if (view_itr == viewManager->end())
+    throw torrent::input_error("Could not find view '" + arg->as_string() + "'.");
+
+  // Make a filtered copy of the current item list
+  core::View::base_type dlist;
+  (*view_itr)->filter_by(*++arg, dlist);
+
+  // Generate result by iterating over all items
+  torrent::Object             resultRaw = torrent::Object::create_list();
+  torrent::Object::list_type& result = resultRaw.as_list();
+  ++arg;  // skip to first command
+
+  for (core::View::iterator item = dlist.begin(); item != dlist.end(); ++item) {
+    // Add empty row to result
+    torrent::Object::list_type& row = result.insert(result.end(), torrent::Object::create_list())->as_list();
+
+    // Call the provided commands and assemble their results
+    for (torrent::Object::list_const_iterator command = arg; command != args.end(); command++) {
+      auto& cmdstr = command->as_string();
+      row.push_back(rpc::parse_command(rpc::make_target(*item), cmdstr.c_str(), cmdstr.c_str() + cmdstr.size()).first);
+    }
+  }
+
+  return resultRaw;
+}
+
+static void
+call_watch_command(const std::string& command, const std::string& path) {
+  rpc::commands.call_catch(command.c_str(), rpc::make_target(), path);
+}
+
+torrent::Object
+directory_watch_added(const torrent::Object::list_type& args) {
+  if (args.size() != 2)
+    throw torrent::input_error("Too few arguments.");
+
+  auto& path = args.front().as_string();
+  auto& command = args.back().as_string();
+
+  if (!control->directory_events()->open())
+    throw torrent::input_error("Could not open inotify:" + std::string(rak::error_number::current().c_str()));
+
+  control->directory_events()->notify_on(path.c_str(),
+                                         torrent::directory_events::flag_on_added | torrent::directory_events::flag_on_updated,
+                                         std::bind(&call_watch_command, command, std::placeholders::_1));
+  return torrent::Object();
+}
+
+void
+initialize_command_events() {
+  CMD2_ANY_STRING  ("on_ratio",        std::bind(&apply_on_ratio, std::placeholders::_2));
+
+  CMD2_ANY         ("start_tied",      std::bind(&apply_start_tied));
+  CMD2_ANY         ("stop_untied",     std::bind(&apply_stop_untied));
+  CMD2_ANY         ("close_untied",    std::bind(&apply_close_untied));
+  CMD2_ANY         ("remove_untied",   std::bind(&apply_remove_untied));
+
+  // TODO: Deprecate schedule2 in the future.
+  CMD2_ANY_LIST    ("schedule",         std::bind(&apply_schedule, std::placeholders::_2));
+  CMD2_ANY_LIST    ("schedule2",        std::bind(&apply_schedule, std::placeholders::_2));
+  CMD2_ANY_STRING_V("schedule.remove",  std::bind(&rpc::CommandScheduler::erase_str, control->command_scheduler(), std::placeholders::_2));
+  CMD2_ANY_STRING_V("schedule_remove2", std::bind(&rpc::CommandScheduler::erase_str, control->command_scheduler(), std::placeholders::_2));
+
+  CMD2_ANY_STRING_V("import",          std::bind(&apply_import, std::placeholders::_2));
+  CMD2_ANY_STRING_V("try_import",      std::bind(&apply_try_import, std::placeholders::_2));
+
+  CMD2_ANY_LIST    ("load.normal",        std::bind(&apply_load, std::placeholders::_2, core::Manager::create_quiet | core::Manager::create_tied));
+  CMD2_ANY_LIST    ("load.verbose",       std::bind(&apply_load, std::placeholders::_2, core::Manager::create_tied));
+  CMD2_ANY_LIST    ("load.start",         std::bind(&apply_load, std::placeholders::_2,
+                                                         core::Manager::create_quiet | core::Manager::create_tied | core::Manager::create_start));
+  CMD2_ANY_LIST    ("load.start_verbose", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_tied  | core::Manager::create_start));
+  CMD2_ANY_LIST    ("load.raw",           std::bind(&apply_load, std::placeholders::_2, core::Manager::create_quiet | core::Manager::create_raw_data));
+  CMD2_ANY_LIST    ("load.raw_verbose",   std::bind(&apply_load, std::placeholders::_2, core::Manager::create_raw_data));
+  CMD2_ANY_LIST    ("load.raw_start",     std::bind(&apply_load, std::placeholders::_2,
+                                                         core::Manager::create_quiet | core::Manager::create_start | core::Manager::create_raw_data));
+  CMD2_ANY_LIST    ("load.raw_start_verbose", std::bind(&apply_load, std::placeholders::_2, core::Manager::create_start | core::Manager::create_raw_data));
+
+  CMD2_ANY_VALUE   ("close_low_diskspace",        std::bind(&apply_close_low_diskspace, std::placeholders::_2, 99));
+  CMD2_ANY_VALUE   ("close_low_diskspace.normal", std::bind(&apply_close_low_diskspace, std::placeholders::_2, 3));
+
+  CMD2_ANY_LIST    ("download_list",       std::bind(&apply_download_list, std::placeholders::_2));
+  CMD2_ANY_LIST    ("d.multicall2",        std::bind(&d_multicall, std::placeholders::_2));
+  CMD2_ANY_LIST    ("d.multicall.filtered", std::bind(&d_multicall_filtered, std::placeholders::_2));
+
+  CMD2_ANY_LIST    ("directory.watch.added", std::bind(&directory_watch_added, std::placeholders::_2));
+}

src/command_file.cc

@@ -0,0 +1,144 @@
+// rTorrent - BitTorrent client
+// Copyright (C) 2005-2011, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+#include "config.h"
+
+#include <rak/error_number.h>
+#include <rak/path.h>
+#include <torrent/data/file.h>
+#include <torrent/data/file_list.h>
+#include <torrent/data/file_list_iterator.h>
+
+#include "core/manager.h"
+
+#include "globals.h"
+#include "control.h"
+#include "command_helpers.h"
+
+void
+apply_f_set_priority(torrent::File* file, uint32_t value) {
+  if (value > torrent::PRIORITY_HIGH)
+    throw torrent::input_error("Invalid value.");
+
+  file->set_priority(static_cast<torrent::priority_enum>(value));
+}
+
+// TODO: Redundant.
+torrent::Object
+apply_f_path(torrent::File* file) {
+  if (file->path()->empty())
+    return std::string();
+
+  torrent::Object resultRaw(*file->path()->begin());
+  torrent::Object::string_type& result = resultRaw.as_string();
+
+  for (torrent::Path::const_iterator itr = ++file->path()->begin(), last = file->path()->end(); itr != last; itr++)
+    result += '/' + *itr;
+
+  return resultRaw;
+}
+
+torrent::Object
+apply_f_path_components(torrent::File* file) {
+  torrent::Object resultRaw = torrent::Object::create_list();
+  torrent::Object::list_type& result = resultRaw.as_list();
+
+  for (torrent::Path::const_iterator itr = file->path()->begin(), last = file->path()->end(); itr != last; itr++)
+    result.push_back(*itr);
+
+  return resultRaw;
+}
+
+torrent::Object
+apply_f_path_depth(torrent::File* file) {
+  return (int64_t)file->path()->size();
+}
+
+torrent::Object
+apply_fi_filename_last(torrent::FileListIterator* itr) {
+  if (itr->file()->path()->empty())
+    return "EMPTY";
+
+  if (itr->depth() >= itr->file()->path()->size())
+    return "ERROR";
+
+  return itr->file()->path()->at(itr->depth());
+}
+
+void
+initialize_command_file() {
+  CMD2_FILE("f.is_created",             std::bind(&torrent::File::is_created, std::placeholders::_1));
+  CMD2_FILE("f.is_open",                std::bind(&torrent::File::is_open, std::placeholders::_1));
+
+  CMD2_FILE("f.is_create_queued",       std::bind(&torrent::File::is_create_queued, std::placeholders::_1));
+  CMD2_FILE("f.is_resize_queued",       std::bind(&torrent::File::is_resize_queued, std::placeholders::_1));
+
+  CMD2_FILE_VALUE_V("f.set_create_queued",   std::bind(&torrent::File::set_flags,   std::placeholders::_1, torrent::File::flag_create_queued));
+  CMD2_FILE_VALUE_V("f.set_resize_queued",   std::bind(&torrent::File::set_flags,   std::placeholders::_1, torrent::File::flag_resize_queued));
+  CMD2_FILE_VALUE_V("f.unset_create_queued", std::bind(&torrent::File::unset_flags, std::placeholders::_1, torrent::File::flag_create_queued));
+  CMD2_FILE_VALUE_V("f.unset_resize_queued", std::bind(&torrent::File::unset_flags, std::placeholders::_1, torrent::File::flag_resize_queued));
+
+  CMD2_FILE  ("f.prioritize_first",         std::bind(&torrent::File::has_flags,   std::placeholders::_1, torrent::File::flag_prioritize_first));
+  CMD2_FILE_V("f.prioritize_first.enable",  std::bind(&torrent::File::set_flags,   std::placeholders::_1, torrent::File::flag_prioritize_first));
+  CMD2_FILE_V("f.prioritize_first.disable", std::bind(&torrent::File::unset_flags, std::placeholders::_1, torrent::File::flag_prioritize_first));
+  CMD2_FILE  ("f.prioritize_last",          std::bind(&torrent::File::has_flags,   std::placeholders::_1, torrent::File::flag_prioritize_last));
+  CMD2_FILE_V("f.prioritize_last.enable",   std::bind(&torrent::File::set_flags,   std::placeholders::_1, torrent::File::flag_prioritize_last));
+  CMD2_FILE_V("f.prioritize_last.disable",  std::bind(&torrent::File::unset_flags, std::placeholders::_1, torrent::File::flag_prioritize_last));
+
+  CMD2_FILE("f.size_bytes",             std::bind(&torrent::File::size_bytes, std::placeholders::_1));
+  CMD2_FILE("f.size_chunks",            std::bind(&torrent::File::size_chunks, std::placeholders::_1));
+  CMD2_FILE("f.completed_chunks",       std::bind(&torrent::File::completed_chunks, std::placeholders::_1));
+
+  CMD2_FILE("f.offset",                 std::bind(&torrent::File::offset, std::placeholders::_1));
+  CMD2_FILE("f.range_first",            std::bind(&torrent::File::range_first, std::placeholders::_1));
+  CMD2_FILE("f.range_second",           std::bind(&torrent::File::range_second, std::placeholders::_1));
+
+  CMD2_FILE("f.priority",               std::bind(&torrent::File::priority, std::placeholders::_1));
+  CMD2_FILE_VALUE_V("f.priority.set",   std::bind(&apply_f_set_priority, std::placeholders::_1, std::placeholders::_2));
+
+  CMD2_FILE("f.path",                   std::bind(&apply_f_path, std::placeholders::_1));
+  CMD2_FILE("f.path_components",        std::bind(&apply_f_path_components, std::placeholders::_1));
+  CMD2_FILE("f.path_depth",             std::bind(&apply_f_path_depth, std::placeholders::_1));
+  CMD2_FILE("f.frozen_path",            std::bind(&torrent::File::frozen_path, std::placeholders::_1));
+
+  CMD2_FILE("f.match_depth_prev",       std::bind(&torrent::File::match_depth_prev, std::placeholders::_1));
+  CMD2_FILE("f.match_depth_next",       std::bind(&torrent::File::match_depth_next, std::placeholders::_1));
+
+  CMD2_FILE("f.last_touched",           std::bind(&torrent::File::last_touched, std::placeholders::_1));
+
+  CMD2_FILEITR("fi.filename_last",      std::bind(&apply_fi_filename_last, std::placeholders::_1));
+  CMD2_FILEITR("fi.is_file",            std::bind(&torrent::FileListIterator::is_file, std::placeholders::_1));
+}

src/command_groups.cc

@@ -0,0 +1,389 @@
+#include "config.h"
+
+#include <torrent/download/resource_manager.h>
+#include <torrent/download/choke_group.h>
+#include <torrent/download/choke_queue.h>
+#include <torrent/utils/log.h>
+#include <torrent/utils/option_strings.h>
+
+#include "ui/root.h"
+#include "rpc/parse.h"
+#include "rpc/parse_commands.h"
+
+#include "globals.h"
+#include "control.h"
+#include "command_helpers.h"
+
+// For cg_d_group.
+#include "core/download.h"
+
+#define LT_LOG_SUBSYSTEM(log_fmt, ...)                                  \
+  lt_log_print_subsystem(torrent::LOG_TORRENT_INFO, "choke_queue", log_fmt, __VA_ARGS__);
+
+// A hack to allow testing of the new choke_group API without the
+// working parts present.
+#define USE_CHOKE_GROUP 0
+
+#if USE_CHOKE_GROUP
+
+int64_t
+cg_get_index(const torrent::Object& raw_args) {
+  const torrent::Object& arg = (raw_args.is_list() && !raw_args.as_list().empty()) ? raw_args.as_list().front() : raw_args;
+
+  int64_t index = 0;
+
+  if (arg.is_string()) {
+    if (!rpc::parse_whole_value_nothrow(arg.as_string().c_str(), &index))
+      return torrent::resource_manager()->group_index_of(arg.as_string());
+
+  } else {
+    index = arg.as_value();
+  }
+
+  if (index < 0)
+    index = (int64_t)torrent::resource_manager()->group_size() + index;
+
+  return std::min<uint64_t>(index, torrent::resource_manager()->group_size());
+}
+
+torrent::choke_group*
+cg_get_group(const torrent::Object& raw_args) {
+  return torrent::resource_manager()->group_at(cg_get_index(raw_args));
+}
+
+int64_t
+cg_d_group(core::Download* download) {
+  return torrent::resource_manager()->entry_at(download->main()).group();
+}
+
+const std::string&
+cg_d_group_name(core::Download* download) {
+  return torrent::resource_manager()->group_at(torrent::resource_manager()->entry_at(download->main()).group())->name();
+}
+
+void
+cg_d_group_set(core::Download* download, const torrent::Object& arg) {
+  torrent::resource_manager()->set_group(torrent::resource_manager()->find_throw(download->main()), cg_get_index(arg));
+}
+
+torrent::Object
+apply_cg_list() {
+  torrent::Object::list_type result;
+
+  for (torrent::ResourceManager::group_iterator
+         itr = torrent::resource_manager()->group_begin(),
+         last = torrent::resource_manager()->group_end(); itr != last; itr++)
+    result.push_back((*itr)->name());
+
+  return torrent::Object::from_list(result);
+}
+
+torrent::Object
+apply_cg_insert(const std::string& arg) {
+  int64_t dummy;
+
+  if (rpc::parse_whole_value_nothrow(arg.c_str(), &dummy))
+    throw torrent::input_error("Cannot use a value string as choke group name.");
+
+  torrent::resource_manager()->push_group(arg);
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_cg_all_update_balance(bool is_up) {
+  LT_LOG_SUBSYSTEM("apply update balance: resource_manager is_up:%i", (int)is_up);
+
+  for (torrent::ResourceManager::group_iterator
+         itr = torrent::resource_manager()->group_begin(),
+         last = torrent::resource_manager()->group_end(); itr != last; itr++) {
+    if (is_up)
+      itr->up_queue()->balance();
+    else
+      itr->down_queue()->balance();
+  }
+
+  return torrent::Object();
+}
+
+//
+// The hacked version:
+//
+#else
+
+std::vector<torrent::choke_group*> cg_list_hack;
+
+int64_t
+cg_get_index(const torrent::Object& raw_args) {
+  const torrent::Object& arg = (raw_args.is_list() && !raw_args.as_list().empty()) ? raw_args.as_list().front() : raw_args;
+
+  int64_t index = 0;
+
+  if (arg.is_string()) {
+    if (!rpc::parse_whole_value_nothrow(arg.as_string().c_str(), &index)) {
+      auto itr = std::find_if(cg_list_hack.begin(), cg_list_hack.end(), [&arg](torrent::choke_group* cg) { return arg.as_string() == cg->name(); });
+
+      if (itr == cg_list_hack.end())
+        throw torrent::input_error("Choke group not found.");
+
+      return std::distance(cg_list_hack.begin(), itr);
+    }
+
+  } else {
+    index = arg.as_value();
+  }
+
+  if (index < 0)
+    index = (int64_t)cg_list_hack.size() + index;
+
+  if ((size_t)index >= cg_list_hack.size())
+    throw torrent::input_error("Choke group not found.");
+
+  return index;
+}
+
+torrent::choke_group*
+cg_get_group(const torrent::Object& raw_args) {
+  int64_t index = cg_get_index(raw_args);
+
+  if ((size_t)index >= cg_list_hack.size())
+    throw torrent::input_error("Choke group not found.");
+
+  return cg_list_hack.at(index);
+}
+
+int64_t cg_d_group(core::Download* download) { return download->group(); }
+const std::string& cg_d_group_name(core::Download* download) {
+  return cg_list_hack.at(download->group())->name();
+}
+void    cg_d_group_set(core::Download* download, const torrent::Object& arg) { download->set_group(cg_get_index(arg)); }
+
+torrent::Object
+apply_cg_list() {
+  torrent::Object::list_type result;
+
+  for (auto itr : cg_list_hack)
+    result.push_back(itr->name());
+
+  return torrent::Object::from_list(result);
+}
+
+int
+cg_get_can_unchoke(torrent::choke_queue* cq) {
+  return cq->max_unchoked_signed() - (int)cq->size_unchoked();
+}
+
+torrent::Object
+apply_cg_insert(const std::string& arg) {
+  int64_t dummy;
+
+  if (rpc::parse_whole_value_nothrow(arg.c_str(), &dummy))
+    throw torrent::input_error("Cannot use a value string as choke group name.");
+
+  if (arg.empty() ||
+      std::find_if(cg_list_hack.begin(), cg_list_hack.end(), [&arg](torrent::choke_group* cg) { return arg == cg->name(); }) != cg_list_hack.end())
+    throw torrent::input_error("Duplicate name for choke group.");
+
+  cg_list_hack.push_back(new torrent::choke_group());
+  cg_list_hack.back()->set_name(arg);
+
+  cg_list_hack.back()->up_queue()->set_heuristics(torrent::choke_queue::HEURISTICS_UPLOAD_LEECH);
+  cg_list_hack.back()->down_queue()->set_heuristics(torrent::choke_queue::HEURISTICS_DOWNLOAD_LEECH);
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_cg_index_of(const std::string& arg) {
+  auto itr = std::find_if(cg_list_hack.begin(), cg_list_hack.end(), [&arg](torrent::choke_group* cg) { return arg == cg->name(); });
+
+  if (itr == cg_list_hack.end())
+    throw torrent::input_error("Choke group not found.");
+
+  return std::distance(cg_list_hack.begin(), itr);
+}
+
+torrent::Object
+apply_cg_all_update_balance(bool is_up) {
+  LT_LOG_SUBSYSTEM("apply update balance: hack is_up:%i", (int)is_up);
+
+  for (auto itr : cg_list_hack) {
+    if (is_up)
+      itr->up_queue()->balance();
+    else
+      itr->down_queue()->balance();
+  }
+
+  return torrent::Object();
+}
+
+//
+// End of choke group hack.
+//
+#endif
+
+
+torrent::Object
+apply_cg_max_set(const torrent::Object::list_type& args, bool is_up) {
+  if (args.size() != 2)
+    throw torrent::input_error("Incorrect number of arguments.");
+
+  int64_t second_arg = 0;
+  rpc::parse_whole_value(args.back().as_string().c_str(), &second_arg);
+
+  if (is_up)
+    cg_get_group(args.front())->up_queue()->set_max_unchoked(second_arg);
+  else
+    cg_get_group(args.front())->down_queue()->set_max_unchoked(second_arg);
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_cg_heuristics_set(const torrent::Object::list_type& args, bool is_up) {
+  if (args.size() != 2)
+    throw torrent::input_error("Incorrect number of arguments.");
+
+  int t = torrent::option_find_string(is_up ? torrent::OPTION_CHOKE_HEURISTICS_UPLOAD : torrent::OPTION_CHOKE_HEURISTICS_DOWNLOAD,
+                                      args.back().as_string().c_str());
+
+  if (is_up)
+    cg_get_group(args.front())->up_queue()->set_heuristics((torrent::choke_queue::heuristics_enum)t);
+  else
+    cg_get_group(args.front())->down_queue()->set_heuristics((torrent::choke_queue::heuristics_enum)t);
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_cg_tracker_mode_set(const torrent::Object::list_type& args) {
+  if (args.size() != 2)
+    throw torrent::input_error("Incorrect number of arguments.");
+
+  int t = torrent::option_find_string(torrent::OPTION_TRACKER_MODE, args.back().as_string().c_str());
+
+  cg_get_group(args.front())->set_tracker_mode((torrent::choke_group::tracker_mode_enum)t);
+
+  return torrent::Object();
+}
+
+#define CG_GROUP_AT()          std::bind(&cg_get_group, std::placeholders::_2)
+#define CHOKE_GROUP(direction) std::bind(direction, CG_GROUP_AT())
+
+/*
+
+<cg_index> -> '0'..'(choke_group.size)'
+           -> '-1'..'-(choke_group.size)'
+           -> '<group_name>'
+
+(choke_group.list) -> List of group names.
+(choke_group.size) -> Number of groups.
+
+(choke_group.insert,"group_name")
+
+Adds a new group with default settings, use index '-1' to accessing it
+immediately afterwards.
+
+(choke_group.index_of,"group_name") -> <group_index>
+
+Throws if the group name was not found.
+
+(choke_group.general.size,<cg_index>) -> <size>
+
+Number of torrents in this group.
+
+(choke_group.tracker.mode,<cg_index>) -> "tracker_mode"
+(choke_group.tracker.mode.set,<cg_index>,"tracker_mode")
+
+Decide on how aggressive a tracker should be, see
+'strings.tracker_mode' for list of available options
+
+(choke_group.up.rate,<cg_index>) -> <bytes/second>
+(choke_group.down.rate,<cg_index>) -> <bytes/second>
+
+Upload / download rate for the aggregate of all torrents in this
+particular group.
+
+(choke_group.up.max,<cg_index>) -> <max_upload_slots>
+(choke_group.up.max.unlimited,<cg_index>) -> <max_upload_slots>
+(choke_group.up.max.set,<cg_index>, <max_upload_slots>)
+(choke_group.down.max,<cg_index>) -> <max_download_slots>
+(choke_group.down.max.unlimited,<cg_index>) -> <max_download_slots>
+(choke_group.down.max.set,<cg_index>, <max_download_slots)
+
+Number of unchoked upload / download peers regulated on a group basis.
+
+(choke_group.up.total,<cg_index>) -> <number of queued and unchoked interested peers>
+(choke_group.up.queued,<cg_index>) -> <number of queued interested peers>
+(choke_group.up.unchoked,<cg_index>) -> <number of unchoked uploads>
+(choke_group.down.total,<cg_index>) -> <number of queued and unchoked interested peers>
+(choke_group.down.queued,<cg_index>) -> <number of queued interested peers>
+(choke_group.down.unchoked,<cg_index>) -> <number of unchoked uploads>
+
+(choke_group.up.heuristics,<cg_index>) -> "heuristics"
+(choke_group.up.heuristics.set,<cg_index>,"heuristics")
+(choke_group.down.heuristics,<cg_index>) -> "heuristics"
+(choke_group.down.heuristics.set,<cg_index>,"heuristics")
+
+Heuristics are used for deciding what peers to choke and unchoke, see
+'strings.choke_heuristics{,_download,_upload}' for a list of available
+options.
+
+(d.group) -> <choke_group_index>
+(d.group.name) -> "choke_group_name"
+(d.group.set,<cg_index>)
+
+ */
+
+
+void
+initialize_command_groups() {
+  CMD2_ANY         ("choke_group.list",                std::bind(&apply_cg_list));
+  CMD2_ANY_STRING  ("choke_group.insert",              std::bind(&apply_cg_insert, std::placeholders::_2));
+
+#if USE_CHOKE_GROUP
+  CMD2_ANY         ("choke_group.size",                std::bind(&torrent::ResourceManager::group_size, torrent::resource_manager()));
+  CMD2_ANY_STRING  ("choke_group.index_of",            std::bind(&torrent::ResourceManager::group_index_of, torrent::resource_manager(), std::placeholders::_2));
+#else
+  apply_cg_insert("default");
+
+  CMD2_ANY         ("choke_group.size",                std::bind(&std::vector<torrent::choke_group*>::size, cg_list_hack));
+  CMD2_ANY_STRING  ("choke_group.index_of",            std::bind(&apply_cg_index_of, std::placeholders::_2));
+#endif
+
+  // Commands specific for a group. Supports as the first argument the
+  // name, the index or a negative index.
+  CMD2_ANY         ("choke_group.general.size",        std::bind(&torrent::choke_group::size, CG_GROUP_AT()));
+
+  CMD2_ANY         ("choke_group.tracker.mode",        std::bind(&torrent::option_as_string, torrent::OPTION_TRACKER_MODE,
+                                                                 std::bind(&torrent::choke_group::tracker_mode, CG_GROUP_AT())));
+  CMD2_ANY_LIST    ("choke_group.tracker.mode.set",    std::bind(&apply_cg_tracker_mode_set, std::placeholders::_2));
+
+  CMD2_ANY         ("choke_group.all.up.update_balance",   std::bind(&apply_cg_all_update_balance, true));
+  CMD2_ANY         ("choke_group.all.down.update_balance", std::bind(&apply_cg_all_update_balance, false));
+
+  CMD2_ANY         ("choke_group.up.rate",             std::bind(&torrent::choke_group::up_rate, CG_GROUP_AT()));
+  CMD2_ANY         ("choke_group.down.rate",           std::bind(&torrent::choke_group::down_rate, CG_GROUP_AT()));
+
+  CMD2_ANY         ("choke_group.up.max.unlimited",    std::bind(&torrent::choke_queue::is_unlimited, CHOKE_GROUP(&torrent::choke_group::up_queue)));
+  CMD2_ANY         ("choke_group.up.max",              std::bind(&torrent::choke_queue::max_unchoked_signed, CHOKE_GROUP(&torrent::choke_group::up_queue)));
+  CMD2_ANY_LIST    ("choke_group.up.max.set",          std::bind(&apply_cg_max_set, std::placeholders::_2, true));
+
+  CMD2_ANY         ("choke_group.up.total",            std::bind(&torrent::choke_queue::size_total, CHOKE_GROUP(&torrent::choke_group::up_queue)));
+  CMD2_ANY         ("choke_group.up.queued",           std::bind(&torrent::choke_queue::size_queued, CHOKE_GROUP(&torrent::choke_group::up_queue)));
+  CMD2_ANY         ("choke_group.up.unchoked",         std::bind(&torrent::choke_queue::size_unchoked, CHOKE_GROUP(&torrent::choke_group::up_queue)));
+  CMD2_ANY         ("choke_group.up.heuristics",       std::bind(&torrent::option_as_string, torrent::OPTION_CHOKE_HEURISTICS,
+                                                                 std::bind(&torrent::choke_queue::heuristics, CHOKE_GROUP(&torrent::choke_group::up_queue))));
+  CMD2_ANY_LIST    ("choke_group.up.heuristics.set",   std::bind(&apply_cg_heuristics_set, std::placeholders::_2, true));
+
+  CMD2_ANY         ("choke_group.down.max.unlimited",  std::bind(&torrent::choke_queue::is_unlimited, CHOKE_GROUP(&torrent::choke_group::down_queue)));
+  CMD2_ANY         ("choke_group.down.max",            std::bind(&torrent::choke_queue::max_unchoked_signed, CHOKE_GROUP(&torrent::choke_group::down_queue)));
+  CMD2_ANY_LIST    ("choke_group.down.max.set",        std::bind(&apply_cg_max_set, std::placeholders::_2, false));
+
+  CMD2_ANY         ("choke_group.down.total",          std::bind(&torrent::choke_queue::size_total, CHOKE_GROUP(&torrent::choke_group::down_queue)));
+  CMD2_ANY         ("choke_group.down.queued",         std::bind(&torrent::choke_queue::size_queued, CHOKE_GROUP(&torrent::choke_group::down_queue)));
+  CMD2_ANY         ("choke_group.down.unchoked",       std::bind(&torrent::choke_queue::size_unchoked, CHOKE_GROUP(&torrent::choke_group::down_queue)));
+  CMD2_ANY         ("choke_group.down.heuristics",     std::bind(&torrent::option_as_string, torrent::OPTION_CHOKE_HEURISTICS,
+                                                                 std::bind(&torrent::choke_queue::heuristics, CHOKE_GROUP(&torrent::choke_group::down_queue))));
+  CMD2_ANY_LIST    ("choke_group.down.heuristics.set", std::bind(&apply_cg_heuristics_set, std::placeholders::_2, false));
+}

src/command_helpers.cc

@@ -0,0 +1,76 @@
+// rTorrent - BitTorrent client
+// Copyright (C) 2005-2011, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+#include "config.h"
+
+#include <torrent/exceptions.h>
+
+#include "globals.h"
+#include "control.h"
+#include "command_helpers.h"
+
+void initialize_command_dynamic();
+void initialize_command_download();
+void initialize_command_events();
+void initialize_command_file();
+void initialize_command_ip();
+void initialize_command_peer();
+void initialize_command_local();
+void initialize_command_logging();
+void initialize_command_network();
+void initialize_command_groups();
+void initialize_command_throttle();
+void initialize_command_tracker();
+void initialize_command_scheduler();
+void initialize_command_ui();
+
+void
+initialize_commands() {
+  initialize_command_dynamic();
+  initialize_command_events();
+  initialize_command_network();
+  initialize_command_groups();
+  initialize_command_local();
+  initialize_command_logging();
+  initialize_command_ui();
+  initialize_command_download();
+  initialize_command_file();
+  initialize_command_ip();
+  initialize_command_peer();
+  initialize_command_throttle();
+  initialize_command_tracker();
+  initialize_command_scheduler();
+}

src/command_helpers.h

@@ -0,0 +1,155 @@
+#ifndef RTORRENT_UTILS_COMMAND_HELPERS_H
+#define RTORRENT_UTILS_COMMAND_HELPERS_H
+
+#include "rpc/command.h"
+#include "rpc/parse_commands.h"
+#include "rpc/object_storage.h"
+
+void initialize_commands();
+
+//
+// New std::function based command_base helper functions:
+//
+
+#define CMD2_A_FUNCTION(key, function, slot, parm, doc)                 \
+  rpc::commands.insert_slot<rpc::command_base_is_type<rpc::function>::type>(key, slot, &rpc::function, \
+                            rpc::CommandMap::flag_dont_delete | rpc::CommandMap::flag_public_rpc, NULL, NULL);
+
+#define CMD2_A_FUNCTION_PRIVATE(key, function, slot, parm, doc)         \
+  rpc::commands.insert_slot<rpc::command_base_is_type<rpc::function>::type>(key, slot, &rpc::function,   \
+                            rpc::CommandMap::flag_dont_delete, NULL, NULL);
+
+#define CMD2_ANY(key, slot)          CMD2_A_FUNCTION(key, command_base_call<rpc::target_type>, slot, "i:", "")
+
+#define CMD2_ANY_P(key, slot)        CMD2_A_FUNCTION_PRIVATE(key, command_base_call<rpc::target_type>, slot, "i:", "")
+#define CMD2_ANY_VOID(key, slot)     CMD2_A_FUNCTION(key, command_base_call<rpc::target_type>, object_convert_void(slot), "i:", "")
+#define CMD2_ANY_V(key, slot)        CMD2_A_FUNCTION(key, command_base_call_list<rpc::target_type>, object_convert_void(slot), "i:", "")
+#define CMD2_ANY_L(key, slot)        CMD2_A_FUNCTION(key, command_base_call_list<rpc::target_type>, slot, "A:", "")
+
+#define CMD2_ANY_VALUE(key, slot)    CMD2_A_FUNCTION(key, command_base_call_value<rpc::target_type>, slot, "i:i", "")
+#define CMD2_ANY_VALUE_V(key, slot)  CMD2_A_FUNCTION(key, command_base_call_value<rpc::target_type>, object_convert_void(slot), "i:i", "")
+#define CMD2_ANY_VALUE_KB(key, slot) CMD2_A_FUNCTION(key, command_base_call_value_kb<rpc::target_type>, object_convert_void(slot), "i:i", "")
+
+#define CMD2_ANY_STRING(key, slot)   CMD2_A_FUNCTION(key, command_base_call_string<rpc::target_type>, slot, "i:s", "")
+#define CMD2_ANY_STRING_V(key, slot) CMD2_A_FUNCTION(key, command_base_call_string<rpc::target_type>, object_convert_void(slot), "i:s", "")
+
+#define CMD2_ANY_LIST(key, slot)     CMD2_A_FUNCTION(key, command_base_call_list<rpc::target_type>, slot, "i:", "")
+
+#define CMD2_DL(key, slot)           CMD2_A_FUNCTION(key, command_base_call<core::Download*>, slot, "i:", "")
+#define CMD2_DL_V(key, slot)         CMD2_A_FUNCTION(key, command_base_call<core::Download*>, object_convert_void(slot), "i:", "")
+#define CMD2_DL_VALUE(key, slot)     CMD2_A_FUNCTION(key, command_base_call_value<core::Download*>, slot, "i:", "")
+#define CMD2_DL_VALUE_V(key, slot)   CMD2_A_FUNCTION(key, command_base_call_value<core::Download*>, object_convert_void(slot), "i:", "")
+#define CMD2_DL_STRING(key, slot)    CMD2_A_FUNCTION(key, command_base_call_string<core::Download*>, slot, "i:", "")
+#define CMD2_DL_STRING_V(key, slot)  CMD2_A_FUNCTION(key, command_base_call_string<core::Download*>, object_convert_void(slot), "i:", "")
+#define CMD2_DL_LIST(key, slot)      CMD2_A_FUNCTION(key, command_base_call_list<core::Download*>, slot, "i:", "")
+
+#define CMD2_DL_VALUE_P(key, slot)   CMD2_A_FUNCTION_PRIVATE(key, command_base_call_value<core::Download*>, slot, "i:", "")
+#define CMD2_DL_STRING_P(key, slot)  CMD2_A_FUNCTION_PRIVATE(key, command_base_call_string<core::Download*>, slot, "i:", "")
+
+#define CMD2_FILE(key, slot)         CMD2_A_FUNCTION(key, command_base_call<torrent::File*>, slot, "i:", "")
+#define CMD2_FILE_V(key, slot)       CMD2_A_FUNCTION(key, command_base_call<torrent::File*>, object_convert_void(slot), "i:", "")
+#define CMD2_FILE_VALUE_V(key, slot) CMD2_A_FUNCTION(key, command_base_call_value<torrent::File*>, object_convert_void(slot), "i:i", "")
+
+#define CMD2_FILEITR(key, slot)         CMD2_A_FUNCTION(key, command_base_call<torrent::FileListIterator*>, slot, "i:", "")
+
+#define CMD2_PEER(key, slot)            CMD2_A_FUNCTION(key, command_base_call<torrent::Peer*>, slot, "i:", "")
+#define CMD2_PEER_V(key, slot)          CMD2_A_FUNCTION(key, command_base_call<torrent::Peer*>, object_convert_void(slot), "i:", "")
+#define CMD2_PEER_VALUE_V(key, slot)    CMD2_A_FUNCTION(key, command_base_call_value<torrent::Peer*>, object_convert_void(slot), "i:i", "")
+
+#define CMD2_TRACKER(key, slot)         CMD2_A_FUNCTION(key, command_base_call<torrent::tracker::Tracker*>, slot, "i:", "")
+#define CMD2_TRACKER_V(key, slot)       CMD2_A_FUNCTION(key, command_base_call<torrent::tracker::Tracker*>, object_convert_void(slot), "i:", "")
+#define CMD2_TRACKER_VALUE_V(key, slot) CMD2_A_FUNCTION(key, command_base_call_value<torrent::tracker::Tracker*>, object_convert_void(slot), "i:i", "")
+
+#define CMD2_VAR_BOOL(key, value)                                       \
+  control->object_storage()->insert_c_str(key, int64_t(value), rpc::object_storage::flag_bool_type); \
+  CMD2_ANY(key, std::bind(&rpc::object_storage::get, control->object_storage(), \
+                               torrent::raw_string::from_c_str(key)));  \
+  CMD2_ANY_VALUE(key ".set", std::bind(&rpc::object_storage::set_bool, control->object_storage(), \
+                                            torrent::raw_string::from_c_str(key), std::placeholders::_2));
+
+#define CMD2_VAR_VALUE(key, value)                                      \
+  control->object_storage()->insert_c_str(key, int64_t(value), rpc::object_storage::flag_value_type); \
+  CMD2_ANY(key, std::bind(&rpc::object_storage::get, control->object_storage(), \
+                               torrent::raw_string::from_c_str(key)));  \
+  CMD2_ANY_VALUE(key ".set", std::bind(&rpc::object_storage::set_value, control->object_storage(), \
+                                            torrent::raw_string::from_c_str(key), std::placeholders::_2));
+
+#define CMD2_VAR_STRING(key, value)                                     \
+  control->object_storage()->insert_c_str(key, value, rpc::object_storage::flag_string_type); \
+  CMD2_ANY(key, std::bind(&rpc::object_storage::get, control->object_storage(), \
+                               torrent::raw_string::from_c_str(key)));  \
+  CMD2_ANY_STRING(key ".set", std::bind(&rpc::object_storage::set_string, control->object_storage(), \
+                                             torrent::raw_string::from_c_str(key), std::placeholders::_2));
+
+
+#define CMD2_VAR_C_STRING(key, value)                                   \
+  control->object_storage()->insert_c_str(key, value, rpc::object_storage::flag_string_type); \
+  CMD2_ANY(key, std::bind(&rpc::object_storage::get, control->object_storage(), \
+                               torrent::raw_string::from_c_str(key)));
+
+#define CMD2_VAR_LIST(key)                                              \
+  control->object_storage()->insert_c_str(key, torrent::Object::create_list(), rpc::object_storage::flag_list_type); \
+  CMD2_ANY(key, std::bind(&rpc::object_storage::get, control->object_storage(), \
+                               torrent::raw_string::from_c_str(key)));  \
+  CMD2_ANY_LIST(key ".set", std::bind(&rpc::object_storage::set_list, control->object_storage(), \
+                                           torrent::raw_string::from_c_str(key), std::placeholders::_2)); \
+  CMD2_ANY_VOID(key ".push_back", std::bind(&rpc::object_storage::list_push_back, control->object_storage(), \
+                                                 torrent::raw_string::from_c_str(key), std::placeholders::_2));
+
+#define CMD2_FUNC_SINGLE(key, cmds)                                     \
+  CMD2_ANY(key, std::bind(&rpc::command_function_call_object, torrent::Object(torrent::raw_string::from_c_str(cmds)), \
+                               std::placeholders::_1, std::placeholders::_2));
+
+#define CMD2_REDIRECT(from_key, to_key) \
+  rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_public_rpc | rpc::CommandMap::flag_dont_delete);
+#define CMD2_REDIRECT_GENERIC(from_key, to_key) \
+  rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_public_rpc | rpc::CommandMap::flag_no_target | rpc::CommandMap::flag_dont_delete);
+#define CMD2_REDIRECT_GENERIC_NO_EXPORT(from_key, to_key) \
+  rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_no_target | rpc::CommandMap::flag_dont_delete);
+#define CMD2_REDIRECT_FILE(from_key, to_key) \
+  rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_public_rpc | rpc::CommandMap::flag_file_target | rpc::CommandMap::flag_dont_delete);
+#define CMD2_REDIRECT_TRACKER(from_key, to_key) \
+  rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_public_rpc | rpc::CommandMap::flag_tracker_target | rpc::CommandMap::flag_dont_delete);
+
+#define CMD2_REDIRECT_GENERIC_STR(from_key, to_key)                     \
+  rpc::commands.create_redirect(from_key, to_key, \
+                                rpc::CommandMap::flag_public_rpc | rpc::CommandMap::flag_no_target);
+
+#define CMD2_REDIRECT_GENERIC_STR_NO_EXPORT(from_key, to_key)                     \
+  rpc::commands.create_redirect(from_key, to_key, \
+                                rpc::CommandMap::flag_no_target);
+
+//
+// Conversion of return types:
+//
+
+template <typename Functor, typename Result>
+struct object_convert_type;
+
+template <typename Functor>
+struct object_convert_type<Functor, void> {
+
+  template <typename Signature> struct result {
+    typedef torrent::Object type;
+  };
+
+  object_convert_type(Functor s) : m_slot(s) {}
+
+  torrent::Object operator () () { m_slot(); return torrent::Object(); }
+  template <typename Arg1>
+  torrent::Object operator () (Arg1& arg1) { m_slot(arg1); return torrent::Object(); }
+  template <typename Arg1, typename Arg2>
+  torrent::Object operator () (const Arg1& arg1) { m_slot(arg1); return torrent::Object(); }
+  template <typename Arg1, typename Arg2>
+  torrent::Object operator () (Arg1& arg1, Arg2& arg2) { m_slot(arg1, arg2); return torrent::Object(); }
+  template <typename Arg1, typename Arg2>
+  torrent::Object operator () (const Arg1& arg1, const Arg2& arg2) { m_slot(arg1, arg2); return torrent::Object(); }
+
+  Functor m_slot;
+};
+
+template <typename T>
+object_convert_type<T, void>
+object_convert_void(T f) { return f; }
+
+#endif

src/command_ip.cc

@@ -0,0 +1,411 @@
+// rTorrent - BitTorrent client
+// Copyright (C) 2005-2011, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+#include "config.h"
+
+#include <fstream>
+#include <rak/path.h>
+#include <torrent/peer/peer_list.h>
+#include <torrent/utils/log.h>
+#include <torrent/utils/option_strings.h>
+
+#include "globals.h"
+#include "command_helpers.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+
+bool ipv4_range_parse(const char* address, uint32_t* address_start, uint32_t* address_end);
+
+torrent::Object
+apply_ip_tables_insert_table(const std::string& args) {
+  if (ip_tables.find(args) != ip_tables.end())
+    throw torrent::input_error("IP table already exists.");
+
+  ip_tables.insert(args);
+  return torrent::Object();
+}
+
+torrent::Object
+apply_ip_tables_size_data(const std::string& args) {
+  rpc::ip_table_list::const_iterator itr = ip_tables.find(args);
+
+  if (itr != ip_tables.end())
+    throw torrent::input_error("IP table does not exist.");
+
+  uint32_t size = itr->table.sizeof_data();
+  return size;
+}
+
+torrent::Object
+apply_ip_tables_get(const torrent::Object::list_type& args) {
+  if (args.size() != 2)
+    throw torrent::input_error("Incorrect number of arguments.");
+
+  torrent::Object::list_const_iterator args_itr = args.begin();
+
+  const std::string& name    = (args_itr++)->as_string();
+  const std::string& address = (args_itr++)->as_string();
+  uint32_t address_start;
+  uint32_t address_end;
+
+  rpc::ip_table_list::iterator table_itr = ip_tables.find(name);
+
+  if (table_itr == ip_tables.end())
+    throw torrent::input_error("Could not find ip table.");
+
+  if (!ipv4_range_parse(address.c_str(), &address_start, &address_end)) 
+    throw torrent::input_error("Invalid address format.");
+
+  if(!table_itr->table.defined(address_start, address_end))
+    throw torrent::input_error("No value defined for specified IP(s).");
+
+  return table_itr->table.at(address_start, address_end);
+}
+
+torrent::Object
+apply_ip_tables_add_address(const torrent::Object::list_type& args) {
+  if (args.size() != 3)
+    throw torrent::input_error("Incorrect number of arguments.");
+
+  torrent::Object::list_const_iterator args_itr = args.begin();
+
+  const std::string& name      = (args_itr++)->as_string();
+  const std::string& address   = (args_itr++)->as_string();
+  const std::string& value_str = (args_itr++)->as_string();
+
+  int value;
+
+  if (value_str == "block")
+    value = 1;
+  else
+    throw torrent::input_error("Invalid value.");
+
+  rpc::ip_table_list::iterator table_itr = ip_tables.find(name);
+
+  if (table_itr == ip_tables.end())
+    throw torrent::input_error("Could not find ip table.");
+
+  uint32_t address_start;
+  uint32_t address_end;
+
+  if (ipv4_range_parse(address.c_str(), &address_start, &address_end))
+    table_itr->table.insert(address_start, address_end, value);
+  else
+    throw torrent::input_error("Invalid address format.");
+
+  return torrent::Object();
+}
+
+//
+// IPv4 filter functions:
+//
+
+///////////////////////////////////////////////////////////
+// IPV4_RANGE_PARSE parses string into an ip range
+//
+// should be compatible with lines in p2p files
+// everything in address before colon is ignored
+//
+// ip range can be single ip in which case start=end
+// ip range can be cidr notation a.b.c.d/e
+// ip range can be explicit range like in p2p line a.b.c.d-w.x.y.z 
+//
+// returns false if line does not contain valid ip or ip range
+// address_start and address_end will contain start and end ip
+//
+// addresses parsed are returned in host byte order
+// to get network byte order call htonl(address)
+///////////////////////////////////////////////////////////
+bool
+ipv4_range_parse(const char* address, uint32_t* address_start, uint32_t* address_end) {
+  // same length as buffer used to do reads so no worries about overflow
+  char address_copy[4096];
+  bool valid = false;
+  char address_start_str[20];
+  int  address_start_index=0;
+  struct sockaddr_in sa_start;
+  *address_start=0;
+  *address_end=0;
+
+  // get rid of everything after '#' comments
+  // copy everything up to '#'  to address_copy and work from there
+  while(address[address_start_index] != '#' && address[address_start_index] != '\r' &&
+        address[address_start_index] != '\n' && address[address_start_index] != '\0' &&
+        address_start_index < 4096 ) {
+
+    address_copy[address_start_index] = address[address_start_index];
+    address_start_index++;
+  }
+
+  address_copy[address_start_index] = '\0';
+  address_start_index=0;
+
+  // skip everything up to and including last ':' character and whitespace
+  const char* addr = strrchr(address_copy, ':');
+
+  addr = (addr == NULL) ? address_copy : addr + 1;
+
+  while(addr[0] == ' ' || addr[0] == '\t')
+    addr++;
+
+  while(((addr[0] >= '0' && addr[0] <= '9') || addr[0] == '.') && address_start_index < 19) {
+    address_start_str[address_start_index] = addr[0];
+    address_start_index++;
+    addr++;
+  }
+
+  address_start_str[address_start_index] = '\0';
+
+  if(strchr(addr, '-') != NULL) {
+    // explicit range
+    char address_end_str[20];
+    int address_end_index=0;
+    struct sockaddr_in sa_end;
+
+    while(addr[0] == '-' || addr[0] == ' ' || addr[0] == '\t')
+      addr++;
+
+    while(((addr[0] >= '0' && addr[0] <= '9') || addr[0] == '.') && address_end_index < 19) {
+      address_end_str[address_end_index] = addr[0];
+      address_end_index++;
+      addr++;
+    }
+
+    address_end_str[address_end_index] = '\0';
+
+    if(inet_pton(AF_INET, address_start_str, &(sa_start.sin_addr)) != 0 && inet_pton(AF_INET, address_end_str, &(sa_end.sin_addr)) != 0) {
+      *address_start = ntohl(sa_start.sin_addr.s_addr);
+      *address_end = ntohl(sa_end.sin_addr.s_addr);
+
+      if(*address_start <= *address_end)
+        valid=true;
+    }
+  } else if(strchr(addr, '/') != NULL) {
+    // cidr range
+    char mask_bits_str[20];
+    int mask_bits_index=0;
+    uint32_t mask_bits;
+
+    while(addr[0] == '/' || addr[0] == ' ' || addr[0] == '\t')
+      addr++;
+
+    while( (addr[0] >= '0' && addr[0] <= '9') && mask_bits_index < 19) {
+      mask_bits_str[mask_bits_index] = addr[0];
+      mask_bits_index++;
+      addr++;
+    }
+
+    mask_bits_str[mask_bits_index] = '\0';
+
+    if(inet_pton(AF_INET, address_start_str, &(sa_start.sin_addr)) != 0 && sscanf(mask_bits_str, "%u", &mask_bits) != 0) {
+      if(mask_bits <=32) {
+        uint32_t ip=ntohl(sa_start.sin_addr.s_addr);
+        uint32_t mask=0;
+        uint32_t end_mask=0;
+
+        mask = (~mask) << (32-mask_bits);
+        *address_start = ip & mask;
+        end_mask = (~end_mask) >> mask_bits;
+        *address_end = (ip & mask) | end_mask;
+
+        valid=true;
+      }
+    }
+  } else {
+    // single ip
+    if(inet_pton(AF_INET, address_start_str, &(sa_start.sin_addr)) != 0) {
+      *address_start = ntohl(sa_start.sin_addr.s_addr);
+      *address_end = *address_start;
+
+      valid=true;
+    }
+  }
+
+  return valid;
+}
+
+///////////////////////////////////////////////////////////
+// IPV4_FILTER_PARSE
+//
+// should now be compatible with lines in p2p files
+//
+// addresses in table MUST be in host byte order
+// ntohl is called after parsing ip address(es)
+///////////////////////////////////////////////////////////
+void
+ipv4_filter_parse(const char* address, int value) {
+  uint32_t address_start;
+  uint32_t address_end;
+
+  if (ipv4_range_parse(address, &address_start, &address_end) ) {
+    torrent::PeerList::ipv4_filter()->insert(address_start, address_end, value);
+
+    char start_str[INET_ADDRSTRLEN];
+    char end_str[INET_ADDRSTRLEN];
+    uint32_t net_start = htonl(address_start);
+    uint32_t net_end = htonl(address_end);
+
+    inet_ntop(AF_INET, &net_start, start_str, INET_ADDRSTRLEN);
+    inet_ntop(AF_INET, &net_end, end_str, INET_ADDRSTRLEN);
+
+    lt_log_print(torrent::LOG_CONNECTION_FILTER, "Adding ip filter for %s-%s.", start_str, end_str);
+  }
+}
+
+torrent::Object
+apply_ipv4_filter_size_data() {
+  return torrent::PeerList::ipv4_filter()->sizeof_data();
+}
+
+torrent::Object
+apply_ipv4_filter_get(const std::string& args) {
+  uint32_t address_start;
+  uint32_t address_end;
+
+  if (!ipv4_range_parse(args.c_str(), &address_start, &address_end)) 
+    throw torrent::input_error("Invalid address format.");
+
+  if(!torrent::PeerList::ipv4_filter()->defined(address_start, address_end))
+    throw torrent::input_error("No value defined for specified IP(s).");
+
+  return torrent::PeerList::ipv4_filter()->at(address_start, address_end);
+}
+
+torrent::Object
+apply_ipv4_filter_add_address(const torrent::Object::list_type& args) {
+  if (args.size() != 2)
+    throw torrent::input_error("Incorrect number of arguments.");
+
+  ipv4_filter_parse(args.front().as_string().c_str(),
+                    torrent::option_find_string(torrent::OPTION_IP_FILTER, args.back().as_string().c_str()));
+  return torrent::Object();
+}
+
+torrent::Object
+apply_ipv4_filter_load(const torrent::Object::list_type& args) {
+  if (args.size() != 2)
+    throw torrent::input_error("Incorrect number of arguments.");
+
+  std::string filename = args.front().as_string();
+  std::string value_name = args.back().as_string();
+  int value = torrent::option_find_string(torrent::OPTION_IP_FILTER, value_name.c_str());
+
+  std::fstream file(rak::path_expand(filename).c_str(), std::ios::in);
+  
+  if (!file.is_open())
+    throw torrent::input_error("Could not open ip filter file: " + filename);
+
+  unsigned int lineNumber = 0;
+  char buffer[4096];
+
+  try {
+    while (file.good() && !file.getline(buffer, 4096).fail()) {
+      if (file.gcount() == 0)
+        throw torrent::internal_error("parse_command_file(...) file.gcount() == 0.");
+
+      lineNumber++;
+
+      if (buffer[0] == '\0' || buffer[0] == '#')
+        continue;
+
+      ipv4_filter_parse(buffer, value);
+    }
+
+  } catch (torrent::input_error& e) {
+    snprintf(buffer, 2048, "Error in ip filter file: %s:%u: %s", filename.c_str(), lineNumber, e.what());
+
+    throw torrent::input_error(buffer);
+  }
+
+  lt_log_print(torrent::LOG_CONNECTION_FILTER, "loaded %u %s address blocks (%u kb in-memory) from '%s'",
+               lineNumber,
+               value_name.c_str(),
+               torrent::PeerList::ipv4_filter()->sizeof_data() / 1024,
+               filename.c_str());
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_ipv4_filter_dump() {
+  torrent::Object raw_result = torrent::Object::create_list();
+  torrent::Object::list_type& result = raw_result.as_list();
+
+  torrent::ipv4_table::range_map_type range_map = torrent::PeerList::ipv4_filter()->range_map;
+  torrent::ipv4_table::range_map_type::iterator iter = range_map.begin();
+
+  while(iter != range_map.end()) {
+    char buffer[64];
+    uint32_t address_start = iter->first;
+    uint32_t address_end = (iter->second).first;
+    int value = (iter->second).second;
+
+    char start_str[INET_ADDRSTRLEN];
+    char end_str[INET_ADDRSTRLEN];
+    uint32_t net_start = htonl(address_start);
+    uint32_t net_end = htonl(address_end);
+
+    inet_ntop(AF_INET, &net_start, start_str, INET_ADDRSTRLEN);
+    inet_ntop(AF_INET, &net_end, end_str, INET_ADDRSTRLEN);
+
+    snprintf(buffer, 64, "%s-%s %s", start_str, end_str, torrent::option_as_string(torrent::OPTION_IP_FILTER, value));
+
+    result.push_back((std::string)buffer);
+
+    iter++;
+  }
+
+  return raw_result;
+}
+
+void
+initialize_command_ip() {
+  CMD2_ANY_STRING  ("ip_tables.insert_table",  std::bind(&apply_ip_tables_insert_table, std::placeholders::_2));
+  CMD2_ANY_STRING  ("ip_tables.size_data",     std::bind(&apply_ip_tables_size_data, std::placeholders::_2));
+  CMD2_ANY_LIST    ("ip_tables.get",           std::bind(&apply_ip_tables_get, std::placeholders::_2));
+  CMD2_ANY_LIST    ("ip_tables.add_address",   std::bind(&apply_ip_tables_add_address, std::placeholders::_2));
+
+  CMD2_ANY         ("ipv4_filter.size_data",   std::bind(&apply_ipv4_filter_size_data));
+  CMD2_ANY_STRING  ("ipv4_filter.get",         std::bind(&apply_ipv4_filter_get, std::placeholders::_2));
+  CMD2_ANY_LIST    ("ipv4_filter.add_address", std::bind(&apply_ipv4_filter_add_address, std::placeholders::_2));
+  CMD2_ANY_LIST    ("ipv4_filter.load",        std::bind(&apply_ipv4_filter_load, std::placeholders::_2));
+  CMD2_ANY_LIST    ("ipv4_filter.dump",        std::bind(&apply_ipv4_filter_dump));
+}

src/command_local.cc

@@ -0,0 +1,332 @@
+#include "config.h"
+
+#include <fcntl.h>
+#include <functional>
+#include <stdio.h>
+#include <unistd.h>
+#include <rak/path.h>
+#include <rak/error_number.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <torrent/torrent.h>
+#include <torrent/chunk_manager.h>
+#include <torrent/data/file_manager.h>
+#include <torrent/data/chunk_utils.h>
+#include <torrent/utils/option_strings.h>
+
+#include "core/download.h"
+#include "core/download_list.h"
+#include "core/download_store.h"
+#include "core/manager.h"
+#include "rak/string_manip.h"
+#include "rpc/parse_commands.h"
+#include "rpc/scgi.h"
+#include "utils/file_status_cache.h"
+
+#include "globals.h"
+#include "rpc/lua.h"
+#include "control.h"
+#include "command_helpers.h"
+
+typedef torrent::ChunkManager CM_t;
+typedef torrent::FileManager  FM_t;
+
+torrent::Object
+apply_pieces_stats_total_size() {
+  uint64_t size = 0;
+  core::DownloadList* d_list = control->core()->download_list();
+
+  for (core::DownloadList::iterator itr = d_list->begin(), last = d_list->end(); itr != last; itr++)
+    if ((*itr)->is_active())
+      size += (*itr)->file_list()->size_bytes();
+
+  return size;
+}
+
+torrent::Object
+system_env(const torrent::Object::string_type& arg) {
+  if (arg.empty())
+    throw torrent::input_error("system.env: Missing variable name.");
+
+  char* val = getenv(arg.c_str());
+  return std::string(val ? val : "");
+}
+
+torrent::Object
+system_hostname() {
+  char buffer[1024];
+
+  if (gethostname(buffer, 1023) == -1)
+    throw torrent::input_error("Unable to read hostname.");
+
+//   if (shorten)
+//     *std::find(buffer, buffer + 1023, '.') = '\0';
+
+  return std::string(buffer);
+}
+
+torrent::Object
+system_get_cwd() {
+  char* buffer = getcwd(NULL, 0);
+
+  if (buffer == NULL)
+    throw torrent::input_error("Unable to read cwd.");
+
+  torrent::Object result = torrent::Object(std::string(buffer));
+  free(buffer);
+
+  return result;
+}
+
+torrent::Object
+system_set_cwd(const torrent::Object::string_type& rawArgs) {
+  if (::chdir(rawArgs.c_str()) != 0)
+    throw torrent::input_error("Could not change current working directory.");
+
+  return torrent::Object();
+}
+
+inline torrent::Object::list_const_iterator
+post_increment(torrent::Object::list_const_iterator& itr, const torrent::Object::list_const_iterator& last) {
+  if (itr == last)
+    throw torrent::input_error("Invalid number of arguments.");
+
+  return itr++;
+}
+
+inline const std::string&
+check_name(const std::string& str) {
+  if (!rak::is_all_name(str))
+    throw torrent::input_error("Non-alphanumeric characters found.");
+
+  return str;
+}
+
+torrent::Object
+group_insert(const torrent::Object::list_type& args) {
+  torrent::Object::list_const_iterator itr = args.begin();
+  torrent::Object::list_const_iterator last = args.end();
+
+  const std::string& name = check_name(post_increment(itr, last)->as_string());
+  const std::string& view = check_name(post_increment(itr, last)->as_string());
+
+  rpc::commands.call("method.insert", rpc::create_object_list("group." + name + ".ratio.enable", "simple",
+                                                              "schedule2=group." + name + ".ratio,5,60,on_ratio=" + name));
+  rpc::commands.call("method.insert", rpc::create_object_list("group." + name + ".ratio.disable", "simple",
+                                                              "schedule_remove2=group." + name + ".ratio"));
+  rpc::commands.call("method.insert", rpc::create_object_list("group."  + name + ".ratio.command", "simple",
+                                                              "d.try_close= ;d.ignore_commands.set=1"));
+  rpc::commands.call("method.insert", rpc::create_object_list("group2." + name + ".view", "string", view));
+  rpc::commands.call("method.insert", rpc::create_object_list("group2." + name + ".ratio.min", "value", (int64_t)200));
+  rpc::commands.call("method.insert", rpc::create_object_list("group2." + name + ".ratio.max", "value", (int64_t)300));
+  rpc::commands.call("method.insert", rpc::create_object_list("group2." + name + ".ratio.upload", "value", (int64_t)20 << 20));
+
+  if (rpc::call_command_value("method.use_intermediate") == 1) {
+    // Deprecated in 0.7.0:
+
+    CMD2_REDIRECT_GENERIC_STR("group." + name + ".view",          "group2." + name + ".view");
+    CMD2_REDIRECT_GENERIC_STR("group." + name + ".view.set",      "group2." + name + ".view.set");
+    CMD2_REDIRECT_GENERIC_STR("group." + name + ".ratio.min",     "group2." + name + ".ratio.min");
+    CMD2_REDIRECT_GENERIC_STR("group." + name + ".ratio.min.set",    "group2." + name + ".ratio.min.set");
+    CMD2_REDIRECT_GENERIC_STR("group." + name + ".ratio.max",        "group2." + name + ".ratio.max");
+    CMD2_REDIRECT_GENERIC_STR("group." + name + ".ratio.max.set",    "group2." + name + ".ratio.max.set");
+    CMD2_REDIRECT_GENERIC_STR("group." + name + ".ratio.upload",     "group2." + name + ".ratio.upload");
+    CMD2_REDIRECT_GENERIC_STR("group." + name + ".ratio.upload.set", "group2." + name + ".ratio.upload.set");
+
+  } if (rpc::call_command_value("method.use_intermediate") == 2) {
+    // Deprecated in 0.7.0:
+
+    CMD2_REDIRECT_GENERIC_STR_NO_EXPORT("group." + name + ".view",          "group2." + name + ".view");
+    CMD2_REDIRECT_GENERIC_STR_NO_EXPORT("group." + name + ".view.set",      "group2." + name + ".view.set");
+    CMD2_REDIRECT_GENERIC_STR_NO_EXPORT("group." + name + ".ratio.min",     "group2." + name + ".ratio.min");
+    CMD2_REDIRECT_GENERIC_STR_NO_EXPORT("group." + name + ".ratio.min.set",    "group2." + name + ".ratio.min.set");
+    CMD2_REDIRECT_GENERIC_STR_NO_EXPORT("group." + name + ".ratio.max",        "group2." + name + ".ratio.max");
+    CMD2_REDIRECT_GENERIC_STR_NO_EXPORT("group." + name + ".ratio.max.set",    "group2." + name + ".ratio.max.set");
+    CMD2_REDIRECT_GENERIC_STR_NO_EXPORT("group." + name + ".ratio.upload",     "group2." + name + ".ratio.upload");
+    CMD2_REDIRECT_GENERIC_STR_NO_EXPORT("group." + name + ".ratio.upload.set", "group2." + name + ".ratio.upload.set");
+  }
+
+  return name;
+}
+
+static const int file_print_use_space = 0x1;
+static const int file_print_delim_space = 0x2;
+
+void
+file_print_list(torrent::Object::list_const_iterator first, torrent::Object::list_const_iterator last, FILE* output, int flags) {
+  while (first != last) {
+    switch (first->type()) {
+    case torrent::Object::TYPE_STRING:
+      fprintf(output, (const char*)" %s" + !(flags & file_print_use_space), first->as_string().c_str());
+      break;
+    case torrent::Object::TYPE_VALUE:
+      fprintf(output, (const char*)" %" PRIi64 + !(flags & file_print_use_space), first->as_value());
+      break;
+    case torrent::Object::TYPE_LIST:
+      file_print_list(first->as_list().begin(), first->as_list().end(), output, 0);
+      break;
+    case torrent::Object::TYPE_NONE:
+      break;
+    default:
+      throw torrent::input_error("Invalid type.");
+    }
+
+    flags |= (flags & file_print_delim_space) >> 1;
+    first++;
+  }
+}
+
+torrent::Object
+cmd_file_append(const torrent::Object::list_type& args) {
+  if (args.empty())
+    throw torrent::input_error("Invalid number of arguments.");
+
+  FILE* output = fopen(args.front().as_string().c_str(), "a");
+
+  if (output == NULL)
+    throw torrent::input_error("Could not append to file '" + args.front().as_string() + "': " + rak::error_number::current().c_str());
+
+  file_print_list(++args.begin(), args.end(), output, file_print_delim_space);
+
+  fprintf(output, "\n");
+  fclose(output);
+  return torrent::Object();
+}
+
+void
+initialize_command_local() {
+  core::DownloadList*    dList = control->core()->download_list();
+  core::DownloadStore*   dStore = control->core()->download_store();
+  torrent::ChunkManager* chunkManager = torrent::chunk_manager();
+  torrent::FileManager*  fileManager = torrent::file_manager();
+
+  CMD2_ANY         ("system.hostname", std::bind(&system_hostname));
+  CMD2_ANY         ("system.pid",      std::bind(&getpid));
+
+  CMD2_VAR_C_STRING("system.api_version",           (int64_t)API_VERSION);
+  CMD2_VAR_C_STRING("system.client_version",        PACKAGE_VERSION);
+  CMD2_VAR_C_STRING("system.library_version",       torrent::version());
+
+  CMD2_VAR_VALUE   ("system.file.allocate",         0);
+  CMD2_VAR_VALUE   ("system.file.max_size",         (int64_t)512 << 30);
+  CMD2_VAR_VALUE   ("system.file.split_size",       -1);
+  CMD2_VAR_STRING  ("system.file.split_suffix",     ".part");
+
+  CMD2_ANY         ("system.file_status_cache.size",   std::bind(&utils::FileStatusCache::size,
+                                                                 (utils::FileStatusCache::base_type*)control->core()->file_status_cache()));
+  CMD2_ANY_V       ("system.file_status_cache.prune",  std::bind(&utils::FileStatusCache::prune, control->core()->file_status_cache()));
+
+  CMD2_VAR_BOOL    ("file.prioritize_toc",          0);
+  CMD2_VAR_LIST    ("file.prioritize_toc.first");
+  CMD2_VAR_LIST    ("file.prioritize_toc.last");
+
+  CMD2_ANY         ("system.files.advise_random",             std::bind(&FM_t::advise_random, fileManager));
+  CMD2_ANY_VALUE_V ("system.files.advise_random.set",         std::bind(&FM_t::set_advise_random, fileManager, std::placeholders::_2));
+  CMD2_ANY         ("system.files.advise_random.hashing",     std::bind(&FM_t::advise_random_hashing, fileManager));
+  CMD2_ANY_VALUE_V ("system.files.advise_random.hashing.set", std::bind(&FM_t::set_advise_random_hashing, fileManager, std::placeholders::_2));
+  CMD2_VAR_BOOL    ("system.files.session.fdatasync",         true);
+
+  CMD2_ANY         ("system.files.opened_counter",     std::bind(&FM_t::files_opened_counter, fileManager));
+  CMD2_ANY         ("system.files.closed_counter",     std::bind(&FM_t::files_closed_counter, fileManager));
+  CMD2_ANY         ("system.files.failed_counter",     std::bind(&FM_t::files_failed_counter, fileManager));
+
+  CMD2_ANY_STRING  ("system.env",                      std::bind(&system_env, std::placeholders::_2));
+
+  CMD2_ANY         ("system.time",                     []([[maybe_unused]] auto t, [[maybe_unused]] auto o) -> torrent::Object {
+      return torrent::this_thread::cached_seconds().count();
+    });
+  CMD2_ANY         ("system.time_seconds",             []([[maybe_unused]] auto t, [[maybe_unused]] auto o) -> torrent::Object {
+      return torrent::utils::cast_seconds(torrent::utils::time_since_epoch()).count();
+    });
+  CMD2_ANY         ("system.time_usec",                []([[maybe_unused]] auto t, [[maybe_unused]] auto o) -> torrent::Object {
+      return torrent::utils::time_since_epoch().count();
+    });
+
+  CMD2_ANY_VALUE_V ("system.umask.set",                std::bind(&umask, std::placeholders::_2));
+
+  CMD2_VAR_BOOL    ("system.daemon",                   false);
+
+  CMD2_ANY_V       ("system.shutdown.normal",          std::bind(&Control::receive_normal_shutdown, control));
+  CMD2_ANY_V       ("system.shutdown.quick",           std::bind(&Control::receive_quick_shutdown, control));
+  CMD2_REDIRECT_GENERIC_NO_EXPORT("system.shutdown", "system.shutdown.normal");
+
+  CMD2_ANY         ("system.cwd",                      std::bind(&system_get_cwd));
+  CMD2_ANY_STRING  ("system.cwd.set",                  std::bind(&system_set_cwd, std::placeholders::_2));
+
+  CMD2_ANY         ("pieces.sync.always_safe",         std::bind(&CM_t::safe_sync, chunkManager));
+  CMD2_ANY_VALUE_V ("pieces.sync.always_safe.set",     std::bind(&CM_t::set_safe_sync, chunkManager, std::placeholders::_2));
+  CMD2_ANY         ("pieces.sync.safe_free_diskspace", std::bind(&CM_t::safe_free_diskspace, chunkManager));
+  CMD2_ANY         ("pieces.sync.timeout",             std::bind(&CM_t::timeout_sync, chunkManager));
+  CMD2_ANY_VALUE_V ("pieces.sync.timeout.set",         std::bind(&CM_t::set_timeout_sync, chunkManager, std::placeholders::_2));
+  CMD2_ANY         ("pieces.sync.timeout_safe",        std::bind(&CM_t::timeout_safe_sync, chunkManager));
+  CMD2_ANY_VALUE_V ("pieces.sync.timeout_safe.set",    std::bind(&CM_t::set_timeout_safe_sync, chunkManager, std::placeholders::_2));
+  CMD2_ANY         ("pieces.sync.queue_size",          std::bind(&CM_t::sync_queue_size, chunkManager));
+
+  CMD2_ANY         ("pieces.preload.type",             std::bind(&CM_t::preload_type, chunkManager));
+  CMD2_ANY_VALUE_V ("pieces.preload.type.set",         std::bind(&CM_t::set_preload_type, chunkManager, std::placeholders::_2));
+  CMD2_ANY         ("pieces.preload.min_size",         std::bind(&CM_t::preload_min_size, chunkManager));
+  CMD2_ANY_VALUE_V ("pieces.preload.min_size.set",     std::bind(&CM_t::set_preload_min_size, chunkManager, std::placeholders::_2));
+  CMD2_ANY         ("pieces.preload.min_rate",         std::bind(&CM_t::preload_required_rate, chunkManager));
+  CMD2_ANY_VALUE_V ("pieces.preload.min_rate.set",     std::bind(&CM_t::set_preload_required_rate, chunkManager, std::placeholders::_2));
+
+  CMD2_ANY         ("pieces.memory.current",           std::bind(&CM_t::memory_usage, chunkManager));
+  CMD2_ANY         ("pieces.memory.sync_queue",        std::bind(&CM_t::sync_queue_memory_usage, chunkManager));
+  CMD2_ANY         ("pieces.memory.block_count",       std::bind(&CM_t::memory_block_count, chunkManager));
+  CMD2_ANY         ("pieces.memory.max",               std::bind(&CM_t::max_memory_usage, chunkManager));
+  CMD2_ANY_VALUE_V ("pieces.memory.max.set",           std::bind(&CM_t::set_max_memory_usage, chunkManager, std::placeholders::_2));
+  CMD2_ANY         ("pieces.stats_preloaded",          std::bind(&CM_t::stats_preloaded, chunkManager));
+  CMD2_ANY         ("pieces.stats_not_preloaded",      std::bind(&CM_t::stats_not_preloaded, chunkManager));
+
+  CMD2_ANY         ("pieces.stats.total_size",         std::bind(&apply_pieces_stats_total_size));
+
+  CMD2_ANY         ("pieces.hash.queue_size",          std::bind(&torrent::main_thread::hash_queue_size));
+  CMD2_VAR_BOOL    ("pieces.hash.on_completion",       true);
+
+  CMD2_VAR_STRING  ("directory.default",       "./");
+
+  CMD2_VAR_STRING  ("session.name",            "");
+  CMD2_VAR_BOOL    ("session.use_lock",        true);
+  CMD2_VAR_BOOL    ("session.on_completion",   true);
+
+  CMD2_ANY         ("session.path",            std::bind(&core::DownloadStore::path, dStore));
+  CMD2_ANY_STRING_V("session.path.set",        std::bind(&core::DownloadStore::set_path, dStore, std::placeholders::_2));
+
+  CMD2_ANY_V       ("session.save",            std::bind(&core::DownloadList::session_save, dList));
+
+#ifdef HAVE_LUA
+  rpc::LuaEngine* lua_engine = control->lua_engine();
+
+  CMD2_ANY         ("lua.execute",            std::bind(&rpc::execute_lua, lua_engine, std::placeholders::_1, std::placeholders::_2, 0));
+  CMD2_ANY         ("lua.execute.str",        std::bind(&rpc::execute_lua, lua_engine, std::placeholders::_1, std::placeholders::_2, rpc::LuaEngine::flag_string));
+#endif
+
+#define CMD2_EXECUTE(key, flags)                                        \
+  CMD2_ANY(key, std::bind(&rpc::ExecFile::execute_object, &rpc::execFile, std::placeholders::_2, flags));
+
+  CMD2_EXECUTE     ("execute",                rpc::ExecFile::flag_expand_tilde | rpc::ExecFile::flag_throw);
+  CMD2_EXECUTE     ("execute2",                rpc::ExecFile::flag_expand_tilde | rpc::ExecFile::flag_throw);
+  CMD2_EXECUTE     ("execute.throw",           rpc::ExecFile::flag_expand_tilde | rpc::ExecFile::flag_throw);
+  CMD2_EXECUTE     ("execute.throw.bg",        rpc::ExecFile::flag_expand_tilde | rpc::ExecFile::flag_throw | rpc::ExecFile::flag_background);
+  CMD2_EXECUTE     ("execute.nothrow",         rpc::ExecFile::flag_expand_tilde);
+  CMD2_EXECUTE     ("execute.nothrow.bg",      rpc::ExecFile::flag_expand_tilde | rpc::ExecFile::flag_background);
+  CMD2_EXECUTE     ("execute.raw",             rpc::ExecFile::flag_throw);
+  CMD2_EXECUTE     ("execute.raw.bg",          rpc::ExecFile::flag_throw | rpc::ExecFile::flag_background);
+  CMD2_EXECUTE     ("execute.raw_nothrow",     0);
+  CMD2_EXECUTE     ("execute.raw_nothrow.bg",  rpc::ExecFile::flag_background);
+  CMD2_EXECUTE     ("execute.capture",         rpc::ExecFile::flag_throw | rpc::ExecFile::flag_expand_tilde | rpc::ExecFile::flag_capture);
+  CMD2_EXECUTE     ("execute.capture_nothrow", rpc::ExecFile::flag_expand_tilde | rpc::ExecFile::flag_capture);
+
+  CMD2_ANY_LIST    ("file.append",    std::bind(&cmd_file_append, std::placeholders::_2));
+
+  // TODO: Convert to new command types:
+  *rpc::command_base::argument(0) = "placeholder.0";
+  *rpc::command_base::argument(1) = "placeholder.1";
+  *rpc::command_base::argument(2) = "placeholder.2";
+  *rpc::command_base::argument(3) = "placeholder.3";
+  CMD2_ANY_P("argument.0", std::bind(&rpc::command_base::argument_ref, 0));
+  CMD2_ANY_P("argument.1", std::bind(&rpc::command_base::argument_ref, 1));
+  CMD2_ANY_P("argument.2", std::bind(&rpc::command_base::argument_ref, 2));
+  CMD2_ANY_P("argument.3", std::bind(&rpc::command_base::argument_ref, 3));
+
+  CMD2_ANY_LIST  ("group.insert", std::bind(&group_insert, std::placeholders::_2));
+}

src/command_logging.cc

@@ -0,0 +1,147 @@
+#include "config.h"
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <torrent/data/chunk_utils.h>
+#include <torrent/object.h>
+#include <torrent/utils/log.h>
+#include <torrent/utils/option_strings.h>
+
+#include "core/download.h"
+#include "core/download_list.h"
+#include "core/manager.h"
+#include "rak/path.h"
+#include "rpc/parse_commands.h"
+
+#include "globals.h"
+#include "control.h"
+#include "command_helpers.h"
+
+static const int log_flag_use_gz = 0x1;
+static const int log_flag_append_pid = 0x2;
+static const int log_flag_append_file = 0x4;
+
+void
+log_add_group_output_str(const char* group_name, const char* output_id) {
+  int log_group = torrent::option_find_string(torrent::OPTION_LOG_GROUP, group_name);
+  torrent::log_add_group_output(log_group, output_id);
+}
+
+torrent::Object
+apply_log_open(int output_flags, const torrent::Object::list_type& args) {
+  if (args.size() < 2)
+    throw torrent::input_error("Invalid number of arguments.");
+
+  torrent::Object::list_const_iterator itr = args.begin();
+
+  std::string output_id = (itr++)->as_string();
+  std::string file_name = rak::path_expand((itr++)->as_string());
+
+  if ((output_flags & log_flag_append_pid)) {
+    char buffer[32];
+    snprintf(buffer, 32, ".%li", (long)getpid());
+
+    file_name += buffer;
+  }
+
+  bool append = (output_flags & log_flag_append_file);
+
+  if ((output_flags & log_flag_use_gz))
+    torrent::log_open_gz_file_output(output_id.c_str(), file_name.c_str(), append);
+  else
+    torrent::log_open_file_output(output_id.c_str(), file_name.c_str(), append);
+
+  while (itr != args.end())
+    log_add_group_output_str((itr++)->as_string().c_str(), output_id.c_str());
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_log_add_output(const torrent::Object::list_type& args) {
+  if (args.size() != 2)
+    throw torrent::input_error("Invalid number of arguments.");
+  
+  log_add_group_output_str(args.front().as_string().c_str(),
+                           args.back().as_string().c_str());
+
+  return torrent::Object();
+}
+
+// TODO: Deprecated.
+torrent::Object
+apply_log(const torrent::Object::string_type& arg, int logType) {
+  if (rpc::execFile.log_fd() != -1) {
+    switch (logType) {
+    case 0: ::close(rpc::execFile.log_fd()); rpc::execFile.set_log_fd(-1); break;
+    case 1:
+//       if (control->scgi()) {
+//         ::close(control->scgi()->log_fd());
+//         control->scgi()->set_log_fd(-1);
+//       }
+      break;
+    default: break;
+    }
+  }
+
+  if (!arg.empty()) {
+    int logFd = open(rak::path_expand(arg).c_str(), O_WRONLY | O_APPEND | O_CREAT, 0644);
+
+    if (logFd < 0)
+      throw torrent::input_error("Could not open execute log file.");
+
+    switch (logType) {
+    case 0: rpc::execFile.set_log_fd(logFd); break;
+//     case 1: if (control->scgi()) control->scgi()->set_log_fd(logFd); break;
+    default: break;
+    }
+
+    control->core()->push_log("Opened log file.");
+
+  } else {
+    control->core()->push_log("Closed log file.");
+  }
+
+  return torrent::Object();
+}
+
+torrent::Object
+log_vmmap_dump(const std::string& str) {
+  core::DownloadList* d_list = control->core()->download_list();
+  std::vector<torrent::vm_mapping> all_mappings;
+
+  for (core::DownloadList::iterator itr = d_list->begin(), last = d_list->end(); itr != last; itr++) {
+    std::vector<torrent::vm_mapping> tmp_mappings = torrent::chunk_list_mapping((*itr)->download());
+
+    all_mappings.insert(all_mappings.end(), tmp_mappings.begin(), tmp_mappings.end());    
+  }
+
+  FILE* log_file = fopen(str.c_str(), "w");
+
+  for (std::vector<torrent::vm_mapping>::iterator itr = all_mappings.begin(), last = all_mappings.end(); itr != last; itr++) {
+    fprintf(log_file, "%8p-%8p [%5llxk]\n", itr->ptr, (char*)itr->ptr + itr->length, (long long unsigned int)(itr->length / 1024));
+  }
+
+  fclose(log_file);
+  return torrent::Object();
+}
+
+void
+initialize_command_logging() {
+  CMD2_ANY_LIST    ("log.open_file",        std::bind(&apply_log_open, 0, std::placeholders::_2));
+  CMD2_ANY_LIST    ("log.open_gz_file",     std::bind(&apply_log_open, log_flag_use_gz, std::placeholders::_2));
+  CMD2_ANY_LIST    ("log.open_file_pid",    std::bind(&apply_log_open, log_flag_append_pid, std::placeholders::_2));
+  CMD2_ANY_LIST    ("log.open_gz_file_pid", std::bind(&apply_log_open, log_flag_append_pid | log_flag_use_gz, std::placeholders::_2));
+  CMD2_ANY_LIST    ("log.append_file",      std::bind(&apply_log_open, log_flag_append_file, std::placeholders::_2));
+  CMD2_ANY_LIST    ("log.append_gz_file",   std::bind(&apply_log_open, log_flag_append_file, std::placeholders::_2));
+
+  CMD2_ANY_STRING_V("log.close",      std::bind(&torrent::log_close_output_str, std::placeholders::_2));
+
+  CMD2_ANY_LIST    ("log.add_output", std::bind(&apply_log_add_output, std::placeholders::_2));
+
+  CMD2_ANY_STRING  ("log.execute",    std::bind(&apply_log, std::placeholders::_2, 0));
+  CMD2_ANY_STRING  ("log.vmmap.dump", std::bind(&log_vmmap_dump, std::placeholders::_2));
+  CMD2_ANY_STRING_V("log.rpc",        std::bind(&ThreadWorker::set_rpc_log, worker_thread, std::placeholders::_2));
+  CMD2_REDIRECT    ("log.xmlrpc",     "log.rpc"); // For backwards compatibility
+}

src/command_network.cc

@@ -0,0 +1,273 @@
+#include "config.h"
+
+#include <functional>
+#include <cstdio>
+#include <unistd.h>
+#include <rak/address_info.h>
+#include <rak/path.h>
+#include <torrent/connection_manager.h>
+#include <torrent/tracker/tracker.h>
+#include <torrent/torrent.h>
+#include <torrent/rate.h>
+#include <torrent/data/file_manager.h>
+#include <torrent/download/resource_manager.h>
+#include <torrent/utils/log.h>
+#include <torrent/utils/option_strings.h>
+
+#include "core/curl_stack.h"
+#include "core/download.h"
+#include "core/manager.h"
+#include "rpc/scgi.h"
+#include "ui/root.h"
+#include "rpc/parse.h"
+#include "rpc/parse_commands.h"
+
+#include "globals.h"
+#include "control.h"
+#include "command_helpers.h"
+
+torrent::Object
+apply_encryption(const torrent::Object::list_type& args) {
+  uint32_t options_mask = torrent::ConnectionManager::encryption_none;
+
+  for (torrent::Object::list_const_iterator itr = args.begin(), last = args.end(); itr != last; itr++) {
+    uint32_t opt = torrent::option_find_string(torrent::OPTION_ENCRYPTION, itr->as_string().c_str());
+
+    if (opt == torrent::ConnectionManager::encryption_none)
+      options_mask = torrent::ConnectionManager::encryption_none;
+    else
+      options_mask |= opt;
+  }
+
+  torrent::connection_manager()->set_encryption_options(options_mask);
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_tos(const torrent::Object::string_type& arg) {
+  rpc::command_base::value_type value;
+
+  if (!rpc::parse_whole_value_nothrow(arg.c_str(), &value, 16, 1))
+    value = torrent::option_find_string(torrent::OPTION_IP_TOS, arg.c_str());
+
+  torrent::connection_manager()->set_priority(value);
+
+  return torrent::Object();
+}
+
+torrent::Object apply_encoding_list(const std::string& arg) { torrent::encoding_list()->push_back(arg); return torrent::Object(); }
+
+void
+initialize_rpc() {
+  rpc::rpc.initialize();
+
+  rpc::rpc.slot_find_download() = [](const char* hash) {
+      return control->core()->download_list()->find_hex_ptr(hash);
+    };
+  rpc::rpc.slot_find_file() = [](core::Download* d, uint32_t index) -> torrent::File* {
+      if (index >= d->file_list()->size_files())
+        throw torrent::input_error("invalid parameters: index not found");
+
+      return (*d->file_list())[index].get();
+    };
+  rpc::rpc.slot_find_tracker() = [](core::Download* d, uint32_t index) -> torrent::tracker::Tracker {
+      if (index >= d->tracker_controller().size())
+        throw torrent::input_error("invalid parameters: index not found");
+
+      // TODO: This should be rewritten to check if the tracker is valid and use a different
+      // function.
+      return d->tracker_controller().at(index);
+    };
+  rpc::rpc.slot_find_peer() = [](core::Download* d, const torrent::HashString& hash) -> torrent::Peer* {
+      auto itr = d->connection_list()->find(hash.c_str());
+
+      if (itr == d->connection_list()->end())
+        throw torrent::input_error("invalid parameters: hash not found");
+
+      return *itr;
+    };
+
+  unsigned int count = 0;
+
+  for (rpc::CommandMap::const_iterator itr = rpc::commands.begin(), last = rpc::commands.end(); itr != last; itr++, count++) {
+    if (!(itr->second.m_flags & rpc::CommandMap::flag_public_rpc))
+      continue;
+
+    rpc::rpc.insert_command(itr->first.c_str(), itr->second.m_parm, itr->second.m_doc);
+  }
+
+  lt_log_print(torrent::LOG_RPC_EVENTS, "RPC initialized with %u functions.", count);
+}
+
+torrent::Object
+apply_scgi(const std::string& arg, int type) {
+  if (worker_thread->scgi() != NULL)
+    throw torrent::input_error("SCGI already enabled.");
+
+  initialize_rpc();
+
+  rpc::SCgi* scgi = new rpc::SCgi;
+
+  rak::address_info* ai = NULL;
+  rak::socket_address sa;
+  rak::socket_address* saPtr;
+
+  try {
+    int port, err;
+    char dummy;
+    char address[1024];
+    std::string path;
+
+    switch (type) {
+    case 1:
+      if (std::sscanf(arg.c_str(), ":%i%c", &port, &dummy) == 1) {
+        sa.sa_inet()->clear();
+        saPtr = &sa;
+
+        lt_log_print(torrent::LOG_RPC_EVENTS, "SCGI socket is open to any address and is a security risk");
+
+      } else if (std::sscanf(arg.c_str(), "%1023[^:]:%i%c", address, &port, &dummy) == 2 ||
+                 std::sscanf(arg.c_str(), "[%64[^]]]:%i%c", address, &port, &dummy) == 2) { // [xx::xx]:port format
+        if ((err = rak::address_info::get_address_info(address,PF_UNSPEC, SOCK_STREAM, &ai)) != 0)
+          throw torrent::input_error("Could not bind address: " + std::string(rak::address_info::strerror(err)) + ".");
+
+        saPtr = ai->address();
+
+        lt_log_print(torrent::LOG_RPC_EVENTS, "SCGI socket is bound to an address and might be a security risk");
+
+      } else {
+        throw torrent::input_error("Could not parse address.");
+      }
+
+      if (port <= 0 || port >= (1 << 16))
+        throw torrent::input_error("Invalid port number.");
+
+      saPtr->set_port(port);
+      scgi->open_port(saPtr, saPtr->length(), rpc::call_command_value("network.scgi.dont_route"));
+
+      break;
+
+    case 2:
+    default:
+      path = rak::path_expand(arg);
+
+      unlink(path.c_str());
+      scgi->open_named(path);
+      break;
+    }
+
+    if (ai != NULL) rak::address_info::free_address_info(ai);
+
+  } catch (torrent::local_error& e) {
+    if (ai != NULL) rak::address_info::free_address_info(ai);
+
+    delete scgi;
+    throw torrent::input_error(e.what());
+  }
+
+  worker_thread->set_scgi(scgi);
+  return torrent::Object();
+}
+
+torrent::Object
+apply_xmlrpc_dialect(const std::string& arg) {
+  int value;
+
+  if (arg == "i8")
+    value = rpc::XmlRpc::dialect_i8;
+  else if (arg == "apache")
+    value = rpc::XmlRpc::dialect_apache;
+  else if (arg == "generic")
+    value = rpc::XmlRpc::dialect_generic;
+  else
+    value = -1;
+
+  rpc::rpc.set_dialect(value);
+  return torrent::Object();
+}
+
+void
+initialize_command_network() {
+  torrent::ConnectionManager* cm = torrent::connection_manager();
+  torrent::FileManager* fileManager = torrent::file_manager();
+  core::CurlStack* httpStack = control->core()->http_stack();
+
+  CMD2_ANY_STRING  ("encoding.add", std::bind(&apply_encoding_list, std::placeholders::_2));
+
+  // Isn't port_open used?
+  CMD2_VAR_BOOL    ("network.port_open",   true);
+  CMD2_VAR_BOOL    ("network.port_random", true);
+  CMD2_VAR_STRING  ("network.port_range",  "6881-6999");
+
+  CMD2_ANY         ("network.listen.port",        std::bind(&torrent::ConnectionManager::listen_port, cm));
+  CMD2_ANY         ("network.listen.backlog",     std::bind(&torrent::ConnectionManager::listen_backlog, cm));
+  CMD2_ANY_VALUE_V ("network.listen.backlog.set", std::bind(&torrent::ConnectionManager::set_listen_backlog, cm, std::placeholders::_2));
+
+  CMD2_VAR_BOOL    ("protocol.pex",            true);
+  CMD2_ANY_LIST    ("protocol.encryption.set", std::bind(&apply_encryption, std::placeholders::_2));
+
+  CMD2_VAR_STRING  ("protocol.connection.leech", "leech");
+  CMD2_VAR_STRING  ("protocol.connection.seed",  "seed");
+
+  CMD2_VAR_STRING  ("protocol.choke_heuristics.up.leech", "upload_leech");
+  CMD2_VAR_STRING  ("protocol.choke_heuristics.up.seed",  "upload_leech");
+  CMD2_VAR_STRING  ("protocol.choke_heuristics.down.leech", "download_leech");
+  CMD2_VAR_STRING  ("protocol.choke_heuristics.down.seed",  "download_leech");
+
+  CMD2_ANY         ("network.http.cacert",                std::bind(&core::CurlStack::http_cacert, httpStack));
+  CMD2_ANY_STRING_V("network.http.cacert.set",            std::bind(&core::CurlStack::set_http_cacert, httpStack, std::placeholders::_2));
+  CMD2_ANY         ("network.http.capath",                std::bind(&core::CurlStack::http_capath, httpStack));
+  CMD2_ANY_STRING_V("network.http.capath.set",            std::bind(&core::CurlStack::set_http_capath, httpStack, std::placeholders::_2));
+  CMD2_ANY         ("network.http.dns_cache_timeout",     std::bind(&core::CurlStack::dns_timeout, httpStack));
+  CMD2_ANY_VALUE_V ("network.http.dns_cache_timeout.set", std::bind(&core::CurlStack::set_dns_timeout, httpStack, std::placeholders::_2));
+  CMD2_ANY         ("network.http.current_open",          std::bind(&core::CurlStack::active, httpStack));
+  CMD2_ANY         ("network.http.max_open",              std::bind(&core::CurlStack::max_active, httpStack));
+  CMD2_ANY_VALUE_V ("network.http.max_open.set",          std::bind(&core::CurlStack::set_max_active, httpStack, std::placeholders::_2));
+  CMD2_ANY         ("network.http.proxy_address",         std::bind(&core::CurlStack::http_proxy, httpStack));
+  CMD2_ANY_STRING_V("network.http.proxy_address.set",     std::bind(&core::CurlStack::set_http_proxy, httpStack, std::placeholders::_2));
+  CMD2_ANY         ("network.http.ssl_verify_host",       std::bind(&core::CurlStack::ssl_verify_host, httpStack));
+  CMD2_ANY_VALUE_V ("network.http.ssl_verify_host.set",   std::bind(&core::CurlStack::set_ssl_verify_host, httpStack, std::placeholders::_2));
+  CMD2_ANY         ("network.http.ssl_verify_peer",       std::bind(&core::CurlStack::ssl_verify_peer, httpStack));
+  CMD2_ANY_VALUE_V ("network.http.ssl_verify_peer.set",   std::bind(&core::CurlStack::set_ssl_verify_peer, httpStack, std::placeholders::_2));
+
+  CMD2_ANY         ("network.send_buffer.size",        std::bind(&torrent::ConnectionManager::send_buffer_size, cm));
+  CMD2_ANY_VALUE_V ("network.send_buffer.size.set",    std::bind(&torrent::ConnectionManager::set_send_buffer_size, cm, std::placeholders::_2));
+  CMD2_ANY         ("network.receive_buffer.size",     std::bind(&torrent::ConnectionManager::receive_buffer_size, cm));
+  CMD2_ANY_VALUE_V ("network.receive_buffer.size.set", std::bind(&torrent::ConnectionManager::set_receive_buffer_size, cm, std::placeholders::_2));
+  CMD2_ANY_STRING  ("network.tos.set",                 std::bind(&apply_tos, std::placeholders::_2));
+
+  CMD2_ANY         ("network.bind_address",          std::bind(&core::Manager::bind_address, control->core()));
+  CMD2_ANY_STRING_V("network.bind_address.set",      std::bind(&core::Manager::set_bind_address, control->core(), std::placeholders::_2));
+  CMD2_ANY         ("network.local_address",         std::bind(&core::Manager::local_address, control->core()));
+  CMD2_ANY_STRING_V("network.local_address.set",     std::bind(&core::Manager::set_local_address, control->core(), std::placeholders::_2));
+  CMD2_ANY         ("network.proxy_address",         std::bind(&core::Manager::proxy_address, control->core()));
+  CMD2_ANY_STRING_V("network.proxy_address.set",     std::bind(&core::Manager::set_proxy_address, control->core(), std::placeholders::_2));
+
+  CMD2_ANY         ("network.open_files",            std::bind(&torrent::FileManager::open_files, fileManager));
+  CMD2_ANY         ("network.max_open_files",        std::bind(&torrent::FileManager::max_open_files, fileManager));
+  CMD2_ANY_VALUE_V ("network.max_open_files.set",    std::bind(&torrent::FileManager::set_max_open_files, fileManager, std::placeholders::_2));
+  CMD2_ANY         ("network.total_handshakes",      std::bind(&torrent::total_handshakes));
+  CMD2_ANY         ("network.open_sockets",          std::bind(&torrent::ConnectionManager::size, cm));
+  CMD2_ANY         ("network.max_open_sockets",      std::bind(&torrent::ConnectionManager::max_size, cm));
+  CMD2_ANY_VALUE_V ("network.max_open_sockets.set",  std::bind(&torrent::ConnectionManager::set_max_size, cm, std::placeholders::_2));
+
+  CMD2_ANY_STRING  ("network.scgi.open_port",        std::bind(&apply_scgi, std::placeholders::_2, 1));
+  CMD2_ANY_STRING  ("network.scgi.open_local",       std::bind(&apply_scgi, std::placeholders::_2, 2));
+  CMD2_VAR_BOOL    ("network.scgi.dont_route",       false);
+
+  CMD2_ANY_STRING  ("network.xmlrpc.dialect.set",    [](const auto&, const auto& arg) { return apply_xmlrpc_dialect(arg); })
+  CMD2_ANY         ("network.xmlrpc.size_limit",     [](const auto&, const auto&){ return rpc::rpc.size_limit(); });
+  CMD2_ANY_VALUE_V ("network.xmlrpc.size_limit.set", [](const auto&, const auto& arg){ return rpc::rpc.set_size_limit(arg); });
+
+  CMD2_VAR_BOOL    ("network.rpc.use_xmlrpc",        true);
+  CMD2_VAR_BOOL    ("network.rpc.use_jsonrpc",       true);
+
+  CMD2_ANY         ("network.block.ipv4",            std::bind(&torrent::ConnectionManager::is_block_ipv4, cm));
+  CMD2_ANY_VALUE_V ("network.block.ipv4.set",        std::bind(&torrent::ConnectionManager::set_block_ipv4, cm, std::placeholders::_2));
+  CMD2_ANY         ("network.block.ipv6",            std::bind(&torrent::ConnectionManager::is_block_ipv6, cm));
+  CMD2_ANY_VALUE_V ("network.block.ipv6.set",        std::bind(&torrent::ConnectionManager::set_block_ipv6, cm, std::placeholders::_2));
+
+  CMD2_ANY         ("network.prefer.ipv6",           std::bind(&torrent::ConnectionManager::is_prefer_ipv6, cm));
+  CMD2_ANY_VALUE_V ("network.prefer.ipv6.set",       std::bind(&torrent::ConnectionManager::set_prefer_ipv6, cm, std::placeholders::_2));
+}

src/command_peer.cc

@@ -0,0 +1,138 @@
+// rTorrent - BitTorrent client
+// Copyright (C) 2005-2011, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+#include "config.h"
+
+#include <rak/error_number.h>
+#include <rak/path.h>
+#include <rak/socket_address.h>
+#include <rak/string_manip.h>
+#include <torrent/bitfield.h>
+#include <torrent/rate.h>
+#include <torrent/peer/connection_list.h>
+#include <torrent/peer/peer.h>
+#include <torrent/peer/peer_info.h>
+
+#include "core/manager.h"
+#include "display/utils.h"
+
+#include "globals.h"
+#include "control.h"
+#include "command_helpers.h"
+
+torrent::Object
+retrieve_p_id(torrent::Peer* peer) {
+  const torrent::HashString* hashString = &peer->id();
+
+  return rak::transform_hex(hashString->begin(), hashString->end());
+}
+
+torrent::Object
+retrieve_p_id_html(torrent::Peer* peer) {
+  const torrent::HashString* hashString = &peer->id();
+
+  return rak::copy_escape_html(hashString->begin(), hashString->end());
+}
+
+torrent::Object
+retrieve_p_address(torrent::Peer* peer) {
+  const rak::socket_address *addr = rak::socket_address::cast_from(peer->peer_info()->socket_address());
+
+  if (addr->family() == rak::socket_address::af_inet6)
+    return "[" + addr->address_str() + "]";
+  else
+    return addr->address_str();
+}
+
+torrent::Object
+retrieve_p_port(torrent::Peer* peer) {
+  return rak::socket_address::cast_from(peer->peer_info()->socket_address())->port();
+}
+
+torrent::Object
+retrieve_p_client_version(torrent::Peer* peer) {
+  char buf[128];
+  display::print_client_version(buf, buf + 128, peer->peer_info()->client_info());
+
+  return std::string(buf);
+}
+
+torrent::Object
+retrieve_p_options_str(torrent::Peer* peer) {
+  return rak::transform_hex(peer->peer_info()->options(), peer->peer_info()->options() + 8);
+}
+
+torrent::Object
+retrieve_p_completed_percent(torrent::Peer* peer) {
+  return (100 * peer->bitfield()->size_set()) / peer->bitfield()->size_bits();
+}
+
+void
+initialize_command_peer() {
+  CMD2_PEER("p.id",                std::bind(&retrieve_p_id, std::placeholders::_1));
+  CMD2_PEER("p.id_html",           std::bind(&retrieve_p_id_html, std::placeholders::_1));
+  CMD2_PEER("p.client_version",    std::bind(&retrieve_p_client_version, std::placeholders::_1));
+
+  CMD2_PEER("p.options_str",       std::bind(&retrieve_p_options_str, std::placeholders::_1));
+
+  CMD2_PEER("p.is_encrypted",      std::bind(&torrent::Peer::is_encrypted, std::placeholders::_1));
+  CMD2_PEER("p.is_incoming",       std::bind(&torrent::Peer::is_incoming, std::placeholders::_1));
+  CMD2_PEER("p.is_obfuscated",     std::bind(&torrent::Peer::is_obfuscated, std::placeholders::_1));
+  CMD2_PEER("p.is_snubbed",        std::bind(&torrent::Peer::is_snubbed, std::placeholders::_1));
+
+  CMD2_PEER("p.is_unwanted",       std::bind(&torrent::PeerInfo::is_unwanted,  std::bind(&torrent::Peer::peer_info, std::placeholders::_1)));
+  CMD2_PEER("p.is_preferred",      std::bind(&torrent::PeerInfo::is_preferred, std::bind(&torrent::Peer::peer_info, std::placeholders::_1)));
+
+  CMD2_PEER("p.address",           std::bind(&retrieve_p_address, std::placeholders::_1));
+  CMD2_PEER("p.port",              std::bind(&retrieve_p_port, std::placeholders::_1));
+
+  CMD2_PEER("p.completed_percent", std::bind(&retrieve_p_completed_percent, std::placeholders::_1));
+
+  CMD2_PEER("p.up_rate",           std::bind(&torrent::Rate::rate,  std::bind(&torrent::Peer::up_rate, std::placeholders::_1)));
+  CMD2_PEER("p.up_total",          std::bind(&torrent::Rate::total, std::bind(&torrent::Peer::up_rate, std::placeholders::_1)));
+  CMD2_PEER("p.down_rate",         std::bind(&torrent::Rate::rate,  std::bind(&torrent::Peer::down_rate, std::placeholders::_1)));
+  CMD2_PEER("p.down_total",        std::bind(&torrent::Rate::total, std::bind(&torrent::Peer::down_rate, std::placeholders::_1)));
+  CMD2_PEER("p.peer_rate",         std::bind(&torrent::Rate::rate,  std::bind(&torrent::Peer::peer_rate, std::placeholders::_1)));
+  CMD2_PEER("p.peer_total",        std::bind(&torrent::Rate::total, std::bind(&torrent::Peer::peer_rate, std::placeholders::_1)));
+
+  CMD2_PEER        ("p.snubbed",     std::bind(&torrent::Peer::is_snubbed,  std::placeholders::_1));
+  CMD2_PEER_VALUE_V("p.snubbed.set", std::bind(&torrent::Peer::set_snubbed, std::placeholders::_1, std::placeholders::_2));
+  CMD2_PEER        ("p.banned",      std::bind(&torrent::Peer::is_banned,   std::placeholders::_1));
+  CMD2_PEER_VALUE_V("p.banned.set",  std::bind(&torrent::Peer::set_banned,  std::placeholders::_1, std::placeholders::_2));
+
+  CMD2_PEER_V("p.disconnect",         std::bind(&torrent::Peer::disconnect, std::placeholders::_1, 0));
+  CMD2_PEER_V("p.disconnect_delayed", std::bind(&torrent::Peer::disconnect, std::placeholders::_1, torrent::ConnectionList::disconnect_delayed));
+}

src/command_scheduler.cc

@@ -0,0 +1,83 @@
+#include "config.h"
+
+#include <sys/types.h>
+
+#include "core/manager.h"
+#include "core/download.h"
+#include "core/download_list.h"
+#include "core/view.h"
+#include "core/view_manager.h"
+
+#include "globals.h"
+#include "control.h"
+#include "command_helpers.h"
+
+torrent::Object
+cmd_scheduler_simple_added(core::Download* download) {
+  unsigned int numActive = (*control->view_manager()->find("active"))->size_visible();
+  int64_t maxActive = rpc::call_command("scheduler.max_active", torrent::Object()).as_value();
+
+  if (numActive < (uint64_t)maxActive)
+    control->core()->download_list()->resume(download);
+
+  return torrent::Object();
+}
+
+torrent::Object
+cmd_scheduler_simple_removed(core::Download* download) {
+  control->core()->download_list()->pause(download);
+
+  core::View* viewActive = *control->view_manager()->find("active");
+  int64_t maxActive = rpc::call_command("scheduler.max_active", torrent::Object()).as_value();
+
+  if ((int64_t)viewActive->size_visible() >= maxActive)
+    return torrent::Object();
+
+  // The 'started' view contains all the views we may choose amongst.
+  core::View* viewStarted = *control->view_manager()->find("started");
+
+  for (core::View::iterator itr = viewStarted->begin_visible(), last = viewStarted->end_visible(); itr != last; itr++) {
+    if ((*itr)->is_active())
+      continue;
+
+    control->core()->download_list()->resume(*itr);
+  }
+
+  return torrent::Object();
+}
+
+torrent::Object
+cmd_scheduler_simple_update([[maybe_unused]] core::Download* download) {
+  core::View* viewActive = *control->view_manager()->find("active");
+  core::View* viewStarted = *control->view_manager()->find("started");
+
+  unsigned int numActive = viewActive->size_visible();
+  uint64_t maxActive = rpc::call_command("scheduler.max_active", torrent::Object()).as_value();
+
+  if (viewActive->size_visible() < maxActive) {
+    for (core::View::iterator itr = viewStarted->begin_visible(), last = viewStarted->end_visible(); itr != last; itr++) {
+      if ((*itr)->is_active())
+        continue;
+
+      control->core()->download_list()->resume(*itr);
+
+      if (++numActive >= maxActive)
+        break;
+    }
+
+  } else {
+    while (viewActive->size_visible() > maxActive)
+      control->core()->download_list()->pause(*viewActive->begin_visible());
+  }
+
+  return torrent::Object();
+}
+
+void
+initialize_command_scheduler() {
+  CMD2_VAR_VALUE("scheduler.max_active", int64_t(-1));
+
+  CMD2_DL("scheduler.simple.added",   std::bind(&cmd_scheduler_simple_added, std::placeholders::_1));
+  CMD2_DL("scheduler.simple.removed", std::bind(&cmd_scheduler_simple_removed, std::placeholders::_1));
+  CMD2_DL("scheduler.simple.update",  std::bind(&cmd_scheduler_simple_update, std::placeholders::_1));
+}

src/command_throttle.cc

@@ -0,0 +1,231 @@
+// rTorrent - BitTorrent client
+// Copyright (C) 2005-2011, Jari Sundell
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+// 
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// In addition, as a special exception, the copyright holders give
+// permission to link the code of portions of this program with the
+// OpenSSL library under certain conditions as described in each
+// individual source file, and distribute linked combinations
+// including the two.
+//
+// You must obey the GNU General Public License in all respects for
+// all of the code used other than OpenSSL.  If you modify file(s)
+// with this exception, you may extend this exception to your version
+// of the file(s), but you are not obligated to do so.  If you do not
+// wish to do so, delete this exception statement from your version.
+// If you delete this exception statement from all source files in the
+// program, then also delete it here.
+//
+// Contact:  Jari Sundell <jaris@ifi.uio.no>
+//
+//           Skomakerveien 33
+//           3185 Skoppum, NORWAY
+
+#include "config.h"
+
+#include <cstdio>
+#include <rak/address_info.h>
+#include <torrent/throttle.h>
+#include <torrent/rate.h>
+#include <torrent/download/resource_manager.h>
+
+#include "core/manager.h"
+#include "ui/root.h"
+#include "rpc/parse.h"
+#include "rpc/parse_commands.h"
+
+#include "globals.h"
+#include "control.h"
+#include "command_helpers.h"
+
+std::pair<uint32_t, uint32_t>
+parse_address_range(const torrent::Object::list_type& args, torrent::Object::list_type::const_iterator itr) {
+  unsigned int prefixWidth, ret;
+  char dummy;
+  char host[1024];
+  rak::address_info* ai;
+
+  ret = std::sscanf(itr->as_string().c_str(), "%1023[^/]/%d%c", host, &prefixWidth, &dummy);
+  if (ret < 1 || rak::address_info::get_address_info(host, PF_INET, SOCK_STREAM, &ai) != 0)
+    throw torrent::input_error("Could not resolve host.");
+
+  uint32_t begin, end;
+  rak::socket_address sa;
+  sa.copy(*ai->address(), ai->length());
+  begin = end = sa.sa_inet()->address_h();
+  rak::address_info::free_address_info(ai);
+
+  if (ret == 2) {
+    if (++itr != args.end())
+      throw torrent::input_error("Cannot specify both network and range end.");
+
+    uint32_t netmask = std::numeric_limits<uint32_t>::max() << (32 - prefixWidth);
+    if (prefixWidth >= 32 || sa.sa_inet()->address_h() & ~netmask)
+      throw torrent::input_error("Invalid address/prefix.");
+
+    end = sa.sa_inet()->address_h() | ~netmask;
+
+  } else if (++itr != args.end()) {
+    if (rak::address_info::get_address_info(itr->as_string().c_str(), PF_INET, SOCK_STREAM, &ai) != 0)
+      throw torrent::input_error("Could not resolve host.");
+
+    sa.copy(*ai->address(), ai->length());
+    rak::address_info::free_address_info(ai);
+    end = sa.sa_inet()->address_h();
+  }
+
+  // convert to [begin, end) making sure the end doesn't overflow
+  // (this precludes 255.255.255.255 from ever matching, but that's not a real IP anyway)
+  return std::make_pair((uint32_t)begin, (uint32_t)std::max(end, end + 1));
+}
+
+torrent::Object
+apply_throttle(const torrent::Object::list_type& args, bool up) {
+  torrent::Object::list_const_iterator argItr = args.begin();
+
+  if (argItr == args.end())
+    throw torrent::input_error("Missing throttle name.");
+
+  const std::string& name = argItr->as_string();
+  if (name.empty() || name == "NULL")
+    throw torrent::input_error("Invalid throttle name '" + name + "'.");
+
+  if (++argItr == args.end() || argItr->as_string().empty())
+    throw torrent::input_error("Missing throttle rate for '" + name + "'.");
+
+  int64_t rate;
+  rpc::parse_whole_value_nothrow(argItr->as_string().c_str(), &rate);
+
+  if (rate < 0)
+    throw torrent::input_error("Throttle rate must be non-negative.");
+
+  core::ThrottleMap::iterator itr = control->core()->throttles().find(name);
+  if (itr == control->core()->throttles().end())
+    itr = control->core()->throttles().insert(std::make_pair(name, torrent::ThrottlePair(NULL, NULL))).first;
+
+  torrent::Throttle*& throttle = up ? itr->second.first : itr->second.second;
+  if (rate != 0 && throttle == NULL)
+    throttle = (up ? torrent::up_throttle_global() : torrent::down_throttle_global())->create_slave();
+
+  if (throttle != NULL)
+    throttle->set_max_rate(rate * 1024);
+
+  return torrent::Object();
+}
+
+static const int throttle_info_up   = (1 << 0);
+static const int throttle_info_down = (1 << 1);
+static const int throttle_info_max  = (1 << 2);
+static const int throttle_info_rate = (1 << 3);
+
+torrent::Object
+retrieve_throttle_info(const torrent::Object::string_type& name, int flags) {
+  core::ThrottleMap::iterator itr = control->core()->throttles().find(name);
+  torrent::ThrottlePair throttles = itr == control->core()->throttles().end() ? torrent::ThrottlePair(NULL, NULL) : itr->second;
+  torrent::Throttle* throttle = flags & throttle_info_down ? throttles.second : throttles.first;
+  torrent::Throttle* global = flags & throttle_info_down ? torrent::down_throttle_global() : torrent::up_throttle_global();
+
+  if (throttle == NULL && name.empty())
+    throttle = global;
+
+  if (throttle == NULL)
+    return flags & throttle_info_rate ? (int64_t)0 : (int64_t)-1;
+  else if (!throttle->is_throttled() || !global->is_throttled())
+    return (int64_t)0;
+  else if (flags & throttle_info_rate)
+    return (int64_t)throttle->rate()->rate();
+  else
+    return (int64_t)throttle->max_rate();
+}
+
+torrent::Object
+apply_address_throttle(const torrent::Object::list_type& args) {
+  if (args.size() < 2 || args.size() > 3)
+    throw torrent::input_error("Incorrect number of arguments.");
+
+  std::pair<uint32_t, uint32_t> range = parse_address_range(args, ++args.begin());
+  core::ThrottleMap::iterator throttleItr = control->core()->throttles().find(args.begin()->as_string().c_str());
+  if (throttleItr == control->core()->throttles().end())
+    throw torrent::input_error("Throttle not found.");
+
+  control->core()->set_address_throttle(range.first, range.second, throttleItr->second);
+  return torrent::Object();
+}
+
+torrent::Object
+throttle_update(const char* variable, int64_t value) {
+  rpc::commands.call_command(variable, value);
+
+  control->ui()->adjust_up_throttle(0);
+  control->ui()->adjust_down_throttle(0);
+  return torrent::Object();
+}
+
+void
+initialize_command_throttle() {
+  CMD2_ANY         ("throttle.unchoked_uploads",       std::bind(&torrent::ResourceManager::currently_upload_unchoked, torrent::resource_manager()));
+  CMD2_ANY         ("throttle.max_unchoked_uploads",   std::bind(&torrent::ResourceManager::max_upload_unchoked, torrent::resource_manager()));
+  CMD2_ANY         ("throttle.unchoked_downloads",     std::bind(&torrent::ResourceManager::currently_download_unchoked, torrent::resource_manager()));
+  CMD2_ANY         ("throttle.max_unchoked_downloads", std::bind(&torrent::ResourceManager::max_download_unchoked, torrent::resource_manager()));
+
+  CMD2_VAR_VALUE   ("throttle.min_peers.normal", 100);
+  CMD2_VAR_VALUE   ("throttle.max_peers.normal", 200);
+  CMD2_VAR_VALUE   ("throttle.min_peers.seed",   -1);
+  CMD2_VAR_VALUE   ("throttle.max_peers.seed",   -1);
+
+  CMD2_VAR_VALUE   ("throttle.min_uploads",      0);
+  CMD2_VAR_VALUE   ("throttle.max_uploads",      50);
+  CMD2_VAR_VALUE   ("throttle.min_downloads",    0);
+  CMD2_VAR_VALUE   ("throttle.max_downloads",    50);
+
+  CMD2_VAR_VALUE   ("throttle.max_uploads.div._val",      1);
+  CMD2_VAR_VALUE   ("throttle.max_uploads.global._val",   0);
+  CMD2_VAR_VALUE   ("throttle.max_downloads.div._val",    1);
+  CMD2_VAR_VALUE   ("throttle.max_downloads.global._val", 0);
+
+  CMD2_REDIRECT_GENERIC("throttle.max_uploads.div",      "throttle.max_uploads.div._val");
+  CMD2_REDIRECT_GENERIC("throttle.max_uploads.global",   "throttle.max_uploads.global._val");
+  CMD2_REDIRECT_GENERIC("throttle.max_downloads.div",    "throttle.max_downloads.div._val");
+  CMD2_REDIRECT_GENERIC("throttle.max_downloads.global", "throttle.max_downloads.global._val");
+
+  CMD2_ANY_VALUE   ("throttle.max_uploads.div.set",      std::bind(&throttle_update, "throttle.max_uploads.div._val.set", std::placeholders::_2));
+  CMD2_ANY_VALUE   ("throttle.max_uploads.global.set",   std::bind(&throttle_update, "throttle.max_uploads.global._val.set", std::placeholders::_2));
+  CMD2_ANY_VALUE   ("throttle.max_downloads.div.set",    std::bind(&throttle_update, "throttle.max_downloads.div._val.set", std::placeholders::_2));
+  CMD2_ANY_VALUE   ("throttle.max_downloads.global.set", std::bind(&throttle_update, "throttle.max_downloads.global._val.set", std::placeholders::_2));
+
+  // TODO: Move the logic into some libtorrent function.
+  CMD2_ANY         ("throttle.global_up.rate",              std::bind(&torrent::Rate::rate, torrent::up_rate()));
+  CMD2_ANY         ("throttle.global_up.total",             std::bind(&torrent::Rate::total, torrent::up_rate()));
+  CMD2_ANY         ("throttle.global_up.max_rate",          std::bind(&torrent::Throttle::max_rate, torrent::up_throttle_global()));
+  CMD2_ANY_VALUE_V ("throttle.global_up.max_rate.set",      std::bind(&ui::Root::set_up_throttle_i64, control->ui(), std::placeholders::_2));
+  CMD2_ANY_VALUE_KB("throttle.global_up.max_rate.set_kb",   std::bind(&ui::Root::set_up_throttle_i64, control->ui(), std::placeholders::_2));
+  CMD2_ANY         ("throttle.global_down.rate",            std::bind(&torrent::Rate::rate, torrent::down_rate()));
+  CMD2_ANY         ("throttle.global_down.total",           std::bind(&torrent::Rate::total, torrent::down_rate()));
+  CMD2_ANY         ("throttle.global_down.max_rate",        std::bind(&torrent::Throttle::max_rate, torrent::down_throttle_global()));
+  CMD2_ANY_VALUE_V ("throttle.global_down.max_rate.set",    std::bind(&ui::Root::set_down_throttle_i64, control->ui(), std::placeholders::_2));
+  CMD2_ANY_VALUE_KB("throttle.global_down.max_rate.set_kb", std::bind(&ui::Root::set_down_throttle_i64, control->ui(), std::placeholders::_2));
+
+  // Temporary names, need to change this to accept real rates rather
+  // than kB.
+  CMD2_ANY_LIST    ("throttle.up",                          std::bind(&apply_throttle, std::placeholders::_2, true));
+  CMD2_ANY_LIST    ("throttle.down",                        std::bind(&apply_throttle, std::placeholders::_2, false));
+  CMD2_ANY_LIST    ("throttle.ip",                          std::bind(&apply_address_throttle, std::placeholders::_2));
+
+  CMD2_ANY_STRING  ("throttle.up.max",    std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_up | throttle_info_max));
+  CMD2_ANY_STRING  ("throttle.up.rate",   std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_up | throttle_info_rate));
+  CMD2_ANY_STRING  ("throttle.down.max",  std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_down | throttle_info_max));
+  CMD2_ANY_STRING  ("throttle.down.rate", std::bind(&retrieve_throttle_info, std::placeholders::_2, throttle_info_down | throttle_info_rate));
+}

src/command_tracker.cc

@@ -0,0 +1,146 @@
+#include "config.h"
+
+#include <cassert>
+#include <cstdio>
+#include <netdb.h>
+#include <rak/address_info.h>
+#include <rak/error_number.h>
+#include <torrent/net/resolver.h>
+#include <torrent/tracker/dht_controller.h>
+#include <torrent/tracker/tracker.h>
+#include <torrent/utils/log.h>
+
+#include "core/download.h"
+#include "core/manager.h"
+
+#include "globals.h"
+#include "control.h"
+#include "command_helpers.h"
+#include "core/dht_manager.h"
+
+void
+tracker_set_enabled(torrent::tracker::Tracker* tracker, bool state) {
+  if (state)
+    tracker->enable();
+  else
+    tracker->disable();
+}
+
+torrent::Object
+apply_dht_add_node(const std::string& arg) {
+  if (!torrent::dht_controller()->is_valid())
+    throw torrent::input_error("DHT not enabled.");
+
+  int port, ret;
+  char dummy;
+  char host[1024];
+
+  ret = std::sscanf(arg.c_str(), "%1023[^:]:%i%c", host, &port, &dummy);
+
+  if (ret == 1)
+    port = 6881;
+  else if (ret != 2)
+    throw torrent::input_error("Could not parse host.");
+
+  if (port < 1 || port > 65535)
+    throw torrent::input_error("Invalid port number.");
+
+  assert(std::this_thread::get_id() == torrent::main_thread::thread()->thread_id());
+
+  // Currently discarding SOCK_STREAM.
+  torrent::this_thread::resolver()->resolve_specific(nullptr, host, PF_INET, [port](torrent::c_sa_shared_ptr sa, int err) {
+      if (sa == nullptr) {
+        lt_log_print(torrent::LOG_DHT_WARN, "Could not resolve host: %s", gai_strerror(err));
+        return;
+      }
+
+      torrent::dht_controller()->add_node(sa.get(), port);
+  });
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_enable_trackers(int64_t arg) {
+  if (arg == 0) {
+    for (auto itr : *control->core()->download_list())
+      itr->tracker_controller().for_each([](auto& tracker) { tracker.disable(); });
+
+  } else if (rpc::call_command_value("trackers.use_udp") == 0) {
+    for (auto itr : *control->core()->download_list()) {
+      itr->tracker_controller().for_each([](auto& tracker) {
+          if (tracker.type() == torrent::TRACKER_UDP)
+            tracker.disable();
+          else
+            tracker.enable();
+        });
+    }
+
+  } else {
+    for (auto itr : *control->core()->download_list())
+      itr->tracker_controller().for_each([](auto& tracker) { tracker.enable(); });
+  }
+
+  return torrent::Object();
+}
+
+void
+initialize_command_tracker() {
+  CMD2_TRACKER        ("t.is_busy",           std::bind(&torrent::tracker::Tracker::is_busy, std::placeholders::_1));
+  CMD2_TRACKER        ("t.is_enabled",        std::bind(&torrent::tracker::Tracker::is_enabled, std::placeholders::_1));
+  CMD2_TRACKER        ("t.is_extra_tracker",  std::bind(&torrent::tracker::Tracker::is_extra_tracker, std::placeholders::_1));
+  CMD2_TRACKER        ("t.is_open",           std::bind(&torrent::tracker::Tracker::is_busy, std::placeholders::_1));
+  CMD2_TRACKER        ("t.is_scrapable",      std::bind(&torrent::tracker::Tracker::is_scrapable, std::placeholders::_1));
+  CMD2_TRACKER        ("t.is_usable",         std::bind(&torrent::tracker::Tracker::is_usable, std::placeholders::_1));
+
+  // TODO: Deprecate.
+  CMD2_TRACKER        ("t.can_scrape",        std::bind(&torrent::tracker::Tracker::is_scrapable, std::placeholders::_1));
+
+  CMD2_TRACKER_V      ("t.enable",            std::bind(&torrent::tracker::Tracker::enable, std::placeholders::_1));
+  CMD2_TRACKER_V      ("t.disable",           std::bind(&torrent::tracker::Tracker::disable, std::placeholders::_1));
+
+  CMD2_TRACKER_VALUE_V("t.is_enabled.set",    std::bind(&tracker_set_enabled, std::placeholders::_1, std::placeholders::_2));
+
+  CMD2_TRACKER        ("t.url",               std::bind(&torrent::tracker::Tracker::url, std::placeholders::_1));
+  CMD2_TRACKER        ("t.group",             std::bind(&torrent::tracker::Tracker::group, std::placeholders::_1));
+  CMD2_TRACKER        ("t.type",              std::bind(&torrent::tracker::Tracker::type, std::placeholders::_1));
+  CMD2_TRACKER        ("t.id",                std::bind(&torrent::tracker::Tracker::tracker_id, std::placeholders::_1));
+
+  CMD2_TRACKER        ("t.latest_event",      [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().latest_event(); });
+  CMD2_TRACKER        ("t.latest_new_peers",  [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().latest_new_peers(); });
+  CMD2_TRACKER        ("t.latest_sum_peers",  [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().latest_sum_peers(); });
+
+  CMD2_TRACKER        ("t.normal_interval",   [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().normal_interval(); });
+  CMD2_TRACKER        ("t.min_interval",      [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().min_interval(); });
+
+  CMD2_TRACKER        ("t.activity_time_next", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().activity_time_next(); });
+  CMD2_TRACKER        ("t.activity_time_last", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().activity_time_last(); });
+
+  CMD2_TRACKER        ("t.success_time_next", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().success_time_next(); });
+  CMD2_TRACKER        ("t.success_time_last", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().success_time_last(); });
+  CMD2_TRACKER        ("t.success_counter",   [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().success_counter(); });
+
+  CMD2_TRACKER        ("t.failed_time_next",  [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().failed_time_next(); });
+  CMD2_TRACKER        ("t.failed_time_last",  [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().failed_time_last(); });
+  CMD2_TRACKER        ("t.failed_counter",    [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().failed_counter(); });
+
+  CMD2_TRACKER        ("t.scrape_time_last",  [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().scrape_time_last(); });
+  CMD2_TRACKER        ("t.scrape_counter",    [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().scrape_counter(); });
+
+  CMD2_TRACKER        ("t.scrape_complete",   [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().scrape_complete(); });
+  CMD2_TRACKER        ("t.scrape_incomplete", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().scrape_incomplete(); });
+  CMD2_TRACKER        ("t.scrape_downloaded", [](torrent::tracker::Tracker* tracker, [[maybe_unused]] auto o) -> auto { return tracker->state().scrape_downloaded(); });
+
+  CMD2_ANY_VALUE      ("trackers.enable",     std::bind(&apply_enable_trackers, int64_t(1)));
+  CMD2_ANY_VALUE      ("trackers.disable",    std::bind(&apply_enable_trackers, int64_t(0)));
+  CMD2_VAR_BOOL       ("trackers.delay_scrape", false);
+  CMD2_VAR_VALUE      ("trackers.numwant",    -1);
+  CMD2_VAR_BOOL       ("trackers.use_udp",    true);
+
+  CMD2_ANY_STRING_V   ("dht.mode.set",          std::bind(&core::DhtManager::set_mode, control->dht_manager(), std::placeholders::_2));
+  CMD2_VAR_VALUE      ("dht.port",              int64_t(6881));
+  CMD2_ANY_STRING     ("dht.add_node",          std::bind(&apply_dht_add_node, std::placeholders::_2));
+  CMD2_ANY            ("dht.statistics",        std::bind(&core::DhtManager::dht_statistics, control->dht_manager()));
+  CMD2_ANY            ("dht.throttle.name",     std::bind(&core::DhtManager::throttle_name, control->dht_manager()));
+  CMD2_ANY_STRING_V   ("dht.throttle.name.set", std::bind(&core::DhtManager::set_throttle_name, control->dht_manager(), std::placeholders::_2));
+}

src/command_ui.cc

@@ -0,0 +1,885 @@
+#include "config.h"
+
+#include <sys/types.h>
+
+#include <ctime>
+#include <regex>
+#include <rak/algorithm.h>
+#include <torrent/utils/log.h>
+
+#include "core/manager.h"
+#include "core/view_manager.h"
+#include "display/canvas.h"
+#include "ui/root.h"
+#include "ui/download_list.h"
+#include "display/color_map.h"
+#include "rpc/parse.h"
+
+#include "globals.h"
+#include "control.h"
+#include "command_helpers.h"
+
+typedef void (core::ViewManager::*view_event_slot)(const std::string&, const torrent::Object&);
+
+torrent::Object
+apply_view_filter_on(const torrent::Object::list_type& args) {
+  if (args.size() < 1)
+    throw torrent::input_error("Too few arguments.");
+
+  const std::string& name = args.front().as_string();
+
+  if (name.empty())
+    throw torrent::input_error("First argument must be a string.");
+
+  core::ViewManager::filter_args filterArgs;
+
+  for (torrent::Object::list_const_iterator itr = ++args.begin(), last = args.end(); itr != last; itr++)
+    filterArgs.push_back(itr->as_string());
+
+  control->view_manager()->set_filter_on(name, filterArgs);
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_view_event(view_event_slot viewFilterSlot, const torrent::Object::list_type& args) {
+  if (args.size() != 2)
+    throw torrent::input_error("Wrong argument count.");
+
+  (control->view_manager()->*viewFilterSlot)(args.front().as_string(), args.back());
+  return torrent::Object();
+}
+
+torrent::Object
+apply_view_sort(const torrent::Object::list_type& args) {
+  if (args.size() <= 0 || args.size() > 2)
+    throw torrent::input_error("Wrong argument count.");
+
+  const std::string& name = args.front().as_string();
+
+  if (name.empty())
+    throw torrent::input_error("First argument must be a string.");
+
+  int32_t value = 0;
+
+  if (args.size() == 2)
+    value = rpc::convert_to_value(args.back());
+
+  control->view_manager()->sort(name, value);
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_view_list() {
+  torrent::Object rawResult = torrent::Object::create_list();
+  torrent::Object::list_type& result = rawResult.as_list();
+
+  for (core::ViewManager::const_iterator itr = control->view_manager()->begin(), last = control->view_manager()->end(); itr != last; itr++)
+    result.push_back((*itr)->name());
+
+  return rawResult;
+}
+
+torrent::Object
+apply_view_set(const torrent::Object::list_type& args) {
+  if (args.size() != 2)
+    throw torrent::input_error("Wrong argument count.");
+
+  core::ViewManager::iterator itr = control->view_manager()->find(args.back().as_string());
+
+  if (itr == control->view_manager()->end())
+    throw torrent::input_error("Could not find view \"" + args.back().as_string() + "\".");
+
+//   if (args.front().as_string() == "main")
+//     control->ui()->download_list()->set_view(*itr);
+//   else
+
+  throw torrent::input_error("No such target.");
+}
+
+torrent::Object
+apply_print([[maybe_unused]] rpc::target_type target, const torrent::Object& rawArgs) {
+  char buffer[1024];
+  rpc::print_object(buffer, buffer + 1024, &rawArgs, 0);
+
+  control->core()->push_log(buffer);
+  return torrent::Object();
+}
+
+torrent::Object
+apply_cat([[maybe_unused]] rpc::target_type target, const torrent::Object& rawArgs) {
+  std::string result;
+
+  rpc::print_object_std(&result, &rawArgs, 0);
+  return result;
+}
+
+torrent::Object
+apply_value([[maybe_unused]] rpc::target_type target, const torrent::Object::list_type& args) {
+  if (args.size() < 1)
+    throw torrent::input_error("'value' takes at least a number argument!");
+  if (args.size() > 2)
+    throw torrent::input_error("'value' takes at most two arguments!");
+
+  torrent::Object::value_type val = 0;
+  if (args.front().is_value()) {
+    val = args.front().as_value();
+  } else {
+    int base = args.size() > 1 ? args.back().is_value() ?
+               args.back().as_value() : strtol(args.back().as_string().c_str(), NULL, 10) : 10;
+    char* endptr = 0;
+
+    val = strtoll(args.front().as_string().c_str(), &endptr, base);
+    while (*endptr == ' ' || *endptr == '\n') ++endptr;
+    if (*endptr)
+      throw torrent::input_error("Junk at end of number: " + args.front().as_string());
+  }
+
+  return val;
+}
+
+torrent::Object
+apply_try(rpc::target_type target, const torrent::Object& args) {
+  try {
+    return rpc::call_object(args, target);
+  } catch (torrent::input_error& e) {
+    lt_log_print(torrent::LOG_RPC_EVENTS, "try command caught input_error: %s", e.what());
+  }
+
+  return torrent::Object();
+}
+
+// Move these boolean operators to a new file.
+
+inline bool
+as_boolean(const torrent::Object& rawArgs) {
+  switch (rawArgs.type()) {
+  case torrent::Object::TYPE_VALUE:  return rawArgs.as_value();
+  case torrent::Object::TYPE_STRING: return !rawArgs.as_string().empty();
+
+  // We need to properly handle argument lists that are single-object
+  // at a higher level.
+  case torrent::Object::TYPE_LIST:   return !rawArgs.as_list().empty() && as_boolean(rawArgs.as_list().front());
+  // case torrent::Object::TYPE_MAP:    return !rawArgs.as_map().empty();
+  default: return false;
+  }
+}
+
+torrent::Object
+apply_not(rpc::target_type target, const torrent::Object& rawArgs) {
+  bool result;
+
+  if (rawArgs.is_dict_key())
+    result = as_boolean(rpc::commands.call_command(rawArgs.as_dict_key().c_str(), rawArgs.as_dict_obj(),
+                                                   target));
+  // TODO: Thus we should clean this up...
+  else if (rawArgs.is_list() && !rawArgs.as_list().empty())
+    return apply_not(target, rawArgs.as_list().front());
+
+  else
+    result = as_boolean(rawArgs);
+
+  return (int64_t)!result;
+}
+
+torrent::Object
+apply_false([[maybe_unused]] rpc::target_type target, [[maybe_unused]] const torrent::Object& rawArgs) {
+  return (int64_t)0;
+}
+
+torrent::Object
+apply_and(rpc::target_type target, const torrent::Object& rawArgs) {
+  if (rawArgs.type() != torrent::Object::TYPE_LIST)
+    return as_boolean(rawArgs);
+
+  for (torrent::Object::list_const_iterator itr = rawArgs.as_list().begin(), last = rawArgs.as_list().end(); itr != last; itr++)
+    if (itr->is_dict_key()) {
+      if (!as_boolean(rpc::commands.call_command(itr->as_dict_key().c_str(), itr->as_dict_obj(), target)))
+        return (int64_t)false;
+
+    } else if (itr->is_value()) {
+      if (!itr->as_value())
+        return (int64_t)false;
+
+    } else {
+      // TODO: Switch to new versions that only accept the new command syntax.
+      if (!as_boolean(rpc::parse_command_single(target, itr->as_string())))
+        return (int64_t)false;
+    }
+
+  return (int64_t)true;
+}
+
+torrent::Object
+apply_or(rpc::target_type target, const torrent::Object& rawArgs) {
+  if (rawArgs.type() != torrent::Object::TYPE_LIST)
+    return as_boolean(rawArgs);
+
+  for (torrent::Object::list_const_iterator itr = rawArgs.as_list().begin(), last = rawArgs.as_list().end(); itr != last; itr++)
+    if (itr->is_dict_key()) {
+      if (as_boolean(rpc::commands.call_command(itr->as_dict_key().c_str(), itr->as_dict_obj(), target)))
+        return (int64_t)true;
+
+    } else if (itr->is_value()) {
+      if (itr->as_value())
+        return (int64_t)true;
+
+    } else {
+      if (as_boolean(rpc::parse_command_single(target, itr->as_string())))
+        return (int64_t)true;
+    }
+
+  return (int64_t)false;
+}
+
+torrent::Object
+apply_cmp(rpc::target_type target, const torrent::Object::list_type& args) {
+  // We only need to check if empty() since if size() == 1 it calls
+  // the same command for both, or if size() == 2 then each side of
+  // the comparison has different commands.
+  if (args.empty())
+    throw torrent::input_error("Wrong argument count.");
+
+  // This really should be converted to using args flagged as
+  // commands, so that we can compare commands and statics values.
+
+  torrent::Object result1;
+  torrent::Object result2;
+
+  rpc::target_type target1 = rpc::is_target_pair(target) ? rpc::get_target_left(target) : target;
+  rpc::target_type target2 = rpc::is_target_pair(target) ? rpc::get_target_right(target) : target;
+
+  if (args.front().is_dict_key())
+    result1 = rpc::commands.call_command(args.front().as_dict_key().c_str(), args.front().as_dict_obj(), target1);
+  else
+    result1 = rpc::parse_command_single(target1, args.front().as_string());
+
+  if (args.back().is_dict_key())
+    result2 = rpc::commands.call_command(args.back().as_dict_key().c_str(), args.back().as_dict_obj(), target2);
+  else
+    result2 = rpc::parse_command_single(target2, args.back().as_string());
+
+  if (result1.type() != result2.type())
+    throw torrent::input_error("Type mismatch.");
+
+  switch (result1.type()) {
+  case torrent::Object::TYPE_VALUE:  return result1.as_value() - result2.as_value();
+  case torrent::Object::TYPE_STRING: return result1.as_string().compare(result2.as_string());
+  default: return torrent::Object();
+  }
+}
+
+torrent::Object apply_less(rpc::target_type target, const torrent::Object::list_type& args) {
+  torrent::Object result = apply_cmp(target, args);
+  return result.is_value() ? result.as_value() <  0 : (int64_t)false;
+}
+
+torrent::Object apply_greater(rpc::target_type target, const torrent::Object::list_type& args) {
+  torrent::Object result = apply_cmp(target, args);
+  return result.is_value() ? result.as_value() >  0 : (int64_t)false;
+}
+
+torrent::Object apply_equal(rpc::target_type target, const torrent::Object::list_type& args) {
+  torrent::Object result = apply_cmp(target, args);
+  return result.is_value() ? result.as_value() == 0 : (int64_t)false;
+}
+
+torrent::Object
+apply_compare(rpc::target_type target, const torrent::Object::list_type& args) {
+  if (!rpc::is_target_pair(target))
+    throw torrent::input_error("Can only compare a target pair.");
+
+  if (args.size() < 2)
+    throw torrent::input_error("Need at least order and one field.");
+
+  torrent::Object::list_const_iterator itr = args.begin();
+  std::string order = (itr++)->as_string();
+  const char* current = order.c_str();
+
+  torrent::Object result1;
+  torrent::Object result2;
+
+  for (torrent::Object::list_const_iterator last = args.end(); itr != last; itr++) {
+    std::string field = itr->as_string();
+    result1 = rpc::parse_command_single(rpc::get_target_left(target), field);
+    result2 = rpc::parse_command_single(rpc::get_target_right(target), field);
+
+    if (result1.type() != result2.type())
+      throw torrent::input_error(std::string("Type mismatch in compare of ") + field);
+
+    bool descending = *current == 'd' || *current == 'D' || *current == '-';
+    if (*current) {
+      if (!descending && !(*current == 'a' || *current == 'A' || *current == '+'))
+        throw torrent::input_error(std::string("Bad order '") + *current + "' in " + order);
+      ++current;
+    }
+
+    switch (result1.type()) {
+      case torrent::Object::TYPE_VALUE:
+        if (result1.as_value() != result2.as_value())
+          return (int64_t) (descending ^ (result1.as_value() < result2.as_value()));
+        break;
+
+      case torrent::Object::TYPE_STRING:
+        if (result1.as_string() != result2.as_string())
+          return (int64_t) (descending ^ (result1.as_string() < result2.as_string()));
+        break;
+
+      default:
+        break; // treat unknown types as equal
+    }
+  }
+
+  // if all else is equal, ensure stable sort order based on memory location
+  return (int64_t) (target.second < target.third);
+}
+
+// Regexp based 'match' function.
+// arg1: the text to match.
+// arg2: the regexp pattern.
+// eg: match{d.name=,.*linux.*iso}
+torrent::Object apply_match(rpc::target_type target, const torrent::Object::list_type& args) {
+  if (args.size() != 2)
+    throw torrent::input_error("Wrong argument count for 'match': 2 arguments needed.");
+
+  // This really should be converted to using args flagged as
+  // commands, so that we can compare commands and statics values.
+
+  torrent::Object result1;
+  torrent::Object result2;
+
+  rpc::target_type target1 = rpc::is_target_pair(target) ? rpc::get_target_left(target) : target;
+  rpc::target_type target2 = rpc::is_target_pair(target) ? rpc::get_target_right(target) : target;
+
+  if (args.front().is_dict_key())
+    result1 = rpc::commands.call_command(args.front().as_dict_key().c_str(), args.front().as_dict_obj(), target1);
+  else
+    result1 = rpc::parse_command_single(target1, args.front().as_string());
+
+  if (args.back().is_dict_key())
+    result2 = rpc::commands.call_command(args.back().as_dict_key().c_str(), args.back().as_dict_obj(), target2);
+  else
+    result2 = args.back().as_string();
+
+  if (result1.type() != result2.type())
+    throw torrent::input_error("Type mismatch for 'match' arguments.");
+
+  std::string text = result1.as_string();
+  std::string pattern = result2.as_string();
+
+  std::transform(text.begin(), text.end(), text.begin(), ::tolower);
+  std::transform(pattern.begin(), pattern.end(), pattern.begin(), ::tolower);
+
+  bool isAMatch = false;
+  try {
+    std::regex re(pattern);
+    isAMatch = std::regex_match(text, re);
+  } catch (const std::regex_error& exc) {
+    control->core()->push_log_std("regex_error: " + std::string(exc.what()));
+  }
+
+  return isAMatch ? (int64_t)true : (int64_t)false;
+}
+
+torrent::Object
+apply_to_time(const torrent::Object& rawArgs, int flags) {
+  std::tm *u;
+  time_t t = (uint64_t)rawArgs.as_value();
+
+  if (flags & 0x1)
+    u = std::localtime(&t);
+  else
+    u = std::gmtime(&t);
+
+  if (u == NULL)
+    return torrent::Object();
+
+  char buffer[11];
+
+  if (flags & 0x2)
+    snprintf(buffer, 11, "%02u/%02u/%04u", u->tm_mday, (u->tm_mon + 1), (1900 + u->tm_year));
+  else
+    snprintf(buffer, 9, "%2d:%02d:%02d", u->tm_hour, u->tm_min, u->tm_sec);
+
+  return std::string(buffer);
+}
+
+torrent::Object
+apply_to_elapsed_time(const torrent::Object& rawArgs) {
+  auto cached_seconds = torrent::this_thread::cached_seconds().count();
+
+  uint64_t arg = cached_seconds - rawArgs.as_value();
+
+  char buffer[48];
+  snprintf(buffer, 48, "%2d:%02d:%02d", (int)(arg / 3600), (int)((arg / 60) % 60), (int)(arg % 60));
+
+  return std::string(buffer);
+}
+
+torrent::Object
+apply_to_kb(const torrent::Object& rawArgs) {
+  char buffer[32];
+  snprintf(buffer, 32, "%5.1f", (double)rawArgs.as_value() / (1 << 10));
+
+  return std::string(buffer);
+}
+
+torrent::Object
+apply_to_mb(const torrent::Object& rawArgs) {
+  char buffer[32];
+  snprintf(buffer, 32, "%8.1f", (double)rawArgs.as_value() / (1 << 20));
+
+  return std::string(buffer);
+}
+
+torrent::Object
+apply_to_xb(const torrent::Object& rawArgs) {
+  char buffer[48];
+  int64_t arg = rawArgs.as_value();
+
+  if (arg < (int64_t(1000) << 10))
+    snprintf(buffer, 48, "%5.1f KB", (double)arg / (int64_t(1) << 10));
+  else if (arg < (int64_t(1000) << 20))
+    snprintf(buffer, 48, "%5.1f MB", (double)arg / (int64_t(1) << 20));
+  else if (arg < (int64_t(1000) << 30))
+    snprintf(buffer, 48, "%5.1f GB", (double)arg / (int64_t(1) << 30));
+  else
+    snprintf(buffer, 48, "%5.1f TB", (double)arg / (int64_t(1) << 40));
+
+  return std::string(buffer);
+}
+
+torrent::Object
+apply_to_throttle(const torrent::Object& rawArgs) {
+  int64_t arg = rawArgs.as_value();
+  if (arg < 0)
+    return "---";
+  else if (arg == 0)
+    return "off";
+
+  char buffer[32];
+  snprintf(buffer, 32, "%3d", (int)(arg / (1 << 10)));
+  return std::string(buffer);
+}
+
+// A series of if/else statements. Every even arguments are
+// conditionals and odd arguments are branches to be executed, except
+// the last one which is always a branch.
+//
+// if (cond1) { branch1 }
+// <cond1>,<branch1>
+//
+// if (cond1) { branch1 } else if (cond2) { branch2 } else { branch3 }
+// <cond1>,<branch1>,<cond2>,<branch2>,<branch3>
+torrent::Object
+apply_if(rpc::target_type target, const torrent::Object& rawArgs, int flags) {
+  const torrent::Object::list_type& args = rawArgs.as_list();
+  torrent::Object::list_const_iterator itr = args.begin();
+
+  while (itr != args.end() && itr != --args.end()) {
+    torrent::Object tmp;
+    const torrent::Object* conditional;
+
+    if (flags & 0x1 && itr->is_string())
+      conditional = &(tmp = rpc::parse_command(target, itr->as_string().c_str(), itr->as_string().c_str() + itr->as_string().size()).first);
+    else if (flags & 0x1 && itr->is_dict_key())
+      conditional = &(tmp = rpc::commands.call_command(itr->as_dict_key().c_str(), itr->as_dict_obj(), target));
+    else
+      conditional = &*itr;
+
+    bool result;
+
+    switch (conditional->type()) {
+    case torrent::Object::TYPE_STRING:
+      result = !conditional->as_string().empty();
+      break;
+    case torrent::Object::TYPE_VALUE:
+      result = conditional->as_value();
+      break;
+    case torrent::Object::TYPE_NONE:
+      result = false;
+      break;
+    default:
+      throw torrent::input_error("Type not supported by 'if'.");
+    };
+
+    itr++;
+
+    if (result)
+      break;
+
+    itr++;
+  }
+
+  if (itr == args.end())
+    return torrent::Object();
+
+  if (flags & 0x1 && itr->is_string()) {
+    return rpc::parse_command(target, itr->as_string().c_str(), itr->as_string().c_str() + itr->as_string().size()).first;
+
+  } else if (flags & 0x1 && itr->is_dict_key()) {
+    return rpc::commands.call_command(itr->as_dict_key().c_str(), itr->as_dict_obj(), target);
+
+  } else if (flags & 0x1 && itr->is_list()) {
+    // Move this into a special function or something. Also, might be
+    // nice to have a parse_command function that takes list
+    // iterator...
+
+    for (torrent::Object::list_type::const_iterator cmdItr = itr->as_list().begin(), last = itr->as_list().end(); cmdItr != last; cmdItr++)
+      if (cmdItr->is_string())
+        rpc::parse_command(target, cmdItr->as_string().c_str(), cmdItr->as_string().c_str() + cmdItr->as_string().size());
+
+    return torrent::Object();
+
+  } else {
+    return *itr;
+  }
+}
+
+torrent::Object
+cmd_view_size(const torrent::Object::string_type& args) {
+  return (*control->view_manager()->find_throw(args))->size_visible();
+}
+
+torrent::Object
+cmd_view_size_not_visible(const torrent::Object::string_type& args) {
+  return (*control->view_manager()->find_throw(args))->size_not_visible();
+}
+
+torrent::Object
+cmd_view_persistent(const torrent::Object::string_type& args) {
+  core::View* view = *control->view_manager()->find_throw(args);
+
+  if (!view->get_filter().is_empty() || !view->event_added().is_empty() || !view->event_removed().is_empty())
+    throw torrent::input_error("Cannot set modified views as persitent.");
+
+  view->set_filter("d.views.has=" + args);
+  view->set_event_added("d.views.push_back_unique=" + args);
+  view->set_event_removed("d.views.remove=" + args);
+
+  return torrent::Object();
+}
+
+// TODO: These don't need wrapper functions anymore...
+torrent::Object
+cmd_ui_set_view(const torrent::Object::string_type& args) {
+  control->ui()->download_list()->set_current_view(args);
+  return torrent::Object();
+}
+
+torrent::Object
+cmd_ui_current_view() {
+  return control->ui()->download_list()->current_view()->name();
+}
+
+torrent::Object
+cmd_ui_unfocus_download(core::Download* download) {
+  control->ui()->download_list()->unfocus_download(download);
+
+  return torrent::Object();
+}
+
+torrent::Object
+cmd_view_filter_download(core::Download* download, const torrent::Object::string_type& args) {
+  (*control->view_manager()->find_throw(args))->filter_download(download);
+
+  return torrent::Object();
+}
+
+torrent::Object
+cmd_view_set_visible(core::Download* download, const torrent::Object::string_type& args) {
+  (*control->view_manager()->find_throw(args))->set_visible(download);
+
+  return torrent::Object();
+}
+
+torrent::Object
+cmd_view_set_not_visible(core::Download* download, const torrent::Object::string_type& args) {
+  (*control->view_manager()->find_throw(args))->set_not_visible(download);
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_elapsed_less(const torrent::Object::list_type& args) {
+  if (args.size() != 2)
+    throw torrent::input_error("Wrong argument count.");
+
+  int64_t start_time = rpc::convert_to_value(args.front());
+  auto cached_seconds = torrent::this_thread::cached_seconds().count();
+
+  return (int64_t)(start_time != 0 && cached_seconds - start_time < rpc::convert_to_value(args.back()));
+}
+
+torrent::Object
+apply_elapsed_greater(const torrent::Object::list_type& args) {
+  if (args.size() != 2)
+    throw torrent::input_error("Wrong argument count.");
+
+  int64_t start_time = rpc::convert_to_value(args.front());
+  auto cached_seconds = torrent::this_thread::cached_seconds().count();
+
+  return (int64_t)(start_time != 0 && cached_seconds - start_time > rpc::convert_to_value(args.back()));
+}
+
+inline std::vector<int64_t>
+as_vector(const torrent::Object::list_type& args) {
+  if (args.size() == 0)
+    throw torrent::input_error("Wrong argument count in as_vector.");
+
+  std::vector<int64_t> result;
+
+  for (torrent::Object::list_const_iterator itr = args.begin(), last = args.end(); itr != last; itr++) {
+
+    if (itr->is_value()) {
+      result.push_back(itr->as_value());
+    } else if (itr->is_string()) {
+      result.push_back(rpc::convert_to_value(itr->as_string()));
+    } else if (itr->is_list()) {
+      std::vector<int64_t> subResult = as_vector(itr->as_list());
+      result.insert(result.end(), subResult.begin(), subResult.end());
+    } else {
+      throw torrent::input_error("Wrong type supplied to as_vector.");
+    }
+
+  }
+
+  return result;
+}
+
+int64_t
+apply_math_basic(const char* name, const std::function<int64_t(int64_t,int64_t)> op, const torrent::Object::list_type& args) {
+  int64_t val = 0, rhs = 0;
+  bool divides = !strcmp(name, "math.div") || !strcmp(name, "math.mod");
+
+  if (args.size() == 0)
+    throw torrent::input_error(std::string(name) + ": No arguments provided!");
+
+  for (torrent::Object::list_const_iterator itr = args.begin(), last = args.end(); itr != last; itr++) {
+
+    if (itr->is_value()) {
+      rhs = itr->as_value();
+    } else if (itr->is_string()) {
+      rhs = rpc::convert_to_value(itr->as_string());
+    } else if (itr->is_list()) {
+      rhs = apply_math_basic(name, op, itr->as_list());
+    } else {
+      throw torrent::input_error(std::string(name) + ": Wrong argument type");
+    }
+
+    if (divides && !rhs && itr != args.begin())
+      throw torrent::input_error(std::string(name) + ": Division by zero!");
+
+    val = itr == args.begin() ? rhs : op(val, rhs);
+
+  }
+
+  return val;
+}
+
+int64_t
+apply_arith_basic(const std::function<int64_t(int64_t,int64_t)> op, const torrent::Object::list_type& args) {
+  if (args.size() == 0)
+    throw torrent::input_error("Wrong argument count in apply_arith_basic.");
+
+  int64_t val = 0;
+
+  for (torrent::Object::list_const_iterator itr = args.begin(), last = args.end(); itr != last; itr++) {
+
+    if (itr->is_value()) {
+      val = itr == args.begin() ? itr->as_value() : (op(val, itr->as_value()) ? val : itr->as_value());
+    } else if (itr->is_string()) {
+      int64_t cval = rpc::convert_to_value(itr->as_string());
+      val = itr == args.begin() ? cval : (op(val, cval) ? val : cval);
+    } else if (itr->is_list()) {
+      int64_t fval = apply_arith_basic(op, itr->as_list());
+      val = itr == args.begin() ? fval : (op(val, fval) ? val : fval);
+    } else {
+      throw torrent::input_error("Wrong type supplied to apply_arith_basic.");
+    }
+
+  }
+
+  return val;
+}
+
+int64_t
+apply_arith_count(const torrent::Object::list_type& args) {
+  if (args.size() == 0)
+    throw torrent::input_error("Wrong argument count in apply_arith_count.");
+
+  int64_t val = 0;
+
+  for (torrent::Object::list_const_iterator itr = args.begin(), last = args.end(); itr != last; itr++) {
+
+    switch (itr->type()) {
+    case torrent::Object::TYPE_VALUE:
+    case torrent::Object::TYPE_STRING:
+      val++;
+      break;
+    case torrent::Object::TYPE_LIST:
+      val += apply_arith_count(itr->as_list());
+      break;
+    default:
+      throw torrent::input_error("Wrong type supplied to apply_arith_count.");
+    }
+
+  }
+
+  return val;
+}
+
+int64_t
+apply_arith_other(const char* op, const torrent::Object::list_type& args) {
+  if (args.size() == 0)
+    throw torrent::input_error("Wrong argument count in apply_arith_other.");
+
+  if (strcmp(op, "average") == 0) {
+    return (int64_t)(apply_math_basic(op, std::plus<int64_t>(), args) / apply_arith_count(args));
+  } else if (strcmp(op, "median") == 0) {
+    std::vector<int64_t> result = as_vector(args);
+    return (int64_t)rak::median(result.begin(), result.end());
+  } else {
+    throw torrent::input_error("Wrong operation supplied to apply_arith_other.");
+  }
+}
+
+torrent::Object
+cmd_status_throttle_names(bool up, const torrent::Object::list_type& args) {
+  if (args.size() == 0)
+    return torrent::Object();
+
+  std::vector<std::string> throttle_name_list;
+
+  for (torrent::Object::list_const_iterator itr = args.begin(), last = args.end(); itr != last; itr++) {
+    if (itr->is_string())
+      throttle_name_list.push_back(itr->as_string());
+  }
+
+  if (up)
+    control->ui()->set_status_throttle_up_names(throttle_name_list);
+  else
+    control->ui()->set_status_throttle_down_names(throttle_name_list);
+
+  return torrent::Object();
+}
+
+torrent::Object
+apply_set_color(int color_id, const torrent::Object::string_type& color_str) {
+  control->object_storage()->set_str_string(display::color_vars[color_id], color_str);
+  display::Canvas::build_colors();
+  return torrent::Object();
+}
+
+void
+initialize_command_ui() {
+  CMD2_VAR_STRING("keys.layout", "qwerty");
+
+  CMD2_ANY_STRING("view.add", object_convert_void(std::bind(&core::ViewManager::insert_throw, control->view_manager(), std::placeholders::_2)));
+
+  CMD2_ANY_L   ("view.list",          std::bind(&apply_view_list));
+  CMD2_ANY_LIST("view.set",           std::bind(&apply_view_set, std::placeholders::_2));
+
+  CMD2_ANY_LIST  ("view.filter",      std::bind(&apply_view_event, &core::ViewManager::set_filter, std::placeholders::_2));
+  CMD2_ANY_LIST  ("view.filter_on",   std::bind(&apply_view_filter_on, std::placeholders::_2));
+  CMD2_ANY_LIST  ("view.filter.temp", std::bind(&apply_view_event, &core::ViewManager::set_filter_temp, std::placeholders::_2));
+  CMD2_VAR_STRING("view.filter.temp.excluded", "default,started,stopped");
+  CMD2_VAR_BOOL  ("view.filter.temp.log", 0);
+
+  CMD2_ANY_LIST("view.sort",          std::bind(&apply_view_sort, std::placeholders::_2));
+  CMD2_ANY_LIST("view.sort_new",      std::bind(&apply_view_event, &core::ViewManager::set_sort_new, std::placeholders::_2));
+  CMD2_ANY_LIST("view.sort_current",  std::bind(&apply_view_event, &core::ViewManager::set_sort_current, std::placeholders::_2));
+
+  CMD2_ANY_LIST("view.event_added",   std::bind(&apply_view_event, &core::ViewManager::set_event_added, std::placeholders::_2));
+  CMD2_ANY_LIST("view.event_removed", std::bind(&apply_view_event, &core::ViewManager::set_event_removed, std::placeholders::_2));
+
+  // Cleanup and add . to view.
+
+  CMD2_ANY_STRING("view.size",              std::bind(&cmd_view_size, std::placeholders::_2));
+  CMD2_ANY_STRING("view.size_not_visible",  std::bind(&cmd_view_size_not_visible, std::placeholders::_2));
+  CMD2_ANY_STRING("view.persistent",        std::bind(&cmd_view_persistent, std::placeholders::_2));
+
+  CMD2_ANY_STRING_V("view.filter_all",      std::bind(&core::View::filter, std::bind(&core::ViewManager::find_ptr_throw, control->view_manager(), std::placeholders::_2)));
+
+  CMD2_DL_STRING ("view.filter_download", std::bind(&cmd_view_filter_download, std::placeholders::_1, std::placeholders::_2));
+  CMD2_DL_STRING ("view.set_visible",     std::bind(&cmd_view_set_visible,     std::placeholders::_1, std::placeholders::_2));
+  CMD2_DL_STRING ("view.set_not_visible", std::bind(&cmd_view_set_not_visible, std::placeholders::_1, std::placeholders::_2));
+
+  // Commands that affect the default rtorrent UI.
+  CMD2_DL        ("ui.unfocus_download",   std::bind(&cmd_ui_unfocus_download, std::placeholders::_1));
+  CMD2_ANY       ("ui.current_view",       std::bind(&cmd_ui_current_view));
+  CMD2_ANY_STRING("ui.current_view.set",   std::bind(&cmd_ui_set_view, std::placeholders::_2));
+
+  CMD2_ANY        ("ui.input.history.size",     std::bind(&ui::Root::get_input_history_size, control->ui()));
+  CMD2_ANY_VALUE_V("ui.input.history.size.set", std::bind(&ui::Root::set_input_history_size, control->ui(), std::placeholders::_2));
+  CMD2_ANY_V      ("ui.input.history.clear",    std::bind(&ui::Root::clear_input_history, control->ui()));
+
+  CMD2_VAR_VALUE ("ui.throttle.global.step.small",  5);
+  CMD2_VAR_VALUE ("ui.throttle.global.step.medium", 50);
+  CMD2_VAR_VALUE ("ui.throttle.global.step.large",  500);
+
+  CMD2_VAR_VALUE ("ui.focus.page_size", 0);
+
+  CMD2_ANY_LIST  ("ui.status.throttle.up.set",   std::bind(&cmd_status_throttle_names, true, std::placeholders::_2));
+  CMD2_ANY_LIST  ("ui.status.throttle.down.set", std::bind(&cmd_status_throttle_names, false, std::placeholders::_2));
+
+  // TODO: Add 'option_string' for rtorrent-specific options.
+  CMD2_VAR_STRING("ui.torrent_list.layout", "full");
+
+  // Move.
+  CMD2_ANY("print", &apply_print);
+  CMD2_ANY("cat",   &apply_cat);
+  CMD2_ANY_LIST("value", &apply_value);
+  CMD2_ANY("try",   &apply_try);
+  CMD2_ANY("if",    std::bind(&apply_if, std::placeholders::_1, std::placeholders::_2, 0));
+  CMD2_ANY("not",   &apply_not);
+  CMD2_ANY("false", &apply_false);
+  CMD2_ANY("and",   &apply_and);
+  CMD2_ANY("or",    &apply_or);
+
+  // A temporary command for handling stuff until we get proper
+  // support for seperation of commands and literals.
+  CMD2_ANY("branch", std::bind(&apply_if, std::placeholders::_1, std::placeholders::_2, 1));
+
+  CMD2_ANY_LIST("less",    &apply_less);
+  CMD2_ANY_LIST("greater", &apply_greater);
+  CMD2_ANY_LIST("equal",   &apply_equal);
+  CMD2_ANY_LIST("compare", &apply_compare);
+  CMD2_ANY_LIST("match",   &apply_match);
+
+  CMD2_ANY_VALUE("convert.gm_time",      std::bind(&apply_to_time, std::placeholders::_2, 0));
+  CMD2_ANY_VALUE("convert.gm_date",      std::bind(&apply_to_time, std::placeholders::_2, 0x2));
+  CMD2_ANY_VALUE("convert.time",         std::bind(&apply_to_time, std::placeholders::_2, 0x1));
+  CMD2_ANY_VALUE("convert.date",         std::bind(&apply_to_time, std::placeholders::_2, 0x1 | 0x2));
+  CMD2_ANY_VALUE("convert.elapsed_time", std::bind(&apply_to_elapsed_time, std::placeholders::_2));
+  CMD2_ANY_VALUE("convert.kb",           std::bind(&apply_to_kb, std::placeholders::_2));
+  CMD2_ANY_VALUE("convert.mb",           std::bind(&apply_to_mb, std::placeholders::_2));
+  CMD2_ANY_VALUE("convert.xb",           std::bind(&apply_to_xb, std::placeholders::_2));
+  CMD2_ANY_VALUE("convert.throttle",     std::bind(&apply_to_throttle, std::placeholders::_2));
+
+  CMD2_ANY_LIST("math.add",              std::bind(&apply_math_basic, "math.add", std::plus<int64_t>(), std::placeholders::_2));
+  CMD2_ANY_LIST("math.sub",              std::bind(&apply_math_basic, "math.sub", std::minus<int64_t>(), std::placeholders::_2));
+  CMD2_ANY_LIST("math.mul",              std::bind(&apply_math_basic, "math.mul", std::multiplies<int64_t>(), std::placeholders::_2));
+  CMD2_ANY_LIST("math.div",              std::bind(&apply_math_basic, "math.div", std::divides<int64_t>(), std::placeholders::_2));
+  CMD2_ANY_LIST("math.mod",              std::bind(&apply_math_basic, "math.mod", std::modulus<int64_t>(), std::placeholders::_2));
+  CMD2_ANY_LIST("math.min",              std::bind(&apply_arith_basic, std::less<int64_t>(), std::placeholders::_2));
+  CMD2_ANY_LIST("math.max",              std::bind(&apply_arith_basic, std::greater<int64_t>(), std::placeholders::_2));
+  CMD2_ANY_LIST("math.cnt",              std::bind(&apply_arith_count, std::placeholders::_2));
+  CMD2_ANY_LIST("math.avg",              std::bind(&apply_arith_other, "average", std::placeholders::_2));
+  CMD2_ANY_LIST("math.med",              std::bind(&apply_arith_other, "median", std::placeholders::_2));
+
+  CMD2_ANY_LIST ("elapsed.less",         std::bind(&apply_elapsed_less, std::placeholders::_2));
+  CMD2_ANY_LIST ("elapsed.greater",      std::bind(&apply_elapsed_greater, std::placeholders::_2));
+
+  // Build set/get methods for all color definitions
+  for (int color_id = 1; color_id < display::RCOLOR_MAX; color_id++) {
+    control->object_storage()->insert_str(display::color_vars[color_id], "", rpc::object_storage::flag_string_type);
+    CMD2_ANY_STRING(std::string(display::color_vars[color_id]) + ".set", [color_id](const auto&, const auto& arg) {
+      return apply_set_color(color_id, arg);
+    });
+    CMD2_ANY(display::color_vars[color_id], [color_id](const auto&, const auto&) {
+      return control->object_storage()->get_str(display::color_vars[color_id]);
+    });
+  }
+}

src/control.cc

@@ -0,0 +1,157 @@
+#include "config.h"
+
+#include <unistd.h>
+#include <sys/stat.h>
+#include <torrent/connection_manager.h>
+#include <torrent/utils/directory_events.h>
+
+#include "core/curl_stack.h"
+#include "core/dht_manager.h"
+#include "core/download_store.h"
+#include "core/http_queue.h"
+#include "core/manager.h"
+#include "core/view_manager.h"
+#include "display/canvas.h"
+#include "display/window.h"
+#include "display/window_http_queue.h"
+#include "display/window_input.h"
+#include "display/window_statusbar.h"
+#include "display/window_title.h"
+#include "display/manager.h"
+#include "input/manager.h"
+#include "input/input_event.h"
+#include "rpc/command_scheduler.h"
+#include "rpc/lua.h"
+#include "rpc/parse_commands.h"
+#include "rpc/object_storage.h"
+#include "ui/root.h"
+
+#include "control.h"
+
+Control::Control() :
+    m_ui(new ui::Root()),
+    m_display(new display::Manager()),
+    m_input(new input::Manager()),
+    m_inputStdin(new input::InputEvent(STDIN_FILENO)),
+    m_commandScheduler(new rpc::CommandScheduler()),
+    m_objectStorage(new rpc::object_storage()),
+    m_lua_engine(new rpc::LuaEngine()),
+    m_directory_events(new torrent::directory_events()) {
+
+  m_core        = new core::Manager();
+  m_viewManager = new core::ViewManager();
+  m_dhtManager  = new core::DhtManager();
+
+  m_inputStdin->slot_pressed(std::bind(&input::Manager::pressed, m_input, std::placeholders::_1));
+
+  m_task_shutdown.slot() = std::bind(&Control::handle_shutdown, this);
+
+  m_commandScheduler->set_slot_error_message([this](const std::string& msg) { m_core->push_log_std(msg); });
+}
+
+Control::~Control() {
+  delete m_inputStdin;
+  delete m_input;
+
+  delete m_viewManager;
+
+  delete m_ui;
+  delete m_display;
+  delete m_core;
+  delete m_dhtManager;
+
+  delete m_directory_events;
+  delete m_commandScheduler;
+  delete m_objectStorage;
+  delete m_lua_engine;
+}
+
+void
+Control::initialize() {
+  display::Canvas::initialize();
+  display::Window::slot_schedule([this](display::Window* w, std::chrono::microseconds t) { m_display->schedule(w, t); });
+  display::Window::slot_unschedule([this](display::Window* w) { m_display->unschedule(w); });
+  display::Window::slot_adjust([this]() { m_display->adjust_layout(); });
+
+  m_core->http_stack()->set_user_agent(USER_AGENT);
+
+  m_core->initialize_second();
+  m_core->listen_open();
+  m_core->download_store()->enable(rpc::call_command_value("session.use_lock"));
+
+  m_core->set_hashing_view(*m_viewManager->find_throw("hashing"));
+
+  m_ui->init(this);
+
+  if(!display::Canvas::daemon()) {
+    m_inputStdin->insert(torrent::this_thread::poll());
+  }
+}
+
+void
+Control::cleanup() {
+  rpc::rpc.cleanup();
+
+  torrent::this_thread::scheduler()->erase(&m_task_shutdown);
+
+  if(!display::Canvas::daemon()) {
+    m_inputStdin->remove(torrent::this_thread::poll());
+  }
+
+  m_core->download_store()->disable();
+
+  m_ui->cleanup();
+  m_core->cleanup();
+
+  display::Canvas::erase_std();
+  display::Canvas::refresh_std();
+  display::Canvas::do_update();
+  display::Canvas::cleanup();
+}
+
+void
+Control::cleanup_exception() {
+  display::Canvas::cleanup();
+}
+
+bool
+Control::is_shutdown_completed() {
+  if (!m_shutdownQuick || worker_thread->is_active())
+    return false;
+
+  // Tracker requests can be disowned, so wait for these to
+  // finish. The edge case of torrent http downloads may delay
+  // shutdown.
+  if (!core()->http_stack()->empty() || !core()->http_queue()->empty())
+    return false;
+
+  return torrent::is_inactive();
+}
+
+void
+Control::handle_shutdown() {
+  rpc::commands.call_catch("event.system.shutdown", rpc::make_target(), "shutdown", "System shutdown event action failed: ");
+
+  if (!m_shutdownQuick) {
+    if (worker_thread->is_active())
+      worker_thread->stop_thread_wait();
+
+    torrent::connection_manager()->listen_close();
+
+    m_directory_events->close();
+    m_core->shutdown(false);
+
+    if (!m_task_shutdown.is_scheduled())
+      torrent::this_thread::scheduler()->wait_for_ceil_seconds(&m_task_shutdown, 5s);
+
+  } else {
+    if (worker_thread->is_active())
+      worker_thread->stop_thread_wait();
+
+    m_core->shutdown(true);
+  }
+
+  m_shutdownQuick = true;
+  m_shutdownReceived = false;
+}
+

src/control.h

@@ -0,0 +1,108 @@
+#ifndef RTORRENT_CONTROL_H
+#define RTORRENT_CONTROL_H
+
+#include <atomic>
+#include <cinttypes>
+#include <sys/types.h>
+#include <torrent/torrent.h>
+#include <torrent/utils/scheduler.h>
+
+namespace ui {
+  class Root;
+}
+
+namespace core {
+  class Manager;
+  class ViewManager;
+  class DhtManager;
+}
+
+namespace display {
+  class Manager;
+}
+
+namespace input {
+  class InputEvent;
+  class Manager;
+}
+
+namespace rpc {
+  class CommandScheduler;
+  class XmlRpc;
+  class object_storage;
+  class LuaEngine;
+}
+
+namespace torrent {
+  class directory_events;
+}
+
+class Control {
+public:
+  Control();
+  ~Control();
+
+  bool                is_shutdown_completed();
+  bool                is_shutdown_received()        { return m_shutdownReceived; }
+  bool                is_shutdown_started()         { return m_shutdownQuick; }
+
+  void                initialize();
+  void                cleanup();
+  void                cleanup_exception();
+
+  void                handle_shutdown();
+
+  void                receive_normal_shutdown()     { m_shutdownReceived = true; }
+  void                receive_quick_shutdown()      { m_shutdownReceived = true; m_shutdownQuick = true; }
+
+  core::Manager*      core()                        { return m_core; }
+  core::ViewManager*  view_manager()                { return m_viewManager; }
+  core::DhtManager*   dht_manager()                 { return m_dhtManager; }
+
+  ui::Root*           ui()                          { return m_ui; }
+  display::Manager*   display()                     { return m_display; }
+  input::Manager*     input()                       { return m_input; }
+  input::InputEvent*  input_stdin()                 { return m_inputStdin; }
+
+  rpc::CommandScheduler* command_scheduler()        { return m_commandScheduler; }
+  rpc::object_storage*   object_storage()           { return m_objectStorage; }
+  rpc::LuaEngine*        lua_engine()               { return m_lua_engine; }
+
+  torrent::directory_events* directory_events()     { return m_directory_events; }
+
+  uint64_t            tick() const                  { return m_tick; }
+  void                inc_tick()                    { m_tick++; }
+
+  const std::string&  working_directory() const     { return m_workingDirectory; }
+  void                set_working_directory(const std::string& dir);
+
+private:
+  Control(const Control&);
+  void operator = (const Control&);
+
+  core::Manager*      m_core;
+  core::ViewManager*  m_viewManager;
+  core::DhtManager*   m_dhtManager;
+
+  ui::Root*           m_ui;
+  display::Manager*   m_display;
+  input::Manager*     m_input;
+  input::InputEvent*  m_inputStdin;
+
+  rpc::CommandScheduler*     m_commandScheduler;
+  rpc::object_storage*       m_objectStorage;
+  rpc::LuaEngine*            m_lua_engine;
+  torrent::directory_events* m_directory_events;
+
+  uint64_t            m_tick{};
+
+  mode_t              m_umask;
+  std::string         m_workingDirectory;
+
+  torrent::utils::SchedulerEntry m_task_shutdown;
+
+  std::atomic<bool>   m_shutdownReceived{};
+  std::atomic<bool>   m_shutdownQuick{};
+};
+
+#endif

src/core/curl_get.cc

@@ -0,0 +1,122 @@
+#include "config.h"
+
+#include "core/curl_get.h"
+
+#include <iostream>
+#include <curl/curl.h>
+#include <curl/easy.h>
+#include <torrent/exceptions.h>
+
+#include "globals.h"
+#include "core/curl_stack.h"
+
+namespace core {
+
+size_t
+curl_get_receive_write(void* data, size_t size, size_t nmemb, void* handle) {
+  if (!((CurlGet*)handle)->stream()->write((const char*)data, size * nmemb).fail())
+    return size * nmemb;
+  else
+    return 0;
+}
+
+CurlGet::CurlGet(CurlStack* s) :
+    m_stack(s) {
+
+  m_task_timeout.slot() = [this]() { receive_timeout(); };
+}
+
+CurlGet::~CurlGet() {
+  close();
+}
+
+void
+CurlGet::start() {
+  if (is_busy())
+    throw torrent::internal_error("Tried to call CurlGet::start on a busy object.");
+
+  if (m_stream == NULL)
+    throw torrent::internal_error("Tried to call CurlGet::start without a valid output stream.");
+
+  if (!m_stack->is_running())
+    return;
+
+  m_handle = curl_easy_init();
+
+  if (m_handle == NULL)
+    throw torrent::internal_error("Call to curl_easy_init() failed.");
+
+  curl_easy_setopt(m_handle, CURLOPT_URL,            m_url.c_str());
+  curl_easy_setopt(m_handle, CURLOPT_WRITEFUNCTION,  &curl_get_receive_write);
+  curl_easy_setopt(m_handle, CURLOPT_WRITEDATA,      this);
+
+  if (m_timeout != 0) {
+    curl_easy_setopt(m_handle, CURLOPT_CONNECTTIMEOUT, (long)60);
+    curl_easy_setopt(m_handle, CURLOPT_TIMEOUT,        (long)m_timeout);
+
+    // Normally libcurl should handle the timeout. But sometimes that doesn't
+    // work right so we do a fallback timeout that just aborts the transfer.
+    torrent::this_thread::scheduler()->update_wait_for_ceil_seconds(&m_task_timeout, 5s + 1s*m_timeout);
+  }
+
+  curl_easy_setopt(m_handle, CURLOPT_FORBID_REUSE,   (long)1);
+  curl_easy_setopt(m_handle, CURLOPT_NOSIGNAL,       (long)1);
+  curl_easy_setopt(m_handle, CURLOPT_FOLLOWLOCATION, (long)1);
+  curl_easy_setopt(m_handle, CURLOPT_MAXREDIRS,      (long)5);
+
+  curl_easy_setopt(m_handle, CURLOPT_IPRESOLVE,      CURL_IPRESOLVE_WHATEVER);
+
+  curl_easy_setopt(m_handle, CURLOPT_ENCODING,       "");
+
+  m_ipv6 = false;
+
+  m_stack->add_get(this);
+}
+
+void
+CurlGet::close() {
+  torrent::this_thread::scheduler()->erase(&m_task_timeout);
+
+  if (!is_busy())
+    return;
+
+  m_stack->remove_get(this);
+
+  curl_easy_cleanup(m_handle);
+
+  m_handle = NULL;
+}
+
+void
+CurlGet::retry_ipv6() {
+  CURL* nhandle = curl_easy_duphandle(m_handle);
+
+  curl_easy_setopt(nhandle, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V6);
+  curl_easy_cleanup(m_handle);
+
+  m_handle = nhandle;
+  m_ipv6 = true;
+}
+
+void
+CurlGet::receive_timeout() {
+  return m_stack->transfer_done(m_handle, "Timed out");
+}
+
+curl_off_t
+CurlGet::size_done() {
+  curl_off_t d = 0;
+  curl_easy_getinfo(m_handle, CURLINFO_SIZE_DOWNLOAD_T, &d);
+
+  return d;
+}
+
+curl_off_t
+CurlGet::size_total() {
+  curl_off_t d = 0;
+  curl_easy_getinfo(m_handle, CURLINFO_CONTENT_LENGTH_DOWNLOAD_T, &d);
+
+  return d;
+}
+
+}

src/core/curl_get.h

@@ -0,0 +1,54 @@
+#ifndef RTORRENT_CORE_CURL_GET_H
+#define RTORRENT_CORE_CURL_GET_H
+
+#include <iosfwd>
+#include <string>
+#include <curl/curl.h>
+#include <torrent/http.h>
+#include <torrent/utils/scheduler.h>
+
+namespace core {
+
+class CurlStack;
+
+class CurlGet : public torrent::Http {
+public:
+  CurlGet(CurlStack* s);
+  virtual ~CurlGet();
+
+  void               start();
+  void               close();
+
+  bool               is_using_ipv6()    { return m_ipv6; }
+  void               retry_ipv6();
+
+  bool               is_busy() const    { return m_handle; }
+  bool               is_active() const  { return m_active; }
+
+  void               set_active(bool a) { m_active = a; }
+
+  curl_off_t         size_done();
+  curl_off_t         size_total();
+
+  CURL*              handle()           { return m_handle; }
+
+private:
+  friend class CurlStack;
+
+  CurlGet(const CurlGet&) = delete;
+  void operator = (const CurlGet&) = delete;
+
+  void               receive_timeout();
+
+  bool               m_active{};
+  bool               m_ipv6;
+
+  torrent::utils::SchedulerEntry m_task_timeout;
+
+  CURL*              m_handle{};
+  CurlStack*         m_stack;
+};
+
+}
+
+#endif

src/core/curl_socket.cc

@@ -0,0 +1,99 @@
+#include "config.h"
+
+#include "curl_socket.h"
+
+#include <cassert>
+#include <curl/multi.h>
+#include <torrent/poll.h>
+#include <torrent/exceptions.h>
+#include <torrent/utils/thread.h>
+
+#include "control.h"
+#include "core/curl_stack.h"
+
+namespace core {
+
+int
+CurlSocket::receive_socket([[maybe_unused]] void* easy_handle, curl_socket_t fd, int what, void* userp, void* socketp) {
+  CurlStack* stack = (CurlStack*)userp;
+  CurlSocket* socket = (CurlSocket*)socketp;
+
+  if (!stack->is_running())
+    return 0;
+
+  if (what == CURL_POLL_REMOVE) {
+    // We also probably need the special code here as we're not
+    // guaranteed that the fd will be closed, afaik.
+    if (socket != NULL)
+      socket->close();
+
+    // TODO: Consider the possibility that we'll need to set the
+    // fd-associated pointer curl holds to NULL.
+
+    delete socket;
+    return 0;
+  }
+
+  if (socket == NULL) {
+    socket = stack->new_socket(fd);
+    torrent::this_thread::poll()->open(socket);
+
+    // No interface for libcurl to signal when it's interested in error events.
+    // Assume that hence it must always be interested in them.
+    torrent::this_thread::poll()->insert_error(socket);
+  }
+
+  if (what == CURL_POLL_NONE || what == CURL_POLL_OUT)
+    torrent::this_thread::poll()->remove_read(socket);
+  else
+    torrent::this_thread::poll()->insert_read(socket);
+
+  if (what == CURL_POLL_NONE || what == CURL_POLL_IN)
+    torrent::this_thread::poll()->remove_write(socket);
+  else
+    torrent::this_thread::poll()->insert_write(socket);
+
+  return 0;
+}
+
+CurlSocket::~CurlSocket() {
+  assert(m_fileDesc == -1 && "CurlSocket::~CurlSocket() m_fileDesc != -1.");
+}
+
+void
+CurlSocket::close() {
+  if (m_fileDesc == -1)
+    throw torrent::internal_error("CurlSocket::close() m_fileDesc == -1.");
+
+  torrent::this_thread::poll()->closed(this);
+  m_fileDesc = -1;
+}
+
+void
+CurlSocket::event_read() {
+#if (LIBCURL_VERSION_NUM >= 0x071003)
+  return m_stack->receive_action(this, CURL_CSELECT_IN);
+#else
+  return m_stack->receive_action(this, 0);
+#endif
+}
+
+void
+CurlSocket::event_write() {
+#if (LIBCURL_VERSION_NUM >= 0x071003)
+  return m_stack->receive_action(this, CURL_CSELECT_OUT);
+#else
+  return m_stack->receive_action(this, 0);
+#endif
+}
+
+void
+CurlSocket::event_error() {
+#if (LIBCURL_VERSION_NUM >= 0x071003)
+  return m_stack->receive_action(this, CURL_CSELECT_ERR);
+#else
+  return m_stack->receive_action(this, 0);
+#endif
+}
+
+}