From ss at comp.lancs.ac.uk  Mon Apr 11 03:10:43 2011
From: ss at comp.lancs.ac.uk (Steven Simpson)
Date: Mon, 11 Apr 2011 11:10:43 +0100
Subject: [Xorp-hackers] [PATCH] Supporting
	asynchronous	method	implementations
In-Reply-To: <4D9462E6.2020704@comp.lancs.ac.uk>
References: <4D500B54.6030707@comp.lancs.ac.uk>	<1300366693-3015-1-git-send-email-ss@comp.lancs.ac.uk>	<4D893549.1090907@candelatech.com>
	<4D9462E6.2020704@comp.lancs.ac.uk>
Message-ID: <4DA2D3A3.7080302@comp.lancs.ac.uk>

Hi again,

On 31/03/11 12:17, Steven Simpson wrote:
> So, XrlCmdMap retains its conditional
> declarations, but XrlDispatcher's interface is now unconditionally
> asynchronous.  I think if I went further, and made XrlCmdMap
> unconditionally asynchronous, it would unconditionally spill into the
> tgt-gen-erated code, and bloat the binaries.

I noticed that enable_tests=True wouldn't work with async, as the files
in xorp/libxipc/tests use XrlCmdMap directly.  I was going to go through
them to make them conditional on XORP_ENABLE_ASYNC_SERVER, but I
realised I could take XrlCmdMap a little further into being fully
asynchronous, by making it accept synchronous command implementations,
and making asynchronous ones out of them.

To start with, the two conditional forms of XrlRecvCallback are now
expressed by XrlRecvAsyncCallback and XrlRecvSyncCallback.  The only
places where the conditional declarations are now used are in
tgt-gen-erated code.

I had hoped to change this:

XrlCmdMap::add_handler(const string&, const XrlRecvCallback&);

?into this:

XrlCmdMap::add_handler(const string&, const XrlRecvAsyncCallback&);
XrlCmdMap::add_handler(const string&, const XrlRecvSyncCallback&);

?and get the second one to transform its argument and then call the
first, but you get compilation problems when XrlDispatcher/XrlRouter try
to override one of them (something about the overriding declaration
hiding the original).  So, instead, I've renamed the overridden method
to add_handler_internal, then created overloaded inline add_handlers
which delegate to add_handler_internal.

As before, enable_async_server=True increases stripped binaries by 2MB. 
I ran [scons check] with [enable_tests=True ignore_check_errors=True],
and there are no differences between lines containing "Tests".  Of lines
containing "Test", there is just one extra line in the async version:

[ 2011/04/07 18:33:29.605291  WARNING test_peer:10200 XrlTestPeerTarget 
obj/i686-pc-linux-gnu/xrl/targets/test_peer_base.cc:971 
callback_test_peer_0_1_send ] Handling method for test_peer/0.1/send failed: 
XrlCmdError 102 Command failed Not connected

I'm wondering whether it's significant or not.  It appears under TEST3,
which then says it succeeded.

Anyway, I'll send another patch...

Cheers,

Steven

-- 





From ss at comp.lancs.ac.uk  Mon Apr 11 03:25:21 2011
From: ss at comp.lancs.ac.uk (ss at comp.lancs.ac.uk)
Date: Mon, 11 Apr 2011 11:25:21 +0100
Subject: [Xorp-hackers] [PATCH] XrlCmdEntry provides method to convert
	synchronous function into asynchronous one. XrlCmdMap made
	full asynchronous,
	but extended to accept synchronous command implementations,
	from which it build asynchronous ones. Conditional declarations are
	now only used by tgt-gen.
In-Reply-To: <4DA2D3A3.7080302@comp.lancs.ac.uk>
References: <4DA2D3A3.7080302@comp.lancs.ac.uk>
Message-ID: <1302517521-2484-1-git-send-email-ss@comp.lancs.ac.uk>

From: Steven Simpson <ss at comp.lancs.ac.uk>

XrlCmdMap::add_handler renamed to *_internal; also where inherited by
XrlDispatcher and XrlRouter.  New add_handler methods added to allow
acceptance of both sync and async command implementations.

