Added 'd.chunks_seen', which is limited to 'Download::peers_accounted()' number of peers for optimization reasons.

Without this change build will fail when using gold linker

.gitignore

@@ -1,9 +1,66 @@
-aclocal.m4
-src/rtorrent
-scripts/libtool.m4
-scripts/ltoptions.m4
-scripts/ltsugar.m4
-scripts/ltversion.m4
-scripts/lt~obsolete.m4
+# Compiled source #
+###################
+*.o
+*.lo
+*.a
+*.la
+*.so
+*.in
+*.sub
+*.pc
+*.orig
+*.rej
 
+# Autoconf files #
+##################
+
+.deps
+.libs
+Makefile
+aclocal.m4
+autom4te.cache
+config.h
+config.guess
+config.status
+confdefs.h
+conftest.dir
+configure
+depcomp
+install-sh
+libtool
+ltmain.sh
+missing
+stamp-h1
+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?
+ehthumbs.db
+Icon?
+Thumbs.db
+TAGS
+
+# rTorrent specific files
+###########################
+src/rtorrent
 test/rtorrentTest

autogen.sh

@@ -6,7 +6,7 @@ echo aclocal...
     exit 1
 }
 
-aclocal -I ./scripts -I . ${ACLOCAL_FLAGS}
+aclocal -I ./scripts -I . ${ACLOCAL_FLAGS} || exit 1
 
 echo autoheader...
 (autoheader --version) < /dev/null > /dev/null 2>&1 || {
@@ -14,16 +14,16 @@ echo autoheader...
     exit 1
 }
 
-autoheader
+autoheader || exit 1
 
 echo -n "libtoolize... "
 if ( (glibtoolize --version) < /dev/null > /dev/null 2>&1 ); then
     echo "using glibtoolize"
-    glibtoolize --automake --copy --force
+    glibtoolize --automake --copy --force || exit 1
 
 elif ( (libtoolize --version) < /dev/null > /dev/null 2>&1 ) ; then
     echo "using libtoolize"
-    libtoolize --automake --copy --force
+    libtoolize --automake --copy --force || exit 1
 
 else
     echo "libtoolize nor glibtoolize not found"
@@ -36,7 +36,7 @@ echo automake...
     exit 1
 }
 
-automake --add-missing --copy --gnu
+automake --add-missing --copy --gnu || exit 1
 
 echo autoconf...
 (autoconf --version) < /dev/null > /dev/null 2>&1 || {
@@ -44,7 +44,7 @@ echo autoconf...
     exit 1
 }
 
-autoconf
+autoconf || exit 1
 
 echo ready to configure
 

configure.ac

@@ -1,4 +1,6 @@
-AC_INIT(rtorrent, 0.9.0, jaris@ifi.uio.no)
+AC_INIT(rtorrent, 0.9.1, jaris@ifi.uio.no)
+
+AC_DEFINE(API_VERSION, 3, api version)
 
 AM_INIT_AUTOMAKE
 AM_CONFIG_HEADER(config.h)
@@ -11,6 +13,8 @@ TORRENT_CHECK_CXXFLAGS()
 TORRENT_ENABLE_DEBUG()
 TORRENT_ENABLE_EXTRA_DEBUG()
 TORRENT_ENABLE_WERROR()
+TORRENT_ENABLE_TR1()
+TORRENT_ENABLE_CXX11()
 
 TORRENT_DISABLE_IPV6
 
@@ -23,13 +27,19 @@ TORRENT_ENABLE_ARCH
 TORRENT_WITH_SYSROOT
 
 TORRENT_WITHOUT_VARIABLE_FDSET()
-TORRENT_WITHOUT_NCURSESW()
 TORRENT_WITHOUT_STATVFS()
 TORRENT_WITHOUT_STATFS()
 
-ACX_PTHREAD(CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS";
-            LIBS="$PTHREAD_LIBS $LIBS"
-)
+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
+
+CFLAGS="$CFLAGS $PTHREAD_CFLAGS $CURSES_CFLAGS"
+CXXFLAGS="$CXXFLAGS $PTHREAD_CFLAGS $CURSES_CFLAGS"
+LIBS="$PTHREAD_LIBS $CURSES_LIB $LIBS"
 
 PKG_CHECK_MODULES(sigc, sigc++-2.0,
 	          CXXFLAGS="$CXXFLAGS $sigc_CFLAGS";
@@ -39,7 +49,7 @@ PKG_CHECK_MODULES(libcurl, libcurl >= 7.15.4,
 	          CXXFLAGS="$CXXFLAGS $libcurl_CFLAGS";
 		  LIBS="$LIBS $libcurl_LIBS")
 
-PKG_CHECK_MODULES(libtorrent, libtorrent >= 0.13.0,
+PKG_CHECK_MODULES(libtorrent, libtorrent >= 0.13.1,
 	          CXXFLAGS="$CXXFLAGS $libtorrent_CFLAGS";
 		  LIBS="$LIBS $libtorrent_LIBS")
 

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.

rak/functional_fun.h

@@ -53,6 +53,8 @@
 
 #include <memory>
 #include <functional>
+#include <tr1/functional>
+#include <tr1/memory>
 
 namespace rak {
 
@@ -96,13 +98,13 @@ public:
 
   bool                is_valid() const     { return m_base.get() != NULL; }
 
-  void                set(base_type* base) { m_base = std::auto_ptr<base_type>(base); }
+  void                set(base_type* base) { m_base = std::tr1::shared_ptr<base_type>(base); }
   base_type*          release()            { return m_base.release(); }
 
   Result operator () ()                    { return (*m_base)(); }
 
 private:
-  std::auto_ptr<base_type> m_base;
+  std::tr1::shared_ptr<base_type> m_base;
 };
 
 template <typename Result, typename Arg1>
@@ -113,13 +115,13 @@ public:
 
   bool                is_valid() const     { return m_base.get() != NULL; }
 
-  void                set(base_type* base) { m_base = std::auto_ptr<base_type>(base); }
+  void                set(base_type* base) { m_base = std::tr1::shared_ptr<base_type>(base); }
   base_type*          release()            { return m_base.release(); }
 
   Result operator () (Arg1 arg1)           { return (*m_base)(arg1); }
 
 private:
-  std::auto_ptr<base_type> m_base;
+  std::tr1::shared_ptr<base_type> m_base;
 };
 
 template <typename Result, typename Arg1, typename Arg2>
@@ -130,13 +132,13 @@ public:
 
   bool                is_valid() const     { return m_base.get() != NULL; }
 
-  void                set(base_type* base) { m_base = std::auto_ptr<base_type>(base); }
+  void                set(base_type* base) { m_base = std::tr1::shared_ptr<base_type>(base); }
   base_type*          release()            { return m_base.release(); }
 
   Result operator () (Arg1 arg1, Arg2 arg2) { return (*m_base)(arg1, arg2); }
 
 private:
-  std::auto_ptr<base_type> m_base;
+  std::tr1::shared_ptr<base_type> m_base;
 };
 
 template <typename Result, typename Arg2>
@@ -147,7 +149,7 @@ public:
 
   bool                is_valid() const     { return m_base.get() != NULL; }
 
-  void                set(base_type* base) { m_base = std::auto_ptr<base_type>(base); }
+  void                set(base_type* base) { m_base = std::tr1::shared_ptr<base_type>(base); }
   base_type*          release()            { return m_base.release(); }
 
   Result operator () (Arg2 arg2)           { return (*m_base)(arg2); }
@@ -156,7 +158,7 @@ public:
   Result operator () (Discard discard, Arg2 arg2) { return (*m_base)(arg2); }
 
 private:
-  std::auto_ptr<base_type> m_base;
+  std::tr1::shared_ptr<base_type> m_base;
 };
 
 template <typename Result, typename Arg1, typename Arg2, typename Arg3>
@@ -167,13 +169,13 @@ public:
 
   bool                is_valid() const     { return m_base.get() != NULL; }
 
-  void                set(base_type* base) { m_base = std::auto_ptr<base_type>(base); }
+  void                set(base_type* base) { m_base = std::tr1::shared_ptr<base_type>(base); }
   base_type*          release()            { return m_base.release(); }
 
   Result operator () (Arg1 arg1, Arg2 arg2, Arg3 arg3) { return (*m_base)(arg1, arg2, arg3); }
 
 private:
-  std::auto_ptr<base_type> m_base;
+  std::tr1::shared_ptr<base_type> m_base;
 };
 
 template <typename Result>

rak/priority_queue_default.h

@@ -38,9 +38,8 @@
 #define RAK_PRIORITY_QUEUE_DEFAULT_H
 
 #include <stdexcept>
+#include <tr1/functional>
 #include <rak/allocators.h>
-#include <rak/functional.h>
-#include <rak/functional_fun.h>
 #include <rak/priority_queue.h>
 #include <rak/timer.h>
 
@@ -48,33 +47,34 @@ namespace rak {
 
 class priority_item {
 public:
+  typedef std::tr1::function<void (void)> slot_void;
+
   priority_item() {}
   ~priority_item() {
     if (is_queued())
       throw std::logic_error("priority_item::~priority_item() called on a queued item.");
 
     m_time = timer();
-    m_slot.set(NULL);
+    m_slot = slot_void();
   }
 
-  bool                is_valid() const                        { return m_slot.is_valid(); }
-  bool                is_queued() const                       { return m_time != timer(); }
+  bool                is_valid() const              { return (bool)m_slot; }
+  bool                is_queued() const             { return m_time != timer(); }
 
-  void                call()                                  { m_slot(); }
-  void                set_slot(function0<void>::base_type* s) { m_slot.set(s); }
-  
-  const timer&        time() const                           { return m_time; }
-  void                clear_time()                           { m_time = timer(); }
-  void                set_time(const timer& t)               { m_time = t; }
+  slot_void&          slot()                        { return m_slot; }
 
-  bool                compare(const timer& t) const          { return m_time > t; }
+  const timer&        time() const                  { return m_time; }
+  void                clear_time()                  { m_time = timer(); }
+  void                set_time(const timer& t)      { m_time = t; }
+
+  bool                compare(const timer& t) const { return m_time > t; }
 
 private:
   priority_item(const priority_item&);
   void operator = (const priority_item&);
 
   timer               m_time;
-  function0<void>     m_slot;
+  slot_void           m_slot;
 };
 
 struct priority_compare {
@@ -94,7 +94,7 @@ priority_queue_perform(priority_queue_default* queue, timer t) {
     queue->pop();
 
     v->clear_time();
-    v->call();
+    v->slot()();
   }
 }
 

scripts/acx_pthread.m4

@@ -1,227 +0,0 @@
-dnl PGSGL:  When updating, comment out port-specific part below;
-dnl see the comment below with the word "PostgreSQL".
-dnl
-dnl Available from the GNU Autoconf Macro Archive at:
-dnl http://www.gnu.org/software/ac-archive/htmldoc/acx_pthread.html
-dnl
-AC_DEFUN([ACX_PTHREAD], [
-AC_REQUIRE([AC_CANONICAL_HOST])
-AC_LANG_SAVE
-AC_LANG_C
-acx_pthread_ok=no
-
-# We used to check for pthread.h first, but this fails if pthread.h
-# requires special compiler flags (e.g. on True64 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_LIBS$PTHREAD_CFLAGS" != x; then
-        save_CFLAGS="$CFLAGS"
-        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
-        save_LIBS="$LIBS"
-        LIBS="$PTHREAD_LIBS $LIBS"
-        AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS])
-        AC_TRY_LINK_FUNC(pthread_join, acx_pthread_ok=yes)
-        AC_MSG_RESULT($acx_pthread_ok)
-        if test x"$acx_pthread_ok" = xno; then
-                PTHREAD_LIBS=""
-                PTHREAD_CFLAGS=""
-        fi
-        LIBS="$save_LIBS"
-        CFLAGS="$save_CFLAGS"
-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 starting with a "-" are
-# C compiler flags, and other 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.
-
-acx_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config pthreadGC2"
-
-# 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)
-# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
-# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
-# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)
-# -pthreads: Solaris/gcc
-# -mthreads: Mingw32/gcc, Lynx/gcc
-# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
-#      doesn't hurt to check since this sometimes defines pthreads too;
-#      also defines -D_REENTRANT)
-# pthread: Linux, etcetera
-# --thread-safe: KAI C++
-# pthread-config: use pthread-config program (for GNU Pth library)
-
-case "${host_cpu}-${host_os}" in
-        *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.  (We need to link with -pthread or
-        # -lpthread.)  (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 just look for -pthreads and -lpthread first:
-
-        acx_pthread_flags="-pthread -pthreads pthread -mt $acx_pthread_flags"
-        ;;
-esac
-
-if test x"$acx_pthread_ok" = xno; then
-for flag in $acx_pthread_flags; do
-
-        tryPTHREAD_CFLAGS=""
-        tryPTHREAD_LIBS=""
-        case $flag in
-                none)
-                AC_MSG_CHECKING([whether pthreads work without any flags])
-                ;;
-
-                -*)
-                AC_MSG_CHECKING([whether pthreads work with $flag])
-                tryPTHREAD_CFLAGS="$flag"
-                ;;
-
-                pthread-config)
-                # skip this if we already have flags defined, for PostgreSQL
-                if test x"$PTHREAD_CFLAGS" != x -o x"$PTHREAD_LIBS" != x; then continue; fi
-                AC_CHECK_PROG(acx_pthread_config, pthread-config, yes, no)
-                if test x"$acx_pthread_config" = xno; then continue; fi
-                tryPTHREAD_CFLAGS="`pthread-config --cflags`"
-                tryPTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
-                ;;
-
-                *)
-                AC_MSG_CHECKING([for the pthreads library -l$flag])
-                tryPTHREAD_LIBS="-l$flag"
-                ;;
-        esac
-
-        save_LIBS="$LIBS"
-        save_CFLAGS="$CFLAGS"
-        LIBS="$tryPTHREAD_LIBS $PTHREAD_LIBS $LIBS"
-        CFLAGS="$CFLAGS $PTHREAD_CFLAGS $tryPTHREAD_CFLAGS"
-
-        # 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_TRY_LINK([#include <pthread.h>],
-                    [pthread_t th; pthread_join(th, 0);
-                     pthread_attr_init(0); pthread_cleanup_push(0, 0);
-                     pthread_create(0,0,0,0); pthread_cleanup_pop(0); ],
-                    [acx_pthread_ok=yes], [acx_pthread_ok=no])
-
-        if test "x$acx_pthread_ok" = xyes; then
-            # Don't use options that are ignored by the compiler.
-            # We find them by checking stderror.
-            cat >conftest.$ac_ext <<_ACEOF
-int
-main (int argc, char **argv)
-{
-  (void) argc;
-  (void) argv;
-  return 0;
-}
-_ACEOF
-            rm -f conftest.$ac_objext conftest$ac_exeext
-            if test "`(eval $ac_link 2>&1 1>&5)`" = ""; then
-                # we continue with more flags because Linux needs -lpthread
-                # for libpq builds on PostgreSQL.  The test above only
-                # tests for building binaries, not shared libraries.
-                PTHREAD_LIBS=" $tryPTHREAD_LIBS $PTHREAD_LIBS"
-                PTHREAD_CFLAGS="$PTHREAD_CFLAGS $tryPTHREAD_CFLAGS"
-            else   acx_pthread_ok=no
-            fi
-        fi
-
-        LIBS="$save_LIBS"
-        CFLAGS="$save_CFLAGS"
-
-        AC_MSG_RESULT($acx_pthread_ok)
-done
-fi
-
-# Various other checks:
-if test "x$acx_pthread_ok" = xyes; then
-        save_LIBS="$LIBS"
-        LIBS="$PTHREAD_LIBS $LIBS"
-        save_CFLAGS="$CFLAGS"
-        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
-
-        # Detect AIX lossage: threads are created detached by default
-        # and the JOINABLE attribute has a nonstandard name (UNDETACHED).
-        AC_MSG_CHECKING([for joinable pthread attribute])
-        AC_TRY_LINK([#include <pthread.h>],
-                    [int attr=PTHREAD_CREATE_JOINABLE;],
-                    ok=PTHREAD_CREATE_JOINABLE, ok=unknown)
-        if test x"$ok" = xunknown; then
-                AC_TRY_LINK([#include <pthread.h>],
-                            [int attr=PTHREAD_CREATE_UNDETACHED;],
-                            ok=PTHREAD_CREATE_UNDETACHED, ok=unknown)
-        fi
-        if test x"$ok" != xPTHREAD_CREATE_JOINABLE; then
-                AC_DEFINE(PTHREAD_CREATE_JOINABLE, $ok,
-                          [Define to the necessary symbol if this constant
-                           uses a non-standard name on your system.])
-        fi
-        AC_MSG_RESULT(${ok})
-        if test x"$ok" = xunknown; then
-                AC_MSG_WARN([we do not know how to create joinable pthreads])
-        fi
-
-        AC_MSG_CHECKING([if more special flags are required for pthreads])
-        flag=no
-# We always add these in PostgreSQL
-#       case "${host_cpu}-${host_os}" in
-#               *-aix* | *-freebsd* | *-darwin*) flag="-D_THREAD_SAFE";;
-#               *solaris* | *-osf* | *-hpux*) flag="-D_REENTRANT";;
-#       esac
-        AC_MSG_RESULT(${flag})
-        if test "x$flag" != xno; then
-                PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
-        fi
-
-        LIBS="$save_LIBS"
-        CFLAGS="$save_CFLAGS"
-
-# Supporting cc_r would require a special CC in all places that
-# use libpq, and that is ugly, so we don't do it.  Users can still
-# define their compiler as cc_r to do thread builds of everything.
-        # More AIX lossage: must compile with cc_r
-        AC_CHECK_PROG(PTHREAD_CC, cc_r, cc_r, ${CC})
-else
-        PTHREAD_CC="$CC"
-fi
-
-AC_SUBST(PTHREAD_LIBS)
-AC_SUBST(PTHREAD_CFLAGS)
-AC_SUBST(PTHREAD_CC)
-
-# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
-if test x"$acx_pthread_ok" = xyes; then
-        ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1])
-        :
-else
-        acx_pthread_ok=no
-        $2
-fi
-AC_LANG_RESTORE
-])dnl ACX_PTHREAD

scripts/attributes.m4

