xorp

ripng_base.hh

00001 /*
00002  * obj/i386-pc-mingw32/xrl/targets/ripng_base.hh
00003  * vim:set sts=4 ts=8 ft=cpp:
00004  *
00005  * Copyright (c) 2001-2011 XORP, Inc and Others
00006  * See the XORP LICENSE.lgpl file for licensing, conditions, and warranties
00007  * on use.
00008  *
00009  * DO NOT EDIT THIS FILE - IT IS PROGRAMMATICALLY GENERATED
00010  *
00011  * Generated by 'tgt-gen'.
00012  */
00013 
00014 
00015 #ifndef __XRL_TARGETS_RIPNG_BASE_HH__
00016 #define __XRL_TARGETS_RIPNG_BASE_HH__
00017 
00018 #undef XORP_LIBRARY_NAME
00019 #define XORP_LIBRARY_NAME "XrlRipngTarget"
00020 
00021 #include "libxorp/xlog.h"
00022 #include "libxipc/xrl_cmd_map.hh"
00023 
00024 class XrlRipngTargetBase {
00025 protected:
00026     XrlCmdMap* _cmds;
00027 
00028 public:
00036     XrlRipngTargetBase(XrlCmdMap* cmds = 0);
00037 
00043     virtual ~XrlRipngTargetBase();
00044 
00055     bool set_command_map(XrlCmdMap* cmds);
00056 
00060     const string& get_name() const { return _cmds->name(); }
00061 
00065     const char* version() const { return "ripng/0.0"; }
00066 
00067 protected:
00068 
00074     virtual XrlCmdError common_0_1_get_target_name(
00075     // Output values,
00076     string& name) = 0;
00077 #ifdef XORP_ENABLE_ASYNC_SERVER
00078     typedef
00079     XorpCallback2<void, const XrlCmdError &,
00080     const string*>::RefPtr
00081     Common01GetTargetNameRF;
00082 
00083     class Common01GetTargetNameCB {
00084         Common01GetTargetNameRF cb;
00085 
00086     public:
00087         operator const Common01GetTargetNameRF& () const { return cb; }
00088         const Common01GetTargetNameRF& operator ->() const { return cb; }
00089         Common01GetTargetNameCB(const Common01GetTargetNameRF& cb)
00090           : cb(cb) { }
00091 
00092         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00093 
00094         void respond(const string& arg_name) const {
00095             cb->dispatch(XrlCmdError::OKAY(),
00096                          &arg_name);
00097         }
00098     };
00099 
00100     struct Common01GetTargetNameRsp :
00101       public Common01GetTargetNameCB {
00102         struct args_str {
00103             string name;
00104         };
00105 
00106     private:
00107         args_str args;
00108 
00109     public:
00110         Common01GetTargetNameRsp(const Common01GetTargetNameRF& cb)
00111           : Common01GetTargetNameCB(cb) { }
00112 
00113         void respond() const {
00114             Common01GetTargetNameCB::
00115             respond(args.name);
00116         }
00117 
00118         args_str* operator ->() {
00119             return &args;
00120         }
00121     };
00122 
00123     virtual void async_common_0_1_get_target_name
00124        (
00125     Common01GetTargetNameCB);
00126 #endif
00127 
00133     virtual XrlCmdError common_0_1_get_version(
00134     // Output values,
00135     string& version) = 0;
00136 #ifdef XORP_ENABLE_ASYNC_SERVER
00137     typedef
00138     XorpCallback2<void, const XrlCmdError &,
00139     const string*>::RefPtr
00140     Common01GetVersionRF;
00141 
00142     class Common01GetVersionCB {
00143         Common01GetVersionRF cb;
00144 
00145     public:
00146         operator const Common01GetVersionRF& () const { return cb; }
00147         const Common01GetVersionRF& operator ->() const { return cb; }
00148         Common01GetVersionCB(const Common01GetVersionRF& cb)
00149           : cb(cb) { }
00150 
00151         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00152 
00153         void respond(const string& arg_version) const {
00154             cb->dispatch(XrlCmdError::OKAY(),
00155                          &arg_version);
00156         }
00157     };
00158 
00159     struct Common01GetVersionRsp :
00160       public Common01GetVersionCB {
00161         struct args_str {
00162             string version;
00163         };
00164 
00165     private:
00166         args_str args;
00167 
00168     public:
00169         Common01GetVersionRsp(const Common01GetVersionRF& cb)
00170           : Common01GetVersionCB(cb) { }
00171 
00172         void respond() const {
00173             Common01GetVersionCB::
00174             respond(args.version);
00175         }
00176 
00177         args_str* operator ->() {
00178             return &args;
00179         }
00180     };
00181 
00182     virtual void async_common_0_1_get_version
00183        (
00184     Common01GetVersionCB);
00185 #endif
00186 
00192     virtual XrlCmdError common_0_1_get_status(
00193     // Output values,
00194     uint32_t&   status,
00195     string& reason) = 0;
00196 #ifdef XORP_ENABLE_ASYNC_SERVER
00197     typedef
00198     XorpCallback3<void, const XrlCmdError &,
00199     const uint32_t*,
00200     const string*>::RefPtr
00201     Common01GetStatusRF;
00202 
00203     class Common01GetStatusCB {
00204         Common01GetStatusRF cb;
00205 
00206     public:
00207         operator const Common01GetStatusRF& () const { return cb; }
00208         const Common01GetStatusRF& operator ->() const { return cb; }
00209         Common01GetStatusCB(const Common01GetStatusRF& cb)
00210           : cb(cb) { }
00211 
00212         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL); }
00213 
00214         void respond(const uint32_t& arg_status,
00215                      const string& arg_reason) const {
00216             cb->dispatch(XrlCmdError::OKAY(),
00217                          &arg_status,
00218                          &arg_reason);
00219         }
00220     };
00221 
00222     struct Common01GetStatusRsp :
00223       public Common01GetStatusCB {
00224         struct args_str {
00225             uint32_t status;
00226             string reason;
00227         };
00228 
00229     private:
00230         args_str args;
00231 
00232     public:
00233         Common01GetStatusRsp(const Common01GetStatusRF& cb)
00234           : Common01GetStatusCB(cb) { }
00235 
00236         void respond() const {
00237             Common01GetStatusCB::
00238             respond(args.status,
00239                         args.reason);
00240         }
00241 
00242         args_str* operator ->() {
00243             return &args;
00244         }
00245     };
00246 
00247     virtual void async_common_0_1_get_status
00248        (
00249     Common01GetStatusCB);
00250 #endif
00251 
00257     virtual XrlCmdError common_0_1_shutdown() = 0;
00258 #ifdef XORP_ENABLE_ASYNC_SERVER
00259     typedef
00260     XorpCallback1<void, const XrlCmdError &>::RefPtr
00261     Common01ShutdownRF;
00262 
00263     class Common01ShutdownCB {
00264         Common01ShutdownRF cb;
00265 
00266     public:
00267         operator const Common01ShutdownRF& () const { return cb; }
00268         const Common01ShutdownRF& operator ->() const { return cb; }
00269         Common01ShutdownCB(const Common01ShutdownRF& cb)
00270           : cb(cb) { }
00271 
00272         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00273 
00274         void respond() const {
00275             cb->dispatch(XrlCmdError::OKAY());
00276         }
00277     };
00278 
00279     struct Common01ShutdownRsp :
00280       public Common01ShutdownCB {
00281         Common01ShutdownRsp(const Common01ShutdownRF& cb)
00282           : Common01ShutdownCB(cb) { }
00283 
00284     };
00285 
00286     virtual void async_common_0_1_shutdown
00287        (
00288     Common01ShutdownCB);
00289 #endif
00290 
00296     virtual XrlCmdError common_0_1_startup() = 0;
00297 #ifdef XORP_ENABLE_ASYNC_SERVER
00298     typedef
00299     XorpCallback1<void, const XrlCmdError &>::RefPtr
00300     Common01StartupRF;
00301 
00302     class Common01StartupCB {
00303         Common01StartupRF cb;
00304 
00305     public:
00306         operator const Common01StartupRF& () const { return cb; }
00307         const Common01StartupRF& operator ->() const { return cb; }
00308         Common01StartupCB(const Common01StartupRF& cb)
00309           : cb(cb) { }
00310 
00311         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00312 
00313         void respond() const {
00314             cb->dispatch(XrlCmdError::OKAY());
00315         }
00316     };
00317 
00318     struct Common01StartupRsp :
00319       public Common01StartupCB {
00320         Common01StartupRsp(const Common01StartupRF& cb)
00321           : Common01StartupCB(cb) { }
00322 
00323     };
00324 
00325     virtual void async_common_0_1_startup
00326        (
00327     Common01StartupCB);
00328 #endif
00329 
00339     virtual XrlCmdError finder_event_observer_0_1_xrl_target_birth(
00340     // Input values,
00341     const string&   target_class,
00342     const string&   target_instance) = 0;
00343 #ifdef XORP_ENABLE_ASYNC_SERVER
00344     typedef
00345     XorpCallback1<void, const XrlCmdError &>::RefPtr
00346     FinderEventObserver01XrlTargetBirthRF;
00347 
00348     class FinderEventObserver01XrlTargetBirthCB {
00349         FinderEventObserver01XrlTargetBirthRF cb;
00350 
00351     public:
00352         operator const FinderEventObserver01XrlTargetBirthRF& () const { return cb; }
00353         const FinderEventObserver01XrlTargetBirthRF& operator ->() const { return cb; }
00354         FinderEventObserver01XrlTargetBirthCB(const FinderEventObserver01XrlTargetBirthRF& cb)
00355           : cb(cb) { }
00356 
00357         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00358 
00359         void respond() const {
00360             cb->dispatch(XrlCmdError::OKAY());
00361         }
00362     };
00363 
00364     struct FinderEventObserver01XrlTargetBirthRsp :
00365       public FinderEventObserver01XrlTargetBirthCB {
00366         FinderEventObserver01XrlTargetBirthRsp(const FinderEventObserver01XrlTargetBirthRF& cb)
00367           : FinderEventObserver01XrlTargetBirthCB(cb) { }
00368 
00369     };
00370 
00371     virtual void async_finder_event_observer_0_1_xrl_target_birth
00372        (
00373     const string&   target_class,
00374     const string&   target_instance,
00375     FinderEventObserver01XrlTargetBirthCB);
00376 #endif
00377 
00387     virtual XrlCmdError finder_event_observer_0_1_xrl_target_death(
00388     // Input values,
00389     const string&   target_class,
00390     const string&   target_instance) = 0;
00391 #ifdef XORP_ENABLE_ASYNC_SERVER
00392     typedef
00393     XorpCallback1<void, const XrlCmdError &>::RefPtr
00394     FinderEventObserver01XrlTargetDeathRF;
00395 
00396     class FinderEventObserver01XrlTargetDeathCB {
00397         FinderEventObserver01XrlTargetDeathRF cb;
00398 
00399     public:
00400         operator const FinderEventObserver01XrlTargetDeathRF& () const { return cb; }
00401         const FinderEventObserver01XrlTargetDeathRF& operator ->() const { return cb; }
00402         FinderEventObserver01XrlTargetDeathCB(const FinderEventObserver01XrlTargetDeathRF& cb)
00403           : cb(cb) { }
00404 
00405         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00406 
00407         void respond() const {
00408             cb->dispatch(XrlCmdError::OKAY());
00409         }
00410     };
00411 
00412     struct FinderEventObserver01XrlTargetDeathRsp :
00413       public FinderEventObserver01XrlTargetDeathCB {
00414         FinderEventObserver01XrlTargetDeathRsp(const FinderEventObserver01XrlTargetDeathRF& cb)
00415           : FinderEventObserver01XrlTargetDeathCB(cb) { }
00416 
00417     };
00418 
00419     virtual void async_finder_event_observer_0_1_xrl_target_death
00420        (
00421     const string&   target_class,
00422     const string&   target_instance,
00423     FinderEventObserver01XrlTargetDeathCB);
00424 #endif
00425 
00435     virtual XrlCmdError policy_backend_0_1_configure(
00436     // Input values,
00437     const uint32_t& filter,
00438     const string&   conf) = 0;
00439 #ifdef XORP_ENABLE_ASYNC_SERVER
00440     typedef
00441     XorpCallback1<void, const XrlCmdError &>::RefPtr
00442     PolicyBackend01ConfigureRF;
00443 
00444     class PolicyBackend01ConfigureCB {
00445         PolicyBackend01ConfigureRF cb;
00446 
00447     public:
00448         operator const PolicyBackend01ConfigureRF& () const { return cb; }
00449         const PolicyBackend01ConfigureRF& operator ->() const { return cb; }
00450         PolicyBackend01ConfigureCB(const PolicyBackend01ConfigureRF& cb)
00451           : cb(cb) { }
00452 
00453         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00454 
00455         void respond() const {
00456             cb->dispatch(XrlCmdError::OKAY());
00457         }
00458     };
00459 
00460     struct PolicyBackend01ConfigureRsp :
00461       public PolicyBackend01ConfigureCB {
00462         PolicyBackend01ConfigureRsp(const PolicyBackend01ConfigureRF& cb)
00463           : PolicyBackend01ConfigureCB(cb) { }
00464 
00465     };
00466 
00467     virtual void async_policy_backend_0_1_configure
00468        (
00469     const uint32_t& filter,
00470     const string&   conf,
00471     PolicyBackend01ConfigureCB);
00472 #endif
00473 
00481     virtual XrlCmdError policy_backend_0_1_reset(
00482     // Input values,
00483     const uint32_t& filter) = 0;
00484 #ifdef XORP_ENABLE_ASYNC_SERVER
00485     typedef
00486     XorpCallback1<void, const XrlCmdError &>::RefPtr
00487     PolicyBackend01ResetRF;
00488 
00489     class PolicyBackend01ResetCB {
00490         PolicyBackend01ResetRF cb;
00491 
00492     public:
00493         operator const PolicyBackend01ResetRF& () const { return cb; }
00494         const PolicyBackend01ResetRF& operator ->() const { return cb; }
00495         PolicyBackend01ResetCB(const PolicyBackend01ResetRF& cb)
00496           : cb(cb) { }
00497 
00498         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00499 
00500         void respond() const {
00501             cb->dispatch(XrlCmdError::OKAY());
00502         }
00503     };
00504 
00505     struct PolicyBackend01ResetRsp :
00506       public PolicyBackend01ResetCB {
00507         PolicyBackend01ResetRsp(const PolicyBackend01ResetRF& cb)
00508           : PolicyBackend01ResetCB(cb) { }
00509 
00510     };
00511 
00512     virtual void async_policy_backend_0_1_reset
00513        (
00514     const uint32_t& filter,
00515     PolicyBackend01ResetCB);
00516 #endif
00517 
00523     virtual XrlCmdError policy_backend_0_1_push_routes() = 0;
00524 #ifdef XORP_ENABLE_ASYNC_SERVER
00525     typedef
00526     XorpCallback1<void, const XrlCmdError &>::RefPtr
00527     PolicyBackend01PushRoutesRF;
00528 
00529     class PolicyBackend01PushRoutesCB {
00530         PolicyBackend01PushRoutesRF cb;
00531 
00532     public:
00533         operator const PolicyBackend01PushRoutesRF& () const { return cb; }
00534         const PolicyBackend01PushRoutesRF& operator ->() const { return cb; }
00535         PolicyBackend01PushRoutesCB(const PolicyBackend01PushRoutesRF& cb)
00536           : cb(cb) { }
00537 
00538         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00539 
00540         void respond() const {
00541             cb->dispatch(XrlCmdError::OKAY());
00542         }
00543     };
00544 
00545     struct PolicyBackend01PushRoutesRsp :
00546       public PolicyBackend01PushRoutesCB {
00547         PolicyBackend01PushRoutesRsp(const PolicyBackend01PushRoutesRF& cb)
00548           : PolicyBackend01PushRoutesCB(cb) { }
00549 
00550     };
00551 
00552     virtual void async_policy_backend_0_1_push_routes
00553        (
00554     PolicyBackend01PushRoutesCB);
00555 #endif
00556 
00574     virtual XrlCmdError policy_redist6_0_1_add_route6(
00575     // Input values,
00576     const IPv6Net&  network,
00577     const bool& unicast,
00578     const bool& multicast,
00579     const IPv6& nexthop,
00580     const uint32_t& metric,
00581     const XrlAtomList&  policytags) = 0;
00582 #ifdef XORP_ENABLE_ASYNC_SERVER
00583     typedef
00584     XorpCallback1<void, const XrlCmdError &>::RefPtr
00585     PolicyRedist601AddRoute6RF;
00586 
00587     class PolicyRedist601AddRoute6CB {
00588         PolicyRedist601AddRoute6RF cb;
00589 
00590     public:
00591         operator const PolicyRedist601AddRoute6RF& () const { return cb; }
00592         const PolicyRedist601AddRoute6RF& operator ->() const { return cb; }
00593         PolicyRedist601AddRoute6CB(const PolicyRedist601AddRoute6RF& cb)
00594           : cb(cb) { }
00595 
00596         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00597 
00598         void respond() const {
00599             cb->dispatch(XrlCmdError::OKAY());
00600         }
00601     };
00602 
00603     struct PolicyRedist601AddRoute6Rsp :
00604       public PolicyRedist601AddRoute6CB {
00605         PolicyRedist601AddRoute6Rsp(const PolicyRedist601AddRoute6RF& cb)
00606           : PolicyRedist601AddRoute6CB(cb) { }
00607 
00608     };
00609 
00610     virtual void async_policy_redist6_0_1_add_route6
00611        (
00612     const IPv6Net&  network,
00613     const bool& unicast,
00614     const bool& multicast,
00615     const IPv6& nexthop,
00616     const uint32_t& metric,
00617     const XrlAtomList&  policytags,
00618     PolicyRedist601AddRoute6CB);
00619 #endif
00620 
00632     virtual XrlCmdError policy_redist6_0_1_delete_route6(
00633     // Input values,
00634     const IPv6Net&  network,
00635     const bool& unicast,
00636     const bool& multicast) = 0;
00637 #ifdef XORP_ENABLE_ASYNC_SERVER
00638     typedef
00639     XorpCallback1<void, const XrlCmdError &>::RefPtr
00640     PolicyRedist601DeleteRoute6RF;
00641 
00642     class PolicyRedist601DeleteRoute6CB {
00643         PolicyRedist601DeleteRoute6RF cb;
00644 
00645     public:
00646         operator const PolicyRedist601DeleteRoute6RF& () const { return cb; }
00647         const PolicyRedist601DeleteRoute6RF& operator ->() const { return cb; }
00648         PolicyRedist601DeleteRoute6CB(const PolicyRedist601DeleteRoute6RF& cb)
00649           : cb(cb) { }
00650 
00651         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00652 
00653         void respond() const {
00654             cb->dispatch(XrlCmdError::OKAY());
00655         }
00656     };
00657 
00658     struct PolicyRedist601DeleteRoute6Rsp :
00659       public PolicyRedist601DeleteRoute6CB {
00660         PolicyRedist601DeleteRoute6Rsp(const PolicyRedist601DeleteRoute6RF& cb)
00661           : PolicyRedist601DeleteRoute6CB(cb) { }
00662 
00663     };
00664 
00665     virtual void async_policy_redist6_0_1_delete_route6
00666        (
00667     const IPv6Net&  network,
00668     const bool& unicast,
00669     const bool& multicast,
00670     PolicyRedist601DeleteRoute6CB);
00671 #endif
00672 
00687     virtual XrlCmdError ripng_0_1_add_rip_address(
00688     // Input values,
00689     const string&   ifname,
00690     const string&   vifname,
00691     const IPv6& addr) = 0;
00692 #ifdef XORP_ENABLE_ASYNC_SERVER
00693     typedef
00694     XorpCallback1<void, const XrlCmdError &>::RefPtr
00695     Ripng01AddRipAddressRF;
00696 
00697     class Ripng01AddRipAddressCB {
00698         Ripng01AddRipAddressRF cb;
00699 
00700     public:
00701         operator const Ripng01AddRipAddressRF& () const { return cb; }
00702         const Ripng01AddRipAddressRF& operator ->() const { return cb; }
00703         Ripng01AddRipAddressCB(const Ripng01AddRipAddressRF& cb)
00704           : cb(cb) { }
00705 
00706         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00707 
00708         void respond() const {
00709             cb->dispatch(XrlCmdError::OKAY());
00710         }
00711     };
00712 
00713     struct Ripng01AddRipAddressRsp :
00714       public Ripng01AddRipAddressCB {
00715         Ripng01AddRipAddressRsp(const Ripng01AddRipAddressRF& cb)
00716           : Ripng01AddRipAddressCB(cb) { }
00717 
00718     };
00719 
00720     virtual void async_ripng_0_1_add_rip_address
00721        (
00722     const string&   ifname,
00723     const string&   vifname,
00724     const IPv6& addr,
00725     Ripng01AddRipAddressCB);
00726 #endif
00727 
00739     virtual XrlCmdError ripng_0_1_remove_rip_address(
00740     // Input values,
00741     const string&   ifname,
00742     const string&   vifname,
00743     const IPv6& addr) = 0;
00744 #ifdef XORP_ENABLE_ASYNC_SERVER
00745     typedef
00746     XorpCallback1<void, const XrlCmdError &>::RefPtr
00747     Ripng01RemoveRipAddressRF;
00748 
00749     class Ripng01RemoveRipAddressCB {
00750         Ripng01RemoveRipAddressRF cb;
00751 
00752     public:
00753         operator const Ripng01RemoveRipAddressRF& () const { return cb; }
00754         const Ripng01RemoveRipAddressRF& operator ->() const { return cb; }
00755         Ripng01RemoveRipAddressCB(const Ripng01RemoveRipAddressRF& cb)
00756           : cb(cb) { }
00757 
00758         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00759 
00760         void respond() const {
00761             cb->dispatch(XrlCmdError::OKAY());
00762         }
00763     };
00764 
00765     struct Ripng01RemoveRipAddressRsp :
00766       public Ripng01RemoveRipAddressCB {
00767         Ripng01RemoveRipAddressRsp(const Ripng01RemoveRipAddressRF& cb)
00768           : Ripng01RemoveRipAddressCB(cb) { }
00769 
00770     };
00771 
00772     virtual void async_ripng_0_1_remove_rip_address
00773        (
00774     const string&   ifname,
00775     const string&   vifname,
00776     const IPv6& addr,
00777     Ripng01RemoveRipAddressCB);
00778 #endif
00779 
00780     virtual XrlCmdError ripng_0_1_set_rip_address_enabled(
00781     // Input values,
00782     const string&   ifname,
00783     const string&   vifname,
00784     const IPv6& addr,
00785     const bool& enabled) = 0;
00786 #ifdef XORP_ENABLE_ASYNC_SERVER
00787     typedef
00788     XorpCallback1<void, const XrlCmdError &>::RefPtr
00789     Ripng01SetRipAddressEnabledRF;
00790 
00791     class Ripng01SetRipAddressEnabledCB {
00792         Ripng01SetRipAddressEnabledRF cb;
00793 
00794     public:
00795         operator const Ripng01SetRipAddressEnabledRF& () const { return cb; }
00796         const Ripng01SetRipAddressEnabledRF& operator ->() const { return cb; }
00797         Ripng01SetRipAddressEnabledCB(const Ripng01SetRipAddressEnabledRF& cb)
00798           : cb(cb) { }
00799 
00800         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00801 
00802         void respond() const {
00803             cb->dispatch(XrlCmdError::OKAY());
00804         }
00805     };
00806 
00807     struct Ripng01SetRipAddressEnabledRsp :
00808       public Ripng01SetRipAddressEnabledCB {
00809         Ripng01SetRipAddressEnabledRsp(const Ripng01SetRipAddressEnabledRF& cb)
00810           : Ripng01SetRipAddressEnabledCB(cb) { }
00811 
00812     };
00813 
00814     virtual void async_ripng_0_1_set_rip_address_enabled
00815        (
00816     const string&   ifname,
00817     const string&   vifname,
00818     const IPv6& addr,
00819     const bool& enabled,
00820     Ripng01SetRipAddressEnabledCB);
00821 #endif
00822 
00823     virtual XrlCmdError ripng_0_1_rip_address_enabled(
00824     // Input values,
00825     const string&   ifname,
00826     const string&   vifname,
00827     const IPv6& addr,
00828     // Output values,
00829     bool&   enabled) = 0;
00830 #ifdef XORP_ENABLE_ASYNC_SERVER
00831     typedef
00832     XorpCallback2<void, const XrlCmdError &,
00833     const bool*>::RefPtr
00834     Ripng01RipAddressEnabledRF;
00835 
00836     class Ripng01RipAddressEnabledCB {
00837         Ripng01RipAddressEnabledRF cb;
00838 
00839     public:
00840         operator const Ripng01RipAddressEnabledRF& () const { return cb; }
00841         const Ripng01RipAddressEnabledRF& operator ->() const { return cb; }
00842         Ripng01RipAddressEnabledCB(const Ripng01RipAddressEnabledRF& cb)
00843           : cb(cb) { }
00844 
00845         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00846 
00847         void respond(const bool& arg_enabled) const {
00848             cb->dispatch(XrlCmdError::OKAY(),
00849                          &arg_enabled);
00850         }
00851     };
00852 
00853     struct Ripng01RipAddressEnabledRsp :
00854       public Ripng01RipAddressEnabledCB {
00855         struct args_str {
00856             bool enabled;
00857         };
00858 
00859     private:
00860         args_str args;
00861 
00862     public:
00863         Ripng01RipAddressEnabledRsp(const Ripng01RipAddressEnabledRF& cb)
00864           : Ripng01RipAddressEnabledCB(cb) { }
00865 
00866         void respond() const {
00867             Ripng01RipAddressEnabledCB::
00868             respond(args.enabled);
00869         }
00870 
00871         args_str* operator ->() {
00872             return &args;
00873         }
00874     };
00875 
00876     virtual void async_ripng_0_1_rip_address_enabled
00877        (
00878     const string&   ifname,
00879     const string&   vifname,
00880     const IPv6& addr,
00881     Ripng01RipAddressEnabledCB);
00882 #endif
00883 
00889     virtual XrlCmdError ripng_0_1_set_cost(
00890     // Input values,
00891     const string&   ifname,
00892     const string&   vifname,
00893     const IPv6& addr,
00894     const uint32_t& cost) = 0;
00895 #ifdef XORP_ENABLE_ASYNC_SERVER
00896     typedef
00897     XorpCallback1<void, const XrlCmdError &>::RefPtr
00898     Ripng01SetCostRF;
00899 
00900     class Ripng01SetCostCB {
00901         Ripng01SetCostRF cb;
00902 
00903     public:
00904         operator const Ripng01SetCostRF& () const { return cb; }
00905         const Ripng01SetCostRF& operator ->() const { return cb; }
00906         Ripng01SetCostCB(const Ripng01SetCostRF& cb)
00907           : cb(cb) { }
00908 
00909         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00910 
00911         void respond() const {
00912             cb->dispatch(XrlCmdError::OKAY());
00913         }
00914     };
00915 
00916     struct Ripng01SetCostRsp :
00917       public Ripng01SetCostCB {
00918         Ripng01SetCostRsp(const Ripng01SetCostRF& cb)
00919           : Ripng01SetCostCB(cb) { }
00920 
00921     };
00922 
00923     virtual void async_ripng_0_1_set_cost
00924        (
00925     const string&   ifname,
00926     const string&   vifname,
00927     const IPv6& addr,
00928     const uint32_t& cost,
00929     Ripng01SetCostCB);
00930 #endif
00931 
00937     virtual XrlCmdError ripng_0_1_cost(
00938     // Input values,
00939     const string&   ifname,
00940     const string&   vifname,
00941     const IPv6& addr,
00942     // Output values,
00943     uint32_t&   cost) = 0;
00944 #ifdef XORP_ENABLE_ASYNC_SERVER
00945     typedef
00946     XorpCallback2<void, const XrlCmdError &,
00947     const uint32_t*>::RefPtr
00948     Ripng01CostRF;
00949 
00950     class Ripng01CostCB {
00951         Ripng01CostRF cb;
00952 
00953     public:
00954         operator const Ripng01CostRF& () const { return cb; }
00955         const Ripng01CostRF& operator ->() const { return cb; }
00956         Ripng01CostCB(const Ripng01CostRF& cb)
00957           : cb(cb) { }
00958 
00959         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00960 
00961         void respond(const uint32_t& arg_cost) const {
00962             cb->dispatch(XrlCmdError::OKAY(),
00963                          &arg_cost);
00964         }
00965     };
00966 
00967     struct Ripng01CostRsp :
00968       public Ripng01CostCB {
00969         struct args_str {
00970             uint32_t cost;
00971         };
00972 
00973     private:
00974         args_str args;
00975 
00976     public:
00977         Ripng01CostRsp(const Ripng01CostRF& cb)
00978           : Ripng01CostCB(cb) { }
00979 
00980         void respond() const {
00981             Ripng01CostCB::
00982             respond(args.cost);
00983         }
00984 
00985         args_str* operator ->() {
00986             return &args;
00987         }
00988     };
00989 
00990     virtual void async_ripng_0_1_cost
00991        (
00992     const string&   ifname,
00993     const string&   vifname,
00994     const IPv6& addr,
00995     Ripng01CostCB);
00996 #endif
00997 
01006     virtual XrlCmdError ripng_0_1_set_horizon(
01007     // Input values,
01008     const string&   ifname,
01009     const string&   vifname,
01010     const IPv6& addr,
01011     const string&   horizon) = 0;
01012 #ifdef XORP_ENABLE_ASYNC_SERVER
01013     typedef
01014     XorpCallback1<void, const XrlCmdError &>::RefPtr
01015     Ripng01SetHorizonRF;
01016 
01017     class Ripng01SetHorizonCB {
01018         Ripng01SetHorizonRF cb;
01019 
01020     public:
01021         operator const Ripng01SetHorizonRF& () const { return cb; }
01022         const Ripng01SetHorizonRF& operator ->() const { return cb; }
01023         Ripng01SetHorizonCB(const Ripng01SetHorizonRF& cb)
01024           : cb(cb) { }
01025 
01026         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01027 
01028         void respond() const {
01029             cb->dispatch(XrlCmdError::OKAY());
01030         }
01031     };
01032 
01033     struct Ripng01SetHorizonRsp :
01034       public Ripng01SetHorizonCB {
01035         Ripng01SetHorizonRsp(const Ripng01SetHorizonRF& cb)
01036           : Ripng01SetHorizonCB(cb) { }
01037 
01038     };
01039 
01040     virtual void async_ripng_0_1_set_horizon
01041        (
01042     const string&   ifname,
01043     const string&   vifname,
01044     const IPv6& addr,
01045     const string&   horizon,
01046     Ripng01SetHorizonCB);
01047 #endif
01048 
01054     virtual XrlCmdError ripng_0_1_horizon(
01055     // Input values,
01056     const string&   ifname,
01057     const string&   vifname,
01058     const IPv6& addr,
01059     // Output values,
01060     string& horizon) = 0;
01061 #ifdef XORP_ENABLE_ASYNC_SERVER
01062     typedef
01063     XorpCallback2<void, const XrlCmdError &,
01064     const string*>::RefPtr
01065     Ripng01HorizonRF;
01066 
01067     class Ripng01HorizonCB {
01068         Ripng01HorizonRF cb;
01069 
01070     public:
01071         operator const Ripng01HorizonRF& () const { return cb; }
01072         const Ripng01HorizonRF& operator ->() const { return cb; }
01073         Ripng01HorizonCB(const Ripng01HorizonRF& cb)
01074           : cb(cb) { }
01075 
01076         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01077 
01078         void respond(const string& arg_horizon) const {
01079             cb->dispatch(XrlCmdError::OKAY(),
01080                          &arg_horizon);
01081         }
01082     };
01083 
01084     struct Ripng01HorizonRsp :
01085       public Ripng01HorizonCB {
01086         struct args_str {
01087             string horizon;
01088         };
01089 
01090     private:
01091         args_str args;
01092 
01093     public:
01094         Ripng01HorizonRsp(const Ripng01HorizonRF& cb)
01095           : Ripng01HorizonCB(cb) { }
01096 
01097         void respond() const {
01098             Ripng01HorizonCB::
01099             respond(args.horizon);
01100         }
01101 
01102         args_str* operator ->() {
01103             return &args;
01104         }
01105     };
01106 
01107     virtual void async_ripng_0_1_horizon
01108        (
01109     const string&   ifname,
01110     const string&   vifname,
01111     const IPv6& addr,
01112     Ripng01HorizonCB);
01113 #endif
01114 
01120     virtual XrlCmdError ripng_0_1_set_passive(
01121     // Input values,
01122     const string&   ifname,
01123     const string&   vifname,
01124     const IPv6& addr,
01125     const bool& passive) = 0;
01126 #ifdef XORP_ENABLE_ASYNC_SERVER
01127     typedef
01128     XorpCallback1<void, const XrlCmdError &>::RefPtr
01129     Ripng01SetPassiveRF;
01130 
01131     class Ripng01SetPassiveCB {
01132         Ripng01SetPassiveRF cb;
01133 
01134     public:
01135         operator const Ripng01SetPassiveRF& () const { return cb; }
01136         const Ripng01SetPassiveRF& operator ->() const { return cb; }
01137         Ripng01SetPassiveCB(const Ripng01SetPassiveRF& cb)
01138           : cb(cb) { }
01139 
01140         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01141 
01142         void respond() const {
01143             cb->dispatch(XrlCmdError::OKAY());
01144         }
01145     };
01146 
01147     struct Ripng01SetPassiveRsp :
01148       public Ripng01SetPassiveCB {
01149         Ripng01SetPassiveRsp(const Ripng01SetPassiveRF& cb)
01150           : Ripng01SetPassiveCB(cb) { }
01151 
01152     };
01153 
01154     virtual void async_ripng_0_1_set_passive
01155        (
01156     const string&   ifname,
01157     const string&   vifname,
01158     const IPv6& addr,
01159     const bool& passive,
01160     Ripng01SetPassiveCB);
01161 #endif
01162 
01169     virtual XrlCmdError ripng_0_1_passive(
01170     // Input values,
01171     const string&   ifname,
01172     const string&   vifname,
01173     const IPv6& addr,
01174     // Output values,
01175     bool&   passive) = 0;
01176 #ifdef XORP_ENABLE_ASYNC_SERVER
01177     typedef
01178     XorpCallback2<void, const XrlCmdError &,
01179     const bool*>::RefPtr
01180     Ripng01PassiveRF;
01181 
01182     class Ripng01PassiveCB {
01183         Ripng01PassiveRF cb;
01184 
01185     public:
01186         operator const Ripng01PassiveRF& () const { return cb; }
01187         const Ripng01PassiveRF& operator ->() const { return cb; }
01188         Ripng01PassiveCB(const Ripng01PassiveRF& cb)
01189           : cb(cb) { }
01190 
01191         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01192 
01193         void respond(const bool& arg_passive) const {
01194             cb->dispatch(XrlCmdError::OKAY(),
01195                          &arg_passive);
01196         }
01197     };
01198 
01199     struct Ripng01PassiveRsp :
01200       public Ripng01PassiveCB {
01201         struct args_str {
01202             bool passive;
01203         };
01204 
01205     private:
01206         args_str args;
01207 
01208     public:
01209         Ripng01PassiveRsp(const Ripng01PassiveRF& cb)
01210           : Ripng01PassiveCB(cb) { }
01211 
01212         void respond() const {
01213             Ripng01PassiveCB::
01214             respond(args.passive);
01215         }
01216 
01217         args_str* operator ->() {
01218             return &args;
01219         }
01220     };
01221 
01222     virtual void async_ripng_0_1_passive
01223        (
01224     const string&   ifname,
01225     const string&   vifname,
01226     const IPv6& addr,
01227     Ripng01PassiveCB);
01228 #endif
01229 
01235     virtual XrlCmdError ripng_0_1_set_accept_non_rip_requests(
01236     // Input values,
01237     const string&   ifname,
01238     const string&   vifname,
01239     const IPv6& addr,
01240     const bool& accept) = 0;
01241 #ifdef XORP_ENABLE_ASYNC_SERVER
01242     typedef
01243     XorpCallback1<void, const XrlCmdError &>::RefPtr
01244     Ripng01SetAcceptNonRipRequestsRF;
01245 
01246     class Ripng01SetAcceptNonRipRequestsCB {
01247         Ripng01SetAcceptNonRipRequestsRF cb;
01248 
01249     public:
01250         operator const Ripng01SetAcceptNonRipRequestsRF& () const { return cb; }
01251         const Ripng01SetAcceptNonRipRequestsRF& operator ->() const { return cb; }
01252         Ripng01SetAcceptNonRipRequestsCB(const Ripng01SetAcceptNonRipRequestsRF& cb)
01253           : cb(cb) { }
01254 
01255         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01256 
01257         void respond() const {
01258             cb->dispatch(XrlCmdError::OKAY());
01259         }
01260     };
01261 
01262     struct Ripng01SetAcceptNonRipRequestsRsp :
01263       public Ripng01SetAcceptNonRipRequestsCB {
01264         Ripng01SetAcceptNonRipRequestsRsp(const Ripng01SetAcceptNonRipRequestsRF& cb)
01265           : Ripng01SetAcceptNonRipRequestsCB(cb) { }
01266 
01267     };
01268 
01269     virtual void async_ripng_0_1_set_accept_non_rip_requests
01270        (
01271     const string&   ifname,
01272     const string&   vifname,
01273     const IPv6& addr,
01274     const bool& accept,
01275     Ripng01SetAcceptNonRipRequestsCB);
01276 #endif
01277 
01284     virtual XrlCmdError ripng_0_1_accept_non_rip_requests(
01285     // Input values,
01286     const string&   ifname,
01287     const string&   vifname,
01288     const IPv6& addr,
01289     // Output values,
01290     bool&   accept) = 0;
01291 #ifdef XORP_ENABLE_ASYNC_SERVER
01292     typedef
01293     XorpCallback2<void, const XrlCmdError &,
01294     const bool*>::RefPtr
01295     Ripng01AcceptNonRipRequestsRF;
01296 
01297     class Ripng01AcceptNonRipRequestsCB {
01298         Ripng01AcceptNonRipRequestsRF cb;
01299 
01300     public:
01301         operator const Ripng01AcceptNonRipRequestsRF& () const { return cb; }
01302         const Ripng01AcceptNonRipRequestsRF& operator ->() const { return cb; }
01303         Ripng01AcceptNonRipRequestsCB(const Ripng01AcceptNonRipRequestsRF& cb)
01304           : cb(cb) { }
01305 
01306         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01307 
01308         void respond(const bool& arg_accept) const {
01309             cb->dispatch(XrlCmdError::OKAY(),
01310                          &arg_accept);
01311         }
01312     };
01313 
01314     struct Ripng01AcceptNonRipRequestsRsp :
01315       public Ripng01AcceptNonRipRequestsCB {
01316         struct args_str {
01317             bool accept;
01318         };
01319 
01320     private:
01321         args_str args;
01322 
01323     public:
01324         Ripng01AcceptNonRipRequestsRsp(const Ripng01AcceptNonRipRequestsRF& cb)
01325           : Ripng01AcceptNonRipRequestsCB(cb) { }
01326 
01327         void respond() const {
01328             Ripng01AcceptNonRipRequestsCB::
01329             respond(args.accept);
01330         }
01331 
01332         args_str* operator ->() {
01333             return &args;
01334         }
01335     };
01336 
01337     virtual void async_ripng_0_1_accept_non_rip_requests
01338        (
01339     const string&   ifname,
01340     const string&   vifname,
01341     const IPv6& addr,
01342     Ripng01AcceptNonRipRequestsCB);
01343 #endif
01344 
01350     virtual XrlCmdError ripng_0_1_set_accept_default_route(
01351     // Input values,
01352     const string&   ifname,
01353     const string&   vifname,
01354     const IPv6& addr,
01355     const bool& accept) = 0;
01356 #ifdef XORP_ENABLE_ASYNC_SERVER
01357     typedef
01358     XorpCallback1<void, const XrlCmdError &>::RefPtr
01359     Ripng01SetAcceptDefaultRouteRF;
01360 
01361     class Ripng01SetAcceptDefaultRouteCB {
01362         Ripng01SetAcceptDefaultRouteRF cb;
01363 
01364     public:
01365         operator const Ripng01SetAcceptDefaultRouteRF& () const { return cb; }
01366         const Ripng01SetAcceptDefaultRouteRF& operator ->() const { return cb; }
01367         Ripng01SetAcceptDefaultRouteCB(const Ripng01SetAcceptDefaultRouteRF& cb)
01368           : cb(cb) { }
01369 
01370         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01371 
01372         void respond() const {
01373             cb->dispatch(XrlCmdError::OKAY());
01374         }
01375     };
01376 
01377     struct Ripng01SetAcceptDefaultRouteRsp :
01378       public Ripng01SetAcceptDefaultRouteCB {
01379         Ripng01SetAcceptDefaultRouteRsp(const Ripng01SetAcceptDefaultRouteRF& cb)
01380           : Ripng01SetAcceptDefaultRouteCB(cb) { }
01381 
01382     };
01383 
01384     virtual void async_ripng_0_1_set_accept_default_route
01385        (
01386     const string&   ifname,
01387     const string&   vifname,
01388     const IPv6& addr,
01389     const bool& accept,
01390     Ripng01SetAcceptDefaultRouteCB);
01391 #endif
01392 
01398     virtual XrlCmdError ripng_0_1_accept_default_route(
01399     // Input values,
01400     const string&   ifname,
01401     const string&   vifname,
01402     const IPv6& addr,
01403     // Output values,
01404     bool&   accept) = 0;
01405 #ifdef XORP_ENABLE_ASYNC_SERVER
01406     typedef
01407     XorpCallback2<void, const XrlCmdError &,
01408     const bool*>::RefPtr
01409     Ripng01AcceptDefaultRouteRF;
01410 
01411     class Ripng01AcceptDefaultRouteCB {
01412         Ripng01AcceptDefaultRouteRF cb;
01413 
01414     public:
01415         operator const Ripng01AcceptDefaultRouteRF& () const { return cb; }
01416         const Ripng01AcceptDefaultRouteRF& operator ->() const { return cb; }
01417         Ripng01AcceptDefaultRouteCB(const Ripng01AcceptDefaultRouteRF& cb)
01418           : cb(cb) { }
01419 
01420         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01421 
01422         void respond(const bool& arg_accept) const {
01423             cb->dispatch(XrlCmdError::OKAY(),
01424                          &arg_accept);
01425         }
01426     };
01427 
01428     struct Ripng01AcceptDefaultRouteRsp :
01429       public Ripng01AcceptDefaultRouteCB {
01430         struct args_str {
01431             bool accept;
01432         };
01433 
01434     private:
01435         args_str args;
01436 
01437     public:
01438         Ripng01AcceptDefaultRouteRsp(const Ripng01AcceptDefaultRouteRF& cb)
01439           : Ripng01AcceptDefaultRouteCB(cb) { }
01440 
01441         void respond() const {
01442             Ripng01AcceptDefaultRouteCB::
01443             respond(args.accept);
01444         }
01445 
01446         args_str* operator ->() {
01447             return &args;
01448         }
01449     };
01450 
01451     virtual void async_ripng_0_1_accept_default_route
01452        (
01453     const string&   ifname,
01454     const string&   vifname,
01455     const IPv6& addr,
01456     Ripng01AcceptDefaultRouteCB);
01457 #endif
01458 
01464     virtual XrlCmdError ripng_0_1_set_advertise_default_route(
01465     // Input values,
01466     const string&   ifname,
01467     const string&   vifname,
01468     const IPv6& addr,
01469     const bool& advertise) = 0;
01470 #ifdef XORP_ENABLE_ASYNC_SERVER
01471     typedef
01472     XorpCallback1<void, const XrlCmdError &>::RefPtr
01473     Ripng01SetAdvertiseDefaultRouteRF;
01474 
01475     class Ripng01SetAdvertiseDefaultRouteCB {
01476         Ripng01SetAdvertiseDefaultRouteRF cb;
01477 
01478     public:
01479         operator const Ripng01SetAdvertiseDefaultRouteRF& () const { return cb; }
01480         const Ripng01SetAdvertiseDefaultRouteRF& operator ->() const { return cb; }
01481         Ripng01SetAdvertiseDefaultRouteCB(const Ripng01SetAdvertiseDefaultRouteRF& cb)
01482           : cb(cb) { }
01483 
01484         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01485 
01486         void respond() const {
01487             cb->dispatch(XrlCmdError::OKAY());
01488         }
01489     };
01490 
01491     struct Ripng01SetAdvertiseDefaultRouteRsp :
01492       public Ripng01SetAdvertiseDefaultRouteCB {
01493         Ripng01SetAdvertiseDefaultRouteRsp(const Ripng01SetAdvertiseDefaultRouteRF& cb)
01494           : Ripng01SetAdvertiseDefaultRouteCB(cb) { }
01495 
01496     };
01497 
01498     virtual void async_ripng_0_1_set_advertise_default_route
01499        (
01500     const string&   ifname,
01501     const string&   vifname,
01502     const IPv6& addr,
01503     const bool& advertise,
01504     Ripng01SetAdvertiseDefaultRouteCB);
01505 #endif
01506 
01512     virtual XrlCmdError ripng_0_1_advertise_default_route(
01513     // Input values,
01514     const string&   ifname,
01515     const string&   vifname,
01516     const IPv6& addr,
01517     // Output values,
01518     bool&   advertise) = 0;
01519 #ifdef XORP_ENABLE_ASYNC_SERVER
01520     typedef
01521     XorpCallback2<void, const XrlCmdError &,
01522     const bool*>::RefPtr
01523     Ripng01AdvertiseDefaultRouteRF;
01524 
01525     class Ripng01AdvertiseDefaultRouteCB {
01526         Ripng01AdvertiseDefaultRouteRF cb;
01527 
01528     public:
01529         operator const Ripng01AdvertiseDefaultRouteRF& () const { return cb; }
01530         const Ripng01AdvertiseDefaultRouteRF& operator ->() const { return cb; }
01531         Ripng01AdvertiseDefaultRouteCB(const Ripng01AdvertiseDefaultRouteRF& cb)
01532           : cb(cb) { }
01533 
01534         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01535 
01536         void respond(const bool& arg_advertise) const {
01537             cb->dispatch(XrlCmdError::OKAY(),
01538                          &arg_advertise);
01539         }
01540     };
01541 
01542     struct Ripng01AdvertiseDefaultRouteRsp :
01543       public Ripng01AdvertiseDefaultRouteCB {
01544         struct args_str {
01545             bool advertise;
01546         };
01547 
01548     private:
01549         args_str args;
01550 
01551     public:
01552         Ripng01AdvertiseDefaultRouteRsp(const Ripng01AdvertiseDefaultRouteRF& cb)
01553           : Ripng01AdvertiseDefaultRouteCB(cb) { }
01554 
01555         void respond() const {
01556             Ripng01AdvertiseDefaultRouteCB::
01557             respond(args.advertise);
01558         }
01559 
01560         args_str* operator ->() {
01561             return &args;
01562         }
01563     };
01564 
01565     virtual void async_ripng_0_1_advertise_default_route
01566        (
01567     const string&   ifname,
01568     const string&   vifname,
01569     const IPv6& addr,
01570     Ripng01AdvertiseDefaultRouteCB);
01571 #endif
01572 
01579     virtual XrlCmdError ripng_0_1_set_route_timeout(
01580     // Input values,
01581     const string&   ifname,
01582     const string&   vifname,
01583     const IPv6& addr,
01584     const uint32_t& t_secs) = 0;
01585 #ifdef XORP_ENABLE_ASYNC_SERVER
01586     typedef
01587     XorpCallback1<void, const XrlCmdError &>::RefPtr
01588     Ripng01SetRouteTimeoutRF;
01589 
01590     class Ripng01SetRouteTimeoutCB {
01591         Ripng01SetRouteTimeoutRF cb;
01592 
01593     public:
01594         operator const Ripng01SetRouteTimeoutRF& () const { return cb; }
01595         const Ripng01SetRouteTimeoutRF& operator ->() const { return cb; }
01596         Ripng01SetRouteTimeoutCB(const Ripng01SetRouteTimeoutRF& cb)
01597           : cb(cb) { }
01598 
01599         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01600 
01601         void respond() const {
01602             cb->dispatch(XrlCmdError::OKAY());
01603         }
01604     };
01605 
01606     struct Ripng01SetRouteTimeoutRsp :
01607       public Ripng01SetRouteTimeoutCB {
01608         Ripng01SetRouteTimeoutRsp(const Ripng01SetRouteTimeoutRF& cb)
01609           : Ripng01SetRouteTimeoutCB(cb) { }
01610 
01611     };
01612 
01613     virtual void async_ripng_0_1_set_route_timeout
01614        (
01615     const string&   ifname,
01616     const string&   vifname,
01617     const IPv6& addr,
01618     const uint32_t& t_secs,
01619     Ripng01SetRouteTimeoutCB);
01620 #endif
01621 
01628     virtual XrlCmdError ripng_0_1_route_timeout(
01629     // Input values,
01630     const string&   ifname,
01631     const string&   vifname,
01632     const IPv6& addr,
01633     // Output values,
01634     uint32_t&   t_secs) = 0;
01635 #ifdef XORP_ENABLE_ASYNC_SERVER
01636     typedef
01637     XorpCallback2<void, const XrlCmdError &,
01638     const uint32_t*>::RefPtr
01639     Ripng01RouteTimeoutRF;
01640 
01641     class Ripng01RouteTimeoutCB {
01642         Ripng01RouteTimeoutRF cb;
01643 
01644     public:
01645         operator const Ripng01RouteTimeoutRF& () const { return cb; }
01646         const Ripng01RouteTimeoutRF& operator ->() const { return cb; }
01647         Ripng01RouteTimeoutCB(const Ripng01RouteTimeoutRF& cb)
01648           : cb(cb) { }
01649 
01650         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01651 
01652         void respond(const uint32_t& arg_t_secs) const {
01653             cb->dispatch(XrlCmdError::OKAY(),
01654                          &arg_t_secs);
01655         }
01656     };
01657 
01658     struct Ripng01RouteTimeoutRsp :
01659       public Ripng01RouteTimeoutCB {
01660         struct args_str {
01661             uint32_t t_secs;
01662         };
01663 
01664     private:
01665         args_str args;
01666 
01667     public:
01668         Ripng01RouteTimeoutRsp(const Ripng01RouteTimeoutRF& cb)
01669           : Ripng01RouteTimeoutCB(cb) { }
01670 
01671         void respond() const {
01672             Ripng01RouteTimeoutCB::
01673             respond(args.t_secs);
01674         }
01675 
01676         args_str* operator ->() {
01677             return &args;
01678         }
01679     };
01680 
01681     virtual void async_ripng_0_1_route_timeout
01682        (
01683     const string&   ifname,
01684     const string&   vifname,
01685     const IPv6& addr,
01686     Ripng01RouteTimeoutCB);
01687 #endif
01688 
01695     virtual XrlCmdError ripng_0_1_set_deletion_delay(
01696     // Input values,
01697     const string&   ifname,
01698     const string&   vifname,
01699     const IPv6& addr,
01700     const uint32_t& t_secs) = 0;
01701 #ifdef XORP_ENABLE_ASYNC_SERVER
01702     typedef
01703     XorpCallback1<void, const XrlCmdError &>::RefPtr
01704     Ripng01SetDeletionDelayRF;
01705 
01706     class Ripng01SetDeletionDelayCB {
01707         Ripng01SetDeletionDelayRF cb;
01708 
01709     public:
01710         operator const Ripng01SetDeletionDelayRF& () const { return cb; }
01711         const Ripng01SetDeletionDelayRF& operator ->() const { return cb; }
01712         Ripng01SetDeletionDelayCB(const Ripng01SetDeletionDelayRF& cb)
01713           : cb(cb) { }
01714 
01715         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01716 
01717         void respond() const {
01718             cb->dispatch(XrlCmdError::OKAY());
01719         }
01720     };
01721 
01722     struct Ripng01SetDeletionDelayRsp :
01723       public Ripng01SetDeletionDelayCB {
01724         Ripng01SetDeletionDelayRsp(const Ripng01SetDeletionDelayRF& cb)
01725           : Ripng01SetDeletionDelayCB(cb) { }
01726 
01727     };
01728 
01729     virtual void async_ripng_0_1_set_deletion_delay
01730        (
01731     const string&   ifname,
01732     const string&   vifname,
01733     const IPv6& addr,
01734     const uint32_t& t_secs,
01735     Ripng01SetDeletionDelayCB);
01736 #endif
01737 
01744     virtual XrlCmdError ripng_0_1_deletion_delay(
01745     // Input values,
01746     const string&   ifname,
01747     const string&   vifname,
01748     const IPv6& addr,
01749     // Output values,
01750     uint32_t&   t_secs) = 0;
01751 #ifdef XORP_ENABLE_ASYNC_SERVER
01752     typedef
01753     XorpCallback2<void, const XrlCmdError &,
01754     const uint32_t*>::RefPtr
01755     Ripng01DeletionDelayRF;
01756 
01757     class Ripng01DeletionDelayCB {
01758         Ripng01DeletionDelayRF cb;
01759 
01760     public:
01761         operator const Ripng01DeletionDelayRF& () const { return cb; }
01762         const Ripng01DeletionDelayRF& operator ->() const { return cb; }
01763         Ripng01DeletionDelayCB(const Ripng01DeletionDelayRF& cb)
01764           : cb(cb) { }
01765 
01766         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01767 
01768         void respond(const uint32_t& arg_t_secs) const {
01769             cb->dispatch(XrlCmdError::OKAY(),
01770                          &arg_t_secs);
01771         }
01772     };
01773 
01774     struct Ripng01DeletionDelayRsp :
01775       public Ripng01DeletionDelayCB {
01776         struct args_str {
01777             uint32_t t_secs;
01778         };
01779 
01780     private:
01781         args_str args;
01782 
01783     public:
01784         Ripng01DeletionDelayRsp(const Ripng01DeletionDelayRF& cb)
01785           : Ripng01DeletionDelayCB(cb) { }
01786 
01787         void respond() const {
01788             Ripng01DeletionDelayCB::
01789             respond(args.t_secs);
01790         }
01791 
01792         args_str* operator ->() {
01793             return &args;
01794         }
01795     };
01796 
01797     virtual void async_ripng_0_1_deletion_delay
01798        (
01799     const string&   ifname,
01800     const string&   vifname,
01801     const IPv6& addr,
01802     Ripng01DeletionDelayCB);
01803 #endif
01804 
01811     virtual XrlCmdError ripng_0_1_set_request_interval(
01812     // Input values,
01813     const string&   ifname,
01814     const string&   vifname,
01815     const IPv6& addr,
01816     const uint32_t& t_secs) = 0;
01817 #ifdef XORP_ENABLE_ASYNC_SERVER
01818     typedef
01819     XorpCallback1<void, const XrlCmdError &>::RefPtr
01820     Ripng01SetRequestIntervalRF;
01821 
01822     class Ripng01SetRequestIntervalCB {
01823         Ripng01SetRequestIntervalRF cb;
01824 
01825     public:
01826         operator const Ripng01SetRequestIntervalRF& () const { return cb; }
01827         const Ripng01SetRequestIntervalRF& operator ->() const { return cb; }
01828         Ripng01SetRequestIntervalCB(const Ripng01SetRequestIntervalRF& cb)
01829           : cb(cb) { }
01830 
01831         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01832 
01833         void respond() const {
01834             cb->dispatch(XrlCmdError::OKAY());
01835         }
01836     };
01837 
01838     struct Ripng01SetRequestIntervalRsp :
01839       public Ripng01SetRequestIntervalCB {
01840         Ripng01SetRequestIntervalRsp(const Ripng01SetRequestIntervalRF& cb)
01841           : Ripng01SetRequestIntervalCB(cb) { }
01842 
01843     };
01844 
01845     virtual void async_ripng_0_1_set_request_interval
01846        (
01847     const string&   ifname,
01848     const string&   vifname,
01849     const IPv6& addr,
01850     const uint32_t& t_secs,
01851     Ripng01SetRequestIntervalCB);
01852 #endif
01853 
01860     virtual XrlCmdError ripng_0_1_request_interval(
01861     // Input values,
01862     const string&   ifname,
01863     const string&   vifname,
01864     const IPv6& addr,
01865     // Output values,
01866     uint32_t&   t_secs) = 0;
01867 #ifdef XORP_ENABLE_ASYNC_SERVER
01868     typedef
01869     XorpCallback2<void, const XrlCmdError &,
01870     const uint32_t*>::RefPtr
01871     Ripng01RequestIntervalRF;
01872 
01873     class Ripng01RequestIntervalCB {
01874         Ripng01RequestIntervalRF cb;
01875 
01876     public:
01877         operator const Ripng01RequestIntervalRF& () const { return cb; }
01878         const Ripng01RequestIntervalRF& operator ->() const { return cb; }
01879         Ripng01RequestIntervalCB(const Ripng01RequestIntervalRF& cb)
01880           : cb(cb) { }
01881 
01882         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01883 
01884         void respond(const uint32_t& arg_t_secs) const {
01885             cb->dispatch(XrlCmdError::OKAY(),
01886                          &arg_t_secs);
01887         }
01888     };
01889 
01890     struct Ripng01RequestIntervalRsp :
01891       public Ripng01RequestIntervalCB {
01892         struct args_str {
01893             uint32_t t_secs;
01894         };
01895 
01896     private:
01897         args_str args;
01898 
01899     public:
01900         Ripng01RequestIntervalRsp(const Ripng01RequestIntervalRF& cb)
01901           : Ripng01RequestIntervalCB(cb) { }
01902 
01903         void respond() const {
01904             Ripng01RequestIntervalCB::
01905             respond(args.t_secs);
01906         }
01907 
01908         args_str* operator ->() {
01909             return &args;
01910         }
01911     };
01912 
01913     virtual void async_ripng_0_1_request_interval
01914        (
01915     const string&   ifname,
01916     const string&   vifname,
01917     const IPv6& addr,
01918     Ripng01RequestIntervalCB);
01919 #endif
01920 
01927     virtual XrlCmdError ripng_0_1_set_update_interval(
01928     // Input values,
01929     const string&   ifname,
01930     const string&   vifname,
01931     const IPv6& addr,
01932     const uint32_t& t_secs) = 0;
01933 #ifdef XORP_ENABLE_ASYNC_SERVER
01934     typedef
01935     XorpCallback1<void, const XrlCmdError &>::RefPtr
01936     Ripng01SetUpdateIntervalRF;
01937 
01938     class Ripng01SetUpdateIntervalCB {
01939         Ripng01SetUpdateIntervalRF cb;
01940 
01941     public:
01942         operator const Ripng01SetUpdateIntervalRF& () const { return cb; }
01943         const Ripng01SetUpdateIntervalRF& operator ->() const { return cb; }
01944         Ripng01SetUpdateIntervalCB(const Ripng01SetUpdateIntervalRF& cb)
01945           : cb(cb) { }
01946 
01947         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01948 
01949         void respond() const {
01950             cb->dispatch(XrlCmdError::OKAY());
01951         }
01952     };
01953 
01954     struct Ripng01SetUpdateIntervalRsp :
01955       public Ripng01SetUpdateIntervalCB {
01956         Ripng01SetUpdateIntervalRsp(const Ripng01SetUpdateIntervalRF& cb)
01957           : Ripng01SetUpdateIntervalCB(cb) { }
01958 
01959     };
01960 
01961     virtual void async_ripng_0_1_set_update_interval
01962        (
01963     const string&   ifname,
01964     const string&   vifname,
01965     const IPv6& addr,
01966     const uint32_t& t_secs,
01967     Ripng01SetUpdateIntervalCB);
01968 #endif
01969 
01976     virtual XrlCmdError ripng_0_1_update_interval(
01977     // Input values,
01978     const string&   ifname,
01979     const string&   vifname,
01980     const IPv6& addr,
01981     // Output values,
01982     uint32_t&   t_secs) = 0;
01983 #ifdef XORP_ENABLE_ASYNC_SERVER
01984     typedef
01985     XorpCallback2<void, const XrlCmdError &,
01986     const uint32_t*>::RefPtr
01987     Ripng01UpdateIntervalRF;
01988 
01989     class Ripng01UpdateIntervalCB {
01990         Ripng01UpdateIntervalRF cb;
01991 
01992     public:
01993         operator const Ripng01UpdateIntervalRF& () const { return cb; }
01994         const Ripng01UpdateIntervalRF& operator ->() const { return cb; }
01995         Ripng01UpdateIntervalCB(const Ripng01UpdateIntervalRF& cb)
01996           : cb(cb) { }
01997 
01998         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01999 
02000         void respond(const uint32_t& arg_t_secs) const {
02001             cb->dispatch(XrlCmdError::OKAY(),
02002                          &arg_t_secs);
02003         }
02004     };
02005 
02006     struct Ripng01UpdateIntervalRsp :
02007       public Ripng01UpdateIntervalCB {
02008         struct args_str {
02009             uint32_t t_secs;
02010         };
02011 
02012     private:
02013         args_str args;
02014 
02015     public:
02016         Ripng01UpdateIntervalRsp(const Ripng01UpdateIntervalRF& cb)
02017           : Ripng01UpdateIntervalCB(cb) { }
02018 
02019         void respond() const {
02020             Ripng01UpdateIntervalCB::
02021             respond(args.t_secs);
02022         }
02023 
02024         args_str* operator ->() {
02025             return &args;
02026         }
02027     };
02028 
02029     virtual void async_ripng_0_1_update_interval
02030        (
02031     const string&   ifname,
02032     const string&   vifname,
02033     const IPv6& addr,
02034     Ripng01UpdateIntervalCB);
02035 #endif
02036 
02043     virtual XrlCmdError ripng_0_1_set_update_jitter(
02044     // Input values,
02045     const string&   ifname,
02046     const string&   vifname,
02047     const IPv6& addr,
02048     const uint32_t& t_jitter) = 0;
02049 #ifdef XORP_ENABLE_ASYNC_SERVER
02050     typedef
02051     XorpCallback1<void, const XrlCmdError &>::RefPtr
02052     Ripng01SetUpdateJitterRF;
02053 
02054     class Ripng01SetUpdateJitterCB {
02055         Ripng01SetUpdateJitterRF cb;
02056 
02057     public:
02058         operator const Ripng01SetUpdateJitterRF& () const { return cb; }
02059         const Ripng01SetUpdateJitterRF& operator ->() const { return cb; }
02060         Ripng01SetUpdateJitterCB(const Ripng01SetUpdateJitterRF& cb)
02061           : cb(cb) { }
02062 
02063         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02064 
02065         void respond() const {
02066             cb->dispatch(XrlCmdError::OKAY());
02067         }
02068     };
02069 
02070     struct Ripng01SetUpdateJitterRsp :
02071       public Ripng01SetUpdateJitterCB {
02072         Ripng01SetUpdateJitterRsp(const Ripng01SetUpdateJitterRF& cb)
02073           : Ripng01SetUpdateJitterCB(cb) { }
02074 
02075     };
02076 
02077     virtual void async_ripng_0_1_set_update_jitter
02078        (
02079     const string&   ifname,
02080     const string&   vifname,
02081     const IPv6& addr,
02082     const uint32_t& t_jitter,
02083     Ripng01SetUpdateJitterCB);
02084 #endif
02085 
02092     virtual XrlCmdError ripng_0_1_update_jitter(
02093     // Input values,
02094     const string&   ifname,
02095     const string&   vifname,
02096     const IPv6& addr,
02097     // Output values,
02098     uint32_t&   t_jitter) = 0;
02099 #ifdef XORP_ENABLE_ASYNC_SERVER
02100     typedef
02101     XorpCallback2<void, const XrlCmdError &,
02102     const uint32_t*>::RefPtr
02103     Ripng01UpdateJitterRF;
02104 
02105     class Ripng01UpdateJitterCB {
02106         Ripng01UpdateJitterRF cb;
02107 
02108     public:
02109         operator const Ripng01UpdateJitterRF& () const { return cb; }
02110         const Ripng01UpdateJitterRF& operator ->() const { return cb; }
02111         Ripng01UpdateJitterCB(const Ripng01UpdateJitterRF& cb)
02112           : cb(cb) { }
02113 
02114         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02115 
02116         void respond(const uint32_t& arg_t_jitter) const {
02117             cb->dispatch(XrlCmdError::OKAY(),
02118                          &arg_t_jitter);
02119         }
02120     };
02121 
02122     struct Ripng01UpdateJitterRsp :
02123       public Ripng01UpdateJitterCB {
02124         struct args_str {
02125             uint32_t t_jitter;
02126         };
02127 
02128     private:
02129         args_str args;
02130 
02131     public:
02132         Ripng01UpdateJitterRsp(const Ripng01UpdateJitterRF& cb)
02133           : Ripng01UpdateJitterCB(cb) { }
02134 
02135         void respond() const {
02136             Ripng01UpdateJitterCB::
02137             respond(args.t_jitter);
02138         }
02139 
02140         args_str* operator ->() {
02141             return &args;
02142         }
02143     };
02144 
02145     virtual void async_ripng_0_1_update_jitter
02146        (
02147     const string&   ifname,
02148     const string&   vifname,
02149     const IPv6& addr,
02150     Ripng01UpdateJitterCB);
02151 #endif
02152 
02158     virtual XrlCmdError ripng_0_1_set_triggered_update_delay(
02159     // Input values,
02160     const string&   ifname,
02161     const string&   vifname,
02162     const IPv6& addr,
02163     const uint32_t& t_secs) = 0;
02164 #ifdef XORP_ENABLE_ASYNC_SERVER
02165     typedef
02166     XorpCallback1<void, const XrlCmdError &>::RefPtr
02167     Ripng01SetTriggeredUpdateDelayRF;
02168 
02169     class Ripng01SetTriggeredUpdateDelayCB {
02170         Ripng01SetTriggeredUpdateDelayRF cb;
02171 
02172     public:
02173         operator const Ripng01SetTriggeredUpdateDelayRF& () const { return cb; }
02174         const Ripng01SetTriggeredUpdateDelayRF& operator ->() const { return cb; }
02175         Ripng01SetTriggeredUpdateDelayCB(const Ripng01SetTriggeredUpdateDelayRF& cb)
02176           : cb(cb) { }
02177 
02178         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02179 
02180         void respond() const {
02181             cb->dispatch(XrlCmdError::OKAY());
02182         }
02183     };
02184 
02185     struct Ripng01SetTriggeredUpdateDelayRsp :
02186       public Ripng01SetTriggeredUpdateDelayCB {
02187         Ripng01SetTriggeredUpdateDelayRsp(const Ripng01SetTriggeredUpdateDelayRF& cb)
02188           : Ripng01SetTriggeredUpdateDelayCB(cb) { }
02189 
02190     };
02191 
02192     virtual void async_ripng_0_1_set_triggered_update_delay
02193        (
02194     const string&   ifname,
02195     const string&   vifname,
02196     const IPv6& addr,
02197     const uint32_t& t_secs,
02198     Ripng01SetTriggeredUpdateDelayCB);
02199 #endif
02200 
02206     virtual XrlCmdError ripng_0_1_triggered_update_delay(
02207     // Input values,
02208     const string&   ifname,
02209     const string&   vifname,
02210     const IPv6& addr,
02211     // Output values,
02212     uint32_t&   t_secs) = 0;
02213 #ifdef XORP_ENABLE_ASYNC_SERVER
02214     typedef
02215     XorpCallback2<void, const XrlCmdError &,
02216     const uint32_t*>::RefPtr
02217     Ripng01TriggeredUpdateDelayRF;
02218 
02219     class Ripng01TriggeredUpdateDelayCB {
02220         Ripng01TriggeredUpdateDelayRF cb;
02221 
02222     public:
02223         operator const Ripng01TriggeredUpdateDelayRF& () const { return cb; }
02224         const Ripng01TriggeredUpdateDelayRF& operator ->() const { return cb; }
02225         Ripng01TriggeredUpdateDelayCB(const Ripng01TriggeredUpdateDelayRF& cb)
02226           : cb(cb) { }
02227 
02228         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02229 
02230         void respond(const uint32_t& arg_t_secs) const {
02231             cb->dispatch(XrlCmdError::OKAY(),
02232                          &arg_t_secs);
02233         }
02234     };
02235 
02236     struct Ripng01TriggeredUpdateDelayRsp :
02237       public Ripng01TriggeredUpdateDelayCB {
02238         struct args_str {
02239             uint32_t t_secs;
02240         };
02241 
02242     private:
02243         args_str args;
02244 
02245     public:
02246         Ripng01TriggeredUpdateDelayRsp(const Ripng01TriggeredUpdateDelayRF& cb)
02247           : Ripng01TriggeredUpdateDelayCB(cb) { }
02248 
02249         void respond() const {
02250             Ripng01TriggeredUpdateDelayCB::
02251             respond(args.t_secs);
02252         }
02253 
02254         args_str* operator ->() {
02255             return &args;
02256         }
02257     };
02258 
02259     virtual void async_ripng_0_1_triggered_update_delay
02260        (
02261     const string&   ifname,
02262     const string&   vifname,
02263     const IPv6& addr,
02264     Ripng01TriggeredUpdateDelayCB);
02265 #endif
02266 
02273     virtual XrlCmdError ripng_0_1_set_triggered_update_jitter(
02274     // Input values,
02275     const string&   ifname,
02276     const string&   vifname,
02277     const IPv6& addr,
02278     const uint32_t& t_jitter) = 0;
02279 #ifdef XORP_ENABLE_ASYNC_SERVER
02280     typedef
02281     XorpCallback1<void, const XrlCmdError &>::RefPtr
02282     Ripng01SetTriggeredUpdateJitterRF;
02283 
02284     class Ripng01SetTriggeredUpdateJitterCB {
02285         Ripng01SetTriggeredUpdateJitterRF cb;
02286 
02287     public:
02288         operator const Ripng01SetTriggeredUpdateJitterRF& () const { return cb; }
02289         const Ripng01SetTriggeredUpdateJitterRF& operator ->() const { return cb; }
02290         Ripng01SetTriggeredUpdateJitterCB(const Ripng01SetTriggeredUpdateJitterRF& cb)
02291           : cb(cb) { }
02292 
02293         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02294 
02295         void respond() const {
02296             cb->dispatch(XrlCmdError::OKAY());
02297         }
02298     };
02299 
02300     struct Ripng01SetTriggeredUpdateJitterRsp :
02301       public Ripng01SetTriggeredUpdateJitterCB {
02302         Ripng01SetTriggeredUpdateJitterRsp(const Ripng01SetTriggeredUpdateJitterRF& cb)
02303           : Ripng01SetTriggeredUpdateJitterCB(cb) { }
02304 
02305     };
02306 
02307     virtual void async_ripng_0_1_set_triggered_update_jitter
02308        (
02309     const string&   ifname,
02310     const string&   vifname,
02311     const IPv6& addr,
02312     const uint32_t& t_jitter,
02313     Ripng01SetTriggeredUpdateJitterCB);
02314 #endif
02315 
02322     virtual XrlCmdError ripng_0_1_triggered_update_jitter(
02323     // Input values,
02324     const string&   ifname,
02325     const string&   vifname,
02326     const IPv6& addr,
02327     // Output values,
02328     uint32_t&   t_jitter) = 0;
02329 #ifdef XORP_ENABLE_ASYNC_SERVER
02330     typedef
02331     XorpCallback2<void, const XrlCmdError &,
02332     const uint32_t*>::RefPtr
02333     Ripng01TriggeredUpdateJitterRF;
02334 
02335     class Ripng01TriggeredUpdateJitterCB {
02336         Ripng01TriggeredUpdateJitterRF cb;
02337 
02338     public:
02339         operator const Ripng01TriggeredUpdateJitterRF& () const { return cb; }
02340         const Ripng01TriggeredUpdateJitterRF& operator ->() const { return cb; }
02341         Ripng01TriggeredUpdateJitterCB(const Ripng01TriggeredUpdateJitterRF& cb)
02342           : cb(cb) { }
02343 
02344         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02345 
02346         void respond(const uint32_t& arg_t_jitter) const {
02347             cb->dispatch(XrlCmdError::OKAY(),
02348                          &arg_t_jitter);
02349         }
02350     };
02351 
02352     struct Ripng01TriggeredUpdateJitterRsp :
02353       public Ripng01TriggeredUpdateJitterCB {
02354         struct args_str {
02355             uint32_t t_jitter;
02356         };
02357 
02358     private:
02359         args_str args;
02360 
02361     public:
02362         Ripng01TriggeredUpdateJitterRsp(const Ripng01TriggeredUpdateJitterRF& cb)
02363           : Ripng01TriggeredUpdateJitterCB(cb) { }
02364 
02365         void respond() const {
02366             Ripng01TriggeredUpdateJitterCB::
02367             respond(args.t_jitter);
02368         }
02369 
02370         args_str* operator ->() {
02371             return &args;
02372         }
02373     };
02374 
02375     virtual void async_ripng_0_1_triggered_update_jitter
02376        (
02377     const string&   ifname,
02378     const string&   vifname,
02379     const IPv6& addr,
02380     Ripng01TriggeredUpdateJitterCB);
02381 #endif
02382 
02388     virtual XrlCmdError ripng_0_1_set_interpacket_delay(
02389     // Input values,
02390     const string&   ifname,
02391     const string&   vifname,
02392     const IPv6& addr,
02393     const uint32_t& t_msecs) = 0;
02394 #ifdef XORP_ENABLE_ASYNC_SERVER
02395     typedef
02396     XorpCallback1<void, const XrlCmdError &>::RefPtr
02397     Ripng01SetInterpacketDelayRF;
02398 
02399     class Ripng01SetInterpacketDelayCB {
02400         Ripng01SetInterpacketDelayRF cb;
02401 
02402     public:
02403         operator const Ripng01SetInterpacketDelayRF& () const { return cb; }
02404         const Ripng01SetInterpacketDelayRF& operator ->() const { return cb; }
02405         Ripng01SetInterpacketDelayCB(const Ripng01SetInterpacketDelayRF& cb)
02406           : cb(cb) { }
02407 
02408         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02409 
02410         void respond() const {
02411             cb->dispatch(XrlCmdError::OKAY());
02412         }
02413     };
02414 
02415     struct Ripng01SetInterpacketDelayRsp :
02416       public Ripng01SetInterpacketDelayCB {
02417         Ripng01SetInterpacketDelayRsp(const Ripng01SetInterpacketDelayRF& cb)
02418           : Ripng01SetInterpacketDelayCB(cb) { }
02419 
02420     };
02421 
02422     virtual void async_ripng_0_1_set_interpacket_delay
02423        (
02424     const string&   ifname,
02425     const string&   vifname,
02426     const IPv6& addr,
02427     const uint32_t& t_msecs,
02428     Ripng01SetInterpacketDelayCB);
02429 #endif
02430 
02436     virtual XrlCmdError ripng_0_1_interpacket_delay(
02437     // Input values,
02438     const string&   ifname,
02439     const string&   vifname,
02440     const IPv6& addr,
02441     // Output values,
02442     uint32_t&   t_msecs) = 0;
02443 #ifdef XORP_ENABLE_ASYNC_SERVER
02444     typedef
02445     XorpCallback2<void, const XrlCmdError &,
02446     const uint32_t*>::RefPtr
02447     Ripng01InterpacketDelayRF;
02448 
02449     class Ripng01InterpacketDelayCB {
02450         Ripng01InterpacketDelayRF cb;
02451 
02452     public:
02453         operator const Ripng01InterpacketDelayRF& () const { return cb; }
02454         const Ripng01InterpacketDelayRF& operator ->() const { return cb; }
02455         Ripng01InterpacketDelayCB(const Ripng01InterpacketDelayRF& cb)
02456           : cb(cb) { }
02457 
02458         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02459 
02460         void respond(const uint32_t& arg_t_msecs) const {
02461             cb->dispatch(XrlCmdError::OKAY(),
02462                          &arg_t_msecs);
02463         }
02464     };
02465 
02466     struct Ripng01InterpacketDelayRsp :
02467       public Ripng01InterpacketDelayCB {
02468         struct args_str {
02469             uint32_t t_msecs;
02470         };
02471 
02472     private:
02473         args_str args;
02474 
02475     public:
02476         Ripng01InterpacketDelayRsp(const Ripng01InterpacketDelayRF& cb)
02477           : Ripng01InterpacketDelayCB(cb) { }
02478 
02479         void respond() const {
02480             Ripng01InterpacketDelayCB::
02481             respond(args.t_msecs);
02482         }
02483 
02484         args_str* operator ->() {
02485             return &args;
02486         }
02487     };
02488 
02489     virtual void async_ripng_0_1_interpacket_delay
02490        (
02491     const string&   ifname,
02492     const string&   vifname,
02493     const IPv6& addr,
02494     Ripng01InterpacketDelayCB);
02495 #endif
02496 
02508     virtual XrlCmdError ripng_0_1_rip_address_status(
02509     // Input values,
02510     const string&   ifname,
02511     const string&   vifname,
02512     const IPv6& addr,
02513     // Output values,
02514     string& status) = 0;
02515 #ifdef XORP_ENABLE_ASYNC_SERVER
02516     typedef
02517     XorpCallback2<void, const XrlCmdError &,
02518     const string*>::RefPtr
02519     Ripng01RipAddressStatusRF;
02520 
02521     class Ripng01RipAddressStatusCB {
02522         Ripng01RipAddressStatusRF cb;
02523 
02524     public:
02525         operator const Ripng01RipAddressStatusRF& () const { return cb; }
02526         const Ripng01RipAddressStatusRF& operator ->() const { return cb; }
02527         Ripng01RipAddressStatusCB(const Ripng01RipAddressStatusRF& cb)
02528           : cb(cb) { }
02529 
02530         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02531 
02532         void respond(const string& arg_status) const {
02533             cb->dispatch(XrlCmdError::OKAY(),
02534                          &arg_status);
02535         }
02536     };
02537 
02538     struct Ripng01RipAddressStatusRsp :
02539       public Ripng01RipAddressStatusCB {
02540         struct args_str {
02541             string status;
02542         };
02543 
02544     private:
02545         args_str args;
02546 
02547     public:
02548         Ripng01RipAddressStatusRsp(const Ripng01RipAddressStatusRF& cb)
02549           : Ripng01RipAddressStatusCB(cb) { }
02550 
02551         void respond() const {
02552             Ripng01RipAddressStatusCB::
02553             respond(args.status);
02554         }
02555 
02556         args_str* operator ->() {
02557             return &args;
02558         }
02559     };
02560 
02561     virtual void async_ripng_0_1_rip_address_status
02562        (
02563     const string&   ifname,
02564     const string&   vifname,
02565     const IPv6& addr,
02566     Ripng01RipAddressStatusCB);
02567 #endif
02568 
02574     virtual XrlCmdError ripng_0_1_get_all_addresses(
02575     // Output values,
02576     XrlAtomList&    ifnames,
02577     XrlAtomList&    vifnames,
02578     XrlAtomList&    addrs) = 0;
02579 #ifdef XORP_ENABLE_ASYNC_SERVER
02580     typedef
02581     XorpCallback4<void, const XrlCmdError &,
02582     const XrlAtomList*,
02583     const XrlAtomList*,
02584     const XrlAtomList*>::RefPtr
02585     Ripng01GetAllAddressesRF;
02586 
02587     class Ripng01GetAllAddressesCB {
02588         Ripng01GetAllAddressesRF cb;
02589 
02590     public:
02591         operator const Ripng01GetAllAddressesRF& () const { return cb; }
02592         const Ripng01GetAllAddressesRF& operator ->() const { return cb; }
02593         Ripng01GetAllAddressesCB(const Ripng01GetAllAddressesRF& cb)
02594           : cb(cb) { }
02595 
02596         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL); }
02597 
02598         void respond(const XrlAtomList& arg_ifnames,
02599                      const XrlAtomList& arg_vifnames,
02600                      const XrlAtomList& arg_addrs) const {
02601             cb->dispatch(XrlCmdError::OKAY(),
02602                          &arg_ifnames,
02603                          &arg_vifnames,
02604                          &arg_addrs);
02605         }
02606     };
02607 
02608     struct Ripng01GetAllAddressesRsp :
02609       public Ripng01GetAllAddressesCB {
02610         struct args_str {
02611             XrlAtomList ifnames;
02612             XrlAtomList vifnames;
02613             XrlAtomList addrs;
02614         };
02615 
02616     private:
02617         args_str args;
02618 
02619     public:
02620         Ripng01GetAllAddressesRsp(const Ripng01GetAllAddressesRF& cb)
02621           : Ripng01GetAllAddressesCB(cb) { }
02622 
02623         void respond() const {
02624             Ripng01GetAllAddressesCB::
02625             respond(args.ifnames,
02626                         args.vifnames,
02627                         args.addrs);
02628         }
02629 
02630         args_str* operator ->() {
02631             return &args;
02632         }
02633     };
02634 
02635     virtual void async_ripng_0_1_get_all_addresses
02636        (
02637     Ripng01GetAllAddressesCB);
02638 #endif
02639 
02645     virtual XrlCmdError ripng_0_1_get_counters(
02646     // Input values,
02647     const string&   ifname,
02648     const string&   vifname,
02649     const IPv6& addr,
02650     // Output values,
02651     XrlAtomList&    counter_descriptions,
02652     XrlAtomList&    counter_values) = 0;
02653 #ifdef XORP_ENABLE_ASYNC_SERVER
02654     typedef
02655     XorpCallback3<void, const XrlCmdError &,
02656     const XrlAtomList*,
02657     const XrlAtomList*>::RefPtr
02658     Ripng01GetCountersRF;
02659 
02660     class Ripng01GetCountersCB {
02661         Ripng01GetCountersRF cb;
02662 
02663     public:
02664         operator const Ripng01GetCountersRF& () const { return cb; }
02665         const Ripng01GetCountersRF& operator ->() const { return cb; }
02666         Ripng01GetCountersCB(const Ripng01GetCountersRF& cb)
02667           : cb(cb) { }
02668 
02669         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL); }
02670 
02671         void respond(const XrlAtomList& arg_counter_descriptions,
02672                      const XrlAtomList& arg_counter_values) const {
02673             cb->dispatch(XrlCmdError::OKAY(),
02674                          &arg_counter_descriptions,
02675                          &arg_counter_values);
02676         }
02677     };
02678 
02679     struct Ripng01GetCountersRsp :
02680       public Ripng01GetCountersCB {
02681         struct args_str {
02682             XrlAtomList counter_descriptions;
02683             XrlAtomList counter_values;
02684         };
02685 
02686     private:
02687         args_str args;
02688 
02689     public:
02690         Ripng01GetCountersRsp(const Ripng01GetCountersRF& cb)
02691           : Ripng01GetCountersCB(cb) { }
02692 
02693         void respond() const {
02694             Ripng01GetCountersCB::
02695             respond(args.counter_descriptions,
02696                         args.counter_values);
02697         }
02698 
02699         args_str* operator ->() {
02700             return &args;
02701         }
02702     };
02703 
02704     virtual void async_ripng_0_1_get_counters
02705        (
02706     const string&   ifname,
02707     const string&   vifname,
02708     const IPv6& addr,
02709     Ripng01GetCountersCB);
02710 #endif
02711 
02717     virtual XrlCmdError ripng_0_1_get_peers(
02718     // Input values,
02719     const string&   ifname,
02720     const string&   vifname,
02721     const IPv6& addr,
02722     // Output values,
02723     XrlAtomList&    peers) = 0;
02724 #ifdef XORP_ENABLE_ASYNC_SERVER
02725     typedef
02726     XorpCallback2<void, const XrlCmdError &,
02727     const XrlAtomList*>::RefPtr
02728     Ripng01GetPeersRF;
02729 
02730     class Ripng01GetPeersCB {
02731         Ripng01GetPeersRF cb;
02732 
02733     public:
02734         operator const Ripng01GetPeersRF& () const { return cb; }
02735         const Ripng01GetPeersRF& operator ->() const { return cb; }
02736         Ripng01GetPeersCB(const Ripng01GetPeersRF& cb)
02737           : cb(cb) { }
02738 
02739         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02740 
02741         void respond(const XrlAtomList& arg_peers) const {
02742             cb->dispatch(XrlCmdError::OKAY(),
02743                          &arg_peers);
02744         }
02745     };
02746 
02747     struct Ripng01GetPeersRsp :
02748       public Ripng01GetPeersCB {
02749         struct args_str {
02750             XrlAtomList peers;
02751         };
02752 
02753     private:
02754         args_str args;
02755 
02756     public:
02757         Ripng01GetPeersRsp(const Ripng01GetPeersRF& cb)
02758           : Ripng01GetPeersCB(cb) { }
02759 
02760         void respond() const {
02761             Ripng01GetPeersCB::
02762             respond(args.peers);
02763         }
02764 
02765         args_str* operator ->() {
02766             return &args;
02767         }
02768     };
02769 
02770     virtual void async_ripng_0_1_get_peers
02771        (
02772     const string&   ifname,
02773     const string&   vifname,
02774     const IPv6& addr,
02775     Ripng01GetPeersCB);
02776 #endif
02777 
02784     virtual XrlCmdError ripng_0_1_get_all_peers(
02785     // Output values,
02786     XrlAtomList&    peers,
02787     XrlAtomList&    ifnames,
02788     XrlAtomList&    vifnames,
02789     XrlAtomList&    addrs) = 0;
02790 #ifdef XORP_ENABLE_ASYNC_SERVER
02791     typedef
02792     XorpCallback5<void, const XrlCmdError &,
02793     const XrlAtomList*,
02794     const XrlAtomList*,
02795     const XrlAtomList*,
02796     const XrlAtomList*>::RefPtr
02797     Ripng01GetAllPeersRF;
02798 
02799     class Ripng01GetAllPeersCB {
02800         Ripng01GetAllPeersRF cb;
02801 
02802     public:
02803         operator const Ripng01GetAllPeersRF& () const { return cb; }
02804         const Ripng01GetAllPeersRF& operator ->() const { return cb; }
02805         Ripng01GetAllPeersCB(const Ripng01GetAllPeersRF& cb)
02806           : cb(cb) { }
02807 
02808         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL); }
02809 
02810         void respond(const XrlAtomList& arg_peers,
02811                      const XrlAtomList& arg_ifnames,
02812                      const XrlAtomList& arg_vifnames,
02813                      const XrlAtomList& arg_addrs) const {
02814             cb->dispatch(XrlCmdError::OKAY(),
02815                          &arg_peers,
02816                          &arg_ifnames,
02817                          &arg_vifnames,
02818                          &arg_addrs);
02819         }
02820     };
02821 
02822     struct Ripng01GetAllPeersRsp :
02823       public Ripng01GetAllPeersCB {
02824         struct args_str {
02825             XrlAtomList peers;
02826             XrlAtomList ifnames;
02827             XrlAtomList vifnames;
02828             XrlAtomList addrs;
02829         };
02830 
02831     private:
02832         args_str args;
02833 
02834     public:
02835         Ripng01GetAllPeersRsp(const Ripng01GetAllPeersRF& cb)
02836           : Ripng01GetAllPeersCB(cb) { }
02837 
02838         void respond() const {
02839             Ripng01GetAllPeersCB::
02840             respond(args.peers,
02841                         args.ifnames,
02842                         args.vifnames,
02843                         args.addrs);
02844         }
02845 
02846         args_str* operator ->() {
02847             return &args;
02848         }
02849     };
02850 
02851     virtual void async_ripng_0_1_get_all_peers
02852        (
02853     Ripng01GetAllPeersCB);
02854 #endif
02855 
02867     virtual XrlCmdError ripng_0_1_get_peer_counters(
02868     // Input values,
02869     const string&   ifname,
02870     const string&   vifname,
02871     const IPv6& addr,
02872     const IPv6& peer,
02873     // Output values,
02874     XrlAtomList&    counter_descriptions,
02875     XrlAtomList&    counter_values,
02876     uint32_t&   peer_last_active) = 0;
02877 #ifdef XORP_ENABLE_ASYNC_SERVER
02878     typedef
02879     XorpCallback4<void, const XrlCmdError &,
02880     const XrlAtomList*,
02881     const XrlAtomList*,
02882     const uint32_t*>::RefPtr
02883     Ripng01GetPeerCountersRF;
02884 
02885     class Ripng01GetPeerCountersCB {
02886         Ripng01GetPeerCountersRF cb;
02887 
02888     public:
02889         operator const Ripng01GetPeerCountersRF& () const { return cb; }
02890         const Ripng01GetPeerCountersRF& operator ->() const { return cb; }
02891         Ripng01GetPeerCountersCB(const Ripng01GetPeerCountersRF& cb)
02892           : cb(cb) { }
02893 
02894         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL); }
02895 
02896         void respond(const XrlAtomList& arg_counter_descriptions,
02897                      const XrlAtomList& arg_counter_values,
02898                      const uint32_t& arg_peer_last_active) const {
02899             cb->dispatch(XrlCmdError::OKAY(),
02900                          &arg_counter_descriptions,
02901                          &arg_counter_values,
02902                          &arg_peer_last_active);
02903         }
02904     };
02905 
02906     struct Ripng01GetPeerCountersRsp :
02907       public Ripng01GetPeerCountersCB {
02908         struct args_str {
02909             XrlAtomList counter_descriptions;
02910             XrlAtomList counter_values;
02911             uint32_t peer_last_active;
02912         };
02913 
02914     private:
02915         args_str args;
02916 
02917     public:
02918         Ripng01GetPeerCountersRsp(const Ripng01GetPeerCountersRF& cb)
02919           : Ripng01GetPeerCountersCB(cb) { }
02920 
02921         void respond() const {
02922             Ripng01GetPeerCountersCB::
02923             respond(args.counter_descriptions,
02924                         args.counter_values,
02925                         args.peer_last_active);
02926         }
02927 
02928         args_str* operator ->() {
02929             return &args;
02930         }
02931     };
02932 
02933     virtual void async_ripng_0_1_get_peer_counters
02934        (
02935     const string&   ifname,
02936     const string&   vifname,
02937     const IPv6& addr,
02938     const IPv6& peer,
02939     Ripng01GetPeerCountersCB);
02940 #endif
02941 
02951     virtual XrlCmdError ripng_0_1_trace(
02952     // Input values,
02953     const string&   tvar,
02954     const bool& enable) = 0;
02955 #ifdef XORP_ENABLE_ASYNC_SERVER
02956     typedef
02957     XorpCallback1<void, const XrlCmdError &>::RefPtr
02958     Ripng01TraceRF;
02959 
02960     class Ripng01TraceCB {
02961         Ripng01TraceRF cb;
02962 
02963     public:
02964         operator const Ripng01TraceRF& () const { return cb; }
02965         const Ripng01TraceRF& operator ->() const { return cb; }
02966         Ripng01TraceCB(const Ripng01TraceRF& cb)
02967           : cb(cb) { }
02968 
02969         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02970 
02971         void respond() const {
02972             cb->dispatch(XrlCmdError::OKAY());
02973         }
02974     };
02975 
02976     struct Ripng01TraceRsp :
02977       public Ripng01TraceCB {
02978         Ripng01TraceRsp(const Ripng01TraceRF& cb)
02979           : Ripng01TraceCB(cb) { }
02980 
02981     };
02982 
02983     virtual void async_ripng_0_1_trace
02984        (
02985     const string&   tvar,
02986     const bool& enable,
02987     Ripng01TraceCB);
02988 #endif
02989 
03011     virtual XrlCmdError socket6_user_0_1_recv_event(
03012     // Input values,
03013     const string&   sockid,
03014     const string&   if_name,
03015     const string&   vif_name,
03016     const IPv6& src_host,
03017     const uint32_t& src_port,
03018     const vector<uint8_t>&  data) = 0;
03019 #ifdef XORP_ENABLE_ASYNC_SERVER
03020     typedef
03021     XorpCallback1<void, const XrlCmdError &>::RefPtr
03022     Socket6User01RecvEventRF;
03023 
03024     class Socket6User01RecvEventCB {
03025         Socket6User01RecvEventRF cb;
03026 
03027     public:
03028         operator const Socket6User01RecvEventRF& () const { return cb; }
03029         const Socket6User01RecvEventRF& operator ->() const { return cb; }
03030         Socket6User01RecvEventCB(const Socket6User01RecvEventRF& cb)
03031           : cb(cb) { }
03032 
03033         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03034 
03035         void respond() const {
03036             cb->dispatch(XrlCmdError::OKAY());
03037         }
03038     };
03039 
03040     struct Socket6User01RecvEventRsp :
03041       public Socket6User01RecvEventCB {
03042         Socket6User01RecvEventRsp(const Socket6User01RecvEventRF& cb)
03043           : Socket6User01RecvEventCB(cb) { }
03044 
03045     };
03046 
03047     virtual void async_socket6_user_0_1_recv_event
03048        (
03049     const string&   sockid,
03050     const string&   if_name,
03051     const string&   vif_name,
03052     const IPv6& src_host,
03053     const uint32_t& src_port,
03054     const vector<uint8_t>&  data,
03055     Socket6User01RecvEventCB);
03056 #endif
03057 
03078     virtual XrlCmdError socket6_user_0_1_inbound_connect_event(
03079     // Input values,
03080     const string&   sockid,
03081     const IPv6& src_host,
03082     const uint32_t& src_port,
03083     const string&   new_sockid,
03084     // Output values,
03085     bool&   accept) = 0;
03086 #ifdef XORP_ENABLE_ASYNC_SERVER
03087     typedef
03088     XorpCallback2<void, const XrlCmdError &,
03089     const bool*>::RefPtr
03090     Socket6User01InboundConnectEventRF;
03091 
03092     class Socket6User01InboundConnectEventCB {
03093         Socket6User01InboundConnectEventRF cb;
03094 
03095     public:
03096         operator const Socket6User01InboundConnectEventRF& () const { return cb; }
03097         const Socket6User01InboundConnectEventRF& operator ->() const { return cb; }
03098         Socket6User01InboundConnectEventCB(const Socket6User01InboundConnectEventRF& cb)
03099           : cb(cb) { }
03100 
03101         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
03102 
03103         void respond(const bool& arg_accept) const {
03104             cb->dispatch(XrlCmdError::OKAY(),
03105                          &arg_accept);
03106         }
03107     };
03108 
03109     struct Socket6User01InboundConnectEventRsp :
03110       public Socket6User01InboundConnectEventCB {
03111         struct args_str {
03112             bool accept;
03113         };
03114 
03115     private:
03116         args_str args;
03117 
03118     public:
03119         Socket6User01InboundConnectEventRsp(const Socket6User01InboundConnectEventRF& cb)
03120           : Socket6User01InboundConnectEventCB(cb) { }
03121 
03122         void respond() const {
03123             Socket6User01InboundConnectEventCB::
03124             respond(args.accept);
03125         }
03126 
03127         args_str* operator ->() {
03128             return &args;
03129         }
03130     };
03131 
03132     virtual void async_socket6_user_0_1_inbound_connect_event
03133        (
03134     const string&   sockid,
03135     const IPv6& src_host,
03136     const uint32_t& src_port,
03137     const string&   new_sockid,
03138     Socket6User01InboundConnectEventCB);
03139 #endif
03140 
03152     virtual XrlCmdError socket6_user_0_1_outgoing_connect_event(
03153     // Input values,
03154     const string&   sockid) = 0;
03155 #ifdef XORP_ENABLE_ASYNC_SERVER
03156     typedef
03157     XorpCallback1<void, const XrlCmdError &>::RefPtr
03158     Socket6User01OutgoingConnectEventRF;
03159 
03160     class Socket6User01OutgoingConnectEventCB {
03161         Socket6User01OutgoingConnectEventRF cb;
03162 
03163     public:
03164         operator const Socket6User01OutgoingConnectEventRF& () const { return cb; }
03165         const Socket6User01OutgoingConnectEventRF& operator ->() const { return cb; }
03166         Socket6User01OutgoingConnectEventCB(const Socket6User01OutgoingConnectEventRF& cb)
03167           : cb(cb) { }
03168 
03169         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03170 
03171         void respond() const {
03172             cb->dispatch(XrlCmdError::OKAY());
03173         }
03174     };
03175 
03176     struct Socket6User01OutgoingConnectEventRsp :
03177       public Socket6User01OutgoingConnectEventCB {
03178         Socket6User01OutgoingConnectEventRsp(const Socket6User01OutgoingConnectEventRF& cb)
03179           : Socket6User01OutgoingConnectEventCB(cb) { }
03180 
03181     };
03182 
03183     virtual void async_socket6_user_0_1_outgoing_connect_event
03184        (
03185     const string&   sockid,
03186     Socket6User01OutgoingConnectEventCB);
03187 #endif
03188 
03201     virtual XrlCmdError socket6_user_0_1_error_event(
03202     // Input values,
03203     const string&   sockid,
03204     const string&   error,
03205     const bool& fatal) = 0;
03206 #ifdef XORP_ENABLE_ASYNC_SERVER
03207     typedef
03208     XorpCallback1<void, const XrlCmdError &>::RefPtr
03209     Socket6User01ErrorEventRF;
03210 
03211     class Socket6User01ErrorEventCB {
03212         Socket6User01ErrorEventRF cb;
03213 
03214     public:
03215         operator const Socket6User01ErrorEventRF& () const { return cb; }
03216         const Socket6User01ErrorEventRF& operator ->() const { return cb; }
03217         Socket6User01ErrorEventCB(const Socket6User01ErrorEventRF& cb)
03218           : cb(cb) { }
03219 
03220         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03221 
03222         void respond() const {
03223             cb->dispatch(XrlCmdError::OKAY());
03224         }
03225     };
03226 
03227     struct Socket6User01ErrorEventRsp :
03228       public Socket6User01ErrorEventCB {
03229         Socket6User01ErrorEventRsp(const Socket6User01ErrorEventRF& cb)
03230           : Socket6User01ErrorEventCB(cb) { }
03231 
03232     };
03233 
03234     virtual void async_socket6_user_0_1_error_event
03235        (
03236     const string&   sockid,
03237     const string&   error,
03238     const bool& fatal,
03239     Socket6User01ErrorEventCB);
03240 #endif
03241 
03252     virtual XrlCmdError socket6_user_0_1_disconnect_event(
03253     // Input values,
03254     const string&   sockid) = 0;
03255 #ifdef XORP_ENABLE_ASYNC_SERVER
03256     typedef
03257     XorpCallback1<void, const XrlCmdError &>::RefPtr
03258     Socket6User01DisconnectEventRF;
03259 
03260     class Socket6User01DisconnectEventCB {
03261         Socket6User01DisconnectEventRF cb;
03262 
03263     public:
03264         operator const Socket6User01DisconnectEventRF& () const { return cb; }
03265         const Socket6User01DisconnectEventRF& operator ->() const { return cb; }
03266         Socket6User01DisconnectEventCB(const Socket6User01DisconnectEventRF& cb)
03267           : cb(cb) { }
03268 
03269         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03270 
03271         void respond() const {
03272             cb->dispatch(XrlCmdError::OKAY());
03273         }
03274     };
03275 
03276     struct Socket6User01DisconnectEventRsp :
03277       public Socket6User01DisconnectEventCB {
03278         Socket6User01DisconnectEventRsp(const Socket6User01DisconnectEventRF& cb)
03279           : Socket6User01DisconnectEventCB(cb) { }
03280 
03281     };
03282 
03283     virtual void async_socket6_user_0_1_disconnect_event
03284        (
03285     const string&   sockid,
03286     Socket6User01DisconnectEventCB);
03287 #endif
03288 
03289 private:
03290     XrlCmdRT handle_common_0_1_get_target_name(const XrlArgs& in, XrlCmdOT out);
03291 #ifdef XORP_ENABLE_ASYNC_SERVER
03292     void callback_common_0_1_get_target_name
03293        (const XrlCmdError &e,
03294     const string* arg_name,
03295         XrlRespCallback);
03296 #endif
03297 
03298     XrlCmdRT handle_common_0_1_get_version(const XrlArgs& in, XrlCmdOT out);
03299 #ifdef XORP_ENABLE_ASYNC_SERVER
03300     void callback_common_0_1_get_version
03301        (const XrlCmdError &e,
03302     const string* arg_version,
03303         XrlRespCallback);
03304 #endif
03305 
03306     XrlCmdRT handle_common_0_1_get_status(const XrlArgs& in, XrlCmdOT out);
03307 #ifdef XORP_ENABLE_ASYNC_SERVER
03308     void callback_common_0_1_get_status
03309        (const XrlCmdError &e,
03310     const uint32_t* arg_status,
03311     const string* arg_reason,
03312         XrlRespCallback);
03313 #endif
03314 
03315     XrlCmdRT handle_common_0_1_shutdown(const XrlArgs& in, XrlCmdOT out);
03316 #ifdef XORP_ENABLE_ASYNC_SERVER
03317     void callback_common_0_1_shutdown
03318        (const XrlCmdError &e,
03319         XrlRespCallback);
03320 #endif
03321 
03322     XrlCmdRT handle_common_0_1_startup(const XrlArgs& in, XrlCmdOT out);
03323 #ifdef XORP_ENABLE_ASYNC_SERVER
03324     void callback_common_0_1_startup
03325        (const XrlCmdError &e,
03326         XrlRespCallback);
03327 #endif
03328 
03329     XrlCmdRT handle_finder_event_observer_0_1_xrl_target_birth(const XrlArgs& in, XrlCmdOT out);
03330 #ifdef XORP_ENABLE_ASYNC_SERVER
03331     void callback_finder_event_observer_0_1_xrl_target_birth
03332        (const XrlCmdError &e,
03333         XrlRespCallback);
03334 #endif
03335 
03336     XrlCmdRT handle_finder_event_observer_0_1_xrl_target_death(const XrlArgs& in, XrlCmdOT out);
03337 #ifdef XORP_ENABLE_ASYNC_SERVER
03338     void callback_finder_event_observer_0_1_xrl_target_death
03339        (const XrlCmdError &e,
03340         XrlRespCallback);
03341 #endif
03342 
03343     XrlCmdRT handle_policy_backend_0_1_configure(const XrlArgs& in, XrlCmdOT out);
03344 #ifdef XORP_ENABLE_ASYNC_SERVER
03345     void callback_policy_backend_0_1_configure
03346        (const XrlCmdError &e,
03347         XrlRespCallback);
03348 #endif
03349 
03350     XrlCmdRT handle_policy_backend_0_1_reset(const XrlArgs& in, XrlCmdOT out);
03351 #ifdef XORP_ENABLE_ASYNC_SERVER
03352     void callback_policy_backend_0_1_reset
03353        (const XrlCmdError &e,
03354         XrlRespCallback);
03355 #endif
03356 
03357     XrlCmdRT handle_policy_backend_0_1_push_routes(const XrlArgs& in, XrlCmdOT out);
03358 #ifdef XORP_ENABLE_ASYNC_SERVER
03359     void callback_policy_backend_0_1_push_routes
03360        (const XrlCmdError &e,
03361         XrlRespCallback);
03362 #endif
03363 
03364     XrlCmdRT handle_policy_redist6_0_1_add_route6(const XrlArgs& in, XrlCmdOT out);
03365 #ifdef XORP_ENABLE_ASYNC_SERVER
03366     void callback_policy_redist6_0_1_add_route6
03367        (const XrlCmdError &e,
03368         XrlRespCallback);
03369 #endif
03370 
03371     XrlCmdRT handle_policy_redist6_0_1_delete_route6(const XrlArgs& in, XrlCmdOT out);
03372 #ifdef XORP_ENABLE_ASYNC_SERVER
03373     void callback_policy_redist6_0_1_delete_route6
03374        (const XrlCmdError &e,
03375         XrlRespCallback);
03376 #endif
03377 
03378     XrlCmdRT handle_ripng_0_1_add_rip_address(const XrlArgs& in, XrlCmdOT out);
03379 #ifdef XORP_ENABLE_ASYNC_SERVER
03380     void callback_ripng_0_1_add_rip_address
03381        (const XrlCmdError &e,
03382         XrlRespCallback);
03383 #endif
03384 
03385     XrlCmdRT handle_ripng_0_1_remove_rip_address(const XrlArgs& in, XrlCmdOT out);
03386 #ifdef XORP_ENABLE_ASYNC_SERVER
03387     void callback_ripng_0_1_remove_rip_address
03388        (const XrlCmdError &e,
03389         XrlRespCallback);
03390 #endif
03391 
03392     XrlCmdRT handle_ripng_0_1_set_rip_address_enabled(const XrlArgs& in, XrlCmdOT out);
03393 #ifdef XORP_ENABLE_ASYNC_SERVER
03394     void callback_ripng_0_1_set_rip_address_enabled
03395        (const XrlCmdError &e,
03396         XrlRespCallback);
03397 #endif
03398 
03399     XrlCmdRT handle_ripng_0_1_rip_address_enabled(const XrlArgs& in, XrlCmdOT out);
03400 #ifdef XORP_ENABLE_ASYNC_SERVER
03401     void callback_ripng_0_1_rip_address_enabled
03402        (const XrlCmdError &e,
03403     const bool* arg_enabled,
03404         XrlRespCallback);
03405 #endif
03406 
03407     XrlCmdRT handle_ripng_0_1_set_cost(const XrlArgs& in, XrlCmdOT out);
03408 #ifdef XORP_ENABLE_ASYNC_SERVER
03409     void callback_ripng_0_1_set_cost
03410        (const XrlCmdError &e,
03411         XrlRespCallback);
03412 #endif
03413 
03414     XrlCmdRT handle_ripng_0_1_cost(const XrlArgs& in, XrlCmdOT out);
03415 #ifdef XORP_ENABLE_ASYNC_SERVER
03416     void callback_ripng_0_1_cost
03417        (const XrlCmdError &e,
03418     const uint32_t* arg_cost,
03419         XrlRespCallback);
03420 #endif
03421 
03422     XrlCmdRT handle_ripng_0_1_set_horizon(const XrlArgs& in, XrlCmdOT out);
03423 #ifdef XORP_ENABLE_ASYNC_SERVER
03424     void callback_ripng_0_1_set_horizon
03425        (const XrlCmdError &e,
03426         XrlRespCallback);
03427 #endif
03428 
03429     XrlCmdRT handle_ripng_0_1_horizon(const XrlArgs& in, XrlCmdOT out);
03430 #ifdef XORP_ENABLE_ASYNC_SERVER
03431     void callback_ripng_0_1_horizon
03432        (const XrlCmdError &e,
03433     const string* arg_horizon,
03434         XrlRespCallback);
03435 #endif
03436 
03437     XrlCmdRT handle_ripng_0_1_set_passive(const XrlArgs& in, XrlCmdOT out);
03438 #ifdef XORP_ENABLE_ASYNC_SERVER
03439     void callback_ripng_0_1_set_passive
03440        (const XrlCmdError &e,
03441         XrlRespCallback);
03442 #endif
03443 
03444     XrlCmdRT handle_ripng_0_1_passive(const XrlArgs& in, XrlCmdOT out);
03445 #ifdef XORP_ENABLE_ASYNC_SERVER
03446     void callback_ripng_0_1_passive
03447        (const XrlCmdError &e,
03448     const bool* arg_passive,
03449         XrlRespCallback);
03450 #endif
03451 
03452     XrlCmdRT handle_ripng_0_1_set_accept_non_rip_requests(const XrlArgs& in, XrlCmdOT out);
03453 #ifdef XORP_ENABLE_ASYNC_SERVER
03454     void callback_ripng_0_1_set_accept_non_rip_requests
03455        (const XrlCmdError &e,
03456         XrlRespCallback);
03457 #endif
03458 
03459     XrlCmdRT handle_ripng_0_1_accept_non_rip_requests(const XrlArgs& in, XrlCmdOT out);
03460 #ifdef XORP_ENABLE_ASYNC_SERVER
03461     void callback_ripng_0_1_accept_non_rip_requests
03462        (const XrlCmdError &e,
03463     const bool* arg_accept,
03464         XrlRespCallback);
03465 #endif
03466 
03467     XrlCmdRT handle_ripng_0_1_set_accept_default_route(const XrlArgs& in, XrlCmdOT out);
03468 #ifdef XORP_ENABLE_ASYNC_SERVER
03469     void callback_ripng_0_1_set_accept_default_route
03470        (const XrlCmdError &e,
03471         XrlRespCallback);
03472 #endif
03473 
03474     XrlCmdRT handle_ripng_0_1_accept_default_route(const XrlArgs& in, XrlCmdOT out);
03475 #ifdef XORP_ENABLE_ASYNC_SERVER
03476     void callback_ripng_0_1_accept_default_route
03477        (const XrlCmdError &e,
03478     const bool* arg_accept,
03479         XrlRespCallback);
03480 #endif
03481 
03482     XrlCmdRT handle_ripng_0_1_set_advertise_default_route(const XrlArgs& in, XrlCmdOT out);
03483 #ifdef XORP_ENABLE_ASYNC_SERVER
03484     void callback_ripng_0_1_set_advertise_default_route
03485        (const XrlCmdError &e,
03486         XrlRespCallback);
03487 #endif
03488 
03489     XrlCmdRT handle_ripng_0_1_advertise_default_route(const XrlArgs& in, XrlCmdOT out);
03490 #ifdef XORP_ENABLE_ASYNC_SERVER
03491     void callback_ripng_0_1_advertise_default_route
03492        (const XrlCmdError &e,
03493     const bool* arg_advertise,
03494         XrlRespCallback);
03495 #endif
03496 
03497     XrlCmdRT handle_ripng_0_1_set_route_timeout(const XrlArgs& in, XrlCmdOT out);
03498 #ifdef XORP_ENABLE_ASYNC_SERVER
03499     void callback_ripng_0_1_set_route_timeout
03500        (const XrlCmdError &e,
03501         XrlRespCallback);
03502 #endif
03503 
03504     XrlCmdRT handle_ripng_0_1_route_timeout(const XrlArgs& in, XrlCmdOT out);
03505 #ifdef XORP_ENABLE_ASYNC_SERVER
03506     void callback_ripng_0_1_route_timeout
03507        (const XrlCmdError &e,
03508     const uint32_t* arg_t_secs,
03509         XrlRespCallback);
03510 #endif
03511 
03512     XrlCmdRT handle_ripng_0_1_set_deletion_delay(const XrlArgs& in, XrlCmdOT out);
03513 #ifdef XORP_ENABLE_ASYNC_SERVER
03514     void callback_ripng_0_1_set_deletion_delay
03515        (const XrlCmdError &e,
03516         XrlRespCallback);
03517 #endif
03518 
03519     XrlCmdRT handle_ripng_0_1_deletion_delay(const XrlArgs& in, XrlCmdOT out);
03520 #ifdef XORP_ENABLE_ASYNC_SERVER
03521     void callback_ripng_0_1_deletion_delay
03522        (const XrlCmdError &e,
03523     const uint32_t* arg_t_secs,
03524         XrlRespCallback);
03525 #endif
03526 
03527     XrlCmdRT handle_ripng_0_1_set_request_interval(const XrlArgs& in, XrlCmdOT out);
03528 #ifdef XORP_ENABLE_ASYNC_SERVER
03529     void callback_ripng_0_1_set_request_interval
03530        (const XrlCmdError &e,
03531         XrlRespCallback);
03532 #endif
03533 
03534     XrlCmdRT handle_ripng_0_1_request_interval(const XrlArgs& in, XrlCmdOT out);
03535 #ifdef XORP_ENABLE_ASYNC_SERVER
03536     void callback_ripng_0_1_request_interval
03537        (const XrlCmdError &e,
03538     const uint32_t* arg_t_secs,
03539         XrlRespCallback);
03540 #endif
03541 
03542     XrlCmdRT handle_ripng_0_1_set_update_interval(const XrlArgs& in, XrlCmdOT out);
03543 #ifdef XORP_ENABLE_ASYNC_SERVER
03544     void callback_ripng_0_1_set_update_interval
03545        (const XrlCmdError &e,
03546         XrlRespCallback);
03547 #endif
03548 
03549     XrlCmdRT handle_ripng_0_1_update_interval(const XrlArgs& in, XrlCmdOT out);
03550 #ifdef XORP_ENABLE_ASYNC_SERVER
03551     void callback_ripng_0_1_update_interval
03552        (const XrlCmdError &e,
03553     const uint32_t* arg_t_secs,
03554         XrlRespCallback);
03555 #endif
03556 
03557     XrlCmdRT handle_ripng_0_1_set_update_jitter(const XrlArgs& in, XrlCmdOT out);
03558 #ifdef XORP_ENABLE_ASYNC_SERVER
03559     void callback_ripng_0_1_set_update_jitter
03560        (const XrlCmdError &e,
03561         XrlRespCallback);
03562 #endif
03563 
03564     XrlCmdRT handle_ripng_0_1_update_jitter(const XrlArgs& in, XrlCmdOT out);
03565 #ifdef XORP_ENABLE_ASYNC_SERVER
03566     void callback_ripng_0_1_update_jitter
03567        (const XrlCmdError &e,
03568     const uint32_t* arg_t_jitter,
03569         XrlRespCallback);
03570 #endif
03571 
03572     XrlCmdRT handle_ripng_0_1_set_triggered_update_delay(const XrlArgs& in, XrlCmdOT out);
03573 #ifdef XORP_ENABLE_ASYNC_SERVER
03574     void callback_ripng_0_1_set_triggered_update_delay
03575        (const XrlCmdError &e,
03576         XrlRespCallback);
03577 #endif
03578 
03579     XrlCmdRT handle_ripng_0_1_triggered_update_delay(const XrlArgs& in, XrlCmdOT out);
03580 #ifdef XORP_ENABLE_ASYNC_SERVER
03581     void callback_ripng_0_1_triggered_update_delay
03582        (const XrlCmdError &e,
03583     const uint32_t* arg_t_secs,
03584         XrlRespCallback);
03585 #endif
03586 
03587     XrlCmdRT handle_ripng_0_1_set_triggered_update_jitter(const XrlArgs& in, XrlCmdOT out);
03588 #ifdef XORP_ENABLE_ASYNC_SERVER
03589     void callback_ripng_0_1_set_triggered_update_jitter
03590        (const XrlCmdError &e,
03591         XrlRespCallback);
03592 #endif
03593 
03594     XrlCmdRT handle_ripng_0_1_triggered_update_jitter(const XrlArgs& in, XrlCmdOT out);
03595 #ifdef XORP_ENABLE_ASYNC_SERVER
03596     void callback_ripng_0_1_triggered_update_jitter
03597        (const XrlCmdError &e,
03598     const uint32_t* arg_t_jitter,
03599         XrlRespCallback);
03600 #endif
03601 
03602     XrlCmdRT handle_ripng_0_1_set_interpacket_delay(const XrlArgs& in, XrlCmdOT out);
03603 #ifdef XORP_ENABLE_ASYNC_SERVER
03604     void callback_ripng_0_1_set_interpacket_delay
03605        (const XrlCmdError &e,
03606         XrlRespCallback);
03607 #endif
03608 
03609     XrlCmdRT handle_ripng_0_1_interpacket_delay(const XrlArgs& in, XrlCmdOT out);
03610 #ifdef XORP_ENABLE_ASYNC_SERVER
03611     void callback_ripng_0_1_interpacket_delay
03612        (const XrlCmdError &e,
03613     const uint32_t* arg_t_msecs,
03614         XrlRespCallback);
03615 #endif
03616 
03617     XrlCmdRT handle_ripng_0_1_rip_address_status(const XrlArgs& in, XrlCmdOT out);
03618 #ifdef XORP_ENABLE_ASYNC_SERVER
03619     void callback_ripng_0_1_rip_address_status
03620        (const XrlCmdError &e,
03621     const string* arg_status,
03622         XrlRespCallback);
03623 #endif
03624 
03625     XrlCmdRT handle_ripng_0_1_get_all_addresses(const XrlArgs& in, XrlCmdOT out);
03626 #ifdef XORP_ENABLE_ASYNC_SERVER
03627     void callback_ripng_0_1_get_all_addresses
03628        (const XrlCmdError &e,
03629     const XrlAtomList* arg_ifnames,
03630     const XrlAtomList* arg_vifnames,
03631     const XrlAtomList* arg_addrs,
03632         XrlRespCallback);
03633 #endif
03634 
03635     XrlCmdRT handle_ripng_0_1_get_counters(const XrlArgs& in, XrlCmdOT out);
03636 #ifdef XORP_ENABLE_ASYNC_SERVER
03637     void callback_ripng_0_1_get_counters
03638        (const XrlCmdError &e,
03639     const XrlAtomList* arg_counter_descriptions,
03640     const XrlAtomList* arg_counter_values,
03641         XrlRespCallback);
03642 #endif
03643 
03644     XrlCmdRT handle_ripng_0_1_get_peers(const XrlArgs& in, XrlCmdOT out);
03645 #ifdef XORP_ENABLE_ASYNC_SERVER
03646     void callback_ripng_0_1_get_peers
03647        (const XrlCmdError &e,
03648     const XrlAtomList* arg_peers,
03649         XrlRespCallback);
03650 #endif
03651 
03652     XrlCmdRT handle_ripng_0_1_get_all_peers(const XrlArgs& in, XrlCmdOT out);
03653 #ifdef XORP_ENABLE_ASYNC_SERVER
03654     void callback_ripng_0_1_get_all_peers
03655        (const XrlCmdError &e,
03656     const XrlAtomList* arg_peers,
03657     const XrlAtomList* arg_ifnames,
03658     const XrlAtomList* arg_vifnames,
03659     const XrlAtomList* arg_addrs,
03660         XrlRespCallback);
03661 #endif
03662 
03663     XrlCmdRT handle_ripng_0_1_get_peer_counters(const XrlArgs& in, XrlCmdOT out);
03664 #ifdef XORP_ENABLE_ASYNC_SERVER
03665     void callback_ripng_0_1_get_peer_counters
03666        (const XrlCmdError &e,
03667     const XrlAtomList* arg_counter_descriptions,
03668     const XrlAtomList* arg_counter_values,
03669     const uint32_t* arg_peer_last_active,
03670         XrlRespCallback);
03671 #endif
03672 
03673     XrlCmdRT handle_ripng_0_1_trace(const XrlArgs& in, XrlCmdOT out);
03674 #ifdef XORP_ENABLE_ASYNC_SERVER
03675     void callback_ripng_0_1_trace
03676        (const XrlCmdError &e,
03677         XrlRespCallback);
03678 #endif
03679 
03680     XrlCmdRT handle_socket6_user_0_1_recv_event(const XrlArgs& in, XrlCmdOT out);
03681 #ifdef XORP_ENABLE_ASYNC_SERVER
03682     void callback_socket6_user_0_1_recv_event
03683        (const XrlCmdError &e,
03684         XrlRespCallback);
03685 #endif
03686 
03687     XrlCmdRT handle_socket6_user_0_1_inbound_connect_event(const XrlArgs& in, XrlCmdOT out);
03688 #ifdef XORP_ENABLE_ASYNC_SERVER
03689     void callback_socket6_user_0_1_inbound_connect_event
03690        (const XrlCmdError &e,
03691     const bool* arg_accept,
03692         XrlRespCallback);
03693 #endif
03694 
03695     XrlCmdRT handle_socket6_user_0_1_outgoing_connect_event(const XrlArgs& in, XrlCmdOT out);
03696 #ifdef XORP_ENABLE_ASYNC_SERVER
03697     void callback_socket6_user_0_1_outgoing_connect_event
03698        (const XrlCmdError &e,
03699         XrlRespCallback);
03700 #endif
03701 
03702     XrlCmdRT handle_socket6_user_0_1_error_event(const XrlArgs& in, XrlCmdOT out);
03703 #ifdef XORP_ENABLE_ASYNC_SERVER
03704     void callback_socket6_user_0_1_error_event
03705        (const XrlCmdError &e,
03706         XrlRespCallback);
03707 #endif
03708 
03709     XrlCmdRT handle_socket6_user_0_1_disconnect_event(const XrlArgs& in, XrlCmdOT out);
03710 #ifdef XORP_ENABLE_ASYNC_SERVER
03711     void callback_socket6_user_0_1_disconnect_event
03712        (const XrlCmdError &e,
03713         XrlRespCallback);
03714 #endif
03715 
03716     void add_handlers();
03717     void remove_handlers();
03718 
03719     struct handler_table {
03720         const char *name;
03721         XrlCmdRT (XrlRipngTargetBase::*method)(const XrlArgs&, XrlCmdOT);
03722     };
03723 
03724     static const struct handler_table handlers[];
03725     static const size_t num_handlers;
03726 };
03727 
03728 #endif // __XRL_TARGETS_RIPNG_BASE_HH__
 All Classes Namespaces Functions Variables Typedefs Enumerations