Async conditionals dropped from FinderMessengerBase and XrlDispatcher,
as they now use the new unconditionally asynchronous XrlCmdMap
interface.

Signed-off-by: Steven Simpson <ss at comp.lancs.ac.uk>
---
 xorp/libxipc/finder_messenger.cc |    6 ---
 xorp/libxipc/xrl_cmd_map.cc      |   11 ++++-
 xorp/libxipc/xrl_cmd_map.hh      |   85 +++++++++++++++++++++++++++++++++-----
 xorp/libxipc/xrl_dispatcher.cc   |   12 -----
 xorp/libxipc/xrl_router.cc       |    5 +-
 xorp/libxipc/xrl_router.hh       |    3 +-
 6 files changed, 89 insertions(+), 33 deletions(-)

diff --git a/xorp/libxipc/finder_messenger.cc b/xorp/libxipc/finder_messenger.cc
index 5ee4353..63db5db 100644
--- a/xorp/libxipc/finder_messenger.cc
+++ b/xorp/libxipc/finder_messenger.cc
@@ -97,14 +97,8 @@ FinderMessengerBase::dispatch_xrl(uint32_t seqno, const Xrl& xrl)
     if (manager())
 	manager()->messenger_active_event(this);
     
-#ifdef XORP_ENABLE_ASYNC_SERVER
     ce->dispatch(xrl.args(),
 		 callback(this, &FinderMessengerBase::dispatch_xrl_cb, seqno));
-#else
-    XrlArgs reply_args;
-    XrlCmdError e = ce->dispatch(xrl.args(), &reply_args);
-    dispatch_xrl_cb(e, &reply_args, seqno);
-#endif
 
     // Announce we've dispatched xrl
     if (manager())
diff --git a/xorp/libxipc/xrl_cmd_map.cc b/xorp/libxipc/xrl_cmd_map.cc
index 487f68e..38bb639 100644
--- a/xorp/libxipc/xrl_cmd_map.cc
+++ b/xorp/libxipc/xrl_cmd_map.cc
@@ -28,6 +28,14 @@
 
 #include "xrl_cmd_map.hh"
 
+void
+XrlCmdEntry::invoke_sync(const XrlArgs& in, XrlRespCallback out,
+			 XrlRecvSyncCallback impl)
+{
+    XrlArgs out_args;
+    XrlCmdError e = impl->dispatch(in, &out_args);
+    out->dispatch(e, &out_args);
+}
 
 bool
 XrlCmdMap::add_handler(const XrlCmdEntry& cmd)
@@ -42,7 +50,8 @@ XrlCmdMap::add_handler(const XrlCmdEntry& cmd)
 }
 
 bool
-XrlCmdMap::add_handler(const string& cmd, const XrlRecvCallback& rcb)
+XrlCmdMap::add_handler_internal(const string& cmd,
+				const XrlRecvAsyncCallback& rcb)
 {
     return add_handler(XrlCmdEntry(cmd, rcb));
 }
diff --git a/xorp/libxipc/xrl_cmd_map.hh b/xorp/libxipc/xrl_cmd_map.hh
index 33b8d7d..8566cff 100644
--- a/xorp/libxipc/xrl_cmd_map.hh
+++ b/xorp/libxipc/xrl_cmd_map.hh
@@ -32,54 +32,108 @@
 #include "xrl.hh"
 #include "xrl_error.hh"
 
+
+
+
+
+// This the the original, synchronous, command callback.
+// Out-arguments and error code must be set by the time the function
+// returns.
+typedef
+XorpCallback2<const XrlCmdError, const XrlArgs&, XrlArgs*>::RefPtr
+XrlRecvSyncCallback;
+
+// This is the type of callback that a command implementation must
+// call if it wants to operate asynchronously.
+typedef
+XorpCallback2<void, const XrlCmdError &, const XrlArgs *>::RefPtr
+XrlRespCallback;
+
+// This is the new, asynchronous, command callback.  No errors are
+// returned, nor out-arguments passed.  Instead, the XrlRespCallback
+// is invoked with the results.
+typedef
+XorpCallback2<void, const XrlArgs&, XrlRespCallback>::RefPtr
+XrlRecvAsyncCallback;
+
+
+
+// We define some types depending on whether asynchronous
+// implementations are allowed.
 #ifdef XORP_ENABLE_ASYNC_SERVER