@@ -3,10 +3,10 @@
 AC_DEFUN([CC_ATTRIBUTE_CONSTRUCTOR], [
 	AC_CACHE_CHECK([if compiler supports __attribute__((constructor))],
 		[cc_cv_attribute_constructor],
-		[AC_COMPILE_IFELSE([
+		[AC_COMPILE_IFELSE([AC_LANG_SOURCE([
 			void ctor() __attribute__((constructor));
 			void ctor() { };
-			],
+			])],
 			[cc_cv_attribute_constructor=yes],
 			[cc_cv_attribute_constructor=no])
 		])
@@ -23,9 +23,9 @@ AC_DEFUN([CC_ATTRIBUTE_CONSTRUCTOR], [
 AC_DEFUN([CC_ATTRIBUTE_FORMAT], [
 	AC_CACHE_CHECK([if compiler supports __attribute__((format(printf, n, n)))],
 		[cc_cv_attribute_format],
-		[AC_COMPILE_IFELSE([
+		[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])
 		])
@@ -42,9 +42,9 @@ AC_DEFUN([CC_ATTRIBUTE_FORMAT], [
 AC_DEFUN([CC_ATTRIBUTE_INTERNAL], [
 	AC_CACHE_CHECK([if compiler supports __attribute__((visibility("internal")))],
 		[cc_cv_attribute_internal],
-		[AC_COMPILE_IFELSE([
+		[AC_COMPILE_IFELSE([AC_LANG_SOURCE([
 			void __attribute__((visibility("internal"))) internal_function() { }
-			],
+			])],
 			[cc_cv_attribute_internal=yes],
 			[cc_cv_attribute_internal=no])
 		])
@@ -66,9 +66,9 @@ AC_DEFUN([CC_ATTRIBUTE_VISIBILITY], [
 
 	AC_CACHE_CHECK([if compiler supports __attribute__((visibility("default")))],
 		[cc_cv_attribute_visibility],
-		[AC_COMPILE_IFELSE([
+		[AC_COMPILE_IFELSE([AC_LANG_SOURCE([
 			void __attribute__((visibility("default"))) visibility_function() { }
-			],
+			])],
 			[cc_cv_attribute_visibility=yes],
 			[cc_cv_attribute_visibility=no])
 		])
@@ -90,10 +90,10 @@ AC_DEFUN([CC_ATTRIBUTE_VISIBILITY], [
 AC_DEFUN([CC_ATTRIBUTE_NONNULL], [
 	AC_CACHE_CHECK([if compiler supports __attribute__((nonnull()))],
 		[cc_cv_attribute_nonnull],
-		[AC_COMPILE_IFELSE([
+		[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])
 		])
@@ -110,9 +110,9 @@ AC_DEFUN([CC_ATTRIBUTE_NONNULL], [
 AC_DEFUN([CC_ATTRIBUTE_UNUSED], [
 	AC_CACHE_CHECK([if compiler supports __attribute__((unused))],
 		[cc_cv_attribute_unused],
-		[AC_COMPILE_IFELSE([
+		[AC_COMPILE_IFELSE([AC_LANG_SOURCE([
 			void some_function(void *foo, __attribute__((unused)) void *bar);
-			],
+			])],
 			[cc_cv_attribute_unused=yes],
 			[cc_cv_attribute_unused=no])
 		])
@@ -129,13 +129,13 @@ AC_DEFUN([CC_ATTRIBUTE_UNUSED], [
 AC_DEFUN([CC_FUNC_EXPECT], [
 	AC_CACHE_CHECK([if compiler has __builtin_expect function],
 		[cc_cv_func_expect],
-		[AC_COMPILE_IFELSE([
+		[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])
 		])

scripts/ax_pthread.m4

@@ -0,0 +1,309 @@
+# ===========================================================================
+#        http://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 to any special C compiler that is needed for
+#   multi-threaded programs (defaults to the value of CC otherwise). (This
+#   is necessary on AIX to use the special cc_r compiler alias.)
+#
+#   NOTE: You are assumed to not only compile your program with these flags,
+#   but also link it with them as well. e.g. you should link with
+#   $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS
+#
+#   If you are only building threads programs, you may wish to use these
+#   variables in your default LIBS, CFLAGS, and CC:
+#
+#     LIBS="$PTHREAD_LIBS $LIBS"
+#     CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+#     CC="$PTHREAD_CC"
+#
+#   In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant
+#   has a nonstandard name, 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>
+#
+#   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 <http://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 17
+
+AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD])
+AC_DEFUN([AX_PTHREAD], [
+AC_REQUIRE([AC_CANONICAL_HOST])
+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 True64 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_LIBS$PTHREAD_CFLAGS" != x; then
+        save_CFLAGS="$CFLAGS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+        save_LIBS="$LIBS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS])
+        AC_TRY_LINK_FUNC(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
+        LIBS="$save_LIBS"
+        CFLAGS="$save_CFLAGS"
+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 starting with a "-" are
+# C compiler flags, and other 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 -kthread lthread -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)
+# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
+# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
+# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)
+# -pthreads: Solaris/gcc
+# -mthreads: Mingw32/gcc, Lynx/gcc
+# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
+#      doesn't hurt to check since this sometimes defines pthreads too;
+#      also defines -D_REENTRANT)
+#      ... -mt is also the pthreads flag for HP/aCC
+# pthread: Linux, etcetera
+# --thread-safe: KAI C++
+# pthread-config: use pthread-config program (for GNU Pth library)
+
+case "${host_cpu}-${host_os}" in
+        *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.  (We need to link with -pthreads/-mt/
+        # -lpthread.)  (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 just look for -pthreads and -lpthread first:
+
+        ax_pthread_flags="-pthreads pthread -mt -pthread $ax_pthread_flags"
+        ;;
+
+        *-darwin*)
+        ax_pthread_flags="-pthread $ax_pthread_flags"
+        ;;
+esac
+
+if test x"$ax_pthread_ok" = xno; then
+for flag in $ax_pthread_flags; do
+
+        case $flag in
+                none)
+                AC_MSG_CHECKING([whether pthreads work without any flags])
+                ;;
+
+                -*)
+                AC_MSG_CHECKING([whether pthreads work with $flag])
+                PTHREAD_CFLAGS="$flag"
+                ;;
+
+                pthread-config)
+                AC_CHECK_PROG(ax_pthread_config, pthread-config, yes, no)
+                if test x"$ax_pthread_config" = xno; then continue; fi
+                PTHREAD_CFLAGS="`pthread-config --cflags`"
+                PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
+                ;;
+
+                *)
+                AC_MSG_CHECKING([for the pthreads library -l$flag])
+                PTHREAD_LIBS="-l$flag"
+                ;;
+        esac
+
+        save_LIBS="$LIBS"
+        save_CFLAGS="$CFLAGS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+
+        # 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>
+                        static void routine(void *a) { a = 0; }
+                        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],
+                [])
+
+        LIBS="$save_LIBS"
+        CFLAGS="$save_CFLAGS"
+
+        AC_MSG_RESULT($ax_pthread_ok)
+        if test "x$ax_pthread_ok" = xyes; then
+                break;
+        fi
+
+        PTHREAD_LIBS=""
+        PTHREAD_CFLAGS=""
+done
+fi
+
+# Various other checks:
+if test "x$ax_pthread_ok" = xyes; then
+        save_LIBS="$LIBS"
+        LIBS="$PTHREAD_LIBS $LIBS"
+        save_CFLAGS="$CFLAGS"
+        CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+
+        # Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
+        AC_MSG_CHECKING([for joinable pthread attribute])
+        attr_name=unknown
+        for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
+            AC_LINK_IFELSE([AC_LANG_PROGRAM([#include <pthread.h>],
+                           [int attr = $attr; return attr /* ; */])],
+                [attr_name=$attr; break],
+                [])
+        done
+        AC_MSG_RESULT($attr_name)
+        if test "$attr_name" != PTHREAD_CREATE_JOINABLE; then
+            AC_DEFINE_UNQUOTED(PTHREAD_CREATE_JOINABLE, $attr_name,
+                               [Define to necessary symbol if this constant
+                                uses a non-standard name on your system.])
+        fi
+
+        AC_MSG_CHECKING([if more special flags are required for pthreads])
+        flag=no
+        case "${host_cpu}-${host_os}" in
+            *-aix* | *-freebsd* | *-darwin*) flag="-D_THREAD_SAFE";;
+            *-osf* | *-hpux*) flag="-D_REENTRANT";;
+            *solaris*)
+            if test "$GCC" = "yes"; then
+                flag="-D_REENTRANT"
+            else
+                flag="-mt -D_REENTRANT"
+            fi
+            ;;
+        esac
+        AC_MSG_RESULT(${flag})
+        if test "x$flag" != xno; then
+            PTHREAD_CFLAGS="$flag $PTHREAD_CFLAGS"
+        fi
+
+        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;]])],
+                    [ax_cv_PTHREAD_PRIO_INHERIT=yes],
+                    [ax_cv_PTHREAD_PRIO_INHERIT=no])
+            ])
+        AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes"],
+            AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], 1, [Have PTHREAD_PRIO_INHERIT.]))
+
+        LIBS="$save_LIBS"
+        CFLAGS="$save_CFLAGS"
+
+        # More AIX lossage: must compile with xlc_r or cc_r
+        if test x"$GCC" != xyes; then
+          AC_CHECK_PROGS(PTHREAD_CC, xlc_r cc_r, ${CC})
+        else
+          PTHREAD_CC=$CC
+        fi
+else
+        PTHREAD_CC="$CC"
+fi
+
+AC_SUBST(PTHREAD_LIBS)
+AC_SUBST(PTHREAD_CFLAGS)
+AC_SUBST(PTHREAD_CC)
+
+# 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_with_curses.m4

@@ -0,0 +1,546 @@
+# ===========================================================================
+#      http://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.
+#
+#   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 variable is defined by this macro; it is precious
+#   and may be overridden on the ./configure command line:
+#
+#     CURSES_LIB  - library to add to xxx_LDADD
+#
+#   The library listed in CURSES_LIB is NOT added to LIBS by default. You
+#   need to add CURSES_LIB to the appropriate xxx_LDADD line in your
+#   Makefile.am.  For example:
+#
+#     prog_LDADD = @CURSES_LIB@
+#
+#   If CURSES_LIB is set on the configure command line (such as by running
+#   "./configure CURSES_LIB=-lmycurses"), then the only header searched for
+#   is <curses.h>.  The user may use the CPPFLAGS precious variable to
+#   override the standard #include search path.  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
+#         AX_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 <http://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 13
+
+AU_ALIAS([MP_WITH_CURSES], [AX_WITH_CURSES])
+AC_DEFUN([AX_WITH_CURSES], [
+    AC_ARG_VAR([CURSES_LIB], [linker library for Curses, e.g. -lcurses])
+    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
+    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_LIB" = x && test "x$with_ncursesw" != xno], [
+        LIBS="$ax_saved_LIBS -lncursesw"
+
+        AC_CACHE_CHECK([for NcursesW wide-character library], [ax_cv_ncursesw], [
+            AC_LINK_IFELSE([AC_LANG_CALL([], [initscr])],
+                [ax_cv_ncursesw=yes], [ax_cv_ncursesw=no])
+        ])
+        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_LIB="-lncursesw"
+            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])
+            ])
+            
+            dnl Test if we need to explicitly link against -ltinfow.
+            AC_CACHE_CHECK([if curses tinfo library is linked properly], [ax_cv_ncurses_compiled], [
+                LIBS="$ax_saved_LIBS $CURSES_LIB"
+                AC_LINK_IFELSE([AC_LANG_CALL([], [keypad])], [ax_cv_ncurses_compiled=yes], [ax_cv_ncurses_compiled=no])
+
+                LIBS="$ax_saved_LIBS $CURSES_LIB -ltinfo"
+                AC_LINK_IFELSE([AC_LANG_CALL([], [keypad])], [ax_cv_tinfo_compiled=yes], [ax_cv_tinfo_compiled=no])
+
+                LIBS="$ax_saved_LIBS $CURSES_LIB -ltinfow"
+                AC_LINK_IFELSE([AC_LANG_CALL([], [keypad])], [ax_cv_tinfow_compiled=yes], [ax_cv_tinfow_compiled=no])
+
+                LIBS=$ax_saved_LIBS
+            ])
+
+            AS_IF([test "x$ax_cv_ncurses_compiled" = xno], [
+                AS_IF(
+                    [test "x$ax_cv_tinfo_compiled" = xyes], [
+                        AC_MSG_RESULT([adding libtinfo])
+                        CURSES_LIB="$CURSES_LIB -ltinfo"
+                    ],
+                    [test "x$ax_cv_tinfow_compiled" = xyes], [
+                        AC_MSG_RESULT([adding libtinfow])
+                        CURSES_LIB="$CURSES_LIB -ltinfow"
+                    ], [
+                    AC_MSG_ERROR([no])
+                ])
+            ])
+        ])
+    ])
+
+    # Test for Ncurses
+
+    AS_IF([test "x$CURSES_LIB" = x && test "x$with_ncurses" != xno && test "x$ax_cv_curses_which" = xno], [
+        LIBS="$ax_saved_LIBS -lncurses"
+
+        AC_CACHE_CHECK([for Ncurses library], [ax_cv_ncurses], [
+            AC_LINK_IFELSE([AC_LANG_CALL([], [initscr])],
+                [ax_cv_ncurses=yes], [ax_cv_ncurses=no])
+        ])
+        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_LIB="-lncurses"
+            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])
+            ])
+        ])
+    ])
+
+    # Test for plain Curses (or if CURSES_LIB was set by user)
+
+    AS_IF([test "x$with_plaincurses" != xno && test "x$ax_cv_curses_which" = xno], [
+        AS_IF([test "x$CURSES_LIB" != x], [
+            LIBS="$ax_saved_LIBS $CURSES_LIB"
+        ], [
+            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_LIB" = x], [
+                CURSES_LIB="-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
+])dnl

scripts/checks.m4

@@ -1,15 +1,15 @@
 AC_DEFUN([TORRENT_CHECK_XFS], [
   AC_MSG_CHECKING(for XFS support)
 
-  AC_COMPILE_IFELSE(
-    [[#include <xfs/libxfs.h>
+  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)
@@ -46,13 +46,13 @@ AC_DEFUN([TORRENT_WITH_XFS], [
 AC_DEFUN([TORRENT_CHECK_EPOLL], [
   AC_MSG_CHECKING(for epoll support)
 
-  AC_COMPILE_IFELSE(
-    [[#include <sys/epoll.h>
+  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)
@@ -77,14 +77,14 @@ AC_DEFUN([TORRENT_WITHOUT_EPOLL], [
 AC_DEFUN([TORRENT_CHECK_KQUEUE], [
   AC_MSG_CHECKING(for kqueue support)
 
-  AC_LINK_IFELSE(
-    [[#include <sys/time.h>  /* Because OpenBSD's sys/event.h fails to compile otherwise. Yeah... */
+  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)
@@ -96,8 +96,8 @@ AC_DEFUN([TORRENT_CHECK_KQUEUE], [
 AC_DEFUN([TORRENT_CHECK_KQUEUE_SOCKET_ONLY], [
   AC_MSG_CHECKING(whether kqueue supports pipes and ptys)
 
-  AC_RUN_IFELSE(
-    [[#include <fcntl.h>
+  AC_RUN_IFELSE([AC_LANG_SOURCE([
+      #include <fcntl.h>
       #include <stdlib.h>
       #include <unistd.h>
       #include <sys/event.h>
@@ -122,7 +122,7 @@ AC_DEFUN([TORRENT_CHECK_KQUEUE_SOCKET_ONLY], [
         if ((n = kevent(kfd, NULL, 0, ev_out, 2, &ts)) < 1) return 9;
         return 0;
       }
-    ]],
+      ])],
     [
       AC_MSG_RESULT(yes)
     ], [
@@ -143,6 +143,21 @@ AC_DEFUN([TORRENT_WITH_KQUEUE], [
 ])
 
 
+AC_DEFUN([TORRENT_WITHOUT_KQUEUE], [
+  AC_ARG_WITH(kqueue,
+    [  --without-kqueue         Do not check for kqueue support.],
+    [
+      if test "$withval" = "yes"; then
+        TORRENT_CHECK_KQUEUE
+        TORRENT_CHECK_KQUEUE_SOCKET_ONLY
+      fi
+    ], [
+        TORRENT_CHECK_KQUEUE
+        TORRENT_CHECK_KQUEUE_SOCKET_ONLY
+    ])
+])
+
+
 AC_DEFUN([TORRENT_WITHOUT_VARIABLE_FDSET], [
   AC_ARG_WITH(variable-fdset,
 
@@ -198,26 +213,6 @@ AC_DEFUN([TORRENT_WITH_POSIX_FALLOCATE], [
     ])
 ])
 
-AC_DEFUN([TORRENT_WITHOUT_NCURSESW], [
-  AC_ARG_WITH(ncursesw,
-    [  --without-ncursesw      Don't try to use wide char ncurses.],
-    [
-      if test "$withval" = "no"; then
-	AC_SEARCH_LIBS(add_wch, ncursesw,
-	  AC_DEFINE(HAVE_NCURSESW, 1, defined if ncurses wide character support is available),
-	  AC_SEARCH_LIBS(wbkgdset, ncurses curses,,echo "*** The ncurses library is required!";exit 1)
-        )
-      else
-	AC_SEARCH_LIBS(wbkgdset, ncurses curses,,echo "*** The ncurses library is required!";exit 1)
-      fi
-    ],[
-      AC_SEARCH_LIBS(add_wch, ncursesw,
-	AC_DEFINE(HAVE_NCURSESW, 1, defined if ncurses wide character support is available),
-	AC_SEARCH_LIBS(wbkgdset, ncurses curses,,echo "*** The ncurses library is required!";exit 1)
-      )
-    ])
-])
-
 AC_DEFUN([TORRENT_CHECK_STATVFS], [
   AC_CHECK_HEADERS(sys/vfs.h sys/statvfs.h sys/statfs.h)
 
@@ -364,11 +359,11 @@ AC_DEFUN([TORRENT_CHECK_TR1], [
   AC_LANG_PUSH(C++)
   AC_MSG_CHECKING(for TR1 support)
 
-  AC_COMPILE_IFELSE(
-    [[#include <tr1/unordered_map>
+  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+      #include <tr1/unordered_map>
       class Foo;
       typedef std::tr1::unordered_map<Foo*, int> Bar;
-    ]],
+      ])],
     [
       AC_MSG_RESULT(yes)
       AC_DEFINE(HAVE_TR1, 1, Define to 1 if your C++ library supports the extensions from Technical Report 1)
@@ -381,6 +376,30 @@ AC_DEFUN([TORRENT_CHECK_TR1], [
   AC_LANG_POP(C++)
 ])
 
+AC_DEFUN([TORRENT_CHECK_CXX11], [
+  AC_LANG_PUSH(C++)
+  AC_MSG_CHECKING(for C++11 support)
+
+  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+      #include <functional>
+      #include <unordered_map>
+      class Foo;
+      typedef std::unordered_map<Foo*, int> Bar;
+
+      union test { Bar b1; };
+      ])],
+    [
+      AC_MSG_RESULT(yes)
+      AC_DEFINE(HAVE_CXX11, 1, Define to 1 if your C++ compiler has support for C++11.)
+    ],
+    [
+      AC_MSG_RESULT(no)
+    ]
+  )
+
+  AC_LANG_POP(C++)
+])
+
 AC_DEFUN([TORRENT_WITH_FASTCGI], [
   AC_ARG_WITH(fastcgi,
     [  --with-fastcgi=PATH      Enable FastCGI RPC support. (DO NOT USE)],
@@ -470,3 +489,22 @@ AC_DEFUN([TORRENT_WITH_XMLRPC_C], [
     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++)
+])

scripts/common.m4

@@ -99,11 +99,11 @@ AC_DEFUN([TORRENT_OTFD], [
   AC_LANG_PUSH(C++)
   AC_MSG_CHECKING(for proper overloaded template function disambiguation)
 
-  AC_COMPILE_IFELSE(
-    [[template <typename T> void f(T&) {}
+  AC_COMPILE_IFELSE([AC_LANG_SOURCE([
+      template <typename T> void f(T&) {}
       template <typename T> void f(T*) {}
       int main() { int *i = 0; f(*i); f(i); }
-    ]],
+      ])],
     [
       AC_MSG_RESULT(yes)
     ], [
@@ -119,24 +119,24 @@ AC_DEFUN([TORRENT_MINCORE_SIGNEDNESS], [
   AC_LANG_PUSH(C++)
   AC_MSG_CHECKING(signedness of mincore parameter)
 
-  AC_COMPILE_IFELSE(
-    [[#include <sys/types.h>
+  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(
-        [[#include <sys/types.h>
+      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)
@@ -168,11 +168,11 @@ AC_DEFUN([TORRENT_MINCORE], [
 AC_DEFUN([TORRENT_CHECK_MADVISE], [
   AC_MSG_CHECKING(for madvise)
 
-  AC_COMPILE_IFELSE(
-    [[#include <sys/types.h>
+  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)
@@ -184,10 +184,9 @@ AC_DEFUN([TORRENT_CHECK_MADVISE], [
 AC_DEFUN([TORRENT_CHECK_POPCOUNT], [
   AC_MSG_CHECKING(for __builtin_popcount)
 
-  AC_COMPILE_IFELSE(
-    [[
-      void f() { __builtin_popcount(0); }
-    ]],
+  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.)
@@ -199,12 +198,12 @@ AC_DEFUN([TORRENT_CHECK_POPCOUNT], [
 AC_DEFUN([TORRENT_CHECK_CACHELINE], [
   AC_MSG_CHECKING(for cacheline)
 
-  AC_COMPILE_IFELSE(
-    [[#include <stdlib.h>
+  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      AC_DEFINE(LT_SMP_CACHE_BYTES, SMP_CACHE_BYTES, Largest L1 cache size we know of, should work on all archs.)
@@ -224,10 +223,10 @@ dnl   Need to fix this so that it uses the stuff defined by the system.
 AC_DEFUN([TORRENT_CHECK_EXECINFO], [
   AC_MSG_CHECKING(for execinfo.h)
 
-  AC_RUN_IFELSE(
-    [[#include <execinfo.h>
+  AC_RUN_IFELSE([AC_LANG_SOURCE([
+      #include <execinfo.h>
       int main() { backtrace((void**)0, 0); backtrace_symbols((char**)0, 0); return 0;}
-    ]],
+      ])],
     [
       AC_MSG_RESULT(yes)
       AC_DEFINE(USE_EXECINFO, 1, Use execinfo.h)
@@ -239,8 +238,8 @@ AC_DEFUN([TORRENT_CHECK_EXECINFO], [
 AC_DEFUN([TORRENT_CHECK_ALIGNED], [
   AC_MSG_CHECKING(the byte alignment)
 
-  AC_RUN_IFELSE(
-    [[#include <inttypes.h>
+  AC_RUN_IFELSE([AC_LANG_SOURCE([
+      #include <inttypes.h>
       int main() {
         char buf[8] = { 0, 0, 0, 0, 1, 0, 0, 0 };
 	int i;
@@ -248,7 +247,7 @@ AC_DEFUN([TORRENT_CHECK_ALIGNED], [
 	  if (*(uint32_t*)(buf + i) == 0) return -1;
 	return 0;
 	}
-    ]],
+      ])],
     [
       AC_MSG_RESULT(none needed)
     ], [
@@ -295,3 +294,18 @@ AC_DEFUN([TORRENT_ENABLE_TR1], [
         TORRENT_CHECK_TR1()
     ])
 ])
+
+AC_DEFUN([TORRENT_ENABLE_CXX11], [
+  AC_ARG_ENABLE(std_c++11,
+    [  --disable-std_c++11     disable check for support for C++11 [[default=enable]]],
+    [
+      if test "$enableval" = "yes"; then
+        TORRENT_CHECK_CXX11()
+      else
+        AC_MSG_CHECKING(for C++11 support)
+        AC_MSG_RESULT(disabled)
+      fi
+    ],[
+        TORRENT_CHECK_CXX11()
+    ])
+])

src/Makefile.am

@@ -34,8 +34,6 @@ libsub_root_a_SOURCES = \
 	signal_handler.h \
 	thread_base.cc \
 	thread_base.h \
-	thread_main.cc \
-	thread_main.h \
 	thread_worker.cc \
 	thread_worker.h
 
@@ -48,7 +46,8 @@ rtorrent_LDADD = \
 	display/libsub_display.a \
 	input/libsub_input.a \
 	rpc/libsub_rpc.a \
-	utils/libsub_utils.a
+	utils/libsub_utils.a \
+	@PTHREAD_LIBS@
 
 rtorrent_SOURCES = \
 	main.cc

src/command_download.cc

@@ -138,10 +138,9 @@ apply_d_change_link(core::Download* download, const torrent::Object::list_type&
 
   switch (changeType) {
   case 0:
-    if (symlink(target.c_str(), link.c_str()) == -1)
+    // if (symlink(target.c_str(), link.c_str()) == -1)
       //     control->core()->push_log("create_link failed: " + std::string(rak::error_number::current().c_str()));
       //     control->core()->push_log("create_link failed: " + std::string(rak::error_number::current().c_str()) + " to " + target);
-      ; // Disabled.
     break;
 
   case 1:
@@ -150,9 +149,9 @@ apply_d_change_link(core::Download* download, const torrent::Object::list_type&
     rak::error_number::clear_global();
 
     if (!fileStat.update_link(link) || !fileStat.is_link() ||
-        unlink(link.c_str()) == -1)
-      ; //     control->core()->push_log("delete_link failed: " + std::string(rak::error_number::current().c_str()));
-
+        unlink(link.c_str()) == -1) {
+      //     control->core()->push_log("delete_link failed: " + std::string(rak::error_number::current().c_str()));
+    }
     break;
   }
   default:
@@ -329,6 +328,16 @@ apply_d_add_peer(core::Download* download, const std::string& arg) {
   torrent::connection_manager()->resolver()(host, (int)rak::socket_address::pf_inet, SOCK_STREAM, call_add_d_peer_t(download, port));
 }
 
+torrent::Object
+d_chunks_seen(core::Download* download) {
+  const uint8_t* seen = download->download()->chunks_seen();
+
+  if (seen == NULL)
+    return std::string();
+  else
+    return std::string((const char*)seen, download->download()->file_list()->size_chunks());
+}
+
 torrent::Object
 f_multicall(core::Download* download, const torrent::Object::list_type& args) {
   if (args.empty())
@@ -348,7 +357,7 @@ f_multicall(core::Download* download, const torrent::Object::list_type& args) {
   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));
+                   tr1::bind(&torrent::Object::as_string_c, tr1::placeholders::_1));
   else if (args.front().is_string() && !args.front().as_string().empty())
     regex_list.push_back(args.front().as_string());
   else
@@ -357,12 +366,12 @@ f_multicall(core::Download* download, const torrent::Object::list_type& args) {
   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())
+                     tr1::bind(&rak::regex::operator(), tr1::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(), cLast = args.end(); cItr != args.end(); cItr++) {
+    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);
     }
@@ -387,7 +396,7 @@ t_multicall(core::Download* download, const torrent::Object::list_type& args) {
   for (int itr = 0, last = download->tracker_list()->size(); 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(), cLast = args.end(); cItr != args.end(); cItr++) {
+    for (torrent::Object::list_const_iterator cItr = ++args.begin(); cItr != args.end(); cItr++) {
       const std::string& cmd = cItr->as_string();
       torrent::Tracker* t = download->tracker_list()->at(itr);
 
@@ -415,7 +424,7 @@ p_multicall(core::Download* download, const torrent::Object::list_type& args) {
        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(), cLast = args.end(); cItr != args.end(); cItr++) {
+    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);
@@ -573,52 +582,52 @@ d_list_remove(core::Download* download, const torrent::Object& rawArgs, const ch
   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_ON_INFO(func) tr1::bind(&torrent::DownloadInfo::func, tr1::bind(&core::Download::info, tr1::placeholders::_1))
+#define CMD2_ON_DATA(func) tr1::bind(&torrent::download_data::func, tr1::bind(&core::Download::data, tr1::placeholders::_1))
+#define CMD2_ON_DL(func) tr1::bind(&torrent::Download::func, tr1::bind(&core::Download::download, tr1::placeholders::_1))
+#define CMD2_ON_FL(func) tr1::bind(&torrent::FileList::func, tr1::bind(&core::Download::file_list, tr1::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_TL std::bind(&core::Download::tracker_list, std::placeholders::_1)
-#define CMD2_BIND_TC std::bind(&core::Download::tracker_controller, std::placeholders::_1)
+#define CMD2_BIND_DL tr1::bind(&core::Download::download, tr1::placeholders::_1)
+#define CMD2_BIND_CL tr1::bind(&core::Download::connection_list, tr1::placeholders::_1)
+#define CMD2_BIND_FL tr1::bind(&core::Download::file_list, tr1::placeholders::_1)
+#define CMD2_BIND_PL tr1::bind(&core::Download::c_peer_list, tr1::placeholders::_1)
+#define CMD2_BIND_TL tr1::bind(&core::Download::tracker_list, tr1::placeholders::_1)
+#define CMD2_BIND_TC tr1::bind(&core::Download::tracker_controller, tr1::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_BIND_INFO tr1::bind(&core::Download::info, tr1::placeholders::_1)
+#define CMD2_BIND_DATA tr1::bind(&core::Download::data, tr1::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, \
+  CMD2_DL(key, tr1::bind(&download_get_variable, tr1::placeholders::_1, first_key, second_key)); \
+  CMD2_DL_VALUE_P(key ".set", tr1::bind(&download_set_variable_value, \
+                                             tr1::placeholders::_1, tr1::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, \
+  CMD2_DL(key, tr1::bind(&download_get_variable, tr1::placeholders::_1, first_key, second_key)); \
+  CMD2_DL_VALUE(key ".set", tr1::bind(&download_set_variable_value, \
+                                           tr1::placeholders::_1, tr1::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, \
+  CMD2_DL(key, tr1::bind(&download_get_variable, tr1::placeholders::_1, first_key, second_key)); \
+  CMD2_DL_VALUE_P(key ".set", tr1::bind(&download_set_variable_value, \
+                                             tr1::placeholders::_1, tr1::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, \
+  CMD2_DL_VALUE_P(key ".set_if_z", tr1::bind(&download_set_variable_value_ifz, \
+                                             tr1::placeholders::_1, tr1::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, \
+  CMD2_DL(key, tr1::bind(&download_get_variable, tr1::placeholders::_1, first_key, second_key)); \
+  CMD2_DL_STRING_P(key ".set", tr1::bind(&download_set_variable_string, \
+                                              tr1::placeholders::_1, tr1::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, \
+  CMD2_DL(key, tr1::bind(&download_get_variable, tr1::placeholders::_1, first_key, second_key)); \
+  CMD2_DL_STRING(key ".set", tr1::bind(&download_set_variable_string, \
+                                            tr1::placeholders::_1, tr1::placeholders::_2, \
                                             first_key, second_key));
 
 int64_t            cg_d_group(core::Download* download);
@@ -627,12 +636,12 @@ void               cg_d_group_set(core::Download* download, const torrent::Objec
 
 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.hash",          tr1::bind(&rak::transform_hex_str<torrent::HashString>, CMD2_ON_INFO(hash)));
+  CMD2_DL("d.local_id",      tr1::bind(&rak::transform_hex_str<torrent::HashString>, CMD2_ON_INFO(local_id)));
+  CMD2_DL("d.local_id_html", tr1::bind(&rak::copy_escape_html_str<torrent::HashString>, CMD2_ON_INFO(local_id)));
+  CMD2_DL("d.bitfield",      tr1::bind(&retrieve_d_bitfield, tr1::placeholders::_1));
+  CMD2_DL("d.base_path",     tr1::bind(&retrieve_d_base_path, tr1::placeholders::_1));
+  CMD2_DL("d.base_filename", tr1::bind(&retrieve_d_base_filename, tr1::placeholders::_1));
 
   CMD2_DL("d.name",          CMD2_ON_INFO(name));
   CMD2_DL("d.creation_date", CMD2_ON_INFO(creation_date));
@@ -642,19 +651,19 @@ initialize_command_download() {
   // 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.up.rate",       tr1::bind(&torrent::Rate::rate,  CMD2_ON_INFO(up_rate)));
+  CMD2_DL         ("d.up.total",      tr1::bind(&torrent::Rate::total, CMD2_ON_INFO(up_rate)));
+  CMD2_DL         ("d.down.rate",     tr1::bind(&torrent::Rate::rate,  CMD2_ON_INFO(down_rate)));
+  CMD2_DL         ("d.down.total",    tr1::bind(&torrent::Rate::total, CMD2_ON_INFO(down_rate)));
+  CMD2_DL         ("d.skip.rate",     tr1::bind(&torrent::Rate::rate,  CMD2_ON_INFO(skip_rate)));
+  CMD2_DL         ("d.skip.total",    tr1::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_VALUE_V ("d.peer_exchange.set", tr1::bind(&torrent::Download::set_pex_enabled, CMD2_BIND_DL, tr1::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_DL_LIST    ("d.create_link", tr1::bind(&apply_d_change_link, tr1::placeholders::_1, tr1::placeholders::_2, 0));
+  CMD2_DL_LIST    ("d.delete_link", tr1::bind(&apply_d_change_link, tr1::placeholders::_1, tr1::placeholders::_2, 1));
+  CMD2_DL         ("d.delete_tied", tr1::bind(&apply_d_delete_tied, tr1::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");
@@ -668,36 +677,36 @@ initialize_command_download() {
 
   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_hash_checked",       tr1::bind(&torrent::Download::is_hash_checked, CMD2_BIND_DL));
+  CMD2_DL         ("d.is_hash_checking",      tr1::bind(&torrent::Download::is_hash_checking, CMD2_BIND_DL));
+  CMD2_DL         ("d.is_multi_file",         tr1::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_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_V       ("d.resume",     tr1::bind(&core::DownloadList::resume_default, control->core()->download_list(), tr1::placeholders::_1));
+  CMD2_DL_V       ("d.pause",      tr1::bind(&core::DownloadList::pause_default, control->core()->download_list(), tr1::placeholders::_1));
+  CMD2_DL_V       ("d.open",       tr1::bind(&core::DownloadList::open_throw, control->core()->download_list(), tr1::placeholders::_1));
+  CMD2_DL_V       ("d.close",      tr1::bind(&core::DownloadList::close_throw, control->core()->download_list(), tr1::placeholders::_1));
+  CMD2_DL_V       ("d.close.directly", tr1::bind(&core::DownloadList::close_directly, control->core()->download_list(), tr1::placeholders::_1));
+  CMD2_DL_V       ("d.erase",      tr1::bind(&core::DownloadList::erase_ptr, control->core()->download_list(), tr1::placeholders::_1));
+  CMD2_DL_V       ("d.check_hash", tr1::bind(&core::DownloadList::check_hash, control->core()->download_list(), tr1::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         ("d.save_resume",       tr1::bind(&core::DownloadStore::save_resume, control->core()->download_store(), tr1::placeholders::_1));
+  CMD2_DL         ("d.save_full_session", tr1::bind(&core::DownloadStore::save_full, control->core()->download_store(), tr1::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));
+  CMD2_DL_STRING_V("add_peer",   tr1::bind(&apply_d_add_peer, tr1::placeholders::_1, tr1::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_STRING("d.custom",       tr1::bind(&retrieve_d_custom, tr1::placeholders::_1, tr1::placeholders::_2));
+  CMD2_DL_STRING("d.custom_throw", tr1::bind(&retrieve_d_custom_throw, tr1::placeholders::_1, tr1::placeholders::_2));
+  CMD2_DL_LIST  ("d.custom.set",   tr1::bind(&apply_d_custom, tr1::placeholders::_1, tr1::placeholders::_2));
 
   CMD2_DL_VAR_STRING_PUBLIC("d.custom1", "rtorrent", "custom1");
   CMD2_DL_VAR_STRING_PUBLIC("d.custom2", "rtorrent", "custom2");
@@ -742,68 +751,68 @@ initialize_command_download() {
   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       ("d.connection_current",     tr1::bind(&torrent::option_as_string, torrent::OPTION_CONNECTION_TYPE, CMD2_ON_DL(connection_type)));
+  CMD2_DL_STRING("d.connection_current.set", tr1::bind(&apply_d_connection_type, tr1::placeholders::_1, tr1::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       ("d.up.choke_heuristics",       tr1::bind(&torrent::option_as_string, torrent::OPTION_CHOKE_HEURISTICS, CMD2_ON_DL(upload_choke_heuristic)));
+  CMD2_DL_STRING("d.up.choke_heuristics.set",   tr1::bind(&apply_d_choke_heuristics, tr1::placeholders::_1, tr1::placeholders::_2, false));
+  CMD2_DL       ("d.down.choke_heuristics",     tr1::bind(&torrent::option_as_string, torrent::OPTION_CHOKE_HEURISTICS, CMD2_ON_DL(download_choke_heuristic)));
+  CMD2_DL_STRING("d.down.choke_heuristics.set", tr1::bind(&apply_d_choke_heuristics, tr1::placeholders::_1, tr1::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.hashing_failed",     tr1::bind(&core::Download::is_hash_failed, tr1::placeholders::_1));
+  CMD2_DL_VALUE_V ("d.hashing_failed.set", tr1::bind(&core::Download::set_hash_failed, tr1::placeholders::_1, tr1::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"));
+  CMD2_DL         ("d.views",                  tr1::bind(&download_get_variable, tr1::placeholders::_1, "rtorrent", "views"));
+  CMD2_DL         ("d.views.has",              tr1::bind(&d_list_has, tr1::placeholders::_1, tr1::placeholders::_2, "rtorrent", "views"));
+  CMD2_DL         ("d.views.remove",           tr1::bind(&d_list_remove, tr1::placeholders::_1, tr1::placeholders::_2, "rtorrent", "views"));
+  CMD2_DL         ("d.views.push_back",        tr1::bind(&d_list_push_back, tr1::placeholders::_1, tr1::placeholders::_2, "rtorrent", "views"));
+  CMD2_DL         ("d.views.push_back_unique", tr1::bind(&d_list_push_back_unique, tr1::placeholders::_1, tr1::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.message",     tr1::bind(&core::Download::message, tr1::placeholders::_1));
+  CMD2_DL_STRING_V("d.message.set", tr1::bind(&core::Download::set_message, tr1::placeholders::_1, tr1::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_VALUE_V ("d.max_file_size.set",   tr1::bind(&torrent::FileList::set_max_file_size, CMD2_BIND_FL, tr1::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_min",           tr1::bind(&torrent::ConnectionList::min_size, CMD2_BIND_CL));
+  CMD2_DL_VALUE_V ("d.peers_min.set",       tr1::bind(&torrent::ConnectionList::set_min_size, CMD2_BIND_CL, tr1::placeholders::_2));
+  CMD2_DL         ("d.peers_max",           tr1::bind(&torrent::ConnectionList::max_size, CMD2_BIND_CL));
+  CMD2_DL_VALUE_V ("d.peers_max.set",       tr1::bind(&torrent::ConnectionList::set_max_size, CMD2_BIND_CL, tr1::placeholders::_2));
+  CMD2_DL         ("d.uploads_max",         tr1::bind(&torrent::Download::uploads_max, CMD2_BIND_DL));
+  CMD2_DL_VALUE_V ("d.uploads_max.set",     tr1::bind(&torrent::Download::set_uploads_max, CMD2_BIND_DL, tr1::placeholders::_2));
+  CMD2_DL         ("d.uploads_min",         tr1::bind(&torrent::Download::uploads_min, CMD2_BIND_DL));
+  CMD2_DL_VALUE_V ("d.uploads_min.set",     tr1::bind(&torrent::Download::set_uploads_min, CMD2_BIND_DL, tr1::placeholders::_2));
+  CMD2_DL         ("d.downloads_max",         tr1::bind(&torrent::Download::downloads_max, CMD2_BIND_DL));
+  CMD2_DL_VALUE_V ("d.downloads_max.set",     tr1::bind(&torrent::Download::set_downloads_max, CMD2_BIND_DL, tr1::placeholders::_2));
+  CMD2_DL         ("d.downloads_min",         tr1::bind(&torrent::Download::downloads_min, CMD2_BIND_DL));
+  CMD2_DL_VALUE_V ("d.downloads_min.set",     tr1::bind(&torrent::Download::set_downloads_min, CMD2_BIND_DL, tr1::placeholders::_2));
+  CMD2_DL         ("d.peers_connected",     tr1::bind(&torrent::ConnectionList::size, CMD2_BIND_CL));
+  CMD2_DL         ("d.peers_not_connected", tr1::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_V       ("d.disconnect.seeders",        tr1::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_V       ("d.accepting_seeders.enable",  tr1::bind(&torrent::DownloadInfo::public_set_flags,   CMD2_BIND_INFO, torrent::DownloadInfo::flag_accepting_seeders));
+  CMD2_DL_V       ("d.accepting_seeders.disable", tr1::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.throttle_name",     tr1::bind(&download_get_variable, tr1::placeholders::_1, "rtorrent", "throttle_name"));
+  CMD2_DL_STRING_V("d.throttle_name.set", tr1::bind(&core::Download::set_throttle_name, tr1::placeholders::_1, tr1::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.ratio",          tr1::bind(&retrieve_d_ratio, tr1::placeholders::_1));
   CMD2_DL         ("d.chunks_hashed",  CMD2_ON_DL(chunks_hashed));
   CMD2_DL         ("d.free_diskspace", CMD2_ON_FL(free_diskspace));
 
@@ -814,50 +823,52 @@ initialize_command_download() {
   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",      tr1::bind(&d_chunks_seen, tr1::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));
 
-  CMD2_DL_V       ("d.tracker_announce",     std::bind(&torrent::Download::manual_request, CMD2_BIND_DL, false)); 
-  CMD2_DL         ("d.tracker_numwant",      std::bind(&torrent::TrackerList::numwant, CMD2_BIND_TL));
-  CMD2_DL_VALUE_V ("d.tracker_numwant.set",  std::bind(&torrent::TrackerList::set_numwant, CMD2_BIND_TL, std::placeholders::_2));
+  CMD2_DL_V       ("d.tracker_announce",     tr1::bind(&torrent::Download::manual_request, CMD2_BIND_DL, false)); 
+  CMD2_DL         ("d.tracker_numwant",      tr1::bind(&torrent::TrackerList::numwant, CMD2_BIND_TL));
+  CMD2_DL_VALUE_V ("d.tracker_numwant.set",  tr1::bind(&torrent::TrackerList::set_numwant, CMD2_BIND_TL, tr1::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_focus",        tr1::bind(&core::Download::tracker_list_size, tr1::placeholders::_1));
+  CMD2_DL         ("d.tracker_size",         tr1::bind(&core::Download::tracker_list_size, tr1::placeholders::_1));
 
-  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",  std::bind(&torrent::TrackerController::scrape_request, CMD2_BIND_TC, std::placeholders::_2));
+  CMD2_DL_LIST    ("d.tracker.insert",       tr1::bind(&download_tracker_insert, tr1::placeholders::_1, tr1::placeholders::_2));
+  CMD2_DL_VALUE_V ("d.tracker.send_scrape",  tr1::bind(&torrent::TrackerController::scrape_request, CMD2_BIND_TC, tr1::placeholders::_2));
 
   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_STRING_V("d.directory.set",      tr1::bind(&apply_d_directory, tr1::placeholders::_1, tr1::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_STRING_V("d.directory_base.set", tr1::bind(&core::Download::set_root_directory, tr1::placeholders::_1, tr1::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.priority",     tr1::bind(&core::Download::priority, tr1::placeholders::_1));
+  CMD2_DL         ("d.priority_str", tr1::bind(&retrieve_d_priority_str, tr1::placeholders::_1));
+  CMD2_DL_VALUE_V ("d.priority.set", tr1::bind(&core::Download::set_priority, tr1::placeholders::_1, tr1::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         ("d.group",     tr1::bind(&torrent::resource_manager_entry::group,
+  //                                           tr1::bind(&torrent::ResourceManager::entry_at, torrent::resource_manager(),
+  //                                                     tr1::bind(&core::Download::main, tr1::placeholders::_1))));
 
-  // CMD2_DL_V       ("d.group.set", std::bind(&torrent::ResourceManager::set_group,
+  // CMD2_DL_V       ("d.group.set", tr1::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)),
+  //                                           tr1::bind(&torrent::ResourceManager::find_throw, torrent::resource_manager(),
+  //                                                     tr1::bind(&core::Download::main, tr1::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, std::placeholders::_1));;
-  CMD2_DL_V       ("d.group.set",  std::bind(&cg_d_group_set, std::placeholders::_1, std::placeholders::_2));
+  CMD2_DL         ("d.group",      tr1::bind(&cg_d_group, tr1::placeholders::_1));
+  CMD2_DL         ("d.group.name", tr1::bind(&cg_d_group, tr1::placeholders::_1));
+  CMD2_DL_V       ("d.group.set",  tr1::bind(&cg_d_group_set, tr1::placeholders::_1, tr1::placeholders::_2));
 
-  CMD2_DL         ("d.initialize_logs", std::bind(&cmd_d_initialize_logs, std::placeholders::_1));
+  CMD2_DL         ("d.initialize_logs", tr1::bind(&cmd_d_initialize_logs, tr1::placeholders::_1));
 
-  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_DL_LIST    ("f.multicall", tr1::bind(&f_multicall, tr1::placeholders::_1, tr1::placeholders::_2));
+  CMD2_DL_LIST    ("p.multicall", tr1::bind(&p_multicall, tr1::placeholders::_1, tr1::placeholders::_2));
+  CMD2_DL_LIST    ("t.multicall", tr1::bind(&t_multicall, tr1::placeholders::_1, tr1::placeholders::_2));
 
-  CMD2_ANY_LIST   ("p.call_target", std::bind(&p_call_target, std::placeholders::_2));
+  CMD2_ANY_LIST   ("p.call_target", tr1::bind(&p_call_target, tr1::placeholders::_2));
 }

src/command_dynamic.cc

@@ -150,22 +150,22 @@ system_method_insert_object(const torrent::Object::list_type& args, int flags) {
   if (!(flags & rpc::object_storage::flag_private))
     cmd_flags |= rpc::CommandMap::flag_public_xmlrpc;
 
-  rpc::object_storage::iterator obj_itr =  control->object_storage()->insert_str(rawKey, value, flags);
+  control->object_storage()->insert_str(rawKey, 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>
-      (create_new_key<0>(rawKey, ""),
-       std::bind(&rpc::object_storage::call_function_str, control->object_storage(),
-                      rawKey, std::placeholders::_1, std::placeholders::_2),
+      (create_new_key(rawKey),
+       tr1::bind(&rpc::object_storage::call_function_str, control->object_storage(),
+                 rawKey, tr1::placeholders::_1, tr1::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>
-      (create_new_key<0>(rawKey, ""),
-       std::bind(&rpc::object_storage::get_str, control->object_storage(), rawKey),
+      (create_new_key(rawKey),
+       tr1::bind(&rpc::object_storage::get_str, control->object_storage(), rawKey),
        &rpc::command_base_call<rpc::target_type>,
        cmd_flags, NULL, NULL);
   }
@@ -174,7 +174,7 @@ system_method_insert_object(const torrent::Object::list_type& args, int flags) {
   // 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>(rawKey, ".rlookup"),
-  //      std::bind(&rpc::object_storage::rlookup_obj_list, control->object_storage(), rawKey),
+  //      tr1::bind(&rpc::object_storage::rlookup_obj_list, control->object_storage(), rawKey),
   //      &rpc::command_base_call_string<rpc::target_type>,
   //      cmd_flags, NULL, NULL);
   // }
@@ -188,21 +188,21 @@ system_method_insert_object(const torrent::Object::list_type& args, int flags) {
     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>
         (create_new_key<5>(rawKey, ".set"),
-         std::bind(&rpc::object_storage::set_str_bool, control->object_storage(), rawKey, std::placeholders::_2),
+         tr1::bind(&rpc::object_storage::set_str_bool, control->object_storage(), rawKey, tr1::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>
         (create_new_key<5>(rawKey, ".set"),
-         std::bind(&rpc::object_storage::set_str_value, control->object_storage(), rawKey, std::placeholders::_2),
+         tr1::bind(&rpc::object_storage::set_str_value, control->object_storage(), rawKey, tr1::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>
         (create_new_key<5>(rawKey, ".set"),
-         std::bind(&rpc::object_storage::set_str_string, control->object_storage(), rawKey, std::placeholders::_2),
+         tr1::bind(&rpc::object_storage::set_str_string, control->object_storage(), rawKey, tr1::placeholders::_2),
          &rpc::command_base_call_string<rpc::target_type>,
          cmd_flags, NULL, NULL);
       break;
@@ -354,7 +354,7 @@ system_method_redirect(const torrent::Object::list_type& args) {
   std::string new_key  = torrent::object_create_string(args.front());
   std::string dest_key = torrent::object_create_string(args.back());
 
-  rpc::commands.create_redirect(create_new_key<0>(new_key, ""), create_new_key<0>(dest_key, ""),
+  rpc::commands.create_redirect(create_new_key(new_key), create_new_key(dest_key),
                                 rpc::CommandMap::flag_public_xmlrpc | rpc::CommandMap::flag_delete_key | rpc::CommandMap::flag_modifiable);
 
   return torrent::Object();
@@ -423,36 +423,36 @@ system_method_list_keys(const torrent::Object::string_type& args) {
 }
 
 #define CMD2_METHOD_INSERT(key, flags) \
-  CMD2_ANY_LIST(key, std::bind(&system_method_insert_object, std::placeholders::_2, flags));
+  CMD2_ANY_LIST(key, tr1::bind(&system_method_insert_object, tr1::placeholders::_2, flags));
 
 void
 initialize_command_dynamic() {
   CMD2_VAR_BOOL    ("method.use_deprecated", true);
   CMD2_VAR_VALUE   ("method.use_intermediate", 1);
 
-  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",             tr1::bind(&system_method_insert, tr1::placeholders::_2));
+  CMD2_ANY_LIST    ("method.insert.value",       tr1::bind(&system_method_insert_object, tr1::placeholders::_2, rpc::object_storage::flag_value_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.erase",     tr1::bind(&system_method_erase, tr1::placeholders::_2));
+  CMD2_ANY_LIST    ("method.redirect",  tr1::bind(&system_method_redirect, tr1::placeholders::_2));
+  CMD2_ANY_STRING  ("method.get",       tr1::bind(&rpc::object_storage::get_str, control->object_storage(),
+                                                       tr1::placeholders::_2));
+  CMD2_ANY_LIST    ("method.set",       tr1::bind(&system_method_set_function, tr1::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_STRING  ("method.const",        tr1::bind(&rpc::object_storage::has_flag_str, control->object_storage(),
+                                                      tr1::placeholders::_2, rpc::object_storage::flag_constant));
+  CMD2_ANY_STRING_V("method.const.enable", tr1::bind(&rpc::object_storage::enable_flag_str, control->object_storage(),
+                                                     tr1::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_LIST    ("method.has_key",   tr1::bind(&system_method_has_key, tr1::placeholders::_2));
+  CMD2_ANY_LIST    ("method.set_key",   tr1::bind(&system_method_set_key, tr1::placeholders::_2));
+  CMD2_ANY_STRING  ("method.list_keys", tr1::bind(&system_method_list_keys, tr1::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_STRING  ("method.rlookup",       tr1::bind(&rpc::object_storage::rlookup_obj_list, control->object_storage(), tr1::placeholders::_2));
+  CMD2_ANY_STRING_V("method.rlookup.clear", tr1::bind(&rpc::object_storage::rlookup_clear, control->object_storage(), tr1::placeholders::_2));
 }

src/command_events.cc

@@ -297,7 +297,7 @@ d_multicall(const torrent::Object::list_type& args) {
   for (core::Download** vItr = dlist; vItr != dlist + dlist_size; vItr++) {
     torrent::Object::list_type& row = result.insert(result.end(), torrent::Object::create_list())->as_list();
 
-    for (torrent::Object::list_const_iterator cItr = ++args.begin(), cLast = args.end(); cItr != args.end(); cItr++) {
+    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(*vItr), cmd.c_str(), cmd.c_str() + cmd.size()).first);
     }
@@ -306,42 +306,33 @@ d_multicall(const torrent::Object::list_type& args) {
   return resultRaw;
 }
 
-torrent::Object
-test_thread_locking() {
-  worker_thread->queue_item(&ThreadWorker::start_log_counter);
-
-  return torrent::Object();
-}
-
 void
 initialize_command_events() {
-  CMD2_ANY("test.thread_locking", std::bind(&test_thread_locking));
+  CMD2_ANY_STRING  ("on_ratio",        tr1::bind(&apply_on_ratio, tr1::placeholders::_2));
 
-  CMD2_ANY_STRING  ("on_ratio",        std::bind(&apply_on_ratio, std::placeholders::_2));
+  CMD2_ANY         ("start_tied",      tr1::bind(&apply_start_tied));
+  CMD2_ANY         ("stop_untied",     tr1::bind(&apply_stop_untied));
+  CMD2_ANY         ("close_untied",    tr1::bind(&apply_close_untied));
+  CMD2_ANY         ("remove_untied",   tr1::bind(&apply_remove_untied));
 
-  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));
+  CMD2_ANY_LIST    ("schedule2",        tr1::bind(&apply_schedule, tr1::placeholders::_2));
+  CMD2_ANY_STRING_V("schedule_remove2", tr1::bind(&rpc::CommandScheduler::erase_str, control->command_scheduler(), tr1::placeholders::_2));
 
-  CMD2_ANY_LIST    ("schedule2",        std::bind(&apply_schedule, 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",          tr1::bind(&apply_import, tr1::placeholders::_2));
+  CMD2_ANY_STRING_V("try_import",      tr1::bind(&apply_try_import, tr1::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,
+  CMD2_ANY_LIST    ("load.normal",        tr1::bind(&apply_load, tr1::placeholders::_2, core::Manager::create_quiet | core::Manager::create_tied));
+  CMD2_ANY_LIST    ("load.verbose",       tr1::bind(&apply_load, tr1::placeholders::_2, core::Manager::create_tied));
+  CMD2_ANY_LIST    ("load.start",         tr1::bind(&apply_load, tr1::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,
+  CMD2_ANY_LIST    ("load.start_verbose", tr1::bind(&apply_load, tr1::placeholders::_2, core::Manager::create_tied  | core::Manager::create_start));
+  CMD2_ANY_LIST    ("load.raw",           tr1::bind(&apply_load, tr1::placeholders::_2, core::Manager::create_quiet | core::Manager::create_raw_data));
+  CMD2_ANY_LIST    ("load.raw_verbose",   tr1::bind(&apply_load, tr1::placeholders::_2, core::Manager::create_raw_data));
+  CMD2_ANY_LIST    ("load.raw_start",     tr1::bind(&apply_load, tr1::placeholders::_2,
                                                          core::Manager::create_quiet | core::Manager::create_start | core::Manager::create_raw_data));
 
-  CMD2_ANY_VALUE   ("close_low_diskspace", std::bind(&apply_close_low_diskspace, std::placeholders::_2));
+  CMD2_ANY_VALUE   ("close_low_diskspace", tr1::bind(&apply_close_low_diskspace, tr1::placeholders::_2));
 
-  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    ("download_list",       tr1::bind(&apply_download_list, tr1::placeholders::_2));
+  CMD2_ANY_LIST    ("d.multicall2",        tr1::bind(&d_multicall, tr1::placeholders::_2));
 }

src/command_file.cc

@@ -100,45 +100,45 @@ apply_fi_filename_last(torrent::FileListIterator* itr) {
 
 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_created",             tr1::bind(&torrent::File::is_created, tr1::placeholders::_1));
+  CMD2_FILE("f.is_open",                tr1::bind(&torrent::File::is_open, tr1::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("f.is_create_queued",       tr1::bind(&torrent::File::is_create_queued, tr1::placeholders::_1));
+  CMD2_FILE("f.is_resize_queued",       tr1::bind(&torrent::File::is_resize_queued, tr1::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_VALUE_V("f.set_create_queued",   tr1::bind(&torrent::File::set_flags,   tr1::placeholders::_1, torrent::File::flag_create_queued));
+  CMD2_FILE_VALUE_V("f.set_resize_queued",   tr1::bind(&torrent::File::set_flags,   tr1::placeholders::_1, torrent::File::flag_resize_queued));
+  CMD2_FILE_VALUE_V("f.unset_create_queued", tr1::bind(&torrent::File::unset_flags, tr1::placeholders::_1, torrent::File::flag_create_queued));
+  CMD2_FILE_VALUE_V("f.unset_resize_queued", tr1::bind(&torrent::File::unset_flags, tr1::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.prioritize_first",         tr1::bind(&torrent::File::has_flags,   tr1::placeholders::_1, torrent::File::flag_prioritize_first));
+  CMD2_FILE_V("f.prioritize_first.enable",  tr1::bind(&torrent::File::set_flags,   tr1::placeholders::_1, torrent::File::flag_prioritize_first));
+  CMD2_FILE_V("f.prioritize_first.disable", tr1::bind(&torrent::File::unset_flags, tr1::placeholders::_1, torrent::File::flag_prioritize_first));
+  CMD2_FILE  ("f.prioritize_last",          tr1::bind(&torrent::File::has_flags,   tr1::placeholders::_1, torrent::File::flag_prioritize_last));
+  CMD2_FILE_V("f.prioritize_last.enable",   tr1::bind(&torrent::File::set_flags,   tr1::placeholders::_1, torrent::File::flag_prioritize_last));
+  CMD2_FILE_V("f.prioritize_last.disable",  tr1::bind(&torrent::File::unset_flags, tr1::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.size_bytes",             tr1::bind(&torrent::File::size_bytes, tr1::placeholders::_1));
+  CMD2_FILE("f.size_chunks",            tr1::bind(&torrent::File::size_chunks, tr1::placeholders::_1));
+  CMD2_FILE("f.completed_chunks",       tr1::bind(&torrent::File::completed_chunks, tr1::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.offset",                 tr1::bind(&torrent::File::offset, tr1::placeholders::_1));
+  CMD2_FILE("f.range_first",            tr1::bind(&torrent::File::range_first, tr1::placeholders::_1));
+  CMD2_FILE("f.range_second",           tr1::bind(&torrent::File::range_second, tr1::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.priority",               tr1::bind(&torrent::File::priority, tr1::placeholders::_1));
+  CMD2_FILE_VALUE_V("f.priority.set",   tr1::bind(&apply_f_set_priority, tr1::placeholders::_1, tr1::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.path",                   tr1::bind(&apply_f_path, tr1::placeholders::_1));
+  CMD2_FILE("f.path_components",        tr1::bind(&apply_f_path_components, tr1::placeholders::_1));
+  CMD2_FILE("f.path_depth",             tr1::bind(&apply_f_path_depth, tr1::placeholders::_1));
+  CMD2_FILE("f.frozen_path",            tr1::bind(&torrent::File::frozen_path, tr1::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.match_depth_prev",       tr1::bind(&torrent::File::match_depth_prev, tr1::placeholders::_1));
+  CMD2_FILE("f.match_depth_next",       tr1::bind(&torrent::File::match_depth_next, tr1::placeholders::_1));
 
-  CMD2_FILE("f.last_touched",           std::bind(&torrent::File::last_touched, std::placeholders::_1));
+  CMD2_FILE("f.last_touched",           tr1::bind(&torrent::File::last_touched, tr1::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));
+  CMD2_FILEITR("fi.filename_last",      tr1::bind(&apply_fi_filename_last, tr1::placeholders::_1));
+  CMD2_FILEITR("fi.is_file",            tr1::bind(&torrent::FileListIterator::is_file, tr1::placeholders::_1));
 }

src/command_groups.cc

@@ -264,8 +264,8 @@ apply_cg_tracker_mode_set(const torrent::Object::list_type& args) {
   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())
+#define CG_GROUP_AT()          tr1::bind(&cg_get_group, tr1::placeholders::_2)
+#define CHOKE_GROUP(direction) tr1::bind(direction, CG_GROUP_AT())
 
 /*
 
@@ -336,54 +336,54 @@ options.
 void
 initialize_command_groups() {
   // Move somewhere else?
-  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.tracker_mode",              std::bind(&torrent::option_list_strings, torrent::OPTION_TRACKER_MODE));
+  CMD2_ANY         ("strings.choke_heuristics",          tr1::bind(&torrent::option_list_strings, torrent::OPTION_CHOKE_HEURISTICS));
+  CMD2_ANY         ("strings.choke_heuristics.upload",   tr1::bind(&torrent::option_list_strings, torrent::OPTION_CHOKE_HEURISTICS_UPLOAD));
+  CMD2_ANY         ("strings.choke_heuristics.download", tr1::bind(&torrent::option_list_strings, torrent::OPTION_CHOKE_HEURISTICS_DOWNLOAD));
+  CMD2_ANY         ("strings.tracker_mode",              tr1::bind(&torrent::option_list_strings, torrent::OPTION_TRACKER_MODE));
 
-  CMD2_ANY         ("choke_group.list",                std::bind(&apply_cg_list));
-  CMD2_ANY_STRING  ("choke_group.insert",              std::bind(&apply_cg_insert, std::placeholders::_2));
+  CMD2_ANY         ("choke_group.list",                tr1::bind(&apply_cg_list));
+  CMD2_ANY_STRING  ("choke_group.insert",              tr1::bind(&apply_cg_insert, tr1::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));
+  CMD2_ANY         ("choke_group.size",                tr1::bind(&torrent::ResourceManager::group_size, torrent::resource_manager()));
+  CMD2_ANY_STRING  ("choke_group.index_of",            tr1::bind(&torrent::ResourceManager::group_index_of, torrent::resource_manager(), tr1::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));
+  CMD2_ANY         ("choke_group.size",                tr1::bind(&std::vector<torrent::choke_group*>::size, cg_list_hack));
+  CMD2_ANY_STRING  ("choke_group.index_of",            tr1::bind(&apply_cg_index_of, tr1::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.general.size",        tr1::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.tracker.mode",        tr1::bind(&torrent::option_as_string, torrent::OPTION_TRACKER_MODE,
+                                                                 tr1::bind(&torrent::choke_group::tracker_mode, CG_GROUP_AT())));
+  CMD2_ANY_LIST    ("choke_group.tracker.mode.set",    tr1::bind(&apply_cg_tracker_mode_set, tr1::placeholders::_2));
 
-  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.rate",             tr1::bind(&torrent::choke_group::up_rate, CG_GROUP_AT()));
+  CMD2_ANY         ("choke_group.down.rate",           tr1::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.max.unlimited",    tr1::bind(&torrent::choke_queue::is_unlimited, CHOKE_GROUP(&torrent::choke_group::up_queue)));
+  CMD2_ANY         ("choke_group.up.max",              tr1::bind(&torrent::choke_queue::max_unchoked_signed, CHOKE_GROUP(&torrent::choke_group::up_queue)));
+  CMD2_ANY_LIST    ("choke_group.up.max.set",          tr1::bind(&apply_cg_max_set, tr1::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.up.total",            tr1::bind(&torrent::choke_queue::size_total, CHOKE_GROUP(&torrent::choke_group::up_queue)));
+  CMD2_ANY         ("choke_group.up.queued",           tr1::bind(&torrent::choke_queue::size_queued, CHOKE_GROUP(&torrent::choke_group::up_queue)));
+  CMD2_ANY         ("choke_group.up.unchoked",         tr1::bind(&torrent::choke_queue::size_unchoked, CHOKE_GROUP(&torrent::choke_group::up_queue)));
+  CMD2_ANY         ("choke_group.up.heuristics",       tr1::bind(&torrent::option_as_string, torrent::OPTION_CHOKE_HEURISTICS,
+                                                                 tr1::bind(&torrent::choke_queue::heuristics, CHOKE_GROUP(&torrent::choke_group::up_queue))));
+  CMD2_ANY_LIST    ("choke_group.up.heuristics.set",   tr1::bind(&apply_cg_heuristics_set, tr1::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.max.unlimited",  tr1::bind(&torrent::choke_queue::is_unlimited, CHOKE_GROUP(&torrent::choke_group::down_queue)));
+  CMD2_ANY         ("choke_group.down.max",            tr1::bind(&torrent::choke_queue::max_unchoked_signed, CHOKE_GROUP(&torrent::choke_group::down_queue)));
+  CMD2_ANY_LIST    ("choke_group.down.max.set",        tr1::bind(&apply_cg_max_set, tr1::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));
+  CMD2_ANY         ("choke_group.down.total",          tr1::bind(&torrent::choke_queue::size_total, CHOKE_GROUP(&torrent::choke_group::down_queue)));
+  CMD2_ANY         ("choke_group.down.queued",         tr1::bind(&torrent::choke_queue::size_queued, CHOKE_GROUP(&torrent::choke_group::down_queue)));
+  CMD2_ANY         ("choke_group.down.unchoked",       tr1::bind(&torrent::choke_queue::size_unchoked, CHOKE_GROUP(&torrent::choke_group::down_queue)));
+  CMD2_ANY         ("choke_group.down.heuristics",     tr1::bind(&torrent::option_as_string, torrent::OPTION_CHOKE_HEURISTICS,
+                                                                 tr1::bind(&torrent::choke_queue::heuristics, CHOKE_GROUP(&torrent::choke_group::down_queue))));
+  CMD2_ANY_LIST    ("choke_group.down.heuristics.set", tr1::bind(&apply_cg_heuristics_set, tr1::placeholders::_2, false));
 }

src/command_helpers.h

@@ -41,6 +41,8 @@
 #include "rpc/parse_commands.h"
 #include "rpc/object_storage.h"
 
+namespace tr1 { using namespace std::tr1; }
+
 void initialize_commands();
 
 //
@@ -98,43 +100,43 @@ void initialize_commands();
 
 #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(),   \
+  CMD2_ANY(key, tr1::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));
+  CMD2_ANY_VALUE(key ".set", tr1::bind(&rpc::object_storage::set_bool, control->object_storage(), \
+                                            torrent::raw_string::from_c_str(key), tr1::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(),   \
+  CMD2_ANY(key, tr1::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));
+  CMD2_ANY_VALUE(key ".set", tr1::bind(&rpc::object_storage::set_value, control->object_storage(), \
+                                            torrent::raw_string::from_c_str(key), tr1::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(),   \
+  CMD2_ANY(key, tr1::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));
+  CMD2_ANY_STRING(key ".set", tr1::bind(&rpc::object_storage::set_string, control->object_storage(), \
+                                             torrent::raw_string::from_c_str(key), tr1::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(),   \
+  CMD2_ANY(key, tr1::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(),   \
+  CMD2_ANY(key, tr1::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));
+  CMD2_ANY_LIST(key ".set", tr1::bind(&rpc::object_storage::set_list, control->object_storage(), \
+                                           torrent::raw_string::from_c_str(key), tr1::placeholders::_2)); \
+  CMD2_ANY_VOID(key ".push_back", tr1::bind(&rpc::object_storage::list_push_back, control->object_storage(), \
+                                                 torrent::raw_string::from_c_str(key), tr1::placeholders::_2));
 
-#define CMD2_FUNC_SINGLE(key, cmds)                                  \
-  CMD2_ANY(key, std::bind(&rpc::command_function_call, torrent::raw_string::from_c_str(cmds), \
-                               std::placeholders::_1, std::placeholders::_2));
+#define CMD2_FUNC_SINGLE(key, cmds)                                     \
+  CMD2_ANY(key, tr1::bind(&rpc::command_function_call, torrent::raw_string::from_c_str(cmds), \
+                               tr1::placeholders::_1, tr1::placeholders::_2));
 
 #define CMD2_REDIRECT(from_key, to_key) \
   rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_public_xmlrpc | rpc::CommandMap::flag_dont_delete);
@@ -148,11 +150,11 @@ void initialize_commands();
   rpc::commands.create_redirect(from_key, to_key, rpc::CommandMap::flag_public_xmlrpc | rpc::CommandMap::flag_tracker_target | rpc::CommandMap::flag_dont_delete);
 
 #define CMD2_REDIRECT_GENERIC_STR(from_key, to_key)                     \
-  rpc::commands.create_redirect(create_new_key<0>(from_key, ""), create_new_key<0>(to_key, ""), \
+  rpc::commands.create_redirect(create_new_key(from_key), create_new_key(to_key), \
                                 rpc::CommandMap::flag_public_xmlrpc | rpc::CommandMap::flag_no_target | rpc::CommandMap::flag_delete_key);
 
 #define CMD2_REDIRECT_GENERIC_STR_NO_EXPORT(from_key, to_key)                     \
-  rpc::commands.create_redirect(create_new_key<0>(from_key, ""), create_new_key<0>(to_key, ""), \
+  rpc::commands.create_redirect(create_new_key(from_key), create_new_key(to_key), \
                                 rpc::CommandMap::flag_no_target | rpc::CommandMap::flag_delete_key);
 
 //
@@ -175,7 +177,11 @@ struct object_convert_type<Functor, void> {
   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;
 };
@@ -197,4 +203,11 @@ create_new_key(const std::string& key, const char postfix[postfix_size]) {
   return buffer;
 }
 
+inline const char*
+create_new_key(const std::string& key) {
+  char *buffer = new char[key.size() + 1];
+  std::memcpy(buffer, key.c_str(), key.size() + 1);
+  return buffer;
+}
+
 #endif

src/command_ip.cc

@@ -75,6 +75,9 @@ ipv4_filter_parse(const char* address, int value) {
   if (values_read < 7)
     block = 8 * (values_read / 2);
 
+  lt_log_print(torrent::LOG_CONNECTION_DEBUG, "Adding ip filter for %u.%u.%u.%u/%u.",
+               ip_values[0], ip_values[1], ip_values[2], ip_values[3], block);
+
   torrent::PeerList::ipv4_filter()->insert((ip_values[0] << 24) + (ip_values[1] << 16) + (ip_values[2] << 8) + ip_values[3],
                                            rpc::ipv4_table::mask_bits - block, value);
 }
@@ -88,6 +91,16 @@ apply_ip_tables_insert_table(const std::string& 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.");
+
+  return itr->table.sizeof_data();
+}
+
 torrent::Object
 apply_ip_tables_get(const torrent::Object::list_type& args) {
   if (args.size() != 2)
@@ -187,30 +200,23 @@ apply_ipv4_filter_load(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();
+  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(args.front().as_string()).c_str(), std::ios::in);
+  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: " + args.front().as_string());
+    throw torrent::input_error("Could not open ip filter file: " + filename);
 
-  int value = torrent::option_find_string(torrent::OPTION_IP_FILTER, args.back().as_string().c_str());
-
-  char buffer[4096];
   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.");
 
-      int lineLength = file.gcount() - 1;
-      // In case we are at the end of the file and the last character is
-      // not a line feed, we'll just increase the read character count so 
-      // that the last would also be included in option line.
-      if (file.eof() && file.get() != '\n')
-        lineLength++;
-      
       lineNumber++;
 
       if (buffer[0] == '\0' || buffer[0] == '#')
@@ -220,28 +226,78 @@ apply_ipv4_filter_load(const torrent::Object::list_type& args) {
     }
 
   } catch (torrent::input_error& e) {
-    snprintf(buffer, 2048, "Error in ip filter file: %s:%u: %s", args.front().as_string().c_str(), lineNumber, e.what());
+    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_INFO, "Loaded %u %s address blocks (%u kb in-memory) from '%s'.",
                lineNumber,
-               args.back().as_string().c_str(),
+               value_name.c_str(),
                torrent::PeerList::ipv4_filter()->sizeof_data() / 1024,
-               args.front().as_string().c_str());
+               filename.c_str());
 
   return torrent::Object();
 }
 
+static void
+append_table(torrent::ipv4_table::base_type* extent, torrent::Object::list_type& result) {
+  torrent::ipv4_table::table_type::iterator first = extent->table.begin();
+  torrent::ipv4_table::table_type::iterator last  = extent->table.end();
+
+  int current_value = 0;
+  uint32_t range_first = 0;
+
+  while (first != last) {
+    if (first->first != NULL) {
+      // Do something more here?...
+      append_table(first->first, result);
+
+    } else if (first->second != 0) {
+      uint32_t position = extent->partition_pos(first);
+
+      char buffer[256];
+      snprintf(buffer, 256, "%u.%u.%u.%u/%u %s",
+               (position >> 24) & 0xff,
+               (position >> 16) & 0xff,
+               (position >> 8) & 0xff,
+               (position >> 0) & 0xff,
+               extent->mask_bits,
+               torrent::option_as_string(torrent::OPTION_IP_FILTER, first->second));
+
+      result.push_back((std::string)buffer);
+
+      range_first = position;
+      current_value = first->second;
+    }
+
+    first++;
+  }
+}
+
+torrent::Object
+apply_ipv4_filter_dump() {
+  torrent::Object raw_result = torrent::Object::create_list();
+  torrent::Object::list_type& result = raw_result.as_list();
+
+  append_table(torrent::PeerList::ipv4_filter()->data(), result);
+
+  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_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         ("strings.ip_filter",       tr1::bind(&torrent::option_list_strings, torrent::OPTION_IP_FILTER));
+  CMD2_ANY         ("strings.ip_tos",          tr1::bind(&torrent::option_list_strings, torrent::OPTION_IP_TOS));
 
-  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_STRING  ("ip_tables.insert_table",  tr1::bind(&apply_ip_tables_insert_table, tr1::placeholders::_2));
+  CMD2_ANY_STRING  ("ip_tables.size_data",     tr1::bind(&apply_ip_tables_size_data, tr1::placeholders::_2));
+  CMD2_ANY_LIST    ("ip_tables.get",           tr1::bind(&apply_ip_tables_get, tr1::placeholders::_2));
+  CMD2_ANY_LIST    ("ip_tables.add_address",   tr1::bind(&apply_ip_tables_add_address, tr1::placeholders::_2));
+
+  CMD2_ANY         ("ipv4_filter.size_data",   tr1::bind(&apply_ipv4_filter_size_data));
+  CMD2_ANY_STRING  ("ipv4_filter.get",         tr1::bind(&apply_ipv4_filter_get, tr1::placeholders::_2));
+  CMD2_ANY_LIST    ("ipv4_filter.add_address", tr1::bind(&apply_ipv4_filter_add_address, tr1::placeholders::_2));
+  CMD2_ANY_LIST    ("ipv4_filter.load",        tr1::bind(&apply_ipv4_filter_load, tr1::placeholders::_2));
+  CMD2_ANY_LIST    ("ipv4_filter.dump",        tr1::bind(&apply_ipv4_filter_dump));
 }

src/command_local.cc

@@ -325,64 +325,65 @@ initialize_command_local() {
   core::DownloadList*    dList = control->core()->download_list();
   core::DownloadStore*   dStore = control->core()->download_store();
 
-  CMD2_ANY         ("system.hostname", std::bind(&system_hostname));
-  CMD2_ANY         ("system.pid",      std::bind(&getpid));
+  CMD2_ANY         ("system.hostname", tr1::bind(&system_hostname));
+  CMD2_ANY         ("system.pid",      tr1::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)64 << 30);
+  CMD2_VAR_VALUE   ("system.file.max_size",         (int64_t)128 << 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,
+  CMD2_ANY         ("system.file_status_cache.size",   tr1::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_ANY_V       ("system.file_status_cache.prune",  tr1::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.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         ("system.files.opened_counter",     tr1::bind(&FM_t::files_opened_counter, fileManager));
+  CMD2_ANY         ("system.files.closed_counter",     tr1::bind(&FM_t::files_closed_counter, fileManager));
+  CMD2_ANY         ("system.files.failed_counter",     tr1::bind(&FM_t::files_failed_counter, fileManager));
 
-  CMD2_ANY         ("system.time",                     std::bind(&rak::timer::seconds, &cachedTime));
-  CMD2_ANY         ("system.time_seconds",             std::bind(&rak::timer::current_seconds));
-  CMD2_ANY         ("system.time_usec",                std::bind(&rak::timer::current_usec));
+  CMD2_ANY         ("system.time",                     tr1::bind(&rak::timer::seconds, &cachedTime));
+  CMD2_ANY         ("system.time_seconds",             tr1::bind(&rak::timer::current_seconds));
+  CMD2_ANY         ("system.time_usec",                tr1::bind(&rak::timer::current_usec));
 
-  CMD2_ANY_VALUE_V ("system.umask.set",                std::bind(&umask, std::placeholders::_2));
+  CMD2_ANY_VALUE_V ("system.umask.set",                tr1::bind(&umask, tr1::placeholders::_2));
 
-  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         ("system.cwd",                      tr1::bind(&system_get_cwd));
+  CMD2_ANY_STRING  ("system.cwd.set",                  tr1::bind(&system_set_cwd, tr1::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.sync.always_safe",         tr1::bind(&CM_t::safe_sync, chunkManager));
+  CMD2_ANY_VALUE_V ("pieces.sync.always_safe.set",     tr1::bind(&CM_t::set_safe_sync, chunkManager, tr1::placeholders::_2));
+  CMD2_ANY         ("pieces.sync.safe_free_diskspace", tr1::bind(&CM_t::safe_free_diskspace, chunkManager));
+  CMD2_ANY         ("pieces.sync.timeout",             tr1::bind(&CM_t::timeout_sync, chunkManager));
+  CMD2_ANY_VALUE_V ("pieces.sync.timeout.set",         tr1::bind(&CM_t::set_timeout_sync, chunkManager, tr1::placeholders::_2));
+  CMD2_ANY         ("pieces.sync.timeout_safe",        tr1::bind(&CM_t::timeout_safe_sync, chunkManager));
+  CMD2_ANY_VALUE_V ("pieces.sync.timeout_safe.set",    tr1::bind(&CM_t::set_timeout_safe_sync, chunkManager, tr1::placeholders::_2));
+  CMD2_ANY         ("pieces.sync.queue_size",          tr1::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.preload.type",             tr1::bind(&CM_t::preload_type, chunkManager));
+  CMD2_ANY_VALUE_V ("pieces.preload.type.set",         tr1::bind(&CM_t::set_preload_type, chunkManager, tr1::placeholders::_2));
+  CMD2_ANY         ("pieces.preload.min_size",         tr1::bind(&CM_t::preload_min_size, chunkManager));
+  CMD2_ANY_VALUE_V ("pieces.preload.min_size.set",     tr1::bind(&CM_t::set_preload_min_size, chunkManager, tr1::placeholders::_2));
+  CMD2_ANY         ("pieces.preload.min_rate",         tr1::bind(&CM_t::preload_required_rate, chunkManager));
+  CMD2_ANY_VALUE_V ("pieces.preload.min_rate.set",     tr1::bind(&CM_t::set_preload_required_rate, chunkManager, tr1::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.memory.current",           tr1::bind(&CM_t::memory_usage, chunkManager));
+  CMD2_ANY         ("pieces.memory.sync_queue",        tr1::bind(&CM_t::sync_queue_memory_usage, chunkManager));
+  CMD2_ANY         ("pieces.memory.block_count",       tr1::bind(&CM_t::memory_block_count, chunkManager));
+  CMD2_ANY         ("pieces.memory.max",               tr1::bind(&CM_t::max_memory_usage, chunkManager));
+  CMD2_ANY_VALUE_V ("pieces.memory.max.set",           tr1::bind(&CM_t::set_max_memory_usage, chunkManager, tr1::placeholders::_2));
+  CMD2_ANY         ("pieces.stats_preloaded",          tr1::bind(&CM_t::stats_preloaded, chunkManager));
+  CMD2_ANY         ("pieces.stats_not_preloaded",      tr1::bind(&CM_t::stats_not_preloaded, chunkManager));
 
-  CMD2_ANY         ("pieces.stats.total_size",         std::bind(&apply_pieces_stats_total_size));
+  CMD2_ANY         ("pieces.stats.total_size",         tr1::bind(&apply_pieces_stats_total_size));
 
-  CMD2_ANY         ("pieces.hash.queue_size",          std::bind(&torrent::hash_queue_size));
+  CMD2_ANY         ("pieces.hash.queue_size",          tr1::bind(&torrent::hash_queue_size));
   CMD2_VAR_BOOL    ("pieces.hash.on_completion",       true);
 
   CMD2_VAR_STRING  ("directory.default",       "./");
@@ -391,13 +392,13 @@ initialize_command_local() {
   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         ("session.path",            tr1::bind(&core::DownloadStore::path, dStore));
+  CMD2_ANY_STRING_V("session.path.set",        tr1::bind(&core::DownloadStore::set_path, dStore, tr1::placeholders::_2));
 
-  CMD2_ANY_V       ("session.save",            std::bind(&core::DownloadList::session_save, dList));
+  CMD2_ANY_V       ("session.save",            tr1::bind(&core::DownloadList::session_save, dList));
 
 #define CMD2_EXECUTE(key, flags)                                         \
-  CMD2_ANY(key, std::bind(&rpc::ExecFile::execute_object, &rpc::execFile, std::placeholders::_2, flags));
+  CMD2_ANY(key, tr1::bind(&rpc::ExecFile::execute_object, &rpc::execFile, tr1::placeholders::_2, flags));
 
   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);
@@ -411,25 +412,25 @@ initialize_command_local() {
   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    ("log.open_file",  std::bind(&apply_log_open_file, std::placeholders::_2));
-  CMD2_ANY_LIST    ("log.add_output", std::bind(&apply_log_add_output, std::placeholders::_2));
+  CMD2_ANY_LIST    ("log.open_file",  tr1::bind(&apply_log_open_file, tr1::placeholders::_2));
+  CMD2_ANY_LIST    ("log.add_output", tr1::bind(&apply_log_add_output, tr1::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.xmlrpc",     std::bind(&ThreadWorker::set_xmlrpc_log, worker_thread, std::placeholders::_2));
-  CMD2_ANY_LIST    ("log.libtorrent", std::bind(&apply_log_libtorrent, std::placeholders::_2));
+  CMD2_ANY_STRING  ("log.execute",    tr1::bind(&apply_log, tr1::placeholders::_2, 0));
+  CMD2_ANY_STRING  ("log.vmmap.dump", tr1::bind(&log_vmmap_dump, tr1::placeholders::_2));
+  CMD2_ANY_STRING_V("log.xmlrpc",     tr1::bind(&ThreadWorker::set_xmlrpc_log, worker_thread, tr1::placeholders::_2));
+  CMD2_ANY_LIST    ("log.libtorrent", tr1::bind(&apply_log_libtorrent, tr1::placeholders::_2));
 
-  CMD2_ANY_LIST    ("file.append",    std::bind(&cmd_file_append, std::placeholders::_2));
+  CMD2_ANY_LIST    ("file.append",    tr1::bind(&cmd_file_append, tr1::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_P("argument.0", tr1::bind(&rpc::command_base::argument_ref, 0));
+  CMD2_ANY_P("argument.1", tr1::bind(&rpc::command_base::argument_ref, 1));
+  CMD2_ANY_P("argument.2", tr1::bind(&rpc::command_base::argument_ref, 2));
+  CMD2_ANY_P("argument.3", tr1::bind(&rpc::command_base::argument_ref, 3));
 
-  CMD2_ANY_LIST  ("group.insert", std::bind(&group_insert, std::placeholders::_2));
+  CMD2_ANY_LIST  ("group.insert", tr1::bind(&group_insert, tr1::placeholders::_2));
 }

src/command_network.cc

@@ -62,6 +62,8 @@
 #include "control.h"
 #include "command_helpers.h"
 
+namespace tr1 { using namespace std::tr1; }
+
 torrent::Object
 apply_encryption(const torrent::Object::list_type& args) {
   uint32_t options_mask = torrent::ConnectionManager::encryption_none;
@@ -92,8 +94,6 @@ apply_tos(const torrent::Object::string_type& arg) {
   return torrent::Object();
 }
 
-torrent::Object apply_hash_read_ahead(int arg)              { torrent::set_hash_read_ahead(arg << 20); return torrent::Object(); }
-torrent::Object apply_hash_interval(int arg)                { torrent::set_hash_interval(arg * 1000); return torrent::Object(); }
 torrent::Object apply_encoding_list(const std::string& arg) { torrent::encoding_list()->push_back(arg); return torrent::Object(); }
 
 torrent::File*
@@ -126,10 +126,10 @@ xmlrpc_find_peer(core::Download* download, const torrent::HashString& hash) {
 void
 initialize_xmlrpc() {
   rpc::xmlrpc.initialize();
-  rpc::xmlrpc.set_slot_find_download(rak::mem_fn(control->core()->download_list(), &core::DownloadList::find_hex_ptr));
-  rpc::xmlrpc.set_slot_find_file(rak::ptr_fn(&xmlrpc_find_file));
-  rpc::xmlrpc.set_slot_find_tracker(rak::ptr_fn(&xmlrpc_find_tracker));
-  rpc::xmlrpc.set_slot_find_peer(rak::ptr_fn(&xmlrpc_find_peer));
+  rpc::xmlrpc.slot_find_download() = tr1::bind(&core::DownloadList::find_hex_ptr, control->core()->download_list(), tr1::placeholders::_1);
+  rpc::xmlrpc.slot_find_file() = tr1::bind(&xmlrpc_find_file, tr1::placeholders::_1, tr1::placeholders::_2);
+  rpc::xmlrpc.slot_find_tracker() = tr1::bind(&xmlrpc_find_tracker, tr1::placeholders::_1, tr1::placeholders::_2);
+  rpc::xmlrpc.slot_find_peer() = tr1::bind(&xmlrpc_find_peer, tr1::placeholders::_1, tr1::placeholders::_2);
 
   unsigned int count = 0;
 
@@ -236,25 +236,23 @@ initialize_command_network() {
   torrent::FileManager* fileManager = torrent::file_manager();
   core::CurlStack* httpStack = control->core()->http_stack();
 
-  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.connection_type", tr1::bind(&torrent::option_list_strings, torrent::OPTION_CONNECTION_TYPE));
+  CMD2_ANY         ("strings.encryption",      tr1::bind(&torrent::option_list_strings, torrent::OPTION_ENCRYPTION));
 
   CMD2_VAR_BOOL    ("log.handshake", false);
 
-  // CMD2_ANY_STRING  ("encoding_list",    std::bind(&apply_encoding_list, std::placeholders::_2));
-  CMD2_ANY_STRING  ("encoding.add", std::bind(&apply_encoding_list, std::placeholders::_2));
+  // CMD2_ANY_STRING  ("encoding_list",    tr1::bind(&apply_encoding_list, tr1::placeholders::_2));
+  CMD2_ANY_STRING  ("encoding.add", tr1::bind(&apply_encoding_list, tr1::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.port",    tr1::bind(&torrent::ConnectionManager::listen_port, cm));
 
   CMD2_VAR_BOOL    ("protocol.pex",            true);
-  CMD2_ANY_LIST    ("protocol.encryption.set", std::bind(&apply_encryption, std::placeholders::_2));
+  CMD2_ANY_LIST    ("protocol.encryption.set", tr1::bind(&apply_encryption, tr1::placeholders::_2));
 
   CMD2_VAR_STRING  ("protocol.connection.leech", "leech");
   CMD2_VAR_STRING  ("protocol.connection.seed",  "seed");
@@ -264,50 +262,43 @@ initialize_command_network() {
   CMD2_VAR_STRING  ("protocol.choke_heuristics.down.leech", "download_leech");
   CMD2_VAR_STRING  ("protocol.choke_heuristics.down.seed",  "download_leech");
 
-  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.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.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.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.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.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.capath",                tr1::bind(&core::CurlStack::http_capath, httpStack));
+  CMD2_ANY_STRING_V("network.http.capath.set",            tr1::bind(&core::CurlStack::set_http_capath, httpStack, tr1::placeholders::_2));
+  CMD2_ANY         ("network.http.cacert",                tr1::bind(&core::CurlStack::http_cacert, httpStack));
+  CMD2_ANY_STRING_V("network.http.cacert.set",            tr1::bind(&core::CurlStack::set_http_cacert, httpStack, tr1::placeholders::_2));
+  CMD2_ANY         ("network.http.proxy_address",         tr1::bind(&core::CurlStack::http_proxy, httpStack));
+  CMD2_ANY_STRING_V("network.http.proxy_address.set",     tr1::bind(&core::CurlStack::set_http_proxy, httpStack, tr1::placeholders::_2));
+  CMD2_ANY         ("network.http.max_open",              tr1::bind(&core::CurlStack::max_active, httpStack));
+  CMD2_ANY_VALUE_V ("network.http.max_open.set",          tr1::bind(&core::CurlStack::set_max_active, httpStack, tr1::placeholders::_2));
+  CMD2_ANY         ("network.http.ssl_verify_peer",       tr1::bind(&core::CurlStack::ssl_verify_peer, httpStack));
+  CMD2_ANY_VALUE_V ("network.http.ssl_verify_peer.set",   tr1::bind(&core::CurlStack::set_ssl_verify_peer, httpStack, tr1::placeholders::_2));
+  CMD2_ANY         ("network.http.dns_cache_timeout",     tr1::bind(&core::CurlStack::dns_timeout, httpStack));
+  CMD2_ANY_VALUE_V ("network.http.dns_cache_timeout.set", tr1::bind(&core::CurlStack::set_dns_timeout, httpStack, tr1::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.send_buffer.size",        tr1::bind(&torrent::ConnectionManager::send_buffer_size, cm));
+  CMD2_ANY_VALUE_V ("network.send_buffer.size.set",    tr1::bind(&torrent::ConnectionManager::set_send_buffer_size, cm, tr1::placeholders::_2));
+  CMD2_ANY         ("network.receive_buffer.size",     tr1::bind(&torrent::ConnectionManager::receive_buffer_size, cm));
+  CMD2_ANY_VALUE_V ("network.receive_buffer.size.set", tr1::bind(&torrent::ConnectionManager::set_receive_buffer_size, cm, tr1::placeholders::_2));
+  CMD2_ANY_STRING  ("network.tos.set",                 tr1::bind(&apply_tos, tr1::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.bind_address",        tr1::bind(&core::Manager::bind_address, control->core()));
+  CMD2_ANY_STRING_V("network.bind_address.set",    tr1::bind(&core::Manager::set_bind_address, control->core(), tr1::placeholders::_2));
+  CMD2_ANY         ("network.local_address",       tr1::bind(&core::Manager::local_address, control->core()));
+  CMD2_ANY_STRING_V("network.local_address.set",   tr1::bind(&core::Manager::set_local_address, control->core(), tr1::placeholders::_2));
+  CMD2_ANY         ("network.proxy_address",       tr1::bind(&core::Manager::proxy_address, control->core()));
+  CMD2_ANY_STRING_V("network.proxy_address.set",   tr1::bind(&core::Manager::set_proxy_address, control->core(), tr1::placeholders::_2));
 
-  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.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         ("network.max_open_files",       tr1::bind(&torrent::FileManager::max_open_files, fileManager));
+  CMD2_ANY_VALUE_V ("network.max_open_files.set",   tr1::bind(&torrent::FileManager::set_max_open_files, fileManager, tr1::placeholders::_2));
+  CMD2_ANY         ("network.open_sockets",         tr1::bind(&torrent::ConnectionManager::size, cm));
+  CMD2_ANY         ("network.max_open_sockets",     tr1::bind(&torrent::ConnectionManager::max_size, cm));
+  CMD2_ANY_VALUE_V ("network.max_open_sockets.set", tr1::bind(&torrent::ConnectionManager::set_max_size, cm, tr1::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_ANY_STRING  ("network.scgi.open_port",   tr1::bind(&apply_scgi, tr1::placeholders::_2, 1));
+  CMD2_ANY_STRING  ("network.scgi.open_local",  tr1::bind(&apply_scgi, tr1::placeholders::_2, 2));
   CMD2_VAR_BOOL    ("network.scgi.dont_route",  false);
 
-  CMD2_ANY_STRING  ("network.xmlrpc.dialect.set",    std::bind(&apply_xmlrpc_dialect, std::placeholders::_2));
-  CMD2_ANY         ("network.xmlrpc.size_limit",     std::bind(&rpc::XmlRpc::size_limit));
-  CMD2_ANY_VALUE_V ("network.xmlrpc.size_limit.set", std::bind(&rpc::XmlRpc::set_size_limit, std::placeholders::_2));
-
-  CMD2_ANY         ("system.hash.read_ahead",        std::bind(&torrent::hash_read_ahead));
-  CMD2_ANY_VALUE_V ("system.hash.read_ahead.set",    std::bind(&apply_hash_read_ahead, std::placeholders::_2));
-  CMD2_ANY         ("system.hash.interval",          std::bind(&torrent::hash_interval));
-  CMD2_ANY_VALUE_V ("system.hash.interval.set",      std::bind(&apply_hash_interval, std::placeholders::_2));
-  CMD2_ANY         ("system.hash.max_tries",         std::bind(&torrent::hash_max_tries));
-  CMD2_ANY_VALUE_V ("system.hash.max_tries.set",     std::bind(&torrent::set_hash_max_tries, std::placeholders::_2));
+  CMD2_ANY_STRING  ("network.xmlrpc.dialect.set",    tr1::bind(&apply_xmlrpc_dialect, tr1::placeholders::_2));
+  CMD2_ANY         ("network.xmlrpc.size_limit",     tr1::bind(&rpc::XmlRpc::size_limit));
+  CMD2_ANY_VALUE_V ("network.xmlrpc.size_limit.set", tr1::bind(&rpc::XmlRpc::set_size_limit, tr1::placeholders::_2));
 }

src/command_peer.cc

@@ -97,37 +97,37 @@ retrieve_p_completed_percent(torrent::Peer* peer) {
 
 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.id",                tr1::bind(&retrieve_p_id, tr1::placeholders::_1));
+  CMD2_PEER("p.id_html",           tr1::bind(&retrieve_p_id_html, tr1::placeholders::_1));
+  CMD2_PEER("p.client_version",    tr1::bind(&retrieve_p_client_version, tr1::placeholders::_1));
 
-  CMD2_PEER("p.options_str",       std::bind(&retrieve_p_options_str, std::placeholders::_1));
+  CMD2_PEER("p.options_str",       tr1::bind(&retrieve_p_options_str, tr1::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_encrypted",      tr1::bind(&torrent::Peer::is_encrypted, tr1::placeholders::_1));
+  CMD2_PEER("p.is_incoming",       tr1::bind(&torrent::Peer::is_incoming, tr1::placeholders::_1));
+  CMD2_PEER("p.is_obfuscated",     tr1::bind(&torrent::Peer::is_obfuscated, tr1::placeholders::_1));
+  CMD2_PEER("p.is_snubbed",        tr1::bind(&torrent::Peer::is_snubbed, tr1::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.is_unwanted",       tr1::bind(&torrent::PeerInfo::is_unwanted,  tr1::bind(&torrent::Peer::peer_info, tr1::placeholders::_1)));
+  CMD2_PEER("p.is_preferred",      tr1::bind(&torrent::PeerInfo::is_preferred, tr1::bind(&torrent::Peer::peer_info, tr1::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.address",           tr1::bind(&retrieve_p_address, tr1::placeholders::_1));
+  CMD2_PEER("p.port",              tr1::bind(&retrieve_p_port, tr1::placeholders::_1));
 
-  CMD2_PEER("p.completed_percent", std::bind(&retrieve_p_completed_percent, std::placeholders::_1));
+  CMD2_PEER("p.completed_percent", tr1::bind(&retrieve_p_completed_percent, tr1::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.up_rate",           tr1::bind(&torrent::Rate::rate,  tr1::bind(&torrent::Peer::up_rate, tr1::placeholders::_1)));
+  CMD2_PEER("p.up_total",          tr1::bind(&torrent::Rate::total, tr1::bind(&torrent::Peer::up_rate, tr1::placeholders::_1)));
+  CMD2_PEER("p.down_rate",         tr1::bind(&torrent::Rate::rate,  tr1::bind(&torrent::Peer::down_rate, tr1::placeholders::_1)));
+  CMD2_PEER("p.down_total",        tr1::bind(&torrent::Rate::total, tr1::bind(&torrent::Peer::down_rate, tr1::placeholders::_1)));
+  CMD2_PEER("p.peer_rate",         tr1::bind(&torrent::Rate::rate,  tr1::bind(&torrent::Peer::peer_rate, tr1::placeholders::_1)));
+  CMD2_PEER("p.peer_total",        tr1::bind(&torrent::Rate::total, tr1::bind(&torrent::Peer::peer_rate, tr1::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        ("p.snubbed",     tr1::bind(&torrent::Peer::is_snubbed,  tr1::placeholders::_1));
+  CMD2_PEER_VALUE_V("p.snubbed.set", tr1::bind(&torrent::Peer::set_snubbed, tr1::placeholders::_1, tr1::placeholders::_2));
+  CMD2_PEER        ("p.banned",      tr1::bind(&torrent::Peer::is_banned,   tr1::placeholders::_1));
+  CMD2_PEER_VALUE_V("p.banned.set",  tr1::bind(&torrent::Peer::set_banned,  tr1::placeholders::_1, tr1::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));
+  CMD2_PEER_V("p.disconnect",         tr1::bind(&torrent::Peer::disconnect, tr1::placeholders::_1, 0));
+  CMD2_PEER_V("p.disconnect_delayed", tr1::bind(&torrent::Peer::disconnect, tr1::placeholders::_1, torrent::ConnectionList::disconnect_delayed));
 }

src/command_scheduler.cc

@@ -115,7 +115,7 @@ 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));
+  CMD2_DL("scheduler.simple.added",   tr1::bind(&cmd_scheduler_simple_added, tr1::placeholders::_1));
+  CMD2_DL("scheduler.simple.removed", tr1::bind(&cmd_scheduler_simple_removed, tr1::placeholders::_1));
+  CMD2_DL("scheduler.simple.update",  tr1::bind(&cmd_scheduler_simple_update, tr1::placeholders::_1));
 }

src/command_throttle.cc

@@ -89,7 +89,7 @@ parse_address_range(const torrent::Object::list_type& args, torrent::Object::lis
 
   // 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, uint32_t>(begin, std::max(end, end + 1));
+  return std::make_pair((uint32_t)begin, (uint32_t)std::max(end, end + 1));
 }
 
 torrent::Object
@@ -164,8 +164,8 @@ apply_address_throttle(const torrent::Object::list_type& args) {
 
 void
 initialize_command_throttle() {
-  CMD2_ANY         ("throttle.unchoked_uploads",   std::bind(&torrent::ResourceManager::currently_upload_unchoked, torrent::resource_manager()));
-  CMD2_ANY         ("throttle.unchoked_downloads", std::bind(&torrent::ResourceManager::currently_download_unchoked, torrent::resource_manager()));
+  CMD2_ANY         ("throttle.unchoked_uploads",   tr1::bind(&torrent::ResourceManager::currently_upload_unchoked, torrent::resource_manager()));
+  CMD2_ANY         ("throttle.unchoked_downloads", tr1::bind(&torrent::ResourceManager::currently_download_unchoked, torrent::resource_manager()));
 
   CMD2_VAR_VALUE   ("throttle.min_peers.normal", 100);
   CMD2_VAR_VALUE   ("throttle.max_peers.normal", 200);
@@ -183,25 +183,25 @@ initialize_command_throttle() {
   CMD2_VAR_VALUE   ("throttle.max_downloads.global", 0);
 
   // 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));
+  CMD2_ANY         ("throttle.global_up.rate",              tr1::bind(&torrent::Rate::rate, torrent::up_rate()));
+  CMD2_ANY         ("throttle.global_up.total",             tr1::bind(&torrent::Rate::total, torrent::up_rate()));
+  CMD2_ANY         ("throttle.global_up.max_rate",          tr1::bind(&torrent::Throttle::max_rate, torrent::up_throttle_global()));
+  CMD2_ANY_VALUE_V ("throttle.global_up.max_rate.set",      tr1::bind(&ui::Root::set_up_throttle_i64, control->ui(), tr1::placeholders::_2));
+  CMD2_ANY_VALUE_KB("throttle.global_up.max_rate.set_kb",   tr1::bind(&ui::Root::set_up_throttle_i64, control->ui(), tr1::placeholders::_2));
+  CMD2_ANY         ("throttle.global_down.rate",            tr1::bind(&torrent::Rate::rate, torrent::down_rate()));
+  CMD2_ANY         ("throttle.global_down.total",           tr1::bind(&torrent::Rate::total, torrent::down_rate()));
+  CMD2_ANY         ("throttle.global_down.max_rate",        tr1::bind(&torrent::Throttle::max_rate, torrent::down_throttle_global()));
+  CMD2_ANY_VALUE_V ("throttle.global_down.max_rate.set",    tr1::bind(&ui::Root::set_down_throttle_i64, control->ui(), tr1::placeholders::_2));
+  CMD2_ANY_VALUE_KB("throttle.global_down.max_rate.set_kb", tr1::bind(&ui::Root::set_down_throttle_i64, control->ui(), tr1::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_LIST    ("throttle.up",                          tr1::bind(&apply_throttle, tr1::placeholders::_2, true));
+  CMD2_ANY_LIST    ("throttle.down",                        tr1::bind(&apply_throttle, tr1::placeholders::_2, false));
+  CMD2_ANY_LIST    ("throttle.ip",                          tr1::bind(&apply_address_throttle, tr1::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));
+  CMD2_ANY_STRING  ("throttle.up.max",    tr1::bind(&retrieve_throttle_info, tr1::placeholders::_2, throttle_info_up | throttle_info_max));
+  CMD2_ANY_STRING  ("throttle.up.rate",   tr1::bind(&retrieve_throttle_info, tr1::placeholders::_2, throttle_info_up | throttle_info_rate));
+  CMD2_ANY_STRING  ("throttle.down.max",  tr1::bind(&retrieve_throttle_info, tr1::placeholders::_2, throttle_info_down | throttle_info_max));
+  CMD2_ANY_STRING  ("throttle.down.rate", tr1::bind(&retrieve_throttle_info, tr1::placeholders::_2, throttle_info_down | throttle_info_rate));
 }

src/command_tracker.cc

@@ -111,48 +111,48 @@ apply_enable_trackers(int64_t arg) {
 
 void
 initialize_command_tracker() {
-  CMD2_TRACKER        ("t.is_open",           std::bind(&torrent::Tracker::is_busy, std::placeholders::_1));
-  CMD2_TRACKER        ("t.is_enabled",        std::bind(&torrent::Tracker::is_enabled, std::placeholders::_1));
-  CMD2_TRACKER_VALUE_V("t.is_enabled.set",    std::bind(&tracker_set_enabled, std::placeholders::_1, std::placeholders::_2));
-  CMD2_TRACKER_V      ("t.enable",            std::bind(&torrent::Tracker::enable, std::placeholders::_1));
-  CMD2_TRACKER_V      ("t.disable",           std::bind(&torrent::Tracker::disable, std::placeholders::_1));
+  CMD2_TRACKER        ("t.is_open",           tr1::bind(&torrent::Tracker::is_busy, tr1::placeholders::_1));
+  CMD2_TRACKER        ("t.is_enabled",        tr1::bind(&torrent::Tracker::is_enabled, tr1::placeholders::_1));
+  CMD2_TRACKER_VALUE_V("t.is_enabled.set",    tr1::bind(&tracker_set_enabled, tr1::placeholders::_1, tr1::placeholders::_2));
+  CMD2_TRACKER_V      ("t.enable",            tr1::bind(&torrent::Tracker::enable, tr1::placeholders::_1));
+  CMD2_TRACKER_V      ("t.disable",           tr1::bind(&torrent::Tracker::disable, tr1::placeholders::_1));
 
-  CMD2_TRACKER        ("t.url",               std::bind(&torrent::Tracker::url, std::placeholders::_1));
-  CMD2_TRACKER        ("t.group",             std::bind(&torrent::Tracker::group, std::placeholders::_1));
-  CMD2_TRACKER        ("t.type",              std::bind(&torrent::Tracker::type, std::placeholders::_1));
-  CMD2_TRACKER        ("t.id",                std::bind(&torrent::Tracker::tracker_id, std::placeholders::_1));
+  CMD2_TRACKER        ("t.url",               tr1::bind(&torrent::Tracker::url, tr1::placeholders::_1));
+  CMD2_TRACKER        ("t.group",             tr1::bind(&torrent::Tracker::group, tr1::placeholders::_1));
+  CMD2_TRACKER        ("t.type",              tr1::bind(&torrent::Tracker::type, tr1::placeholders::_1));
+  CMD2_TRACKER        ("t.id",                tr1::bind(&torrent::Tracker::tracker_id, tr1::placeholders::_1));
 
-  CMD2_TRACKER        ("t.latest_event",      std::bind(&torrent::Tracker::latest_event, std::placeholders::_1));
-  CMD2_TRACKER        ("t.latest_new_peers",  std::bind(&torrent::Tracker::latest_new_peers, std::placeholders::_1));
-  CMD2_TRACKER        ("t.latest_sum_peers",  std::bind(&torrent::Tracker::latest_sum_peers, std::placeholders::_1));
+  CMD2_TRACKER        ("t.latest_event",      tr1::bind(&torrent::Tracker::latest_event, tr1::placeholders::_1));
+  CMD2_TRACKER        ("t.latest_new_peers",  tr1::bind(&torrent::Tracker::latest_new_peers, tr1::placeholders::_1));
+  CMD2_TRACKER        ("t.latest_sum_peers",  tr1::bind(&torrent::Tracker::latest_sum_peers, tr1::placeholders::_1));
 
   // Time since last connection, connection attempt.
 
-  CMD2_TRACKER        ("t.normal_interval",   std::bind(&torrent::Tracker::normal_interval, std::placeholders::_1));
-  CMD2_TRACKER        ("t.min_interval",      std::bind(&torrent::Tracker::min_interval, std::placeholders::_1));
+  CMD2_TRACKER        ("t.normal_interval",   tr1::bind(&torrent::Tracker::normal_interval, tr1::placeholders::_1));
+  CMD2_TRACKER        ("t.min_interval",      tr1::bind(&torrent::Tracker::min_interval, tr1::placeholders::_1));
 
-  CMD2_TRACKER        ("t.success_time_last", std::bind(&torrent::Tracker::success_time_last, std::placeholders::_1));
-  CMD2_TRACKER        ("t.success_counter",   std::bind(&torrent::Tracker::success_counter, std::placeholders::_1));
+  CMD2_TRACKER        ("t.success_time_last", tr1::bind(&torrent::Tracker::success_time_last, tr1::placeholders::_1));
+  CMD2_TRACKER        ("t.success_counter",   tr1::bind(&torrent::Tracker::success_counter, tr1::placeholders::_1));
 
-  CMD2_TRACKER        ("t.failed_time_last",  std::bind(&torrent::Tracker::failed_time_last, std::placeholders::_1));
-  CMD2_TRACKER        ("t.failed_counter",    std::bind(&torrent::Tracker::failed_counter, std::placeholders::_1));
+  CMD2_TRACKER        ("t.failed_time_last",  tr1::bind(&torrent::Tracker::failed_time_last, tr1::placeholders::_1));
+  CMD2_TRACKER        ("t.failed_counter",    tr1::bind(&torrent::Tracker::failed_counter, tr1::placeholders::_1));
 
-  CMD2_TRACKER        ("t.scrape_time_last",  std::bind(&torrent::Tracker::scrape_time_last, std::placeholders::_1));
-  CMD2_TRACKER        ("t.scrape_counter",    std::bind(&torrent::Tracker::scrape_counter, std::placeholders::_1));
+  CMD2_TRACKER        ("t.scrape_time_last",  tr1::bind(&torrent::Tracker::scrape_time_last, tr1::placeholders::_1));
+  CMD2_TRACKER        ("t.scrape_counter",    tr1::bind(&torrent::Tracker::scrape_counter, tr1::placeholders::_1));
 
-  CMD2_TRACKER        ("t.scrape_complete",   std::bind(&torrent::Tracker::scrape_complete, std::placeholders::_1));
-  CMD2_TRACKER        ("t.scrape_incomplete", std::bind(&torrent::Tracker::scrape_incomplete, std::placeholders::_1));
-  CMD2_TRACKER        ("t.scrape_downloaded", std::bind(&torrent::Tracker::scrape_downloaded, std::placeholders::_1));
+  CMD2_TRACKER        ("t.scrape_complete",   tr1::bind(&torrent::Tracker::scrape_complete, tr1::placeholders::_1));
+  CMD2_TRACKER        ("t.scrape_incomplete", tr1::bind(&torrent::Tracker::scrape_incomplete, tr1::placeholders::_1));
+  CMD2_TRACKER        ("t.scrape_downloaded", tr1::bind(&torrent::Tracker::scrape_downloaded, tr1::placeholders::_1));
 
-  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_ANY_VALUE      ("trackers.enable",     tr1::bind(&apply_enable_trackers, int64_t(1)));
+  CMD2_ANY_VALUE      ("trackers.disable",    tr1::bind(&apply_enable_trackers, int64_t(0)));
   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_ANY_STRING_V   ("dht.mode.set",          tr1::bind(&core::DhtManager::set_mode, control->dht_manager(), tr1::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));
+  CMD2_ANY_STRING     ("dht.add_node",          tr1::bind(&apply_dht_add_node, tr1::placeholders::_2));
+  CMD2_ANY            ("dht.statistics",        tr1::bind(&core::DhtManager::dht_statistics, control->dht_manager()));
+  CMD2_ANY            ("dht.throttle.name",     tr1::bind(&core::DhtManager::throttle_name, control->dht_manager()));
+  CMD2_ANY_STRING_V   ("dht.throttle.name.set", tr1::bind(&core::DhtManager::set_throttle_name, control->dht_manager(), tr1::placeholders::_2));
 }

src/command_ui.cc

@@ -541,41 +541,41 @@ 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_STRING("view.add", object_convert_void(tr1::bind(&core::ViewManager::insert_throw, control->view_manager(), tr1::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_L   ("view.list",          tr1::bind(&apply_view_list));
+  CMD2_ANY_LIST("view.set",           tr1::bind(&apply_view_set, tr1::placeholders::_2));
 
-  CMD2_ANY_LIST("view.filter",        std::bind(&apply_view_cfilter, &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",        tr1::bind(&apply_view_cfilter, &core::ViewManager::set_filter, tr1::placeholders::_2));
+  CMD2_ANY_LIST("view.filter_on",     tr1::bind(&apply_view_filter_on, tr1::placeholders::_2));
 
-  CMD2_ANY_LIST("view.sort",          std::bind(&apply_view_sort, std::placeholders::_2));
-  CMD2_ANY_LIST("view.sort_new",      std::bind(&apply_view_cfilter, &core::ViewManager::set_sort_new, std::placeholders::_2));
-  CMD2_ANY_LIST("view.sort_current",  std::bind(&apply_view_cfilter, &core::ViewManager::set_sort_current, std::placeholders::_2));
+  CMD2_ANY_LIST("view.sort",          tr1::bind(&apply_view_sort, tr1::placeholders::_2));
+  CMD2_ANY_LIST("view.sort_new",      tr1::bind(&apply_view_cfilter, &core::ViewManager::set_sort_new, tr1::placeholders::_2));
+  CMD2_ANY_LIST("view.sort_current",  tr1::bind(&apply_view_cfilter, &core::ViewManager::set_sort_current, tr1::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));
+  CMD2_ANY_LIST("view.event_added",   tr1::bind(&apply_view_event, &core::ViewManager::set_event_added, tr1::placeholders::_2));
+  CMD2_ANY_LIST("view.event_removed", tr1::bind(&apply_view_event, &core::ViewManager::set_event_removed, tr1::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("view.size",              tr1::bind(&cmd_view_size, tr1::placeholders::_2));
+  CMD2_ANY_STRING("view.size_not_visible",  tr1::bind(&cmd_view_size_not_visible, tr1::placeholders::_2));
+  CMD2_ANY_STRING("view.persistent",        tr1::bind(&cmd_view_persistent, tr1::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_ANY_STRING_V("view.filter_all",      tr1::bind(&core::View::filter, tr1::bind(&core::ViewManager::find_ptr_throw, control->view_manager(), tr1::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));
+  CMD2_DL_STRING ("view.filter_download", tr1::bind(&cmd_view_filter_download, tr1::placeholders::_1, tr1::placeholders::_2));
+  CMD2_DL_STRING ("view.set_visible",     tr1::bind(&cmd_view_set_visible,     tr1::placeholders::_1, tr1::placeholders::_2));
+  CMD2_DL_STRING ("view.set_not_visible", tr1::bind(&cmd_view_set_not_visible, tr1::placeholders::_1, tr1::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_STRING("ui.current_view.set",   std::bind(&cmd_ui_set_view, std::placeholders::_2));
+  CMD2_DL        ("ui.unfocus_download",   tr1::bind(&cmd_ui_unfocus_download, tr1::placeholders::_1));
+  CMD2_ANY_STRING("ui.current_view.set",   tr1::bind(&cmd_ui_set_view, tr1::placeholders::_2));
 
   // Move.
   CMD2_ANY("print", &apply_print);
   CMD2_ANY("cat",   &apply_cat);
-  CMD2_ANY("if",    std::bind(&apply_if, std::placeholders::_1, std::placeholders::_2, 0));
+  CMD2_ANY("if",    tr1::bind(&apply_if, tr1::placeholders::_1, tr1::placeholders::_2, 0));
   CMD2_ANY("not",   &apply_not);
   CMD2_ANY("false", &apply_false);
   CMD2_ANY("and",   &apply_and);
@@ -583,22 +583,22 @@ initialize_command_ui() {
 
   // 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("branch", tr1::bind(&apply_if, tr1::placeholders::_1, tr1::placeholders::_2, 1));
 
   CMD2_ANY_LIST("less",    &apply_less);
   CMD2_ANY_LIST("greater", &apply_greater);
   CMD2_ANY_LIST("equal",   &apply_equal);
 
-  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_VALUE("convert.gm_time",      tr1::bind(&apply_to_time, tr1::placeholders::_2, 0));
+  CMD2_ANY_VALUE("convert.gm_date",      tr1::bind(&apply_to_time, tr1::placeholders::_2, 0x2));
+  CMD2_ANY_VALUE("convert.time",         tr1::bind(&apply_to_time, tr1::placeholders::_2, 0x1));
+  CMD2_ANY_VALUE("convert.date",         tr1::bind(&apply_to_time, tr1::placeholders::_2, 0x1 | 0x2));
+  CMD2_ANY_VALUE("convert.elapsed_time", tr1::bind(&apply_to_elapsed_time, tr1::placeholders::_2));
+  CMD2_ANY_VALUE("convert.kb",           tr1::bind(&apply_to_kb, tr1::placeholders::_2));
+  CMD2_ANY_VALUE("convert.mb",           tr1::bind(&apply_to_mb, tr1::placeholders::_2));
+  CMD2_ANY_VALUE("convert.xb",           tr1::bind(&apply_to_xb, tr1::placeholders::_2));
+  CMD2_ANY_VALUE("convert.throttle",     tr1::bind(&apply_to_throttle, tr1::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));
+  CMD2_ANY_LIST ("elapsed.less",         tr1::bind(&apply_elapsed_less, tr1::placeholders::_2));
+  CMD2_ANY_LIST ("elapsed.greater",      tr1::bind(&apply_elapsed_greater, tr1::placeholders::_2));
 }

src/control.cc

@@ -77,7 +77,7 @@ Control::Control() :
 
   m_inputStdin->slot_pressed(sigc::mem_fun(m_input, &input::Manager::pressed));
 
-  m_taskShutdown.set_slot(rak::mem_fn(this, &Control::handle_shutdown));
+  m_taskShutdown.slot() = std::tr1::bind(&Control::handle_shutdown, this);
 
   m_commandScheduler->set_slot_error_message(rak::mem_fn(m_core, &core::Manager::push_log_std));
 }
@@ -114,7 +114,7 @@ Control::initialize() {
 
   m_ui->init(this);
 
-  m_inputStdin->insert(main_thread->poll());
+  m_inputStdin->insert(torrent::main_thread()->poll());
 }
 
 void
@@ -124,7 +124,7 @@ Control::cleanup() {
 
   priority_queue_erase(&taskScheduler, &m_taskShutdown);
 
-  m_inputStdin->remove(main_thread->poll());
+  m_inputStdin->remove(torrent::main_thread()->poll());
 
   m_core->download_store()->disable();
 

src/core/Makefile.am

@@ -20,18 +20,10 @@ libsub_core_a_SOURCES = \
 	download_store.h \
 	http_queue.cc \
 	http_queue.h \
-	log.cc \
-	log.h \
 	manager.cc \
 	manager.h \
 	poll_manager.cc \
 	poll_manager.h \
-	poll_manager_epoll.cc \
-	poll_manager_epoll.h \
-	poll_manager_kqueue.cc \
-	poll_manager_kqueue.h \
-	poll_manager_select.cc \
-	poll_manager_select.h \
 	range_map.h \
 	view.cc \
 	view.h \

src/core/curl_get.cc

@@ -82,7 +82,7 @@ CurlGet::start() {
 
     // Normally libcurl should handle the timeout. But sometimes that doesn't
     // work right so we do a fallback timeout that just aborts the transfer.
-    m_taskTimeout.set_slot(rak::mem_fn(this, &CurlGet::receive_timeout));
+    m_taskTimeout.slot() = std::tr1::bind(&CurlGet::receive_timeout, this);
     priority_queue_erase(&taskScheduler, &m_taskTimeout);
     priority_queue_insert(&taskScheduler, &m_taskTimeout, cachedTime + rak::timer::from_seconds(m_timeout + 5));
   }

src/core/curl_socket.cc

@@ -41,6 +41,7 @@
 
 #include <torrent/poll.h>
 #include <torrent/exceptions.h>
+#include <torrent/utils/thread_base.h>
 
 #include "control.h"
 
@@ -69,22 +70,22 @@ CurlSocket::receive_socket(void* easy_handle, curl_socket_t fd, int what, void*
 
   if (socket == NULL) {
     socket = stack->new_socket(fd);
-    main_thread->poll()->open(socket);
+    torrent::main_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.
-    main_thread->poll()->insert_error(socket);
+    torrent::main_thread()->poll()->insert_error(socket);
   } 
 
   if (what == CURL_POLL_NONE || what == CURL_POLL_OUT)
-    main_thread->poll()->remove_read(socket);
+    torrent::main_thread()->poll()->remove_read(socket);
   else
-    main_thread->poll()->insert_read(socket);
+    torrent::main_thread()->poll()->insert_read(socket);
 
   if (what == CURL_POLL_NONE || what == CURL_POLL_IN)
-    main_thread->poll()->remove_write(socket);
+    torrent::main_thread()->poll()->remove_write(socket);
   else
-    main_thread->poll()->insert_write(socket);
+    torrent::main_thread()->poll()->insert_write(socket);
 
   return 0;
 }
@@ -99,7 +100,7 @@ CurlSocket::close() {
   if (m_fileDesc == -1)
     throw torrent::internal_error("CurlSocket::close() m_fileDesc == -1.");
 
-  main_thread->poll()->closed(this);
+  torrent::main_thread()->poll()->closed(this);
   m_fileDesc = -1;
 }
 

src/core/curl_socket.h

@@ -50,6 +50,8 @@ public:
   CurlSocket(int fd, CurlStack* stack) : m_stack(stack) { m_fileDesc = fd; }
   ~CurlSocket();
 
+  const char*        type_name() const { return "curl"; }
+
   void               close();
 
   static int         receive_socket(void* easy_handle, curl_socket_t fd, int what, void* userp, void* socketp);
@@ -62,7 +64,7 @@ private:
   virtual void       event_write();
   virtual void       event_error();
 
-  CurlStack*     m_stack;
+  CurlStack*         m_stack;
 };
 
 }

src/core/curl_stack.cc

@@ -46,8 +46,6 @@
 #include "curl_socket.h"
 #include "curl_stack.h"
 
-namespace std { using namespace tr1; }
-
 namespace core {
 
 CurlStack::CurlStack() :
@@ -57,7 +55,7 @@ CurlStack::CurlStack() :
   m_ssl_verify_peer(true),
   m_dns_timeout(60) {
 
-  m_taskTimeout.set_slot(rak::mem_fn(this, &CurlStack::receive_timeout));
+  m_taskTimeout.slot() = std::tr1::bind(&CurlStack::receive_timeout, this);
 
 #if (LIBCURL_VERSION_NUM >= 0x071000)
   curl_multi_setopt((CURLM*)m_handle, CURLMOPT_TIMERDATA, this);

src/core/dht_manager.cc

@@ -114,7 +114,7 @@ DhtManager::start_dht() {
     torrent::dht_manager()->start(port);
     torrent::dht_manager()->reset_statistics();
 
-    m_updateTimeout.set_slot(rak::mem_fn(this, &DhtManager::update));
+    m_updateTimeout.slot() = std::tr1::bind(&DhtManager::update, this);
     priority_queue_insert(&taskScheduler, &m_updateTimeout, (cachedTime + rak::timer::from_seconds(60)).round_seconds());
 
     m_dhtPrevCycle = 0;
@@ -197,7 +197,7 @@ DhtManager::update() {
         break;
       
     if (itr == end) {
-      m_stopTimeout.set_slot(rak::mem_fn(this, &DhtManager::stop_dht));
+      m_stopTimeout.slot() = std::tr1::bind(&DhtManager::stop_dht, this);
       priority_queue_insert(&taskScheduler, &m_stopTimeout, (cachedTime + rak::timer::from_seconds(15 * 60)).round_seconds());
     }
   }
@@ -248,7 +248,7 @@ DhtManager::log_statistics(bool force) {
   if (m_dhtPrevCycle == 1) {
     char buffer[128];
     snprintf(buffer, sizeof(buffer), "DHT bootstrap complete, have %d nodes in %d buckets.", stats.num_nodes, stats.num_buckets);
-    control->core()->get_log_complete().push_front(buffer);
+    control->core()->push_log_complete(buffer);
     m_dhtPrevCycle = stats.cycle;
     return false;
   };
@@ -271,7 +271,7 @@ DhtManager::log_statistics(bool force) {
              stats.max_peers,
              stats.num_trackers);
 
-    control->core()->get_log_complete().push_front(buffer);
+    control->core()->push_log_complete(buffer);
 
     m_dhtPrevCycle = stats.cycle;
     m_dhtPrevQueriesSent = stats.queries_sent;

src/core/download_factory.cc

@@ -41,6 +41,7 @@
 #include <sstream>
 #include <stdexcept>
 #include <rak/path.h>
+#include <tr1/functional>
 #include <torrent/utils/resume.h>
 #include <torrent/object.h>
 #include <torrent/object_stream.h>
@@ -105,8 +106,8 @@ DownloadFactory::DownloadFactory(Manager* m) :
   m_printLog(true),
   m_isFile(false) {
 
-  m_taskLoad.set_slot(rak::mem_fn(this, &DownloadFactory::receive_load));
-  m_taskCommit.set_slot(rak::mem_fn(this, &DownloadFactory::receive_commit));
+  m_taskLoad.slot() = std::tr1::bind(&DownloadFactory::receive_load, this);
+  m_taskCommit.slot() = std::tr1::bind(&DownloadFactory::receive_commit, this);
 
   // m_variables["connection_leech"] = rpc::call_command_void("protocol.connection.leech");
   // m_variables["connection_seed"]  = rpc::call_command_void("protocol.connection.seed");
@@ -156,8 +157,8 @@ DownloadFactory::receive_load() {
     m_stream = new std::stringstream;
     HttpQueue::iterator itr = m_manager->http_queue()->insert(m_uri, m_stream);
 
-    (*itr)->signal_done().push_front(std::bind(&DownloadFactory::receive_loaded, this));
-    (*itr)->signal_failed().push_front(std::bind(&DownloadFactory::receive_failed, this, std::placeholders::_1));
+    (*itr)->signal_done().push_front(std::tr1::bind(&DownloadFactory::receive_loaded, this));
+    (*itr)->signal_failed().push_front(std::tr1::bind(&DownloadFactory::receive_failed, this, std::tr1::placeholders::_1));
 
     m_variables["tied_to_file"] = (int64_t)false;
 
@@ -325,10 +326,8 @@ DownloadFactory::receive_success() {
   } catch (torrent::input_error& e) {
     std::string msg = "Command on torrent creation failed: " + std::string(e.what());
 
-    if (m_printLog) {
-      m_manager->get_log_important().push_front(msg);
-      m_manager->get_log_complete().push_front(msg);
-    }
+    if (m_printLog)
+      m_manager->push_log_std(msg);
     
     if (m_manager->download_list()->find(infohash) != m_manager->download_list()->end()) {
       // Should stop it, mark it bad. Perhaps even delete it?
@@ -344,10 +343,8 @@ DownloadFactory::receive_success() {
 void
 DownloadFactory::receive_failed(const std::string& msg) {
   // Add message to log.
-  if (m_printLog) {
-    m_manager->get_log_important().push_front(msg + ": \"" + m_uri + "\"");
-    m_manager->get_log_complete().push_front(msg + ": \"" + m_uri + "\"");
-  }
+  if (m_printLog)
+    m_manager->push_log_std(msg + ": \"" + m_uri + "\"");
 
   m_slotFinished();
 }

src/core/download_list.cc

@@ -178,9 +178,11 @@ DownloadList::iterator
 DownloadList::insert(Download* download) {
   iterator itr = base_type::insert(end(), download);
 
+  lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Inserting download.");
+
   try {
-    (*itr)->data()->slot_initial_hash()        = std::bind(&DownloadList::hash_done, this, download);
-    (*itr)->data()->slot_download_done()       = std::bind(&DownloadList::received_finished, this, download);
+    (*itr)->data()->slot_initial_hash()        = tr1::bind(&DownloadList::hash_done, this, download);
+    (*itr)->data()->slot_download_done()       = tr1::bind(&DownloadList::received_finished, this, download);
 
     // This needs to be separated into two different calls to ensure
     // the download remains in the view.
@@ -208,6 +210,8 @@ DownloadList::erase(iterator itr) {
   if (itr == end())
     throw torrent::internal_error("DownloadList::erase(...) could not find download.");
 
+  lt_log_print_info(torrent::LOG_TORRENT_INFO, (*itr)->info(), "download_list", "Erasing download.");
+
   // Makes sure close doesn't restart hashing of this download.
   (*itr)->set_hash_failed(true);
 
@@ -242,6 +246,8 @@ void
 DownloadList::open_throw(Download* download) {
   check_contains(download);
 
+  lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Opening download.");
+
   if (download->download()->info()->is_open())
     return;
   
@@ -257,7 +263,6 @@ DownloadList::open_throw(Download* download) {
 void
 DownloadList::close(Download* download) {
   try {
-
     close_throw(download);
 
   } catch (torrent::local_error& e) {
@@ -267,6 +272,8 @@ DownloadList::close(Download* download) {
 
 void
 DownloadList::close_directly(Download* download) {
+  lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Closing download directly.");
+
   if (download->download()->info()->is_active()) {
     download->download()->stop(torrent::Download::stop_skip_tracker);
 
@@ -280,6 +287,7 @@ DownloadList::close_directly(Download* download) {
 
 void
 DownloadList::close_quick(Download* download) {
+  lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Closing download quickly.");
   close(download);
   
   // Make sure we cancel any tracker requests. This should rather be
@@ -293,6 +301,8 @@ void
 DownloadList::close_throw(Download* download) {
   check_contains(download);
 
+  lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Closing download with throw.");
+
   // When pause gets called it will clear the initial hash check state
   // and set hash failed. This should ensure hashing doesn't restart
   // until resume gets called.
@@ -324,6 +334,8 @@ void
 DownloadList::resume(Download* download, int flags) {
   check_contains(download);
 
+  lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Resuming download: flags:%0x.", flags);
+
   try {
 
     if (download->download()->info()->is_active())
@@ -417,6 +429,8 @@ void
 DownloadList::pause(Download* download, int flags) {
   check_contains(download);
 
+  lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Pausing download: flags:%0x.", flags);
+
   try {
 
     download->set_resume_flags(~uint32_t());
@@ -464,8 +478,9 @@ void
 DownloadList::check_hash(Download* download) {
   check_contains(download);
 
-  try {
+  lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Checking hash.");
 
+  try {
     if (rpc::call_command_value("d.hashing", rpc::make_target(download)) != Download::variable_hashing_stopped)
       return;
 
@@ -480,6 +495,8 @@ void
 DownloadList::hash_done(Download* download) {
   check_contains(download);
 
+  lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Hash done.");
+
   if (download->is_hash_checking() || download->is_active())
     throw torrent::internal_error("DownloadList::hash_done(...) download in invalid state.");
 
@@ -554,6 +571,8 @@ void
 DownloadList::hash_queue(Download* download, int type) {
   check_contains(download);
 
+  lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Hash queue.");
+
   if (rpc::call_command_value("d.hashing", rpc::make_target(download)) != Download::variable_hashing_stopped)
     throw torrent::internal_error("DownloadList::hash_queue(...) hashing already queued.");
 
@@ -583,6 +602,8 @@ void
 DownloadList::received_finished(Download* download) {
   check_contains(download);
 
+  lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Received finished.");
+
   if (rpc::call_command_value("pieces.hash.on_completion"))
     // Set some 'checking_finished_thingie' variable to make hash_done
     // trigger correctly, also so it can bork on missing data.
@@ -596,6 +617,8 @@ void
 DownloadList::confirm_finished(Download* download) {
   check_contains(download);
 
+  lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Confirming finished.");
+
   if (download->download()->info()->is_meta_download())
     return process_meta_download(download);
 
@@ -642,6 +665,9 @@ DownloadList::confirm_finished(Download* download) {
 
   DL_TRIGGER_EVENT(download, "event.download.finished");
 
+  if (find(infohash) == end())
+    return;
+      
 //   if (download->resume_flags() != ~uint32_t())
 //     throw torrent::internal_error("DownloadList::confirm_finished(...) download->resume_flags() != ~uint32_t().");
 
@@ -655,8 +681,7 @@ DownloadList::confirm_finished(Download* download) {
   // being hashed.
   download->set_resume_flags(~uint32_t());
 
-  if (find(infohash) != end() &&
-      !download->is_active() && rpc::call_command_value("d.state", rpc::make_target(download)) == 1)
+  if (!download->is_active() && rpc::call_command_value("d.state", rpc::make_target(download)) == 1)
     resume(download,
            torrent::Download::start_no_create |
            torrent::Download::start_skip_tracker |
@@ -665,6 +690,8 @@ DownloadList::confirm_finished(Download* download) {
 
 void
 DownloadList::process_meta_download(Download* download) {
+  lt_log_print_info(torrent::LOG_TORRENT_INFO, download->info(), "download_list", "Processing meta download.");
+
   rpc::call_command("d.stop", torrent::Object(), rpc::make_target(download));
   rpc::call_command("d.close", torrent::Object(), rpc::make_target(download));
 

src/core/http_queue.cc

@@ -46,8 +46,6 @@
 #include "http_queue.h"
 #include "curl_get.h"
 
-namespace std { using namespace tr1; }
-
 namespace core {
 
 HttpQueue::iterator
@@ -60,8 +58,8 @@ HttpQueue::insert(const std::string& url, std::iostream* s) {
 
   iterator itr = Base::insert(end(), h.get());
 
-  h->signal_done().push_back(std::bind(&HttpQueue::erase, this, itr));
-  h->signal_failed().push_back(std::bind(&HttpQueue::erase, this, itr));
+  h->signal_done().push_back(std::tr1::bind(&HttpQueue::erase, this, itr));
+  h->signal_failed().push_back(std::tr1::bind(&HttpQueue::erase, this, itr));
 
   (*itr)->start();
 

src/core/log.cc

@@ -1,65 +0,0 @@
-// 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 <algorithm>
-#include <rak/functional.h>
-
-#include "globals.h"
-#include "log.h"
-
-namespace core {
-
-void
-Log::push_front(const std::string& msg) {
-  if (!m_enabled)
-    return;
-
-  Base::push_front(Type(cachedTime, msg));
-
-  if (size() > 50)
-    Base::pop_back();
-
-  m_signalUpdate.emit();
-}
-
-Log::iterator
-Log::find_older(rak::timer t) {
-  return std::find_if(begin(), end(), rak::on(rak::mem_ref(&Type::first), std::bind2nd(std::less_equal<rak::timer>(), t)));
-}
-
-}

src/core/log.h

@@ -1,88 +0,0 @@
-// 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
-
-#ifndef RTORRENT_CORE_LOG_H
-#define RTORRENT_CORE_LOG_H
-
-#include <deque>
-#include <string>
-#include <sigc++/signal.h>
-
-#include <rak/timer.h>
-
-namespace core {
-
-class Log : private std::deque<std::pair<rak::timer, std::string> > {
-public:
-  typedef std::pair<rak::timer, std::string> Type;
-  typedef std::deque<Type>                     Base;
-  typedef sigc::signal0<void>                  Signal;
-
-  using Base::iterator;
-  using Base::const_iterator;
-  using Base::reverse_iterator;
-  using Base::const_reverse_iterator;
-
-  using Base::begin;
-  using Base::end;
-  using Base::rbegin;
-  using Base::rend;
-
-  using Base::empty;
-  using Base::size;
-
-  Log() : m_enabled(true) {}
-
-  bool      is_enabled() const { return m_enabled; }
-
-  void      enable()           { m_enabled = true; }
-  void      disable()          { m_enabled = false; }
-
-  void      push_front(const std::string& msg);
-
-  iterator  find_older(rak::timer t);
-
-  Signal&   signal_update() { return m_signalUpdate; }
-
-private:
-  bool      m_enabled;
-
-  Signal    m_signalUpdate;
-};
-
-}
-
-#endif

src/core/manager.cc

@@ -71,13 +71,9 @@
 #include "download_store.h"
 #include "http_queue.h"
 #include "manager.h"
-#include "poll_manager_epoll.h"
-#include "poll_manager_kqueue.h"
-#include "poll_manager_select.h"
+#include "poll_manager.h"
 #include "view.h"
 
-namespace std { using namespace tr1; }
-
 namespace core {
 
 void
@@ -107,47 +103,48 @@ Manager::handshake_log(const sockaddr* sa, int msg, int err, const torrent::Hash
 
   switch (msg) {
   case torrent::ConnectionManager::handshake_incoming:
-    m_logComplete.push_front("Incoming connection from " + peer + download);
+    push_log_complete("Incoming connection from " + peer + download);
     break;
   case torrent::ConnectionManager::handshake_outgoing:
-    m_logComplete.push_front("Outgoing connection to " + peer + download);
+    push_log_complete("Outgoing connection to " + peer + download);
     break;
   case torrent::ConnectionManager::handshake_outgoing_encrypted:
-    m_logComplete.push_front("Outgoing encrypted connection to " + peer + download);
+    push_log_complete("Outgoing encrypted connection to " + peer + download);
     break;
   case torrent::ConnectionManager::handshake_outgoing_proxy:
-    m_logComplete.push_front("Outgoing proxy connection to " + peer + download);
+    push_log_complete("Outgoing proxy connection to " + peer + download);
     break;
   case torrent::ConnectionManager::handshake_success:
-    m_logComplete.push_front("Successful handshake: " + peer + download);
+    push_log_complete("Successful handshake: " + peer + download);
     break;
   case torrent::ConnectionManager::handshake_dropped:
-    m_logComplete.push_front("Dropped handshake: " + peer + " - " + torrent::strerror(err) + download);
+    push_log_complete("Dropped handshake: " + peer + " - " + torrent::strerror(err) + download);
     break;
   case torrent::ConnectionManager::handshake_failed:
-    m_logComplete.push_front("Handshake failed: " + peer + " - " + torrent::strerror(err) + download);
+    push_log_complete("Handshake failed: " + peer + " - " + torrent::strerror(err) + download);
     break;
   case torrent::ConnectionManager::handshake_retry_plaintext:
-    m_logComplete.push_front("Trying again without encryption: " + peer + download);
+    push_log_complete("Trying again without encryption: " + peer + download);
     break;
   case torrent::ConnectionManager::handshake_retry_encrypted:
-    m_logComplete.push_front("Trying again encrypted: " + peer + download);
+    push_log_complete("Trying again encrypted: " + peer + download);
     break;
   default:
-    m_logComplete.push_front("Unknown handshake message for " + peer + download);
+    push_log_complete("Unknown handshake message for " + peer + download);
     break;
   }
 }
 
 void
 Manager::push_log(const char* msg) {
-  m_logImportant.push_front(msg);
-  m_logComplete.push_front(msg);
+  m_log_important->lock_and_push_log(msg, strlen(msg), 0);
+  m_log_complete->lock_and_push_log(msg, strlen(msg), 0);
 }
 
 Manager::Manager() :
-  m_hashingView(NULL)
-//   m_pollManager(NULL) {
+  m_hashingView(NULL),
+  m_log_important(torrent::log_open_log_buffer("important")),
+  m_log_complete(torrent::log_open_log_buffer("complete"))
 {
   m_downloadStore   = new DownloadStore();
   m_downloadList    = new DownloadList();
@@ -164,6 +161,8 @@ Manager::~Manager() {
   torrent::Throttle::destroy_throttle(m_throttles["NULL"].first);
   delete m_downloadList;
 
+  // TODO: Clean up logs objects.
+
   delete m_downloadStore;
   delete m_httpQueue;
   delete m_fileStatusCache;
@@ -206,7 +205,7 @@ Manager::get_address_throttle(const sockaddr* addr) {
 // Most of this should be possible to move out.
 void
 Manager::initialize_second() {
-  torrent::Http::set_factory(std::bind(&CurlStack::new_object, m_httpStack));
+  torrent::Http::slot_factory() = std::tr1::bind(&CurlStack::new_object, m_httpStack);
   m_httpQueue->slot_factory(sigc::mem_fun(m_httpStack, &CurlStack::new_object));
 
   CurlStack::global_init();
@@ -373,8 +372,7 @@ Manager::set_proxy_address(const std::string& addr) {
 
 void
 Manager::receive_http_failed(std::string msg) {
-  m_logImportant.push_front("Http download error: \"" + msg + "\"");
-  m_logComplete.push_front("Http download error: \"" + msg + "\"");
+  push_log_std("Http download error: \"" + msg + "\"");
 }
 
 void

src/core/manager.h

@@ -40,12 +40,12 @@
 #include <iosfwd>
 #include <vector>
 
+#include <torrent/utils/log_buffer.h>
 #include <torrent/connection_manager.h>
 
 #include "download_list.h"
 #include "poll_manager.h"
 #include "range_map.h"
-#include "log.h"
 
 namespace torrent {
   class Bencode;
@@ -85,8 +85,8 @@ public:
   View*               hashing_view()                      { return m_hashingView; }
   void                set_hashing_view(View* v);
 
-  Log&                get_log_important()                 { return m_logImportant; }
-  Log&                get_log_complete()                  { return m_logComplete; }
+  torrent::log_buffer* log_important()                    { return m_log_important; }
+  torrent::log_buffer* log_complete()                     { return m_log_complete; }
 
   ThrottleMap&          throttles()                       { return m_throttles; }
   torrent::ThrottlePair get_throttle(const std::string& name);
@@ -113,8 +113,8 @@ public:
   void                shutdown(bool force);
 
   void                push_log(const char* msg);
-  void                push_log_std(const std::string& msg) { m_logImportant.push_front(msg); m_logComplete.push_front(msg); }
-  void                push_log_complete(const std::string& msg) { m_logComplete.push_front(msg); }
+  void                push_log_std(const std::string& msg) { m_log_important->lock_and_push_log(msg.c_str(), msg.size(), 0); m_log_complete->lock_and_push_log(msg.c_str(), msg.size(), 0); }
+  void                push_log_complete(const std::string& msg) { m_log_complete->lock_and_push_log(msg.c_str(), msg.size(), 0); }
 
   void                handshake_log(const sockaddr* sa, int msg, int err, const torrent::HashString* hash);
 
@@ -152,8 +152,8 @@ private:
   ThrottleMap         m_throttles;
   AddressThrottleMap  m_addressThrottles;
 
-  Log                 m_logImportant;
-  Log                 m_logComplete;
+  torrent::log_buffer* m_log_important;
+  torrent::log_buffer* m_log_complete;
 };
 
 // Meh, cleanup.

src/core/poll_manager.cc

@@ -38,72 +38,54 @@
 
 #include <stdexcept>
 #include <unistd.h>
-#include <rak/error_number.h>
+#include <torrent/exceptions.h>
+#include <torrent/poll_epoll.h>
+#include <torrent/poll_kqueue.h>
+#include <torrent/poll_select.h>
 
 #include "globals.h"
 #include "control.h"
 #include "manager.h"
 #include "poll_manager.h"
-#include "poll_manager_epoll.h"
-#include "poll_manager_kqueue.h"
-#include "poll_manager_select.h"
 
 namespace core {
 
-PollManager::PollManager(torrent::Poll* poll) :
-  m_poll(poll) {
-
-  if (m_poll == NULL)
-    throw std::logic_error("PollManager::PollManager(...) received poll == NULL");
-}
-
-PollManager::~PollManager() {
-  delete m_poll;
-}
-
-PollManager*
-PollManager::create_poll_manager() {
-  PollManager* pollManager = NULL;
-  Log* log = &control->core()->get_log_important();
-
-  const char* poll = getenv("RTORRENT_POLL");
+torrent::Poll*
+create_poll() {
+  const char* poll_name = getenv("RTORRENT_POLL");
 
   int maxOpen = sysconf(_SC_OPEN_MAX);
 
-  if (poll != NULL) {
-    if (!strcmp(poll, "epoll"))
-      pollManager = PollManagerEPoll::create(maxOpen);
-    else if (!strcmp(poll, "kqueue"))
-      pollManager = PollManagerKQueue::create(maxOpen);
-    else if (!strcmp(poll, "select"))
-      pollManager = PollManagerSelect::create(maxOpen);
+  torrent::Poll* poll = NULL;
 
-    if (pollManager == NULL)
-      log->push_front(std::string("Cannot enable '") + poll + "' based polling.");
+  if (poll_name != NULL) {
+    if (!strcmp(poll_name, "epoll"))
+      poll = torrent::PollEPoll::create(maxOpen);
+    else if (!strcmp(poll_name, "kqueue"))
+      poll = torrent::PollKQueue::create(maxOpen);
+    else if (!strcmp(poll_name, "select"))
+      poll = torrent::PollSelect::create(maxOpen);
+
+    if (poll == NULL)
+      control->core()->push_log_std(std::string("Cannot enable '") + poll_name + "' based polling.");
   }
 
-  if (pollManager != NULL)
-      log->push_front(std::string("Using '") + poll + "' based polling.");
+  if (poll != NULL)
+    control->core()->push_log_std(std::string("Using '") + poll_name + "' based polling.");
 
-  else if ((pollManager = PollManagerEPoll::create(maxOpen)) != NULL)
-    log->push_front("Using 'epoll' based polling.");
+  else if ((poll = torrent::PollEPoll::create(maxOpen)) != NULL)
+    control->core()->push_log_std("Using 'epoll' based polling.");
 
-  else if ((pollManager = PollManagerKQueue::create(maxOpen)) != NULL)
-    log->push_front("Using 'kqueue' based polling.");
+  else if ((poll = torrent::PollKQueue::create(maxOpen)) != NULL)
+    control->core()->push_log_std("Using 'kqueue' based polling.");
 
-  else if ((pollManager = PollManagerSelect::create(maxOpen)) != NULL)
-    log->push_front("Using 'select' based polling.");
+  else if ((poll = torrent::PollSelect::create(maxOpen)) != NULL)
+    control->core()->push_log_std("Using 'select' based polling.");
 
   else
-    throw std::runtime_error("Could not create any PollManager.");
+    throw torrent::internal_error("Could not create any Poll object.");
 
-  return pollManager;
-}
-
-void
-PollManager::check_error() {
-  if (rak::error_number::current().value() != rak::error_number::e_intr)
-    throw std::runtime_error("Poll::work(): " + std::string(rak::error_number::current().c_str()));
+  return poll;
 }
 
 }

src/core/poll_manager.h

@@ -37,41 +37,15 @@
 #ifndef RTORRENT_CORE_POLL_MANAGER_H
 #define RTORRENT_CORE_POLL_MANAGER_H
 
-#include <rak/timer.h>
-#include <sigc++/signal.h>
-#include <torrent/poll.h>
-
 #include "curl_stack.h"
 
+namespace torrent {
+class Poll;
+}
+
 namespace core {
 
-// CurlStack really should be somewhere else, but that won't happen
-// until they add an epoll friendly API.
-
-class PollManager {
-public:
-  typedef sigc::signal0<void> Signal;
-
-  PollManager(torrent::Poll* poll);
-  virtual ~PollManager();
-
-  unsigned int        get_open_max() const         { return m_poll->open_max(); }
-
-  torrent::Poll*      get_torrent_poll()           { return m_poll; }
-
-  virtual void        poll(rak::timer timeout) = 0;
-  virtual void        poll_simple(rak::timer timeout) = 0;
-
-  static PollManager* create_poll_manager();
-
-protected:
-  PollManager(const PollManager&);
-  void operator = (const PollManager&);
-
-  void                check_error();
-
-  torrent::Poll*      m_poll;
-};
+torrent::Poll* create_poll();
 
 }
 

src/core/poll_manager_epoll.cc

@@ -1,98 +0,0 @@
-// 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 <cstring>
-#include <stdexcept>
-#include <unistd.h>
-#include <sys/time.h>
-#include <torrent/poll_epoll.h>
-#include <torrent/torrent.h>
-
-#include "poll_manager_epoll.h"
-#include "thread_base.h"
-
-namespace core {
-
-PollManagerEPoll*
-PollManagerEPoll::create(int maxOpenSockets) {
-  torrent::PollEPoll* p = torrent::PollEPoll::create(maxOpenSockets);
-
-  if (p == NULL)
-    return NULL;
-  else
-    return new PollManagerEPoll(p);
-}
-
-PollManagerEPoll::~PollManagerEPoll() {
-}
-
-void
-PollManagerEPoll::poll(rak::timer timeout) {
-  // Add 1ms to ensure we don't idle loop due to the lack of
-  // resolution.
-  torrent::perform();
-  timeout = std::min(timeout, rak::timer(torrent::next_timeout())) + 1000;
-
-  ThreadBase::release_global_lock();
-  ThreadBase::entering_main_polling();
-
-  int status = static_cast<torrent::PollEPoll*>(m_poll)->poll((timeout.usec() + 999) / 1000);
-
-  ThreadBase::leaving_main_polling();
-  ThreadBase::acquire_global_lock();
-
-  if (status == -1)
-    return check_error();
-
-  torrent::perform();
-  static_cast<torrent::PollEPoll*>(m_poll)->perform();
-}
-
-void
-PollManagerEPoll::poll_simple(rak::timer timeout) {
-  // Add 1ms to ensure we don't idle loop due to the lack of
-  // resolution.
-  timeout = timeout + 1000;
-
-  if (static_cast<torrent::PollEPoll*>(m_poll)->poll((timeout.usec() + 999) / 1000) == -1)
-    return check_error();
-
-  static_cast<torrent::PollEPoll*>(m_poll)->perform();
-}
-
-}

src/core/poll_manager_epoll.h

@@ -1,64 +0,0 @@
-// 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
-
-#ifndef RTORRENT_CORE_POLL_MANAGER_EPOLL_H
-#define RTORRENT_CORE_POLL_MANAGER_EPOLL_H
-
-#include "poll_manager.h"
-
-namespace torrent {
-  class PollEPoll;
-}
-
-namespace core {
-
-class PollManagerEPoll : public PollManager {
-public:
-  static PollManagerEPoll* create(int maxOpenSockets);
-  ~PollManagerEPoll();
-
-  torrent::Poll*      get_torrent_poll();
-
-  void                poll(rak::timer timeout);
-  void                poll_simple(rak::timer timeout);
-
-private:
-  PollManagerEPoll(torrent::Poll* p) : PollManager(p) {}
-};
-
-}
-
-#endif

src/core/poll_manager_kqueue.cc

@@ -1,99 +0,0 @@
-// 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 <cstring>
-#include <stdexcept>
-#include <unistd.h>
-#include <sys/time.h>
-#include <torrent/exceptions.h>
-#include <torrent/poll_kqueue.h>
-#include <torrent/torrent.h>
-
-#include "poll_manager_kqueue.h"
-#include "thread_base.h"
-
-namespace core {
-
-PollManagerKQueue*
-PollManagerKQueue::create(int maxOpenSockets) {
-  torrent::PollKQueue* p = torrent::PollKQueue::create(maxOpenSockets);
-
-  if (p == NULL)
-    return NULL;
-  else
-    return new PollManagerKQueue(p);
-}
-
-PollManagerKQueue::~PollManagerKQueue() {
-}
-
-void
-PollManagerKQueue::poll(rak::timer timeout) {
-  // Add 1ms to ensure we don't idle loop due to the lack of
-  // resolution.
-  torrent::perform();
-  timeout = std::min(timeout, rak::timer(torrent::next_timeout())) + 1000;
-
-  ThreadBase::release_global_lock();
-  ThreadBase::entering_main_polling();
-
-  int status = static_cast<torrent::PollKQueue*>(m_poll)->poll((timeout.usec() + 999) / 1000);
-
-  ThreadBase::leaving_main_polling();
-  ThreadBase::acquire_global_lock();
-
-  if (status == -1)
-    return check_error();
-
-  torrent::perform();
-  static_cast<torrent::PollKQueue*>(m_poll)->perform();
-}
-
-void
-PollManagerKQueue::poll_simple(rak::timer timeout) {
-  // Add 1ms to ensure we don't idle loop due to the lack of
-  // resolution.
-  timeout = std::min(timeout, rak::timer(torrent::next_timeout())) + 1000;
-
-  if (static_cast<torrent::PollKQueue*>(m_poll)->poll((timeout.usec() + 999) / 1000) == -1)
-    return check_error();
-
-  static_cast<torrent::PollKQueue*>(m_poll)->perform();
-}
-
-}

src/core/poll_manager_kqueue.h

@@ -1,64 +0,0 @@
-// 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
-
-#ifndef RTORRENT_CORE_POLL_MANAGER_KQUEUE_H
-#define RTORRENT_CORE_POLL_MANAGER_KQUEUE_H
-
-#include "poll_manager.h"
-
-namespace torrent {
-  class PollKQueue;
-}
-
-namespace core {
-
-class PollManagerKQueue : public PollManager {
-public:
-  static PollManagerKQueue* create(int maxOpenSockets);
-  ~PollManagerKQueue();
-
-  torrent::Poll*      get_torrent_poll();
-
-  void                poll(rak::timer timeout);
-  void                poll_simple(rak::timer timeout);
-
-private:
-  PollManagerKQueue(torrent::Poll* p) : PollManager(p) {}
-};
-
-}
-
-#endif

src/core/poll_manager_select.cc

@@ -1,127 +0,0 @@
-// 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 <cstring>
-#include <stdexcept>
-#include <unistd.h>
-#include <sys/time.h>
-#include <rak/allocators.h>
-#include <torrent/exceptions.h>
-#include <torrent/poll_select.h>
-#include <torrent/torrent.h>
-
-#include "poll_manager_select.h"
-#include "thread_base.h"
-
-namespace core {
-
-PollManagerSelect::PollManagerSelect(torrent::Poll* p) : PollManager(p) {
-#if defined USE_VARIABLE_FDSET
-  m_setSize = (m_poll->open_max() + 7) / 8;
-
-  char* buffer = rak::cacheline_allocator<char>::alloc_size(3 * m_setSize);
-  std::memset(buffer, 0, 3 * m_setSize);
-
-  m_readSet = (fd_set*)buffer;
-  m_writeSet = (fd_set*)(buffer += m_setSize);
-  m_errorSet = (fd_set*)(buffer += m_setSize);
-#else
-#error Only variable fdset supported atm.
-#endif
-}
-
-PollManagerSelect*
-PollManagerSelect::create(int maxOpenSockets) {
-  torrent::PollSelect* p = torrent::PollSelect::create(maxOpenSockets);
-
-  if (p == NULL)
-    return NULL;
-
-  return new PollManagerSelect(p);
-}
-
-PollManagerSelect::~PollManagerSelect() {
-  free(m_readSet);
-}
-
-void
-PollManagerSelect::poll(rak::timer timeout) {
-  torrent::perform();
-  timeout = std::min(timeout, rak::timer(torrent::next_timeout())) + 1000;
-
-  std::memset(m_readSet, 0, m_setSize);
-  std::memset(m_writeSet, 0, m_setSize);
-  std::memset(m_errorSet, 0, m_setSize);
-
-  unsigned int maxFd = static_cast<torrent::PollSelect*>(m_poll)->fdset(m_readSet, m_writeSet, m_errorSet);
-
-  timeval t = timeout.tval();
-
-  ThreadBase::entering_main_polling();
-  ThreadBase::release_global_lock();
-
-  int status = select(maxFd + 1, m_readSet, m_writeSet, m_errorSet, &t);
-
-  ThreadBase::leaving_main_polling();
-  ThreadBase::acquire_global_lock();
-
-  if (status == -1)
-    return check_error();
-
-  torrent::perform();
-  static_cast<torrent::PollSelect*>(m_poll)->perform(m_readSet, m_writeSet, m_errorSet);
-}
-
-void
-PollManagerSelect::poll_simple(rak::timer timeout) {
-  torrent::PollSelect* currentPoll = static_cast<torrent::PollSelect*>(m_poll);
-
-  timeout = timeout + 1000;
-  std::memset(m_readSet, 0, 3 * m_setSize);
-
-  unsigned int maxFd = currentPoll->fdset(m_readSet, m_writeSet, m_errorSet);
-
-  timeval t = timeout.tval();
-
-  if (select(maxFd + 1, m_readSet, m_writeSet, m_errorSet, &t) == -1)
-    return check_error();
-
-  currentPoll->perform(m_readSet, m_writeSet, m_errorSet);
-}
-
-}

src/core/poll_manager_select.h

@@ -1,67 +0,0 @@
-// 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
-
-#ifndef RTORRENT_CORE_POLL_MANAGER_SELECT_H
-#define RTORRENT_CORE_POLL_MANAGER_SELECT_H
-
-#include "poll_manager.h"
-
-namespace torrent {
-  class PollSelect;
-}
-
-namespace core {
-
-class lt_cacheline_aligned PollManagerSelect : public PollManager {
-public:
-  static PollManagerSelect* create(int maxOpenSockets);
-  ~PollManagerSelect();
-
-  void                poll(rak::timer timeout);
-  void                poll_simple(rak::timer timeout);
-
-private:
-  PollManagerSelect(torrent::Poll* p);
-
-  unsigned int        m_setSize;
-  fd_set*             m_readSet;
-  fd_set*             m_writeSet;
-  fd_set*             m_errorSet;
-};
-
-}
-
-#endif

src/core/view.cc

@@ -172,7 +172,7 @@ View::initialize(const std::string& name) {
   m_focus = 0;
 
   set_last_changed(rak::timer());
-  m_delayChanged.set_slot(rak::mem_fn(&m_signalChanged, &signal_type::operator()));
+  m_delayChanged.slot() = std::tr1::bind(&signal_type::operator(), &m_signalChanged);
 }
 
 void

src/core/view.h

@@ -49,7 +49,6 @@
 #ifndef RTORRENT_CORE_VIEW_DOWNLOADS_H
 #define RTORRENT_CORE_VIEW_DOWNLOADS_H
 
-#include <memory>
 #include <string>
 #include <vector>
 #include <rak/timer.h>

src/display/attributes.h

@@ -39,7 +39,20 @@
 
 #include <string>
 #include <vector>
+
+#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
 
 // Let us hail the creators of curses for being idiots. The only
 // clever move they made was in the naming.

src/display/canvas.h

@@ -62,10 +62,10 @@ public:
   static void         resize_term(int x, int y)                               { resizeterm(y, x); }
   static void         resize_term(std::pair<int, int> dim)                    { resizeterm(dim.second, dim.first); }
 
-  unsigned int        get_x()                                                 { int x, y; getyx(m_window, y, x); return x; }
+  unsigned int        get_x()                                                 { int x, __UNUSED y; getyx(m_window, y, x); return x; }
   unsigned int        get_y()                                                 { int x, y; getyx(m_window, y, x); return y; }
 
-  unsigned int        width()                                                 { int x, y; getmaxyx(m_window, y, x); return x; }
+  unsigned int        width()                                                 { int x, __UNUSED y; getmaxyx(m_window, y, x); return x; }
   unsigned int        height()                                                { int x, y; getmaxyx(m_window, y, x); return y; }
 
   void                move(unsigned int x, unsigned int y)                    { wmove(m_window, y, x); }
@@ -101,7 +101,7 @@ public:
   static void         initialize();
   static void         cleanup();
 
-  static int          get_screen_width()                                      { int x, y; getmaxyx(stdscr, y, x); return x; }
+  static int          get_screen_width()                                      { int x, __UNUSED y; getmaxyx(stdscr, y, x); return x; }
   static int          get_screen_height()                                     { int x, y; getmaxyx(stdscr, y, x); return y; }
 
   static std::pair<int, int> term_size();

src/display/manager.cc

@@ -50,7 +50,7 @@ namespace display {
 Manager::Manager() :
   m_forceRedraw(false) {
 
-  m_taskUpdate.set_slot(rak::mem_fn(this, &Manager::receive_update));
+  m_taskUpdate.slot() = std::tr1::bind(&Manager::receive_update, this);
 }
 
 Manager::~Manager() {

src/display/text_element_value.cc

@@ -112,7 +112,7 @@ TextElementValueBase::print(char* first, char* last, Canvas::attributes_list* at
     if (u == NULL)
       return first;
 
-    first += std::min<ptrdiff_t>(std::max(snprintf(first, last - first + 1, "%02u/%02u/%04u", u->tm_mday, (u->tm_mon + 1), (1900 + u->tm_year)), 0), last - first + 1);;
+    first += std::min<ptrdiff_t>(std::max(snprintf(first, last - first + 1, "%02u/%02u/%04u", u->tm_mday, (u->tm_mon + 1), (1900 + u->tm_year)), 0), last - first + 1);
 
   } else if (m_flags & flag_time) {
     time_t t = val;

src/display/utils.cc

@@ -195,10 +195,10 @@ print_download_status(char* first, char* last, core::Download* d) {
     first = print_buffer(first, last, "Checking hash [%2i%%]",
                          (d->download()->chunks_hashed() * 100) / d->download()->file_list()->size_chunks());
 
-  } else if (d->tracker_list()->has_active()) {
+  } else if (d->tracker_list()->has_active_not_scrape()) {
     torrent::TrackerList::iterator itr =
       std::find_if(d->tracker_list()->begin(), d->tracker_list()->end(),
-                   std::mem_fun(&torrent::Tracker::is_busy));
+                   std::mem_fun(&torrent::Tracker::is_busy_not_scrape));
     char status[128];
 
     (*itr)->get_status(status, sizeof(status));

src/display/window.cc

@@ -59,7 +59,7 @@ Window::Window(Canvas* canvas, int flags, extent_type minWidth, extent_type minH
   m_maxWidth(maxWidth),
   m_maxHeight(maxHeight) {
 
-  m_taskUpdate.set_slot(rak::mem_fn(this, &Window::redraw));
+  m_taskUpdate.slot() = std::tr1::bind(&Window::redraw, this);
 }
 
 Window::~Window() {

src/display/window_download_list.cc

@@ -93,16 +93,15 @@ WindowDownloadList::redraw() {
 
   while (range.first != range.second) {
     char buffer[m_canvas->width() + 1];
-    char* position;
     char* last = buffer + m_canvas->width() - 2 + 1;
 
-    position = print_download_title(buffer, last, *range.first);
+    print_download_title(buffer, last, *range.first);
     m_canvas->print(0, pos++, "%c %s", range.first == m_view->focus() ? '*' : ' ', buffer);
     
-    position = print_download_info(buffer, last, *range.first);
+    print_download_info(buffer, last, *range.first);
     m_canvas->print(0, pos++, "%c %s", range.first == m_view->focus() ? '*' : ' ', buffer);
 
-    position = print_download_status(buffer, last, *range.first);
+    print_download_status(buffer, last, *range.first);
     m_canvas->print(0, pos++, "%c %s", range.first == m_view->focus() ? '*' : ' ', buffer);
 
     ++range.first;

src/display/window_download_statusbar.cc

@@ -63,33 +63,31 @@ WindowDownloadStatusbar::redraw() {
   m_canvas->erase();
 
   char buffer[m_canvas->width()];
-  char* position;
   char* last = buffer + m_canvas->width() - 2;
 
-  position = print_download_info(buffer, last, m_download);
+  print_download_info(buffer, last, m_download);
   m_canvas->print(0, 0, "%s", buffer);
 
-  position = buffer + std::min<ptrdiff_t>(std::max(snprintf(buffer, last - buffer, "Peers: %i(%i) Min/Max: %i/%i Slots: U:%i/%i D:%i/%i U/I/C/A: %i/%i/%i/%i Unchoked: %u/%u Failed: %i",
-                                        (int)m_download->download()->connection_list()->size(),
-                                        (int)m_download->download()->peer_list()->available_list_size(),
-                                        (int)m_download->download()->connection_list()->min_size(),
-                                        (int)m_download->download()->connection_list()->max_size(),
-                                        (int)m_download->download()->uploads_min(),
-                                        (int)m_download->download()->uploads_max(),
-                                        (int)m_download->download()->downloads_min(),
-                                        (int)m_download->download()->downloads_max(),
-                                        (int)m_download->download()->peers_currently_unchoked(),
-                                        (int)m_download->download()->peers_currently_interested(),
-                                        (int)m_download->download()->peers_complete(),
-                                        (int)m_download->download()->peers_accounted(),
-                                        (int)m_download->info()->upload_unchoked(),
-                                        (int)m_download->info()->download_unchoked(),
-                                        (int)m_download->chunks_failed()),
-                               0), last - buffer);
+  snprintf(buffer, last - buffer, "Peers: %i(%i) Min/Max: %i/%i Slots: U:%i/%i D:%i/%i U/I/C/A: %i/%i/%i/%i Unchoked: %u/%u Failed: %i",
+           (int)m_download->download()->connection_list()->size(),
+           (int)m_download->download()->peer_list()->available_list_size(),
+           (int)m_download->download()->connection_list()->min_size(),
+           (int)m_download->download()->connection_list()->max_size(),
+           (int)m_download->download()->uploads_min(),
+           (int)m_download->download()->uploads_max(),
+           (int)m_download->download()->downloads_min(),
+           (int)m_download->download()->downloads_max(),
+           (int)m_download->download()->peers_currently_unchoked(),
+           (int)m_download->download()->peers_currently_interested(),
+           (int)m_download->download()->peers_complete(),
+           (int)m_download->download()->peers_accounted(),
+           (int)m_download->info()->upload_unchoked(),
+           (int)m_download->info()->download_unchoked(),
+           (int)m_download->chunks_failed());
 
   m_canvas->print(0, 1, "%s", buffer);
 
-  position = print_download_status(buffer, last, m_download);
+  print_download_status(buffer, last, m_download);
   m_canvas->print(0, 2, "[%c:%i] %s",
                   m_download->tracker_list()->has_active() ? 'C' : ' ',
                   (int)(m_download->download()->tracker_controller()->seconds_to_next_timeout()),

src/display/window_file_list.cc

@@ -123,7 +123,7 @@ WindowFileList::redraw() {
   if (fl->size_files() == 0 || m_canvas->height() < 2)
     return;
 
-  iterator entries[m_canvas->height() - 1];
+  std::vector<iterator> entries(m_canvas->height() - 1);
 
   unsigned int last = 0;
 

src/display/window_log.cc

@@ -37,6 +37,8 @@
 #include "config.h"
 
 #include <ctime>
+#include <torrent/torrent.h>
+#include <torrent/utils/thread_base.h>
 
 #include "canvas.h"
 #include "utils.h"
@@ -44,24 +46,25 @@
 
 namespace display {
 
-WindowLog::WindowLog(core::Log* l) :
+WindowLog::WindowLog(torrent::log_buffer* l) :
   Window(new Canvas, 0, 0, 0, extent_full, extent_static),
   m_log(l) {
 
-  m_taskUpdate.set_slot(rak::mem_fn(this, &WindowLog::receive_update)),
+  m_taskUpdate.slot() = std::tr1::bind(&WindowLog::receive_update, this);
 
-  // We're trying out scheduled tasks instead.
-  m_connUpdate = l->signal_update().connect(sigc::mem_fun(*this, &WindowLog::receive_update));
+  unsigned int signal_index = torrent::main_thread()->signal_bitfield()->add_signal(std::tr1::bind(&WindowLog::receive_update, this));
+
+  m_log->lock_and_set_update_slot(std::tr1::bind(&torrent::thread_base::send_event_signal, torrent::main_thread(), signal_index, false));
 }
 
 WindowLog::~WindowLog() {
   priority_queue_erase(&taskScheduler, &m_taskUpdate);
-  m_connUpdate.disconnect();
 }
 
 WindowLog::iterator
 WindowLog::find_older() {
-  return m_log->find_older(cachedTime - rak::timer::from_seconds(60));
+  return m_log->find_older(cachedTime.seconds() - 60);
+  // return m_log->begin();
 }
 
 void
@@ -70,11 +73,13 @@ WindowLog::redraw() {
 
   int pos = m_canvas->height();
 
-  for (core::Log::iterator itr = m_log->begin(), last = find_older(); itr != last && pos > 0; ++itr, --pos) {
-    char buffer[16];
-    print_hhmmss_local(buffer, buffer + 16, static_cast<time_t>(itr->first.seconds()));
+  for (iterator itr = m_log->end(), last = find_older(); itr != last && pos > 0; --pos) {
+    itr--;
 
-    m_canvas->print(0, pos - 1, "(%s) %s", buffer, itr->second.c_str());
+    char buffer[16];
+    print_hhmmss_local(buffer, buffer + 16, static_cast<time_t>(itr->timestamp));
+
+    m_canvas->print(0, pos - 1, "(%s) %s", buffer, itr->message.c_str());
   }
 }
 
@@ -86,11 +91,12 @@ WindowLog::receive_update() {
     return;
 
   iterator itr = find_older();
-  extent_type height = std::min(std::distance(m_log->begin(), itr), (std::iterator_traits<iterator>::difference_type)10);
+  extent_type height = std::min(std::distance(itr, (iterator)m_log->end()), (std::iterator_traits<iterator>::difference_type)10);
 
   if (height != m_maxHeight) {
     m_minHeight = height != 0 ? 1 : 0;
     m_maxHeight = height;
+    mark_dirty();
     m_slotAdjust();
 
   } else {
@@ -100,7 +106,7 @@ WindowLog::receive_update() {
   priority_queue_erase(&taskScheduler, &m_taskUpdate);
 
   if (height != 0)
-    priority_queue_insert(&taskScheduler, &m_taskUpdate, (cachedTime + rak::timer::from_seconds(30)).round_seconds());
+    priority_queue_insert(&taskScheduler, &m_taskUpdate, (cachedTime + rak::timer::from_seconds(5)).round_seconds());
 }
 
 }

src/display/window_log.h

@@ -37,9 +37,7 @@
 #ifndef RTORRENT_DISPLAY_WINDOW_LOG_H
 #define RTORRENT_DISPLAY_WINDOW_LOG_H
 
-#include <sigc++/connection.h>
-
-#include "core/log.h"
+#include <torrent/utils/log_buffer.h>
 
 #include "window.h"
 
@@ -47,9 +45,9 @@ namespace display {
 
 class WindowLog : public Window {
 public:
-  typedef core::Log::iterator iterator;
+  typedef torrent::log_buffer::const_iterator iterator;
 
-  WindowLog(core::Log* l);
+  WindowLog(torrent::log_buffer* l);
   ~WindowLog();
 
   virtual void        redraw();
@@ -59,10 +57,8 @@ public:
 private:
   inline iterator     find_older();
 
-  core::Log*          m_log;
-  sigc::connection    m_connUpdate;
-
-  rak::priority_item  m_taskUpdate;
+  torrent::log_buffer* m_log;
+  rak::priority_item   m_taskUpdate;
 };
 
 }

src/display/window_log_complete.cc

@@ -44,21 +44,17 @@
 
 namespace display {
 
-WindowLogComplete::WindowLogComplete(core::Log* l) :
+WindowLogComplete::WindowLogComplete(torrent::log_buffer* l) :
   Window(new Canvas, 0, 30, 1, extent_full, extent_full),
   m_log(l) {
-
-  // We're trying out scheduled tasks instead.
-  m_connUpdate = l->signal_update().connect(sigc::mem_fun(*this, &WindowLogComplete::receive_update));
 }
 
 WindowLogComplete::~WindowLogComplete() {
-  m_connUpdate.disconnect();
 }
 
 WindowLogComplete::iterator
 WindowLogComplete::find_older() {
-  return m_log->find_older(cachedTime - rak::timer::from_seconds(60));
+  return m_log->find_older(cachedTime.seconds() - 60);
 }
 
 void
@@ -70,28 +66,25 @@ WindowLogComplete::redraw() {
 
   int pos = m_canvas->height();
 
-  for (core::Log::iterator itr = m_log->begin(), last = m_log->end(); itr != last && pos > 0; ++itr) {
+  for (iterator itr = m_log->end(), last = m_log->begin(); itr != last && pos > 0; ) {
+    itr--;
+
     char buffer[16];
 
     // Use an arbitrary min width of 60 for allowing multiple
     // lines. This should ensure we don't mess up the display when the
     // screen is shrunk too much.
-    unsigned int timeWidth = 3 + print_hhmmss_local(buffer, buffer + 16, static_cast<time_t>(itr->first.seconds())) - buffer;
+    unsigned int timeWidth = 3 + print_hhmmss_local(buffer, buffer + 16, static_cast<time_t>(itr->timestamp)) - buffer;
 
     unsigned int logWidth  = m_canvas->width() > 60 ? (m_canvas->width() - timeWidth) : (60 - timeWidth);
-    unsigned int logHeight = (itr->second.size() + logWidth - 1) / logWidth;
+    unsigned int logHeight = (itr->message.size() + logWidth - 1) / logWidth;
 
     for (unsigned int j = logHeight; j > 0 && pos > 0; --j, --pos)
       if (j == 1)
-        m_canvas->print(0, pos - 1, "(%s) %s", buffer, itr->second.substr(0, m_canvas->width() - timeWidth).c_str());
+        m_canvas->print(0, pos - 1, "(%s) %s", buffer, itr->message.substr(0, m_canvas->width() - timeWidth).c_str());
       else
-        m_canvas->print(timeWidth, pos - 1, "%s", itr->second.substr(logWidth * (j - 1), m_canvas->width() - timeWidth).c_str());
+        m_canvas->print(timeWidth, pos - 1, "%s", itr->message.substr(logWidth * (j - 1), m_canvas->width() - timeWidth).c_str());
   }
 }
 
-void
-WindowLogComplete::receive_update() {
-  mark_dirty();
-}
-
 }

src/display/window_log_complete.h

@@ -37,9 +37,7 @@
 #ifndef RTORRENT_DISPLAY_WINDOW_LOG_COMPLETE_H
 #define RTORRENT_DISPLAY_WINDOW_LOG_COMPLETE_H
 
-#include <sigc++/connection.h>
-
-#include "core/log.h"
+#include <torrent/utils/log_buffer.h>
 
 #include "window.h"
 
@@ -47,20 +45,17 @@ namespace display {
 
 class WindowLogComplete : public Window {
 public:
-  typedef core::Log::iterator iterator;
+  typedef torrent::log_buffer::const_iterator iterator;
 
-  WindowLogComplete(core::Log* l);
+  WindowLogComplete(torrent::log_buffer* l);
   ~WindowLogComplete();
 
   virtual void     redraw();
 
-  void             receive_update();
-
 private:
   inline iterator  find_older();
 
-  core::Log*       m_log;
-  sigc::connection m_connUpdate;
+  torrent::log_buffer* m_log;
 };
 
 }

src/globals.cc

@@ -43,6 +43,4 @@ rak::timer                  cachedTime;
 rpc::ip_table_list          ip_tables;
 
 Control*                    control = NULL;
-//__thread ThreadBase* main_thread = NULL;
-ThreadMain* main_thread = NULL;
 ThreadWorker* worker_thread = NULL;

src/globals.h

@@ -41,7 +41,6 @@
 #include <rak/priority_queue_default.h>
 
 #include "thread_base.h"
-#include "thread_main.h"
 #include "thread_worker.h"
 #include "rpc/ip_table_list.h"
 
@@ -57,8 +56,6 @@ extern rak::timer                  cachedTime;
 extern rpc::ip_table_list          ip_tables;
 
 extern Control*      control;
-// extern __thread ThreadBase* main_thread; // Only use for worker threads for now.
-extern ThreadMain*   main_thread;
 extern ThreadWorker* worker_thread;
 
 #endif

src/input/bindings.h

@@ -38,9 +38,10 @@
 #define RTORRENT_INPUT_BINDINGS_H
 
 #include <map>
-#include <ncurses.h>
 #include <sigc++/functors/slot.h>
 
+#include "display/attributes.h"
+
 namespace input {
 
 class Bindings : private std::map<int, sigc::slot0<void> > {

src/input/input_event.cc

@@ -36,10 +36,11 @@
 
 #include "config.h"
 
-#include <ncurses.h>
-
 #include "input_event.h"
 
+//ncurses.h must be included last since sys/mman.h on Solaris munges ERR.
+#include <ncurses.h>
+
 namespace input {
 
 void

src/input/path_input.cc

@@ -42,7 +42,13 @@
 #include <rak/path.h>
 
 #include <sys/types.h>
-#include <sys/dir.h>
+
+#ifdef __sun__
+  #include <dirent.h>
+  #include <sys/stat.h>
+#else
+  #include <sys/dir.h>
+#endif
 
 #include "path_input.h"
 
@@ -72,7 +78,11 @@ PathInput::pressed(int key) {
 
 struct _transform_filename {
   void operator () (utils::directory_entry& entry) {
+#ifdef __sun__
+    if (entry.d_type & S_IFDIR)
+#else
     if (entry.d_type == DT_DIR)
+#endif
       entry.d_name += '/';
   }
 };

src/input/text_input.cc

@@ -36,7 +36,7 @@
 
 #include "config.h"
 
-#include <ncurses.h>
+#include "display/attributes.h"
 
 #include "text_input.h"
 

src/main.cc

@@ -46,6 +46,7 @@
 #include <torrent/http.h>
 #include <torrent/torrent.h>
 #include <torrent/exceptions.h>
+#include <torrent/poll.h>
 #include <torrent/data/chunk_utils.h>
 #include <torrent/utils/log.h>
 #include <rak/functional.h>
@@ -76,11 +77,8 @@
 #include "signal_handler.h"
 #include "option_parser.h"
 
-#include "thread_main.h"
 #include "thread_worker.h"
 
-namespace std { using namespace tr1; }
-
 void handle_sigbus(int signum, siginfo_t* sa, void* ptr);
 void do_panic(int signum);
 void print_help();
@@ -151,14 +149,29 @@ load_arg_torrents(Control* c, char** first, char** last) {
   }
 }
 
-static inline rak::timer
+static uint64_t
 client_next_timeout(Control* c) {
   if (taskScheduler.empty())
-    return c->is_shutdown_started() ? rak::timer::from_milliseconds(100) : rak::timer::from_seconds(60);
+    return (c->is_shutdown_started() ? rak::timer::from_milliseconds(100) : rak::timer::from_seconds(60)).usec();
   else if (taskScheduler.top()->time() <= cachedTime)
     return 0;
   else
-    return taskScheduler.top()->time() - cachedTime;
+    return (taskScheduler.top()->time() - cachedTime).usec();
+}
+
+static void
+client_perform() {
+  // Use throw exclusively.
+  if (control->is_shutdown_completed())
+    throw torrent::shutdown_exception();
+
+  if (control->is_shutdown_received())
+    control->handle_shutdown();
+
+  control->inc_tick();
+
+  cachedTime = rak::timer::current();
+  rak::priority_queue_perform(&taskScheduler, cachedTime);
 }
 
 int
@@ -170,14 +183,11 @@ main(int argc, char** argv) {
 
     cachedTime = rak::timer::current();
 
+    // Initialize logging:
+    torrent::log_initialize();
+
     control = new Control;
     
-    main_thread = new ThreadMain();
-    main_thread->init_thread();
-
-    worker_thread = new ThreadWorker();
-    worker_thread->init_thread();
-
     srandom(cachedTime.usec());
     srand48(cachedTime.usec());
 
@@ -195,19 +205,22 @@ main(int argc, char** argv) {
     // to process new non-socket events.
     SignalHandler::set_handler(SIGUSR1,  sigc::ptr_fun(&do_nothing));
 
-    torrent::initialize(main_thread->poll());
+    torrent::log_add_group_output(torrent::LOG_NOTICE, "important");
+    torrent::log_add_group_output(torrent::LOG_INFO, "complete");
+
+    torrent::Poll::slot_create_poll() = std::tr1::bind(&core::create_poll);
+
+    torrent::initialize();
+    torrent::main_thread()->slot_do_work() = tr1::bind(&client_perform);
+    torrent::main_thread()->slot_next_timeout() = tr1::bind(&client_next_timeout, control);
+
+    worker_thread = new ThreadWorker();
+    worker_thread->init_thread();
 
     // Initialize option handlers after libtorrent to ensure
     // torrent::ConnectionManager* are valid etc.
     initialize_commands();
 
-    // Initialize logging:
-    torrent::log_initialize();
-    torrent::log_open_output("console", std::bind(&core::Manager::push_log, control->core(), std::placeholders::_1));
-    torrent::log_add_group_output(torrent::LOG_INFO, "console");
-
-    lt_log_print(torrent::LOG_INFO, "Started logging to 'console'.");
-
     if (OptionParser::has_flag('D', argc, argv)) {
       rpc::call_command_set_value("method.use_deprecated.set", false);
       lt_log_print(torrent::LOG_WARN, "Disabled deprecated commands.");
@@ -636,18 +649,6 @@ main(int argc, char** argv) {
       CMD2_REDIRECT        ("get_session_on_completion", "session.on_completion");
       CMD2_REDIRECT_GENERIC("set_session_on_completion", "session.on_completion.set");
 
-      CMD2_REDIRECT        ("hash_read_ahead", "system.hash.read_ahead.set");
-      CMD2_REDIRECT        ("get_hash_read_ahead", "system.hash.read_ahead");
-      CMD2_REDIRECT_GENERIC("set_hash_read_ahead", "system.hash.read_ahead.set");
-
-      CMD2_REDIRECT        ("hash_interval", "system.hash.interval.set");
-      CMD2_REDIRECT        ("get_hash_interval", "system.hash.interval");
-      CMD2_REDIRECT_GENERIC("set_hash_interval", "system.hash.interval.set");
-
-      CMD2_REDIRECT        ("hash_max_tries", "system.hash.max_tries.set");
-      CMD2_REDIRECT        ("get_hash_max_tries", "system.hash.max_tries");
-      CMD2_REDIRECT_GENERIC("set_hash_max_tries", "system.hash.max_tries.set");
-
       CMD2_REDIRECT        ("check_hash", "pieces.hash.on_completion.set");
       CMD2_REDIRECT        ("get_check_hash", "pieces.hash.on_completion");
       CMD2_REDIRECT_GENERIC("set_check_hash", "pieces.hash.on_completion.set");
@@ -868,18 +869,7 @@ main(int argc, char** argv) {
 
     worker_thread->start_thread();
 
-    while (!control->is_shutdown_completed()) {
-      if (control->is_shutdown_received())
-        control->handle_shutdown();
-
-      control->inc_tick();
-
-      cachedTime = rak::timer::current();
-      rak::priority_queue_perform(&taskScheduler, cachedTime);
-
-      // Do shutdown check before poll, not after.
-      main_thread->poll_manager()->poll(client_next_timeout(control));
-    }
+    torrent::thread_base::event_loop(torrent::main_thread());
 
     control->core()->download_list()->session_save();
     control->cleanup();
@@ -895,7 +885,6 @@ main(int argc, char** argv) {
 
   delete control;
   delete worker_thread;
-  delete main_thread;
 
   return 0;
 }

src/rpc/command.h

@@ -47,9 +47,7 @@
 #include <torrent/data/file_list_iterator.h>
 
 // Move into config.h or something.
-namespace std {
-  using namespace tr1;
-}
+namespace tr1 { using namespace std::tr1; }
 
 namespace core {
   class Download;
@@ -113,7 +111,7 @@ typedef rt_triple<int, void*, void*> target_type;
 class command_base;
 
 typedef const torrent::Object (*command_base_call_type)(command_base*, target_type, const torrent::Object&);
-typedef std::function<torrent::Object (target_type, const torrent::Object&)> base_function;
+typedef tr1::function<torrent::Object (target_type, const torrent::Object&)> base_function;
 
 template <typename tmpl> struct command_base_is_valid {};
 template <command_base_call_type tmpl_func> struct command_base_is_type {};
@@ -210,9 +208,16 @@ protected:
   // within commands. E.d. callable command strings where one of the
   // arguments within the command needs to be supplied by the caller.
 
+#ifdef HAVE_CXX11
+  union {
+    base_function t_pod;
+    // char t_pod[sizeof(base_function)];
+  };
+#else
   union {
     char t_pod[sizeof(base_function)];
   };
+#endif
 };
 
 template <typename T1 = void, typename T2 = void>
@@ -245,7 +250,7 @@ command_base::_call(command_base* cmd, target_type target, Args args) {
 }
 
 #define COMMAND_BASE_TEMPLATE_TYPE(func_type, func_parm)                \
-  template <typename T, int proper = target_type_id<T>::proper_type> struct func_type { typedef std::function<func_parm> type; }; \
+  template <typename T, int proper = target_type_id<T>::proper_type> struct func_type { typedef tr1::function<func_parm> type; }; \
                                                                         \
   template <> struct command_base_is_valid<func_type<target_type>::type>                { static const int value = 1; }; \
   template <> struct command_base_is_valid<func_type<core::Download*>::type>            { static const int value = 1; }; \

src/rpc/command_scheduler.cc

@@ -71,7 +71,7 @@ CommandScheduler::insert(const std::string& key) {
     delete *itr;
 
   *itr = new CommandSchedulerItem(key);
-  (*itr)->set_slot(rak::bind_mem_fn(this, &CommandScheduler::call_item, *itr));
+  (*itr)->slot() = std::tr1::bind(&CommandScheduler::call_item, this, *itr);
 
   return itr;
 }

src/rpc/command_scheduler_item.h

@@ -39,33 +39,34 @@
 
 #include "globals.h"
 
+#include <tr1/functional>
 #include <torrent/object.h>
 
 namespace rpc {
 
 class CommandSchedulerItem {
 public:
-  typedef rak::function0<void> Slot;
+  typedef std::tr1::function<void ()> slot_void;
 
   CommandSchedulerItem(const std::string& key) : m_key(key), m_interval(0) {}
   ~CommandSchedulerItem();
 
-  bool                is_queued() const                       { return m_task.is_queued(); }
+  bool                is_queued() const           { return m_task.is_queued(); }
 
   void                enable(rak::timer t);
   void                disable();
 
-  const std::string&  key() const                             { return m_key; }
-  torrent::Object&    command()                               { return m_command; }
+  const std::string&  key() const                 { return m_key; }
+  torrent::Object&    command()                   { return m_command; }
 
   // 'interval()' should in the future return some more dynamic values.
-  uint32_t            interval() const                        { return m_interval; }
-  void                set_interval(uint32_t v)                { m_interval = v; }
+  uint32_t            interval() const            { return m_interval; }
+  void                set_interval(uint32_t v)    { m_interval = v; }
 
-  rak::timer          time_scheduled() const                  { return m_timeScheduled; }
+  rak::timer          time_scheduled() const      { return m_timeScheduled; }
   rak::timer          next_time_scheduled() const;
 
-  void                set_slot(Slot::base_type* s)            { m_task.set_slot(s); }
+  slot_void&          slot()                      { return m_task.slot(); }
 
 private:
   CommandSchedulerItem(const CommandSchedulerItem&);

src/rpc/fixed_key.h

@@ -63,7 +63,7 @@ public:
   static fixed_key_type from_string(const std::string& str)             { fixed_key_type k; k.set_c_str(str.c_str(), str.size()); return k; }
   static fixed_key_type from_raw_string(const torrent::raw_string& str) { fixed_key_type k; k.set_data(str.data(), str.size()); return k; }
 
-  bool              empty() const { return m_size == 0;; }
+  bool              empty() const { return m_size == 0; }
   size_type         size() const  { return m_size; }
 
   iterator          begin() const { return m_data; }

src/rpc/object_storage.cc

@@ -246,7 +246,7 @@ object_storage::rlookup_list(const std::string& cmd_key) {
   
   if (r_itr != m_rlookup.end())
     std::transform(r_itr->second.begin(), r_itr->second.end(), std::back_inserter(result),
-                   std::bind(&key_type::c_str, std::bind(rak::mem_ptr(&value_type::first), std::placeholders::_1)));
+                   std::tr1::bind(&key_type::c_str, std::tr1::bind(rak::mem_ptr(&value_type::first), std::tr1::placeholders::_1)));
 
   return result;
 }

src/rpc/object_storage.h

@@ -56,7 +56,7 @@ struct object_storage_node {
   char            flags;
 };
 
-typedef std::unordered_map<fixed_key_type<64>, object_storage_node, hash_fixed_key_type> object_storage_base_type;
+typedef std::tr1::unordered_map<fixed_key_type<64>, object_storage_node, hash_fixed_key_type> object_storage_base_type;
 
 class object_storage : private object_storage_base_type {
 public:

src/rpc/scgi.cc

@@ -88,7 +88,12 @@ SCgi::open_named(const std::string& filename) {
   char buffer[sizeof(sockaddr_un) + filename.size()];
   sockaddr_un* sa = reinterpret_cast<sockaddr_un*>(buffer);
 
+#ifdef __sun__
+  sa->sun_family = AF_UNIX;
+#else
   sa->sun_family = AF_LOCAL;
+#endif
+
   std::memcpy(sa->sun_path, filename.c_str(), filename.size() + 1);
 
   if (!get_fd().open_local())

src/rpc/scgi.h

@@ -59,6 +59,8 @@ public:
   SCgi() : m_logFd(-1) {}
   virtual ~SCgi();
 
+  const char*         type_name() const { return "scgi"; }
+
   void                open_port(void* sa, unsigned int length, bool dontRoute);
   void                open_named(const std::string& filename);
 

src/rpc/scgi_task.cc

@@ -185,7 +185,7 @@ SCgiTask::event_read() {
     result = write(m_parent->log_fd(), "\n---\n", sizeof("\n---\n"));
   }
 
-  lt_log_print(torrent::LOG_RPC_DEBUG, "---\n%*s\n---", m_bufferSize - std::distance(m_buffer, m_body), m_body);
+  lt_log_print_dump(torrent::LOG_RPC_DEBUG, m_body, m_bufferSize - std::distance(m_buffer, m_body), "scgi", "RPC read.", 0);
 
   // Close if the call failed, else stay open to write back data.
   if (!m_parent->receive_call(this, m_body, m_bufferSize - std::distance(m_buffer, m_body)))
@@ -246,7 +246,7 @@ SCgiTask::receive_write(const char* buffer, uint32_t length) {
     result = write(m_parent->log_fd(), "\n---\n", sizeof("\n---\n"));
   }
 
-  lt_log_print(torrent::LOG_RPC_DEBUG, "---\n%*s\n---", m_bufferSize, m_buffer);
+  lt_log_print_dump(torrent::LOG_RPC_DEBUG, m_buffer, m_bufferSize, "scgi", "RPC write.", 0);
 
   event_write();
   return true;

src/rpc/xmlrpc.cc

@@ -156,7 +156,7 @@ xmlrpc_to_target(xmlrpc_env* env, xmlrpc_value* value) {
       throw xmlrpc_error(XMLRPC_TYPE_ERROR, "Unsupported target type found.");
     }
 
-    core::Download* download = xmlrpc.get_slot_find_download()(str);
+    core::Download* download = xmlrpc.slot_find_download()(str);
 
     if (download == NULL) {
       ::free((void*)str);
@@ -186,7 +186,7 @@ xmlrpc_to_target(xmlrpc_env* env, xmlrpc_value* value) {
       if (*str == '\0' || *end_ptr != '\0')
         throw xmlrpc_error(XMLRPC_TYPE_ERROR, "Invalid index.");
 
-      target = rpc::make_target(XmlRpc::call_file, xmlrpc.get_slot_find_file()(download, index));
+      target = rpc::make_target(XmlRpc::call_file, xmlrpc.slot_find_file()(download, index));
       break;
 
     case 't':
@@ -195,7 +195,7 @@ xmlrpc_to_target(xmlrpc_env* env, xmlrpc_value* value) {
       if (*str == '\0' || *end_ptr != '\0')
         throw xmlrpc_error(XMLRPC_TYPE_ERROR, "Invalid index.");
 
-      target = rpc::make_target(XmlRpc::call_tracker, xmlrpc.get_slot_find_tracker()(download, index));
+      target = rpc::make_target(XmlRpc::call_tracker, xmlrpc.slot_find_tracker()(download, index));
       break;
 
     case 'p':
@@ -206,7 +206,7 @@ xmlrpc_to_target(xmlrpc_env* env, xmlrpc_value* value) {
       if (hash_end == end_ptr || *hash_end != '\0')
         throw xmlrpc_error(XMLRPC_TYPE_ERROR, "Not a hash string.");
 
-      target = rpc::make_target(XmlRpc::call_peer, xmlrpc.get_slot_find_peer()(download, hash));
+      target = rpc::make_target(XmlRpc::call_peer, xmlrpc.slot_find_peer()(download, hash));
       break;
     }
     default:
@@ -233,8 +233,8 @@ xmlrpc_to_index_type(int index, int callType, core::Download* download) {
   void* result;
 
   switch (callType) {
-  case XmlRpc::call_file:    result = xmlrpc.get_slot_find_file()(download, index); break;
-  case XmlRpc::call_tracker: result = xmlrpc.get_slot_find_tracker()(download, index); break;
+  case XmlRpc::call_file:    result = xmlrpc.slot_find_file()(download, index); break;
+  case XmlRpc::call_tracker: result = xmlrpc.slot_find_tracker()(download, index); break;
   default: result = NULL; break;
   }
 

src/rpc/xmlrpc.h

@@ -37,7 +37,7 @@
 #ifndef RTORRENT_RPC_XMLRPC_H
 #define RTORRENT_RPC_XMLRPC_H
 
-#include <rak/functional_fun.h>
+#include <tr1/functional>
 #include <torrent/hash_string.h>
 
 namespace core {
@@ -54,11 +54,11 @@ namespace rpc {
 
 class XmlRpc {
 public:
-  typedef rak::function1<core::Download*, const char*>                 slot_find_download;
-  typedef rak::function2<torrent::File*, core::Download*, uint32_t>    slot_find_file;
-  typedef rak::function2<torrent::Tracker*, core::Download*, uint32_t> slot_find_tracker;
-  typedef rak::function2<torrent::Peer*, core::Download*, const torrent::HashString&> slot_find_peer;
-  typedef rak::function2<bool, const char*, uint32_t>                  slot_write;
+  typedef std::tr1::function<core::Download* (const char*)>                 slot_download;
+  typedef std::tr1::function<torrent::File* (core::Download*, uint32_t)>    slot_file;
+  typedef std::tr1::function<torrent::Tracker* (core::Download*, uint32_t)> slot_tracker;
+  typedef std::tr1::function<torrent::Peer* (core::Download*, const torrent::HashString&)> slot_peer;
+  typedef std::tr1::function<bool (const char*, uint32_t)>                  slot_write;
 
   static const int dialect_generic = 0;
   static const int dialect_i8      = 1;
@@ -87,17 +87,10 @@ public:
   int                 dialect() { return m_dialect; }
   void                set_dialect(int dialect);
 
-  slot_find_download& get_slot_find_download()                                    { return m_slotFindDownload; }
-  void                set_slot_find_download(slot_find_download::base_type* slot) { m_slotFindDownload.set(slot); }
-
-  slot_find_file&     get_slot_find_file()                                        { return m_slotFindFile; }
-  void                set_slot_find_file(slot_find_file::base_type* slot)         { m_slotFindFile.set(slot); }
-
-  slot_find_tracker&  get_slot_find_tracker()                                     { return m_slotFindTracker; }
-  void                set_slot_find_tracker(slot_find_tracker::base_type* slot)   { m_slotFindTracker.set(slot); }
-
-  slot_find_peer&     get_slot_find_peer()                                        { return m_slotFindPeer; }
-  void                set_slot_find_peer(slot_find_peer::base_type* slot)         { m_slotFindPeer.set(slot); }
+  slot_download&      slot_find_download() { return m_slotFindDownload; }
+  slot_file&          slot_find_file()     { return m_slotFindFile; }
+  slot_tracker&       slot_find_tracker()  { return m_slotFindTracker; }
+  slot_peer&          slot_find_peer()     { return m_slotFindPeer; }
 
   static int64_t      size_limit();
   static void         set_size_limit(uint64_t size);
@@ -108,10 +101,10 @@ private:
 
   int                 m_dialect;
 
-  slot_find_download  m_slotFindDownload;
-  slot_find_file      m_slotFindFile;
-  slot_find_tracker   m_slotFindTracker;
-  slot_find_peer      m_slotFindPeer;
+  slot_download       m_slotFindDownload;
+  slot_file           m_slotFindFile;
+  slot_tracker        m_slotFindTracker;
+  slot_peer           m_slotFindPeer;
 };
 
 }

src/signal_handler.cc

@@ -41,6 +41,11 @@
 #include "rak/error_number.h"
 #include "signal_handler.h"
 
+#ifdef __sun__
+#include <iso/signal_iso.h>
+//extern "C" void (*signal (int sig, void (*disp)(int)))(int);
+#endif
+
 SignalHandler::Slot SignalHandler::m_handlers[HIGHEST_SIGNAL];
 
 void

src/thread_base.cc

@@ -46,6 +46,7 @@
 #include <unistd.h>
 #include <rak/error_number.h>
 #include <torrent/exceptions.h>
+#include <torrent/torrent.h>
 #include <torrent/utils/log.h>
 
 #include "globals.h"
@@ -82,7 +83,7 @@ public:
       throw torrent::internal_error("Overflowed thread_queue.");
 
     __sync_bool_compare_and_swap(itr, NULL, v);
-    __sync_bool_compare_and_swap(&m_lock, 1, 0);
+    unlock();
   }
 
   value_type* copy_and_clear(value_type* dest) {
@@ -107,78 +108,31 @@ public:
 
 void throw_shutdown_exception() { throw torrent::shutdown_exception(); }
 
-ThreadBase::ThreadBase() :
-  m_state(STATE_UNKNOWN),
-  m_pollManager(NULL) {
-  // Init the poll manager in a special init function called by the
-  // thread itself. Need to be careful with what external stuff
-  // create_poll_manager calls in that case.
-  std::memset(&m_thread, 0, sizeof(pthread_t));
-
-  m_taskShutdown.set_slot(rak::ptr_fn(&throw_shutdown_exception));
+ThreadBase::ThreadBase() {
+  m_taskShutdown.slot() = std::tr1::bind(&throw_shutdown_exception);
 
   m_threadQueue = new thread_queue_hack;
 }
 
 ThreadBase::~ThreadBase() {
-  delete m_pollManager;
   delete m_threadQueue;
 }
 
-void
-ThreadBase::start_thread() {
-  if (m_state != STATE_INITIALIZED ||
-      pthread_create(&m_thread, NULL, (pthread_func)&ThreadBase::event_loop, this))
-    throw torrent::internal_error("Failed to create thread.");
-}
-
+// Move to libtorrent...
 void
 ThreadBase::stop_thread(ThreadBase* thread) {
   if (!thread->m_taskShutdown.is_queued())
     priority_queue_insert(&thread->m_taskScheduler, &thread->m_taskShutdown, cachedTime);
 }
 
-inline rak::timer
-ThreadBase::client_next_timeout() {
+int64_t
+ThreadBase::next_timeout_usec() {
   if (m_taskScheduler.empty())
-    return rak::timer::from_seconds(600);
+    return rak::timer::from_seconds(600).usec();
   else if (m_taskScheduler.top()->time() <= cachedTime)
     return 0;
   else
-    return m_taskScheduler.top()->time() - cachedTime;
-}
-
-void*
-ThreadBase::event_loop(ThreadBase* threadBase) {
-  // Setup stuff...
-  threadBase->m_state = STATE_ACTIVE;
-
-  // Set local poll and priority queue.
-  
-  try {
-
-    while (true) {
-      // Check for new queued items set by other threads.
-      if (!threadBase->m_threadQueue->empty())
-        threadBase->call_queued_items();
-
-      //     // Remember to add global lock thing to the main poll loop ++.
-
-      rak::priority_queue_perform(&threadBase->m_taskScheduler, cachedTime);
-
-      threadBase->m_pollManager->poll_simple(threadBase->client_next_timeout());
-    }
-
-  } catch (torrent::shutdown_exception& e) {
-    acquire_global_lock();
-    lt_log_print(torrent::LOG_THREAD_NOTICE, "Shutting down thread.");
-    release_global_lock();
-  }
-
-  threadBase->m_state = STATE_INACTIVE;
-  __sync_synchronize();
-
-  return NULL;
+    return (m_taskScheduler.top()->time() - cachedTime).usec();
 }
 
 void
@@ -191,6 +145,15 @@ ThreadBase::call_queued_items() {
     (*first++)(this);
 }
 
+void
+ThreadBase::call_events() {
+  // Check for new queued items set by other threads.
+  if (!m_threadQueue->empty())
+    call_queued_items();
+
+  rak::priority_queue_perform(&m_taskScheduler, cachedTime);
+}
+
 void
 ThreadBase::queue_item(thread_base_func newFunc) {
   m_threadQueue->push_back(newFunc);
@@ -205,7 +168,7 @@ ThreadBase::interrupt_main_polling() {
   int sleep_length = 0;
 
   while (ThreadBase::is_main_polling()) {
-    pthread_kill(main_thread->m_thread, SIGUSR1);
+    pthread_kill(torrent::main_thread()->pthread(), SIGUSR1);
 
     if (!ThreadBase::is_main_polling())
       return;

src/thread_base.h

@@ -39,42 +39,26 @@
 
 #include <pthread.h>
 #include <sys/types.h>
-#include <torrent/thread_base.h>
+#include <torrent/utils/thread_base.h>
 
 #include "rak/priority_queue_default.h"
 #include "core/poll_manager.h"
 
-struct thread_queue_hack;
-
 // Move this class to libtorrent.
 
-struct thread_queue_hack;
+class thread_queue_hack;
 
-class ThreadBase : public torrent::ThreadBase {
+class ThreadBase : public torrent::thread_base {
 public:
   typedef rak::priority_queue_default priority_queue;
   typedef void (*thread_base_func)(ThreadBase*);
-  typedef void* (*pthread_func)(void*);
-
-  enum state_type {
-    STATE_UNKNOWN,
-    STATE_INITIALIZED,
-    STATE_ACTIVE,
-    STATE_INACTIVE
-  };
 
   ThreadBase();
   virtual ~ThreadBase();
 
-  bool                is_active() const { return m_state == STATE_ACTIVE; }
-
-  torrent::Poll*      poll() { return m_pollManager->get_torrent_poll(); }
-  core::PollManager*  poll_manager() { return m_pollManager; }
   priority_queue&     task_scheduler() { return m_taskScheduler; }
 
-  virtual void        init_thread() = 0;
-
-  void                start_thread();
+  // Throw torrent::shutdown_exception to stop the thread.
   static void         stop_thread(ThreadBase* thread);
 
   // ATM, only interaction with a thread's allowed by other threads is
@@ -82,8 +66,6 @@ public:
 
   void                queue_item(thread_base_func newFunc);
 
-  static void*        event_loop(ThreadBase* threadBase);
-
   // Only call this when global lock has been acquired, as it checks
   // ThreadBase::is_main_polling() which is only guaranteed to remain
   // 'false' if global lock keeps main thread from entering polling
@@ -93,18 +75,15 @@ public:
   static void         interrupt_main_polling();
 
 protected:
-  inline rak::timer   client_next_timeout();
+  int64_t             next_timeout_usec();
 
   void                call_queued_items();
+  virtual void        call_events();
 
   // TODO: Add thread name.
 
-  pthread_t           m_thread;
-  state_type          m_state;
-
   // The timer needs to be sync'ed when updated...
 
-  core::PollManager*          m_pollManager;
   rak::priority_queue_default m_taskScheduler;
 
   rak::priority_item  m_taskShutdown;

src/thread_main.cc

@@ -1,57 +0,0 @@
-// rTorrent - BitTorrent library
-// 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 "thread_main.h"
-#include "globals.h"
-
-#include <torrent/exceptions.h>
-
-ThreadMain::~ThreadMain() {
-}
-
-void
-ThreadMain::init_thread() {
-  // The main thread always holds the lock while running.
-  acquire_global_lock();
-
-  m_pollManager = core::PollManager::create_poll_manager();
-  m_pollManager->get_torrent_poll()->set_flags(torrent::Poll::flag_waive_global_lock);
-
-  m_state = STATE_INITIALIZED;
-  m_thread = pthread_self();
-}

src/thread_main.h

@@ -1,55 +0,0 @@
-// rTorrent - BitTorrent library
-// 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
-
-#ifndef RTORRENT_THREAD_MAIN_H
-#define RTORRENT_THREAD_MAIN_H
-
-#include "thread_base.h"
-
-// Check if cacheline aligned with inheritance ends up taking two
-// cachelines.
-
-class lt_cacheline_aligned ThreadMain : public ThreadBase {
-public:
-  ThreadMain() {}
-  ~ThreadMain();
-
-  virtual void        init_thread();
-
-private:
-};
-
-#endif

src/thread_worker.cc

@@ -52,7 +52,6 @@
 #include "rpc/parse_commands.h"
 
 ThreadWorker::ThreadWorker() {
-  m_taskTouchLog.set_slot(rak::mem_fn(this, &ThreadWorker::task_touch_log));
 }
 
 ThreadWorker::~ThreadWorker() {
@@ -62,8 +61,7 @@ ThreadWorker::~ThreadWorker() {
 
 void
 ThreadWorker::init_thread() {
-  m_pollManager = core::PollManager::create_poll_manager();
-
+  m_poll = core::create_poll();
   m_state = STATE_INITIALIZED;
 }
 
@@ -101,14 +99,6 @@ ThreadWorker::start_scgi(ThreadBase* baseThread) {
   thread->m_safe.scgi->activate();
 }
 
-void
-ThreadWorker::start_log_counter(ThreadBase* baseThread) {
-  ThreadWorker* thread = (ThreadWorker*)baseThread;
-
-  if (!thread->m_taskTouchLog.is_queued())
-    priority_queue_insert(&thread->m_taskScheduler, &thread->m_taskTouchLog, cachedTime);
-}
-
 void
 ThreadWorker::msg_change_xmlrpc_log(ThreadBase* baseThread) {
   ThreadWorker* thread = (ThreadWorker*)baseThread;
@@ -140,12 +130,3 @@ ThreadWorker::change_xmlrpc_log() {
 
   control->core()->push_log_std("Logging XMLRPC events to '" + m_xmlrpcLog + "'.");
 }
-
-void
-ThreadWorker::task_touch_log() {
-  priority_queue_insert(&m_taskScheduler, &m_taskTouchLog, cachedTime + rak::timer::from_seconds(1));
-
-  acquire_global_lock();
-  control->core()->push_log("Tick Tock.");
-  release_global_lock();
-}

src/thread_worker.h

@@ -53,6 +53,8 @@ public:
   ThreadWorker();
   ~ThreadWorker();
 
+  const char*         name() const { return "worker_rtorrent"; }
+
   virtual void        init_thread();
 
   rpc::SCgi*          scgi() { return m_safe.scgi; }
@@ -61,7 +63,6 @@ public:
   void                set_xmlrpc_log(const std::string& filename);
 
   static void         start_scgi(ThreadBase* thread);
-  static void         start_log_counter(ThreadBase* thread);
   static void         msg_change_xmlrpc_log(ThreadBase* thread);
 
 private:
@@ -75,7 +76,6 @@ private:
     rpc::SCgi* scgi;
   };
 
-  rak::priority_item  m_taskTouchLog;
   safe_type           m_safe;
 
   // The following types shall only be modified while holding the

src/ui/download_list.cc

@@ -74,10 +74,10 @@ DownloadList::DownloadList() :
 
   m_uiArray[DISPLAY_DOWNLOAD]      = NULL;
   m_uiArray[DISPLAY_DOWNLOAD_LIST] = new ElementDownloadList();
-  m_uiArray[DISPLAY_LOG]           = new ElementLogComplete(&control->core()->get_log_complete());
+  m_uiArray[DISPLAY_LOG]           = new ElementLogComplete(control->core()->log_complete());
   m_uiArray[DISPLAY_STRING_LIST]   = new ElementStringList();
 
-  m_windowLog                      = new WLog(&control->core()->get_log_important());
+  m_windowLog                      = new WLog(control->core()->log_important());
 
   setup_keys();
 }

src/ui/element_log_complete.cc

@@ -37,6 +37,8 @@
 #include "config.h"
 
 #include <torrent/exceptions.h>
+#include <torrent/torrent.h>
+#include <torrent/utils/thread_base.h>
 
 #include "display/frame.h"
 #include "display/manager.h"
@@ -48,9 +50,13 @@
 
 namespace ui {
 
-ElementLogComplete::ElementLogComplete(core::Log* l) :
+ElementLogComplete::ElementLogComplete(torrent::log_buffer* l) :
   m_window(NULL),
   m_log(l) {
+
+  unsigned int signal_index = torrent::main_thread()->signal_bitfield()->add_signal(std::tr1::bind(&ElementLogComplete::received_update, this));
+
+  m_log->lock_and_set_update_slot(std::tr1::bind(&torrent::thread_base::send_event_signal, torrent::main_thread(), signal_index, false));
 }
 
 void
@@ -86,4 +92,10 @@ ElementLogComplete::window() {
   return m_window;
 }
 
+void
+ElementLogComplete::received_update() {
+  if (m_window != NULL)
+    m_window->mark_dirty();
+}
+
 }

src/ui/element_log_complete.h

@@ -37,7 +37,7 @@
 #ifndef RTORRENT_UI_ELEMENT_LOG_COMPLETE_H
 #define RTORRENT_UI_ELEMENT_LOG_COMPLETE_H
 
-#include "core/log.h"
+#include <torrent/utils/log_buffer.h>
 
 #include "element_base.h"
 
@@ -53,7 +53,7 @@ class ElementLogComplete : public ElementBase {
 public:
   typedef display::WindowLogComplete    WLogComplete;
 
-  ElementLogComplete(core::Log* l);
+  ElementLogComplete(torrent::log_buffer* l);
 
   void                activate(display::Frame* frame, bool focus = true);
   void                disable();
@@ -61,9 +61,11 @@ public:
   display::Window*    window();
 
 private:
+  void                received_update();
+
   WLogComplete*       m_window;
   
-  core::Log*          m_log;
+  torrent::log_buffer* m_log;
 };
 
 }

src/utils/directory.cc

@@ -42,6 +42,10 @@
 #include <rak/path.h>
 #include <torrent/exceptions.h>
 
+#ifdef __sun__
+#include <sys/stat.h>
+#endif
+
 #include "directory.h"
 
 namespace utils {
@@ -69,6 +73,9 @@ Directory::update(int flags) {
     return false;
 
   struct dirent* entry;
+#ifdef __sun__
+  struct stat s;
+#endif
 
   while ((entry = readdir(d)) != NULL) {
     if ((flags & update_hide_dot) && entry->d_name[0] == '.')
@@ -76,9 +83,16 @@ Directory::update(int flags) {
 
     iterator itr = base_type::insert(end(), value_type());
 
+#ifdef __sun__
+    stat(entry->d_name, &s);
+    itr->d_fileno = entry->d_ino;
+    itr->d_reclen = 0;
+    itr->d_type = s.st_mode;
+#else
     itr->d_fileno = entry->d_fileno;
     itr->d_reclen = entry->d_reclen;
     itr->d_type   = entry->d_type;
+#endif
 
 #ifdef DIRENT_NAMLEN_EXISTS_FOOBAR
     itr->d_name   = std::string(entry->d_name, entry->d_name + entry->d_namlen);

src/utils/directory.h

@@ -49,7 +49,7 @@ struct directory_entry {
 
   // The name and types should match POSIX.
   uint32_t            d_fileno;
-  uint32_t            d_reclen;
+  uint32_t            d_reclen; //Not used. Messes with Solaris.
   uint8_t             d_type;
 
   std::string         d_name;

test/Makefile.am

@@ -1,13 +1,13 @@
 TESTS = rtorrentTest
 check_PROGRAMS = $(TESTS)
 rtorrentTest_LDADD = \
+	../src/libsub_root.a \
 	../src/ui/libsub_ui.a \
 	../src/core/libsub_core.a \
 	../src/display/libsub_display.a \
 	../src/input/libsub_input.a \
 	../src/rpc/libsub_rpc.a \
-	../src/utils/libsub_utils.a \
-	../src/libsub_root.a
+	../src/utils/libsub_utils.a
 
 rtorrentTest_SOURCES = \
 	rpc/command_test.cc \

test/rpc/command_map_test.cc

@@ -3,7 +3,7 @@
 #include "command_helpers.h"
 #include "rpc/command_map.h"
 
-#import "command_map_test.h"
+#include "command_map_test.h"
 
 CPPUNIT_TEST_SUITE_REGISTRATION(CommandMapTest);
 
@@ -21,7 +21,7 @@ torrent::Object cmd_test_any_string(__UNUSED rpc::target_type target, const std:
 void
 CommandMapTest::test_basics() {
   CMD2_ANY("test_a", &cmd_test_map_a);
-  CMD2_ANY("test_b", std::bind(&cmd_test_map_b, std::placeholders::_1, std::placeholders::_2, (uint64_t)2));
+  CMD2_ANY("test_b", tr1::bind(&cmd_test_map_b, tr1::placeholders::_1, tr1::placeholders::_2, (uint64_t)2));
   CMD2_ANY_STRING("any_string", &cmd_test_any_string);
 
   CPPUNIT_ASSERT(m_map.call_command("test_a", (int64_t)1).as_value() == 1);

test/rpc/command_slot_test.cc

@@ -4,7 +4,7 @@
 #include <torrent/object.h>
 #include "rpc/command_map.h"
 
-#import "command_slot_test.h"
+#include "command_slot_test.h"
 
 CPPUNIT_TEST_SUITE_REGISTRATION(CommandSlotTest);
 
@@ -25,7 +25,7 @@ CommandSlotTest::test_basics() {
 //   test_any.set_function<rpc::any_function>(&cmd_test_a);
 //   CPPUNIT_ASSERT(rpc::command_base_call_any(&test_any, rpc::make_target(), (int64_t)1).as_value() == 1);
 
-//   test_any.set_function<rpc::any_function>(std::bind(&cmd_test_b, std::placeholders::_1, std::placeholders::_2, (uint64_t)2));
+//   test_any.set_function<rpc::any_function>(tr1::bind(&cmd_test_b, tr1::placeholders::_1, tr1::placeholders::_2, (uint64_t)2));
 //   CPPUNIT_ASSERT(rpc::command_base_call_any(&test_any, rpc::make_target(), (int64_t)1).as_value() == 2);
 
 //   test_any.set_function<rpc::any_list_function>(&cmd_test_list);

test/rpc/command_test.cc

@@ -1,6 +1,6 @@
 #include "config.h"
 
-#import "command_test.h"
+#include "command_test.h"
 
 CPPUNIT_TEST_SUITE_REGISTRATION(CommandTest);
 

test/rpc/object_storage_test.cc

@@ -1,6 +1,6 @@
 #include "config.h"
 
-#import "object_storage_test.h"
+#include "object_storage_test.h"
 
 CPPUNIT_TEST_SUITE_REGISTRATION(ObjectStorageTest);
 

test/src/command_dynamic_test.cc

@@ -2,7 +2,7 @@
 
 #include <iostream>
 
-#import "command_dynamic_test.h"
+#include "command_dynamic_test.h"
 
 #include "rpc/parse_commands.h"
 #include "control.h"