--- lua-recursor4.cc.orig	2016-09-06 12:50:29 UTC

+++ lua-recursor4.cc

@@ -263,8 +263,8 @@ RecursorLua4::RecursorLua4(const std::st

       return DNSName(boost::get<const DNSName>(dom));

   });

   d_lw->registerFunction("isPartOf", &DNSName::isPartOf);

-  d_lw->registerFunction("countLabels", &DNSName::countLabels);

-  d_lw->registerFunction("wirelength", &DNSName::wirelength);

+  d_lw->registerFunction<unsigned int(DNSName::*)()>("countLabels", [](const DNSName& name) { return name.countLabels(); });

+  d_lw->registerFunction<size_t(DNSName::*)()>("wirelength", [](const DNSName& name) { return name.wirelength(); });

   d_lw->registerFunction<bool(DNSName::*)(const std::string&)>(

     "equal",

      [](const DNSName& lhs, const std::string& rhs) {

@@ -285,9 +285,9 @@ RecursorLua4::RecursorLua4(const std::st

     } );

   d_lw->registerFunction<bool(ComboAddress::*)()>("isIPv4", [](const ComboAddress& ca) { return ca.sin4.sin_family == AF_INET; });

   d_lw->registerFunction<bool(ComboAddress::*)()>("isIPv6", [](const ComboAddress& ca) { return ca.sin4.sin_family == AF_INET6; });

-  d_lw->registerFunction("isMappedIPv4", &ComboAddress::isMappedIPv4);

-  d_lw->registerFunction("mapToIPv4", &ComboAddress::mapToIPv4);

-  d_lw->registerFunction("truncate", &ComboAddress::truncate);

+  d_lw->registerFunction<bool(ComboAddress::*)()>("isMappedIPv4", [](const ComboAddress& ca) { return ca.isMappedIPv4(); });

+  d_lw->registerFunction<ComboAddress(ComboAddress::*)()>("mapToIPv4", [](const ComboAddress& ca) { return ca.mapToIPv4(); });

+  d_lw->registerFunction<void(ComboAddress::*)(unsigned int)>("truncate", [](ComboAddress& ca, unsigned int bits) { ca.truncate(bits); });

   d_lw->writeFunction("newCA", [](const std::string& a) { return ComboAddress(a); });

   typedef std::unordered_set<ComboAddress,ComboAddress::addressOnlyHash,ComboAddress::addressOnlyEqual> cas_t;

rec: Add support for boost::context >= 1.61

https://github.com/PowerDNS/pdns/commits/64413f6afd9b/pdns/mtasker_fcontext.cc

--- mtasker_fcontext.cc.orig	2016-09-06 12:50:29 UTC

+++ mtasker_fcontext.cc

@@ -23,14 +23,15 @@

 #include <exception>

 #include <cassert>

 #include <type_traits>

-#if BOOST_VERSION > 106100

-#include <boost/context/detail/fcontext.hpp>

-#else

-#include <boost/context/fcontext.hpp>

-#endif

 #include <boost/version.hpp>

-

+#if BOOST_VERSION < 106100

+#include <boost/context/fcontext.hpp>

 using boost::context::make_fcontext;

+#else

+#include <boost/context/detail/fcontext.hpp>

+using boost::context::detail::make_fcontext;

+#endif /* BOOST_VERSION < 106100 */

+

 #if BOOST_VERSION < 105600

 /* Note: This typedef means functions taking fcontext_t*, like jump_fcontext(),

@@ -61,8 +62,15 @@ jump_fcontext (fcontext_t* const ofc, fc

     }

 }

 #else

+

+#if BOOST_VERSION < 106100

 using boost::context::fcontext_t;

 using boost::context::jump_fcontext;

+#else

+using boost::context::detail::fcontext_t;

+using boost::context::detail::jump_fcontext;

+using boost::context::detail::transfer_t;

+#endif /* BOOST_VERSION < 106100 */

 static_assert (std::is_pointer<fcontext_t>::value,

                "Boost Context has changed the fcontext_t type again :-(");

@@ -72,7 +80,9 @@ static_assert (std::is_pointer<fcontext_

  * jump. args_t simply provides a way to pass more by reference.

  */

 struct args_t {

+#if BOOST_VERSION < 106100

     fcontext_t prev_ctx = nullptr;

+#endif

     pdns_ucontext_t* self = nullptr;

     boost::function<void(void)>* work = nullptr;

 };

@@ -80,7 +90,11 @@ struct args_t {

 extern "C" {

 static

 void

+#if BOOST_VERSION < 106100

 threadWrapper (intptr_t const xargs) {

+#else

+threadWrapper (transfer_t const t) {

+#endif

     /* Access the args passed from pdns_makecontext, and copy them directly from

      * the calling stack on to ours (we're now using the MThreads stack).

      * This saves heap allocating an args object, at the cost of an extra

@@ -90,11 +104,28 @@ threadWrapper (intptr_t const xargs) {

      * the behaviour of the System V implementation, which can inherently only

      * be passed ints and pointers.

      */

+#if BOOST_VERSION < 106100

     auto args = reinterpret_cast<args_t*>(xargs);

+#else

+    auto args = reinterpret_cast<args_t*>(t.data);

+#endif

     auto ctx = args->self;

     auto work = args->work;

+    /* we switch back to pdns_makecontext() */

+#if BOOST_VERSION < 106100

     jump_fcontext (reinterpret_cast<fcontext_t*>(&ctx->uc_mcontext),

                    static_cast<fcontext_t>(args->prev_ctx), 0);

+#else

+    transfer_t res = jump_fcontext (t.fctx, 0);

+    /* we got switched back from pdns_swapcontext() */

+    if (res.data) {

+      /* if res.data is not a nullptr, it holds a pointer to the context

+         we just switched from, and we need to fill it to be able to

+         switch back to it later. */

+      fcontext_t* ptr = static_cast<fcontext_t*>(res.data);

+      *ptr = res.fctx;

+    }

+#endif

     args = nullptr;

     try {

@@ -106,9 +137,14 @@ threadWrapper (intptr_t const xargs) {

     /* Emulate the System V uc_link feature. */

     auto const next_ctx = ctx->uc_link->uc_mcontext;

+#if BOOST_VERSION < 106100

     jump_fcontext (reinterpret_cast<fcontext_t*>(&ctx->uc_mcontext),

                    static_cast<fcontext_t>(next_ctx),

                    static_cast<bool>(ctx->exception));

+#else

+    jump_fcontext (static_cast<fcontext_t>(next_ctx), 0);

+#endif

+

 #ifdef NDEBUG

     __builtin_unreachable();

 #endif

@@ -129,10 +165,27 @@ pdns_ucontext_t::~pdns_ucontext_t

 void

 pdns_swapcontext

 (pdns_ucontext_t& __restrict octx, pdns_ucontext_t const& __restrict ctx) {

+  /* we either switch back to threadwrapper() if it's the first time,

+     or we switch back to pdns_swapcontext(),

+     in both case we will be returning from a call to jump_fcontext(). */

+#if BOOST_VERSION < 106100

     if (jump_fcontext (reinterpret_cast<fcontext_t*>(&octx.uc_mcontext),

                        static_cast<fcontext_t>(ctx.uc_mcontext), 0)) {

         std::rethrow_exception (ctx.exception);

     }

+#else

+  transfer_t res = jump_fcontext (static_cast<fcontext_t>(ctx.uc_mcontext), &octx.uc_mcontext);

+  if (res.data) {

+    /* if res.data is not a nullptr, it holds a pointer to the context

+       we just switched from, and we need to fill it to be able to

+       switch back to it later. */

+    fcontext_t* ptr = static_cast<fcontext_t*>(res.data);

+    *ptr = res.fctx;

+  }

+  if (ctx.exception) {

+    std::rethrow_exception (ctx.exception);

+  }

+#endif

 }

 void

@@ -146,7 +199,15 @@ pdns_makecontext

     args_t args;

     args.self = &ctx;

     args.work = &start;

+    /* jumping to threadwrapper */

+#if BOOST_VERSION < 106100

     jump_fcontext (reinterpret_cast<fcontext_t*>(&args.prev_ctx),

                    static_cast<fcontext_t>(ctx.uc_mcontext),

                    reinterpret_cast<intptr_t>(&args));

+#else

+    transfer_t res = jump_fcontext (static_cast<fcontext_t>(ctx.uc_mcontext),

+                                    &args);

+    /* back from threadwrapper, updating the context */

+    ctx.uc_mcontext = res.fctx;

+#endif

 }