+
+// Asynchronous implementations do not return anything.
 typedef void XrlCmdRT;
 
+// To report an error, invoke the callback, and stop.
 #define XRL_CMD_RETURN_ERROR(OUT, ERR)	\
     do {				\
 	(OUT)->dispatch((ERR), NULL);	\
 	return;				\
     } while (0)
 
-typedef
-XorpCallback2<void, const XrlCmdError &, const XrlArgs *>::RefPtr
-XrlRespCallback;
-
+// Responses are expressed through a callback.
 typedef XrlRespCallback XrlCmdOT;
 
+// The normal command implementation type is the asynchronous version.
+typedef XrlRecvAsyncCallback XrlRecvCallback;
+
+
 #else
 
+
+// Synchronous implementations return the error code.
 typedef const XrlCmdError XrlCmdRT;
 
+// To report an error, return it.
 #define XRL_CMD_RETURN_ERROR(OUT, ERR)	\
     do {				\
 	return (ERR);			\
     } while (0)
 
+// Placeholders for out-arguments are supplied to the command
+// implementation.
 typedef XrlArgs* XrlCmdOT;
 
+// The normal command implementation type is the synchronous version.
+typedef XrlRecvSyncCallback XrlRecvCallback;
+
 #endif
 
-typedef
-XorpCallback2<XrlCmdRT, const XrlArgs&, XrlCmdOT>::RefPtr XrlRecvCallback;
+
+
 
 class XrlCmdEntry {
+    // An asynchronous command implementation that calls a synchronous
+    // one
+    static void invoke_sync(const XrlArgs& in, XrlRespCallback out,
+			    XrlRecvSyncCallback impl);
+
 public:
-    XrlCmdEntry(const string& s, XrlRecvCallback cb) :
+    // Make an asynchronous command implementation out of a
+    // synchronous one.
+    static XrlRecvAsyncCallback make_async_cb(const XrlRecvSyncCallback& cb) {
+	return callback(&XrlCmdEntry::invoke_sync, cb);
+    }
+
+    XrlCmdEntry(const string& s, XrlRecvAsyncCallback cb) :
 	    _name(s), _cb(cb) {}
+    XrlCmdEntry(const string& s, XrlRecvSyncCallback cb) :
+	    _name(s), _cb(make_async_cb(cb)) {}
+
 #ifdef XORP_USE_USTL
     XrlCmdEntry() { }
 #endif
 
     const string& name() const { return _name; }
 
-    XrlCmdRT dispatch(const XrlArgs& inputs, XrlCmdOT outputs) const {
+    void dispatch(const XrlArgs& inputs, XrlRespCallback outputs) const {
 	return _cb->dispatch(inputs, outputs);
     }
 
 protected:
-    string		_name;
-    XrlRecvCallback	_cb;
+    string			_name;
+    XrlRecvAsyncCallback	_cb;
 };
 
 class XrlCmdMap :
@@ -93,7 +147,16 @@ public:
 
     const string& name() const { return _name; }
 
-    virtual bool add_handler(const string& cmd, const XrlRecvCallback& rcb);
+    virtual bool add_handler_internal(const string& cmd,
+				      const XrlRecvAsyncCallback& rcb);
+
+    bool add_handler(const string& cmd, const XrlRecvAsyncCallback& rcb) {
+	return add_handler_internal(cmd, rcb);
+    }
+
+    bool add_handler(const string& cmd, const XrlRecvSyncCallback& rcb) {
+	return add_handler_internal(cmd, XrlCmdEntry::make_async_cb(rcb));
+    }
 
     virtual bool remove_handler (const string& name);
 
diff --git a/xorp/libxipc/xrl_dispatcher.cc b/xorp/libxipc/xrl_dispatcher.cc
index c9a556e..37a8c01 100644
--- a/xorp/libxipc/xrl_dispatcher.cc
+++ b/xorp/libxipc/xrl_dispatcher.cc
@@ -64,14 +64,8 @@ XrlDispatcher::dispatch_xrl(const string&  method_name,
     }
 
     trace_xrl_dispatch("dispatch_xrl (valid) ", method_name);
-#ifdef XORP_ENABLE_ASYNC_SERVER
     XrlRespCallback resp = callback(this, &XrlDispatcher::dispatch_cb, outputs);
     return c->dispatch(inputs, resp);
-#else
-    XrlArgs resp;
-    XrlCmdError e = c->dispatch(inputs, &resp);
-    outputs->dispatch(e, &resp);
-#endif
 }
 
 XrlDispatcher::XI*
@@ -88,14 +82,8 @@ void
 XrlDispatcher::dispatch_xrl_fast(const XI& xi,
 				 XrlDispatcherCallback outputs) const
 {
-#ifdef XORP_ENABLE_ASYNC_SERVER
     XrlRespCallback resp = callback(this, &XrlDispatcher::dispatch_cb, outputs);
     return xi._cmd->dispatch(xi._xrl.args(), resp);
-#else
-    XrlArgs resp;
-    XrlCmdError e = xi._cmd->dispatch(xi._xrl.args(), &resp);
-    return outputs->dispatch(e, &resp);
-#endif
 }
 
 void
diff --git a/xorp/libxipc/xrl_router.cc b/xorp/libxipc/xrl_router.cc
index ed66b66..2975e3e 100644
--- a/xorp/libxipc/xrl_router.cc
+++ b/xorp/libxipc/xrl_router.cc
@@ -372,14 +372,15 @@ XrlRouter::finalize()
 }
 
 bool
-XrlRouter::add_handler(const string& cmd, const XrlRecvCallback& rcb)
+XrlRouter::add_handler_internal(const string& cmd,
+				const XrlRecvAsyncCallback& rcb)
 {
     if (finalized()) {
 	XLOG_ERROR("Attempting to add handler after XrlRouter finalized.  Handler = \"%s\"", cmd.c_str());
 	return false;
     }
 
-    return XrlCmdMap::add_handler(cmd, rcb);
+    return XrlCmdMap::add_handler_internal(cmd, rcb);
 }
 
 void
diff --git a/xorp/libxipc/xrl_router.hh b/xorp/libxipc/xrl_router.hh
index 5de0194..0679bf1 100644
--- a/xorp/libxipc/xrl_router.hh
+++ b/xorp/libxipc/xrl_router.hh
@@ -130,7 +130,8 @@ public:
      * @param rcb callback to be dispatched when XRL method is received for
      * invocation.
      */
-    bool add_handler(const string& cmd, const XrlRecvCallback& rcb);
+    bool add_handler_internal(const string& cmd,
+			      const XrlRecvAsyncCallback& rcb);
 
     /**
      * @return EventLoop used by XrlRouter instance.
-- 
1.7.0.4


From noreply at github.com  Mon Apr 11 09:47:07 2011
From: noreply at github.com (noreply at github.com)
Date: Mon, 11 Apr 2011 09:47:07 -0700
Subject: [Xorp-hackers] [greearb/xorp.ct] 37b840: Wiki backup on Sun,
	03 Apr 2011 03:00:02 +0200...
Message-ID: <20110411164707.A3867423C6@smtp1.rs.github.com>

Branch: refs/heads/master
Home:   https://github.com/greearb/xorp.ct

Commit: 37b840bfc41087c94bd3e914e1c2afbef2cc9a7d
    https://github.com/greearb/xorp.ct/commit/37b840bfc41087c94bd3e914e1c2afbef2cc9a7d
Author: RUN Admin Team <admin at run.montefiore.ulg.ac.be>
Date:   2011-04-02 (Sat, 02 Apr 2011)

Changed paths:
  M docs/wiki/meta/_dokuwiki.changes
  M docs/wiki/meta/xorp/writing_a_process.changes
  M docs/wiki/meta/xorp/writing_a_process.meta
  M docs/wiki/pages/xorp/writing_a_process.txt

Log Message:
-----------
Wiki backup on Sun, 03 Apr 2011 03:00:02 +0200...


Commit: e204dd5363dec411d689aaad57fd719f2329f367
    https://github.com/greearb/xorp.ct/commit/e204dd5363dec411d689aaad57fd719f2329f367
Author: RUN Admin Team <admin at run.montefiore.ulg.ac.be>
Date:   2011-04-02 (Sat, 02 Apr 2011)

Changed paths:
  M xorp/libxipc/finder_client.cc
  M xorp/libxipc/finder_client.hh
  M xorp/libxipc/finder_client_xrl_target.cc
  M xorp/libxipc/finder_client_xrl_target.hh
  M xorp/libxipc/finder_messenger.cc
  M xorp/libxipc/finder_messenger.hh
  M xorp/libxipc/xrl_cmd_map.hh
  M xorp/libxipc/xrl_dispatcher.cc
  M xorp/libxipc/xrl_dispatcher.hh
  M xorp/libxipc/xrl_pf_stcp.cc
  M xorp/libxipc/xrl_router.cc
  M xorp/libxipc/xrl_router.hh

Log Message:
-----------
Merge branch 'master' of https://github.com/greearb/xorp.ct


Commit: 5a6a76888a9bee49badb6c33f2e8052524952b8c
    https://github.com/greearb/xorp.ct/commit/5a6a76888a9bee49badb6c33f2e8052524952b8c
Author: Steven Simpson <ss at comp.lancs.ac.uk>
Date:   2011-04-11 (Mon, 11 Apr 2011)

Changed paths:
  M xorp/libxipc/finder_messenger.cc
  M xorp/libxipc/xrl_cmd_map.cc
  M xorp/libxipc/xrl_cmd_map.hh
  M xorp/libxipc/xrl_dispatcher.cc
  M xorp/libxipc/xrl_router.cc
  M xorp/libxipc/xrl_router.hh

Log Message:
-----------
xrl:  Convert more low-level xrl processing to async handling.

XrlCmdEntry provides method to convert synchronous function into asynchronous one.
XrlCmdMap made full asynchronous, but extended to accept synchronous command
implementations, from which it build asynchronous ones. Conditional
declarations are now only used by tgt-gen.

XrlCmdMap::add_handler renamed to *_internal; also where inherited by
XrlDispatcher and XrlRouter.  New add_handler methods added to allow
acceptance of both sync and async command implementations.

Async conditionals dropped from FinderMessengerBase and XrlDispatcher,
as they now use the new unconditionally asynchronous XrlCmdMap
interface.

Signed-off-by: Steven Simpson <ss at comp.lancs.ac.uk>


Compare: https://github.com/greearb/xorp.ct/compare/350e78b...5a6a768


From greearb at candelatech.com  Mon Apr 11 09:49:00 2011
From: greearb at candelatech.com (Ben Greear)
Date: Mon, 11 Apr 2011 09:49:00 -0700
Subject: [Xorp-hackers] [PATCH] XrlCmdEntry provides method to convert
 synchronous function into asynchronous one.
In-Reply-To: <1302517521-2484-1-git-send-email-ss@comp.lancs.ac.uk>
References: <4DA2D3A3.7080302@comp.lancs.ac.uk>
	<1302517521-2484-1-git-send-email-ss@comp.lancs.ac.uk>
Message-ID: <4DA330FC.9000208@candelatech.com>

On 04/11/2011 03:25 AM, ss at comp.lancs.ac.uk wrote:
> From: Steven Simpson<ss at comp.lancs.ac.uk>
>
> XrlCmdMap::add_handler renamed to *_internal; also where inherited by
> XrlDispatcher and XrlRouter.  New add_handler methods added to allow
> acceptance of both sync and async command implementations.
>
> Async conditionals dropped from FinderMessengerBase and XrlDispatcher,
> as they now use the new unconditionally asynchronous XrlCmdMap
> interface.

Thanks for the patch.  I edited the subject to be much shorter,
but otherwise pushed it as it is.

I merged in the wiki documentation changes as well...

Thanks,
Ben

-- 
Ben Greear <greearb at candelatech.com>
Candela Technologies Inc  http://www.candelatech.com


From ss at comp.lancs.ac.uk  Wed Apr 13 06:41:37 2011
From: ss at comp.lancs.ac.uk (Steven Simpson)
Date: Wed, 13 Apr 2011 14:41:37 +0100
Subject: [Xorp-hackers] Using results from one XRL to respond to another
In-Reply-To: <4D500B54.6030707@comp.lancs.ac.uk>
References: <4D500B54.6030707@comp.lancs.ac.uk>
Message-ID: <4DA5A811.9020406@comp.lancs.ac.uk>

Ben,

Thanks for applying my patches, and fixing subject lines!  Here's a very
small change for your consideration...

I was just trying to apply the async facility to ECODE, and found myself
writing this function:

void
XrlEuaTciNode::direct_dispatch_cb(const XrlError& e,
				  const vector<uint8_t>* ret,
				  EuaTci01DirectDispatchCB cb)
{
  cb->dispatch(e, *ret);
}

This is meant to conform to a callback type defined by clnt-gen on one
of our interfaces, but it also takes a callback type defined by tgt-gen
on the same interface, and relays its arguments through.

[ret] is a binary out-parameter, and clnt-gen expresses it as a [const
TYPE*] in the callback type.  AFAICT, the function could be called with
ret==NULL, if e!=OKAY.

OTOH, I made tgt-gen express cb->dispatch's corresponding parameter as
[const TYPE&], so the function above has to dereference ret to match types.

I imagine that [*(const TYPE *)NULL] assigned to [const TYPE&] is
practically safe, but I suspect it's undefined behaviour, so I'd have to
write:

  cb->dispatch(e, ret ? *ret : vector<uint8_t>());

...which is not convenient, and probably a waste of time and space. 
IOW, if you are passing a non-OKAY error code, you shouldn't have to
create a load of dummy objects just to meet the signature.

I'll send another patch shortly, just a few lines in tgt-gen, to make
the callback type use pointers instead of references, so it will be
consistent with clnt-gen.  I hope that sounds reasonable.

Cheers,

Steven

-- 



From ss at comp.lancs.ac.uk  Wed Apr 13 06:47:04 2011
From: ss at comp.lancs.ac.uk (ss at comp.lancs.ac.uk)
Date: Wed, 13 Apr 2011 14:47:04 +0100
Subject: [Xorp-hackers] [PATCH] Asynchronous callbacks accept argument
	pointers instead of references:
In-Reply-To: <4DA5A811.9020406@comp.lancs.ac.uk>
References: <4DA5A811.9020406@comp.lancs.ac.uk>
Message-ID: <1302702424-25955-1-git-send-email-ss@comp.lancs.ac.uk>

From: Steven Simpson <ss at comp.lancs.ac.uk>

* Each generated callback typedef takes [const TYPE*] instead of
  [const TYPE&] for each out-parameter.

* The callback_* implementation passed to the async_* function is
  changed to match this typedef, and must dereference out-arguments to
  marshall them.

* The async_* function is changed to pass &out_arg when calling
  callback_* to meet its new signature.

This allows user-defined async implementations to pass NULLs for
out-arguments when returning an error code, rather than being forced
to provide dummy arguments.

Signed-off-by: Steven Simpson <ss at comp.lancs.ac.uk>
---
 xorp/xrl/scripts/tgt-gen |   10 +++++-----
 1 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/xorp/xrl/scripts/tgt-gen b/xorp/xrl/scripts/tgt-gen
index ffce3ac..acc2f3c 100755
--- a/xorp/xrl/scripts/tgt-gen
+++ b/xorp/xrl/scripts/tgt-gen
@@ -132,7 +132,7 @@ def target_virtual_fns(methods):
         r += "    typedef\n"
         r += "    XorpCallback%s<void, const XrlCmdError &" % (len(x.rargs()) + 1)
         for a in x.rargs():
-            r += ",\n%sconst %s&" % (xorp_indent(2), a.cpp_type())
+            r += ",\n%sconst %s*" % (xorp_indent(2), a.cpp_type())
         r += ">::RefPtr\n    %sCB;\n" % (caps_cpp_classname(x.name()))
 
 
@@ -161,7 +161,7 @@ def target_declare_handlers(methods):
         s += "    void callback_%s\n       (const XrlCmdError &e" \
             % cpp_name(x.name())
         for a in x.rargs():
-            s += ",\n%sconst %s& arg_%s" \
+            s += ",\n%sconst %s* arg_%s" \
                 % (xorp_indent(2), a.cpp_type(), cpp_name(a.name()))
         s += ",\n        XrlRespCallback);\n"
         s += "#endif\n\n"
@@ -199,7 +199,7 @@ def target_handler_methods(cls, name, methods):
             % (cls, cpp_name(m.name()))
         for r in m.rargs():
             s += ",\n     "
-            s += "const %s& rarg_%s" % (r.cpp_type(), cpp_name(r.name()))
+            s += "const %s* rarg_%s" % (r.cpp_type(), cpp_name(r.name()))
         s += ",\n     XrlRespCallback c_b)\n"
         s += "{\n"
 
@@ -215,7 +215,7 @@ def target_handler_methods(cls, name, methods):
         if m.rargs():
             s += "\n        /* Marshall return values */\n        try {\n"
             for r in m.rargs():
-                s += xorp_indent(3) + "out.add(\"%s\", rarg_%s);\n" % \
+                s += xorp_indent(3) + "out.add(\"%s\", *rarg_%s);\n" % \
                     (r.name(), cpp_name(r.name()))
             s += \
 """        } catch (const XrlArgs::XrlAtomFound& ) {
@@ -254,7 +254,7 @@ def target_handler_methods(cls, name, methods):
         s += ");\n"
         s += "    return c_b->dispatch(e"
 	for r in m.rargs():
-            s += ",\n        rarg_%s" % (cpp_name(r.name()))
+            s += ",\n        &rarg_%s" % (cpp_name(r.name()))
             sep = ","
         s += ");\n"
         s += "}\n"
-- 
1.7.0.4


From noreply at github.com  Thu Apr 21 16:25:23 2011
From: noreply at github.com (noreply at github.com)
Date: Thu, 21 Apr 2011 16:25:23 -0700
Subject: [Xorp-hackers] [greearb/xorp.ct] 1c0ae6: ospf: Add debug info
	around assert in peer.
Message-ID: <20110421232522.EE9D14245A@smtp1.rs.github.com>

Branch: refs/heads/master
Home:   https://github.com/greearb/xorp.ct

Commit: 1c0ae64998db138ccfbd598ee2b8dd740f0a54cf
    https://github.com/greearb/xorp.ct/commit/1c0ae64998db138ccfbd598ee2b8dd740f0a54cf
Author: Ben Greear <greearb at candelatech.com>
Date:   2011-04-21 (Thu, 21 Apr 2011)

Changed paths:
  M xorp/ospf/peer.cc
  M xorp/ospf/peer.hh

Log Message:
-----------
ospf:  Add debug info around assert in peer.

Someone hit this when (re)loading a config file that added
a new interface.  This doesn't fix the problem, but might
make the logs more useful.

Signed-off-by: Ben Greear <greearb at candelatech.com>



From noreply at github.com  Fri Apr 22 12:29:50 2011
From: noreply at github.com (noreply at github.com)
Date: Fri, 22 Apr 2011 12:29:50 -0700
Subject: [Xorp-hackers] [greearb/xorp.ct] 323cbc: ospf: Deal better with
	reloading ospf config file...
Message-ID: <20110422192950.409194243B@smtp1.rs.github.com>

Branch: refs/heads/master
Home:   https://github.com/greearb/xorp.ct

Commit: 323cbc6d5fd2e2e3e848fe23c2842d6d76cdb71e
    https://github.com/greearb/xorp.ct/commit/323cbc6d5fd2e2e3e848fe23c2842d6d76cdb71e
Author: Ben Greear <greearb at candelatech.com>
Date:   2011-04-22 (Fri, 22 Apr 2011)

Changed paths:
  M xorp/libfeaclient/ifmgr_atoms.cc
  M xorp/libfeaclient/ifmgr_atoms.hh
  M xorp/ospf/peer.cc
  M xorp/ospf/peer_manager.cc
  M xorp/ospf/xrl_io.cc

Log Message:
-----------
ospf:  Deal better with reloading ospf config files.

Problem is this:  When loading a config file that has a new
interface, the route redistribution messages can come before
the new interface info is pushed.  That could lead to trying
to announce routes when the peer has a zero prefix.

This attempts to fix this by basically removing the assert.
I am hoping that the route redistribution will happen properly
when the peer comes up, but I'm not certain that is the case.
So, maybe more fixes coming..but at least we don't crash now.

Core was generated by `xorp_ospfv2'.
Program terminated with signal 6, Aborted.
(gdb) bt
    at libxorp/xlog.c:480
    a3=0xffffffffffffffff <Address 0xffffffffffffffff out of bounds>, a4=140733526888592) at ./libxorp/callback_nodebug.hh:8966

Signed-off-by: Ben Greear <greearb at candelatech.com>



From noreply at github.com  Sat Apr 23 08:32:08 2011
From: noreply at github.com (noreply at github.com)
Date: Sat, 23 Apr 2011 08:32:08 -0700
Subject: [Xorp-hackers] [greearb/xorp.ct] 783b88: BSD: Fix bug with adding
	new virtual interface.
Message-ID: <20110423153208.3E9D242481@smtp1.rs.github.com>

Branch: refs/heads/master
Home:   https://github.com/greearb/xorp.ct

Commit: 783b88d11cd3e8463592974cb74c77e67aabdfc3
    https://github.com/greearb/xorp.ct/commit/783b88d11cd3e8463592974cb74c77e67aabdfc3
Author: Ben Greear <greearb at candelatech.com>
Date:   2011-04-23 (Sat, 23 Apr 2011)

Changed paths:
  M xorp/RELEASE_NOTES
  M xorp/fea/iftree.cc
  M xorp/fea/iftree.hh

Log Message:
-----------
BSD:  Fix bug with adding new virtual interface.

BSD has the bad habit of re-using interface ifindexes
if you delete and then re-add an interface.  Instead of
asserting, delete the old interface with the duplicate
ifindex before adding the new one.

Signed-off-by: Ben Greear <greearb at candelatech.com>


Commit: 7a4f917e23ff01eeef26513404b3a4913af131da
    https://github.com/greearb/xorp.ct/commit/7a4f917e23ff01eeef26513404b3a4913af131da
Author: Ben Greear <greearb at candelatech.com>
Date:   2011-04-23 (Sat, 23 Apr 2011)

Changed paths:
  M xorp/libfeaclient/ifmgr_atoms.cc
  M xorp/libfeaclient/ifmgr_atoms.hh
  M xorp/ospf/peer.cc
  M xorp/ospf/peer.hh
  M xorp/ospf/peer_manager.cc
  M xorp/ospf/xrl_io.cc

Log Message:
-----------
Merge branch 'master' of github.com:greearb/xorp.ct


Compare: https://github.com/greearb/xorp.ct/compare/323cbc6...7a4f917


From noreply at github.com  Thu Apr 28 09:31:37 2011
From: noreply at github.com (noreply at github.com)
Date: Thu, 28 Apr 2011 09:31:37 -0700
Subject: [Xorp-hackers] [greearb/xorp.ct] 4282c5: multicast: Fix critical
	bug with mcast routing ta...
Message-ID: <20110428163137.DAFCA42295@smtp1.rs.github.com>

Branch: refs/heads/master
Home:   https://github.com/greearb/xorp.ct

Commit: 4282c51b9fdf954280fdfb25d49d0a9c4a7fa12d
    https://github.com/greearb/xorp.ct/commit/4282c51b9fdf954280fdfb25d49d0a9c4a7fa12d
Author: Ben Greear <greearb at candelatech.com>
Date:   2011-04-28 (Thu, 28 Apr 2011)

Changed paths:
  M xorp/RELEASE_NOTES
  M xorp/fea/mfea_mrouter.cc

Log Message:
-----------
multicast:  Fix critical bug with mcast routing tables in Linux.

When adding the virtual routing tables for multicast, I messed up
the default routing table for more normal users.  It was set to
254 instead of 253.  This broke multicast routing for users on
recent (2.6.36 and later) kernels.  We did not catch this in
our testing because we always specify the routing table.

Reported-by: Jeff Mitchell <jmitchell at ll.mit.edu>
Tested-by: Jeff Mitchell <jmitchell at ll.mit.edu>
Signed-off-by: Ben Greear <greearb at candelatech.com>