xorp

rip_base.hh

00001 /*
00002  * obj/i386-pc-mingw32/xrl/targets/rip_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_RIP_BASE_HH__
00016 #define __XRL_TARGETS_RIP_BASE_HH__
00017 
00018 #undef XORP_LIBRARY_NAME
00019 #define XORP_LIBRARY_NAME "XrlRipTarget"
00020 
00021 #include "libxorp/xlog.h"
00022 #include "libxipc/xrl_cmd_map.hh"
00023 
00024 class XrlRipTargetBase {
00025 protected:
00026     XrlCmdMap* _cmds;
00027 
00028 public:
00036     XrlRipTargetBase(XrlCmdMap* cmds = 0);
00037 
00043     virtual ~XrlRipTargetBase();
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 "rip/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_redist4_0_1_add_route4(
00575     // Input values,
00576     const IPv4Net&  network,
00577     const bool& unicast,
00578     const bool& multicast,
00579     const IPv4& 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     PolicyRedist401AddRoute4RF;
00586 
00587     class PolicyRedist401AddRoute4CB {
00588         PolicyRedist401AddRoute4RF cb;
00589 
00590     public:
00591         operator const PolicyRedist401AddRoute4RF& () const { return cb; }
00592         const PolicyRedist401AddRoute4RF& operator ->() const { return cb; }
00593         PolicyRedist401AddRoute4CB(const PolicyRedist401AddRoute4RF& 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 PolicyRedist401AddRoute4Rsp :
00604       public PolicyRedist401AddRoute4CB {
00605         PolicyRedist401AddRoute4Rsp(const PolicyRedist401AddRoute4RF& cb)
00606           : PolicyRedist401AddRoute4CB(cb) { }
00607 
00608     };
00609 
00610     virtual void async_policy_redist4_0_1_add_route4
00611        (
00612     const IPv4Net&  network,
00613     const bool& unicast,
00614     const bool& multicast,
00615     const IPv4& nexthop,
00616     const uint32_t& metric,
00617     const XrlAtomList&  policytags,
00618     PolicyRedist401AddRoute4CB);
00619 #endif
00620 
00632     virtual XrlCmdError policy_redist4_0_1_delete_route4(
00633     // Input values,
00634     const IPv4Net&  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     PolicyRedist401DeleteRoute4RF;
00641 
00642     class PolicyRedist401DeleteRoute4CB {
00643         PolicyRedist401DeleteRoute4RF cb;
00644 
00645     public:
00646         operator const PolicyRedist401DeleteRoute4RF& () const { return cb; }
00647         const PolicyRedist401DeleteRoute4RF& operator ->() const { return cb; }
00648         PolicyRedist401DeleteRoute4CB(const PolicyRedist401DeleteRoute4RF& 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 PolicyRedist401DeleteRoute4Rsp :
00659       public PolicyRedist401DeleteRoute4CB {
00660         PolicyRedist401DeleteRoute4Rsp(const PolicyRedist401DeleteRoute4RF& cb)
00661           : PolicyRedist401DeleteRoute4CB(cb) { }
00662 
00663     };
00664 
00665     virtual void async_policy_redist4_0_1_delete_route4
00666        (
00667     const IPv4Net&  network,
00668     const bool& unicast,
00669     const bool& multicast,
00670     PolicyRedist401DeleteRoute4CB);
00671 #endif
00672 
00687     virtual XrlCmdError rip_0_1_add_rip_address(
00688     // Input values,
00689     const string&   ifname,
00690     const string&   vifname,
00691     const IPv4& addr) = 0;
00692 #ifdef XORP_ENABLE_ASYNC_SERVER
00693     typedef
00694     XorpCallback1<void, const XrlCmdError &>::RefPtr
00695     Rip01AddRipAddressRF;
00696 
00697     class Rip01AddRipAddressCB {
00698         Rip01AddRipAddressRF cb;
00699 
00700     public:
00701         operator const Rip01AddRipAddressRF& () const { return cb; }
00702         const Rip01AddRipAddressRF& operator ->() const { return cb; }
00703         Rip01AddRipAddressCB(const Rip01AddRipAddressRF& 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 Rip01AddRipAddressRsp :
00714       public Rip01AddRipAddressCB {
00715         Rip01AddRipAddressRsp(const Rip01AddRipAddressRF& cb)
00716           : Rip01AddRipAddressCB(cb) { }
00717 
00718     };
00719 
00720     virtual void async_rip_0_1_add_rip_address
00721        (
00722     const string&   ifname,
00723     const string&   vifname,
00724     const IPv4& addr,
00725     Rip01AddRipAddressCB);
00726 #endif
00727 
00739     virtual XrlCmdError rip_0_1_remove_rip_address(
00740     // Input values,
00741     const string&   ifname,
00742     const string&   vifname,
00743     const IPv4& addr) = 0;
00744 #ifdef XORP_ENABLE_ASYNC_SERVER
00745     typedef
00746     XorpCallback1<void, const XrlCmdError &>::RefPtr
00747     Rip01RemoveRipAddressRF;
00748 
00749     class Rip01RemoveRipAddressCB {
00750         Rip01RemoveRipAddressRF cb;
00751 
00752     public:
00753         operator const Rip01RemoveRipAddressRF& () const { return cb; }
00754         const Rip01RemoveRipAddressRF& operator ->() const { return cb; }
00755         Rip01RemoveRipAddressCB(const Rip01RemoveRipAddressRF& 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 Rip01RemoveRipAddressRsp :
00766       public Rip01RemoveRipAddressCB {
00767         Rip01RemoveRipAddressRsp(const Rip01RemoveRipAddressRF& cb)
00768           : Rip01RemoveRipAddressCB(cb) { }
00769 
00770     };
00771 
00772     virtual void async_rip_0_1_remove_rip_address
00773        (
00774     const string&   ifname,
00775     const string&   vifname,
00776     const IPv4& addr,
00777     Rip01RemoveRipAddressCB);
00778 #endif
00779 
00780     virtual XrlCmdError rip_0_1_set_rip_address_enabled(
00781     // Input values,
00782     const string&   ifname,
00783     const string&   vifname,
00784     const IPv4& addr,
00785     const bool& enabled) = 0;
00786 #ifdef XORP_ENABLE_ASYNC_SERVER
00787     typedef
00788     XorpCallback1<void, const XrlCmdError &>::RefPtr
00789     Rip01SetRipAddressEnabledRF;
00790 
00791     class Rip01SetRipAddressEnabledCB {
00792         Rip01SetRipAddressEnabledRF cb;
00793 
00794     public:
00795         operator const Rip01SetRipAddressEnabledRF& () const { return cb; }
00796         const Rip01SetRipAddressEnabledRF& operator ->() const { return cb; }
00797         Rip01SetRipAddressEnabledCB(const Rip01SetRipAddressEnabledRF& 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 Rip01SetRipAddressEnabledRsp :
00808       public Rip01SetRipAddressEnabledCB {
00809         Rip01SetRipAddressEnabledRsp(const Rip01SetRipAddressEnabledRF& cb)
00810           : Rip01SetRipAddressEnabledCB(cb) { }
00811 
00812     };
00813 
00814     virtual void async_rip_0_1_set_rip_address_enabled
00815        (
00816     const string&   ifname,
00817     const string&   vifname,
00818     const IPv4& addr,
00819     const bool& enabled,
00820     Rip01SetRipAddressEnabledCB);
00821 #endif
00822 
00823     virtual XrlCmdError rip_0_1_rip_address_enabled(
00824     // Input values,
00825     const string&   ifname,
00826     const string&   vifname,
00827     const IPv4& 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     Rip01RipAddressEnabledRF;
00835 
00836     class Rip01RipAddressEnabledCB {
00837         Rip01RipAddressEnabledRF cb;
00838 
00839     public:
00840         operator const Rip01RipAddressEnabledRF& () const { return cb; }
00841         const Rip01RipAddressEnabledRF& operator ->() const { return cb; }
00842         Rip01RipAddressEnabledCB(const Rip01RipAddressEnabledRF& 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 Rip01RipAddressEnabledRsp :
00854       public Rip01RipAddressEnabledCB {
00855         struct args_str {
00856             bool enabled;
00857         };
00858 
00859     private:
00860         args_str args;
00861 
00862     public:
00863         Rip01RipAddressEnabledRsp(const Rip01RipAddressEnabledRF& cb)
00864           : Rip01RipAddressEnabledCB(cb) { }
00865 
00866         void respond() const {
00867             Rip01RipAddressEnabledCB::
00868             respond(args.enabled);
00869         }
00870 
00871         args_str* operator ->() {
00872             return &args;
00873         }
00874     };
00875 
00876     virtual void async_rip_0_1_rip_address_enabled
00877        (
00878     const string&   ifname,
00879     const string&   vifname,
00880     const IPv4& addr,
00881     Rip01RipAddressEnabledCB);
00882 #endif
00883 
00889     virtual XrlCmdError rip_0_1_set_cost(
00890     // Input values,
00891     const string&   ifname,
00892     const string&   vifname,
00893     const IPv4& addr,
00894     const uint32_t& cost) = 0;
00895 #ifdef XORP_ENABLE_ASYNC_SERVER
00896     typedef
00897     XorpCallback1<void, const XrlCmdError &>::RefPtr
00898     Rip01SetCostRF;
00899 
00900     class Rip01SetCostCB {
00901         Rip01SetCostRF cb;
00902 
00903     public:
00904         operator const Rip01SetCostRF& () const { return cb; }
00905         const Rip01SetCostRF& operator ->() const { return cb; }
00906         Rip01SetCostCB(const Rip01SetCostRF& 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 Rip01SetCostRsp :
00917       public Rip01SetCostCB {
00918         Rip01SetCostRsp(const Rip01SetCostRF& cb)
00919           : Rip01SetCostCB(cb) { }
00920 
00921     };
00922 
00923     virtual void async_rip_0_1_set_cost
00924        (
00925     const string&   ifname,
00926     const string&   vifname,
00927     const IPv4& addr,
00928     const uint32_t& cost,
00929     Rip01SetCostCB);
00930 #endif
00931 
00937     virtual XrlCmdError rip_0_1_cost(
00938     // Input values,
00939     const string&   ifname,
00940     const string&   vifname,
00941     const IPv4& 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     Rip01CostRF;
00949 
00950     class Rip01CostCB {
00951         Rip01CostRF cb;
00952 
00953     public:
00954         operator const Rip01CostRF& () const { return cb; }
00955         const Rip01CostRF& operator ->() const { return cb; }
00956         Rip01CostCB(const Rip01CostRF& 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 Rip01CostRsp :
00968       public Rip01CostCB {
00969         struct args_str {
00970             uint32_t cost;
00971         };
00972 
00973     private:
00974         args_str args;
00975 
00976     public:
00977         Rip01CostRsp(const Rip01CostRF& cb)
00978           : Rip01CostCB(cb) { }
00979 
00980         void respond() const {
00981             Rip01CostCB::
00982             respond(args.cost);
00983         }
00984 
00985         args_str* operator ->() {
00986             return &args;
00987         }
00988     };
00989 
00990     virtual void async_rip_0_1_cost
00991        (
00992     const string&   ifname,
00993     const string&   vifname,
00994     const IPv4& addr,
00995     Rip01CostCB);
00996 #endif
00997 
01006     virtual XrlCmdError rip_0_1_set_horizon(
01007     // Input values,
01008     const string&   ifname,
01009     const string&   vifname,
01010     const IPv4& addr,
01011     const string&   horizon) = 0;
01012 #ifdef XORP_ENABLE_ASYNC_SERVER
01013     typedef
01014     XorpCallback1<void, const XrlCmdError &>::RefPtr
01015     Rip01SetHorizonRF;
01016 
01017     class Rip01SetHorizonCB {
01018         Rip01SetHorizonRF cb;
01019 
01020     public:
01021         operator const Rip01SetHorizonRF& () const { return cb; }
01022         const Rip01SetHorizonRF& operator ->() const { return cb; }
01023         Rip01SetHorizonCB(const Rip01SetHorizonRF& 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 Rip01SetHorizonRsp :
01034       public Rip01SetHorizonCB {
01035         Rip01SetHorizonRsp(const Rip01SetHorizonRF& cb)
01036           : Rip01SetHorizonCB(cb) { }
01037 
01038     };
01039 
01040     virtual void async_rip_0_1_set_horizon
01041        (
01042     const string&   ifname,
01043     const string&   vifname,
01044     const IPv4& addr,
01045     const string&   horizon,
01046     Rip01SetHorizonCB);
01047 #endif
01048 
01054     virtual XrlCmdError rip_0_1_horizon(
01055     // Input values,
01056     const string&   ifname,
01057     const string&   vifname,
01058     const IPv4& 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     Rip01HorizonRF;
01066 
01067     class Rip01HorizonCB {
01068         Rip01HorizonRF cb;
01069 
01070     public:
01071         operator const Rip01HorizonRF& () const { return cb; }
01072         const Rip01HorizonRF& operator ->() const { return cb; }
01073         Rip01HorizonCB(const Rip01HorizonRF& 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 Rip01HorizonRsp :
01085       public Rip01HorizonCB {
01086         struct args_str {
01087             string horizon;
01088         };
01089 
01090     private:
01091         args_str args;
01092 
01093     public:
01094         Rip01HorizonRsp(const Rip01HorizonRF& cb)
01095           : Rip01HorizonCB(cb) { }
01096 
01097         void respond() const {
01098             Rip01HorizonCB::
01099             respond(args.horizon);
01100         }
01101 
01102         args_str* operator ->() {
01103             return &args;
01104         }
01105     };
01106 
01107     virtual void async_rip_0_1_horizon
01108        (
01109     const string&   ifname,
01110     const string&   vifname,
01111     const IPv4& addr,
01112     Rip01HorizonCB);
01113 #endif
01114 
01120     virtual XrlCmdError rip_0_1_set_passive(
01121     // Input values,
01122     const string&   ifname,
01123     const string&   vifname,
01124     const IPv4& addr,
01125     const bool& passive) = 0;
01126 #ifdef XORP_ENABLE_ASYNC_SERVER
01127     typedef
01128     XorpCallback1<void, const XrlCmdError &>::RefPtr
01129     Rip01SetPassiveRF;
01130 
01131     class Rip01SetPassiveCB {
01132         Rip01SetPassiveRF cb;
01133 
01134     public:
01135         operator const Rip01SetPassiveRF& () const { return cb; }
01136         const Rip01SetPassiveRF& operator ->() const { return cb; }
01137         Rip01SetPassiveCB(const Rip01SetPassiveRF& 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 Rip01SetPassiveRsp :
01148       public Rip01SetPassiveCB {
01149         Rip01SetPassiveRsp(const Rip01SetPassiveRF& cb)
01150           : Rip01SetPassiveCB(cb) { }
01151 
01152     };
01153 
01154     virtual void async_rip_0_1_set_passive
01155        (
01156     const string&   ifname,
01157     const string&   vifname,
01158     const IPv4& addr,
01159     const bool& passive,
01160     Rip01SetPassiveCB);
01161 #endif
01162 
01169     virtual XrlCmdError rip_0_1_passive(
01170     // Input values,
01171     const string&   ifname,
01172     const string&   vifname,
01173     const IPv4& 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     Rip01PassiveRF;
01181 
01182     class Rip01PassiveCB {
01183         Rip01PassiveRF cb;
01184 
01185     public:
01186         operator const Rip01PassiveRF& () const { return cb; }
01187         const Rip01PassiveRF& operator ->() const { return cb; }
01188         Rip01PassiveCB(const Rip01PassiveRF& 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 Rip01PassiveRsp :
01200       public Rip01PassiveCB {
01201         struct args_str {
01202             bool passive;
01203         };
01204 
01205     private:
01206         args_str args;
01207 
01208     public:
01209         Rip01PassiveRsp(const Rip01PassiveRF& cb)
01210           : Rip01PassiveCB(cb) { }
01211 
01212         void respond() const {
01213             Rip01PassiveCB::
01214             respond(args.passive);
01215         }
01216 
01217         args_str* operator ->() {
01218             return &args;
01219         }
01220     };
01221 
01222     virtual void async_rip_0_1_passive
01223        (
01224     const string&   ifname,
01225     const string&   vifname,
01226     const IPv4& addr,
01227     Rip01PassiveCB);
01228 #endif
01229 
01235     virtual XrlCmdError rip_0_1_set_accept_non_rip_requests(
01236     // Input values,
01237     const string&   ifname,
01238     const string&   vifname,
01239     const IPv4& addr,
01240     const bool& accept) = 0;
01241 #ifdef XORP_ENABLE_ASYNC_SERVER
01242     typedef
01243     XorpCallback1<void, const XrlCmdError &>::RefPtr
01244     Rip01SetAcceptNonRipRequestsRF;
01245 
01246     class Rip01SetAcceptNonRipRequestsCB {
01247         Rip01SetAcceptNonRipRequestsRF cb;
01248 
01249     public:
01250         operator const Rip01SetAcceptNonRipRequestsRF& () const { return cb; }
01251         const Rip01SetAcceptNonRipRequestsRF& operator ->() const { return cb; }
01252         Rip01SetAcceptNonRipRequestsCB(const Rip01SetAcceptNonRipRequestsRF& 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 Rip01SetAcceptNonRipRequestsRsp :
01263       public Rip01SetAcceptNonRipRequestsCB {
01264         Rip01SetAcceptNonRipRequestsRsp(const Rip01SetAcceptNonRipRequestsRF& cb)
01265           : Rip01SetAcceptNonRipRequestsCB(cb) { }
01266 
01267     };
01268 
01269     virtual void async_rip_0_1_set_accept_non_rip_requests
01270        (
01271     const string&   ifname,
01272     const string&   vifname,
01273     const IPv4& addr,
01274     const bool& accept,
01275     Rip01SetAcceptNonRipRequestsCB);
01276 #endif
01277 
01284     virtual XrlCmdError rip_0_1_accept_non_rip_requests(
01285     // Input values,
01286     const string&   ifname,
01287     const string&   vifname,
01288     const IPv4& 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     Rip01AcceptNonRipRequestsRF;
01296 
01297     class Rip01AcceptNonRipRequestsCB {
01298         Rip01AcceptNonRipRequestsRF cb;
01299 
01300     public:
01301         operator const Rip01AcceptNonRipRequestsRF& () const { return cb; }
01302         const Rip01AcceptNonRipRequestsRF& operator ->() const { return cb; }
01303         Rip01AcceptNonRipRequestsCB(const Rip01AcceptNonRipRequestsRF& 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 Rip01AcceptNonRipRequestsRsp :
01315       public Rip01AcceptNonRipRequestsCB {
01316         struct args_str {
01317             bool accept;
01318         };
01319 
01320     private:
01321         args_str args;
01322 
01323     public:
01324         Rip01AcceptNonRipRequestsRsp(const Rip01AcceptNonRipRequestsRF& cb)
01325           : Rip01AcceptNonRipRequestsCB(cb) { }
01326 
01327         void respond() const {
01328             Rip01AcceptNonRipRequestsCB::
01329             respond(args.accept);
01330         }
01331 
01332         args_str* operator ->() {
01333             return &args;
01334         }
01335     };
01336 
01337     virtual void async_rip_0_1_accept_non_rip_requests
01338        (
01339     const string&   ifname,
01340     const string&   vifname,
01341     const IPv4& addr,
01342     Rip01AcceptNonRipRequestsCB);
01343 #endif
01344 
01350     virtual XrlCmdError rip_0_1_set_accept_default_route(
01351     // Input values,
01352     const string&   ifname,
01353     const string&   vifname,
01354     const IPv4& addr,
01355     const bool& accept) = 0;
01356 #ifdef XORP_ENABLE_ASYNC_SERVER
01357     typedef
01358     XorpCallback1<void, const XrlCmdError &>::RefPtr
01359     Rip01SetAcceptDefaultRouteRF;
01360 
01361     class Rip01SetAcceptDefaultRouteCB {
01362         Rip01SetAcceptDefaultRouteRF cb;
01363 
01364     public:
01365         operator const Rip01SetAcceptDefaultRouteRF& () const { return cb; }
01366         const Rip01SetAcceptDefaultRouteRF& operator ->() const { return cb; }
01367         Rip01SetAcceptDefaultRouteCB(const Rip01SetAcceptDefaultRouteRF& 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 Rip01SetAcceptDefaultRouteRsp :
01378       public Rip01SetAcceptDefaultRouteCB {
01379         Rip01SetAcceptDefaultRouteRsp(const Rip01SetAcceptDefaultRouteRF& cb)
01380           : Rip01SetAcceptDefaultRouteCB(cb) { }
01381 
01382     };
01383 
01384     virtual void async_rip_0_1_set_accept_default_route
01385        (
01386     const string&   ifname,
01387     const string&   vifname,
01388     const IPv4& addr,
01389     const bool& accept,
01390     Rip01SetAcceptDefaultRouteCB);
01391 #endif
01392 
01398     virtual XrlCmdError rip_0_1_accept_default_route(
01399     // Input values,
01400     const string&   ifname,
01401     const string&   vifname,
01402     const IPv4& 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     Rip01AcceptDefaultRouteRF;
01410 
01411     class Rip01AcceptDefaultRouteCB {
01412         Rip01AcceptDefaultRouteRF cb;
01413 
01414     public:
01415         operator const Rip01AcceptDefaultRouteRF& () const { return cb; }
01416         const Rip01AcceptDefaultRouteRF& operator ->() const { return cb; }
01417         Rip01AcceptDefaultRouteCB(const Rip01AcceptDefaultRouteRF& 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 Rip01AcceptDefaultRouteRsp :
01429       public Rip01AcceptDefaultRouteCB {
01430         struct args_str {
01431             bool accept;
01432         };
01433 
01434     private:
01435         args_str args;
01436 
01437     public:
01438         Rip01AcceptDefaultRouteRsp(const Rip01AcceptDefaultRouteRF& cb)
01439           : Rip01AcceptDefaultRouteCB(cb) { }
01440 
01441         void respond() const {
01442             Rip01AcceptDefaultRouteCB::
01443             respond(args.accept);
01444         }
01445 
01446         args_str* operator ->() {
01447             return &args;
01448         }
01449     };
01450 
01451     virtual void async_rip_0_1_accept_default_route
01452        (
01453     const string&   ifname,
01454     const string&   vifname,
01455     const IPv4& addr,
01456     Rip01AcceptDefaultRouteCB);
01457 #endif
01458 
01464     virtual XrlCmdError rip_0_1_set_advertise_default_route(
01465     // Input values,
01466     const string&   ifname,
01467     const string&   vifname,
01468     const IPv4& addr,
01469     const bool& advertise) = 0;
01470 #ifdef XORP_ENABLE_ASYNC_SERVER
01471     typedef
01472     XorpCallback1<void, const XrlCmdError &>::RefPtr
01473     Rip01SetAdvertiseDefaultRouteRF;
01474 
01475     class Rip01SetAdvertiseDefaultRouteCB {
01476         Rip01SetAdvertiseDefaultRouteRF cb;
01477 
01478     public:
01479         operator const Rip01SetAdvertiseDefaultRouteRF& () const { return cb; }
01480         const Rip01SetAdvertiseDefaultRouteRF& operator ->() const { return cb; }
01481         Rip01SetAdvertiseDefaultRouteCB(const Rip01SetAdvertiseDefaultRouteRF& 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 Rip01SetAdvertiseDefaultRouteRsp :
01492       public Rip01SetAdvertiseDefaultRouteCB {
01493         Rip01SetAdvertiseDefaultRouteRsp(const Rip01SetAdvertiseDefaultRouteRF& cb)
01494           : Rip01SetAdvertiseDefaultRouteCB(cb) { }
01495 
01496     };
01497 
01498     virtual void async_rip_0_1_set_advertise_default_route
01499        (
01500     const string&   ifname,
01501     const string&   vifname,
01502     const IPv4& addr,
01503     const bool& advertise,
01504     Rip01SetAdvertiseDefaultRouteCB);
01505 #endif
01506 
01512     virtual XrlCmdError rip_0_1_advertise_default_route(
01513     // Input values,
01514     const string&   ifname,
01515     const string&   vifname,
01516     const IPv4& 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     Rip01AdvertiseDefaultRouteRF;
01524 
01525     class Rip01AdvertiseDefaultRouteCB {
01526         Rip01AdvertiseDefaultRouteRF cb;
01527 
01528     public:
01529         operator const Rip01AdvertiseDefaultRouteRF& () const { return cb; }
01530         const Rip01AdvertiseDefaultRouteRF& operator ->() const { return cb; }
01531         Rip01AdvertiseDefaultRouteCB(const Rip01AdvertiseDefaultRouteRF& 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 Rip01AdvertiseDefaultRouteRsp :
01543       public Rip01AdvertiseDefaultRouteCB {
01544         struct args_str {
01545             bool advertise;
01546         };
01547 
01548     private:
01549         args_str args;
01550 
01551     public:
01552         Rip01AdvertiseDefaultRouteRsp(const Rip01AdvertiseDefaultRouteRF& cb)
01553           : Rip01AdvertiseDefaultRouteCB(cb) { }
01554 
01555         void respond() const {
01556             Rip01AdvertiseDefaultRouteCB::
01557             respond(args.advertise);
01558         }
01559 
01560         args_str* operator ->() {
01561             return &args;
01562         }
01563     };
01564 
01565     virtual void async_rip_0_1_advertise_default_route
01566        (
01567     const string&   ifname,
01568     const string&   vifname,
01569     const IPv4& addr,
01570     Rip01AdvertiseDefaultRouteCB);
01571 #endif
01572 
01579     virtual XrlCmdError rip_0_1_set_route_timeout(
01580     // Input values,
01581     const string&   ifname,
01582     const string&   vifname,
01583     const IPv4& addr,
01584     const uint32_t& t_secs) = 0;
01585 #ifdef XORP_ENABLE_ASYNC_SERVER
01586     typedef
01587     XorpCallback1<void, const XrlCmdError &>::RefPtr
01588     Rip01SetRouteTimeoutRF;
01589 
01590     class Rip01SetRouteTimeoutCB {
01591         Rip01SetRouteTimeoutRF cb;
01592 
01593     public:
01594         operator const Rip01SetRouteTimeoutRF& () const { return cb; }
01595         const Rip01SetRouteTimeoutRF& operator ->() const { return cb; }
01596         Rip01SetRouteTimeoutCB(const Rip01SetRouteTimeoutRF& 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 Rip01SetRouteTimeoutRsp :
01607       public Rip01SetRouteTimeoutCB {
01608         Rip01SetRouteTimeoutRsp(const Rip01SetRouteTimeoutRF& cb)
01609           : Rip01SetRouteTimeoutCB(cb) { }
01610 
01611     };
01612 
01613     virtual void async_rip_0_1_set_route_timeout
01614        (
01615     const string&   ifname,
01616     const string&   vifname,
01617     const IPv4& addr,
01618     const uint32_t& t_secs,
01619     Rip01SetRouteTimeoutCB);
01620 #endif
01621 
01628     virtual XrlCmdError rip_0_1_route_timeout(
01629     // Input values,
01630     const string&   ifname,
01631     const string&   vifname,
01632     const IPv4& 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     Rip01RouteTimeoutRF;
01640 
01641     class Rip01RouteTimeoutCB {
01642         Rip01RouteTimeoutRF cb;
01643 
01644     public:
01645         operator const Rip01RouteTimeoutRF& () const { return cb; }
01646         const Rip01RouteTimeoutRF& operator ->() const { return cb; }
01647         Rip01RouteTimeoutCB(const Rip01RouteTimeoutRF& 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 Rip01RouteTimeoutRsp :
01659       public Rip01RouteTimeoutCB {
01660         struct args_str {
01661             uint32_t t_secs;
01662         };
01663 
01664     private:
01665         args_str args;
01666 
01667     public:
01668         Rip01RouteTimeoutRsp(const Rip01RouteTimeoutRF& cb)
01669           : Rip01RouteTimeoutCB(cb) { }
01670 
01671         void respond() const {
01672             Rip01RouteTimeoutCB::
01673             respond(args.t_secs);
01674         }
01675 
01676         args_str* operator ->() {
01677             return &args;
01678         }
01679     };
01680 
01681     virtual void async_rip_0_1_route_timeout
01682        (
01683     const string&   ifname,
01684     const string&   vifname,
01685     const IPv4& addr,
01686     Rip01RouteTimeoutCB);
01687 #endif
01688 
01695     virtual XrlCmdError rip_0_1_set_deletion_delay(
01696     // Input values,
01697     const string&   ifname,
01698     const string&   vifname,
01699     const IPv4& addr,
01700     const uint32_t& t_secs) = 0;
01701 #ifdef XORP_ENABLE_ASYNC_SERVER
01702     typedef
01703     XorpCallback1<void, const XrlCmdError &>::RefPtr
01704     Rip01SetDeletionDelayRF;
01705 
01706     class Rip01SetDeletionDelayCB {
01707         Rip01SetDeletionDelayRF cb;
01708 
01709     public:
01710         operator const Rip01SetDeletionDelayRF& () const { return cb; }
01711         const Rip01SetDeletionDelayRF& operator ->() const { return cb; }
01712         Rip01SetDeletionDelayCB(const Rip01SetDeletionDelayRF& 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 Rip01SetDeletionDelayRsp :
01723       public Rip01SetDeletionDelayCB {
01724         Rip01SetDeletionDelayRsp(const Rip01SetDeletionDelayRF& cb)
01725           : Rip01SetDeletionDelayCB(cb) { }
01726 
01727     };
01728 
01729     virtual void async_rip_0_1_set_deletion_delay
01730        (
01731     const string&   ifname,
01732     const string&   vifname,
01733     const IPv4& addr,
01734     const uint32_t& t_secs,
01735     Rip01SetDeletionDelayCB);
01736 #endif
01737 
01744     virtual XrlCmdError rip_0_1_deletion_delay(
01745     // Input values,
01746     const string&   ifname,
01747     const string&   vifname,
01748     const IPv4& 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     Rip01DeletionDelayRF;
01756 
01757     class Rip01DeletionDelayCB {
01758         Rip01DeletionDelayRF cb;
01759 
01760     public:
01761         operator const Rip01DeletionDelayRF& () const { return cb; }
01762         const Rip01DeletionDelayRF& operator ->() const { return cb; }
01763         Rip01DeletionDelayCB(const Rip01DeletionDelayRF& 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 Rip01DeletionDelayRsp :
01775       public Rip01DeletionDelayCB {
01776         struct args_str {
01777             uint32_t t_secs;
01778         };
01779 
01780     private:
01781         args_str args;
01782 
01783     public:
01784         Rip01DeletionDelayRsp(const Rip01DeletionDelayRF& cb)
01785           : Rip01DeletionDelayCB(cb) { }
01786 
01787         void respond() const {
01788             Rip01DeletionDelayCB::
01789             respond(args.t_secs);
01790         }
01791 
01792         args_str* operator ->() {
01793             return &args;
01794         }
01795     };
01796 
01797     virtual void async_rip_0_1_deletion_delay
01798        (
01799     const string&   ifname,
01800     const string&   vifname,
01801     const IPv4& addr,
01802     Rip01DeletionDelayCB);
01803 #endif
01804 
01811     virtual XrlCmdError rip_0_1_set_request_interval(
01812     // Input values,
01813     const string&   ifname,
01814     const string&   vifname,
01815     const IPv4& addr,
01816     const uint32_t& t_secs) = 0;
01817 #ifdef XORP_ENABLE_ASYNC_SERVER
01818     typedef
01819     XorpCallback1<void, const XrlCmdError &>::RefPtr
01820     Rip01SetRequestIntervalRF;
01821 
01822     class Rip01SetRequestIntervalCB {
01823         Rip01SetRequestIntervalRF cb;
01824 
01825     public:
01826         operator const Rip01SetRequestIntervalRF& () const { return cb; }
01827         const Rip01SetRequestIntervalRF& operator ->() const { return cb; }
01828         Rip01SetRequestIntervalCB(const Rip01SetRequestIntervalRF& 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 Rip01SetRequestIntervalRsp :
01839       public Rip01SetRequestIntervalCB {
01840         Rip01SetRequestIntervalRsp(const Rip01SetRequestIntervalRF& cb)
01841           : Rip01SetRequestIntervalCB(cb) { }
01842 
01843     };
01844 
01845     virtual void async_rip_0_1_set_request_interval
01846        (
01847     const string&   ifname,
01848     const string&   vifname,
01849     const IPv4& addr,
01850     const uint32_t& t_secs,
01851     Rip01SetRequestIntervalCB);
01852 #endif
01853 
01860     virtual XrlCmdError rip_0_1_request_interval(
01861     // Input values,
01862     const string&   ifname,
01863     const string&   vifname,
01864     const IPv4& 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     Rip01RequestIntervalRF;
01872 
01873     class Rip01RequestIntervalCB {
01874         Rip01RequestIntervalRF cb;
01875 
01876     public:
01877         operator const Rip01RequestIntervalRF& () const { return cb; }
01878         const Rip01RequestIntervalRF& operator ->() const { return cb; }
01879         Rip01RequestIntervalCB(const Rip01RequestIntervalRF& 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 Rip01RequestIntervalRsp :
01891       public Rip01RequestIntervalCB {
01892         struct args_str {
01893             uint32_t t_secs;
01894         };
01895 
01896     private:
01897         args_str args;
01898 
01899     public:
01900         Rip01RequestIntervalRsp(const Rip01RequestIntervalRF& cb)
01901           : Rip01RequestIntervalCB(cb) { }
01902 
01903         void respond() const {
01904             Rip01RequestIntervalCB::
01905             respond(args.t_secs);
01906         }
01907 
01908         args_str* operator ->() {
01909             return &args;
01910         }
01911     };
01912 
01913     virtual void async_rip_0_1_request_interval
01914        (
01915     const string&   ifname,
01916     const string&   vifname,
01917     const IPv4& addr,
01918     Rip01RequestIntervalCB);
01919 #endif
01920 
01927     virtual XrlCmdError rip_0_1_set_update_interval(
01928     // Input values,
01929     const string&   ifname,
01930     const string&   vifname,
01931     const IPv4& addr,
01932     const uint32_t& t_secs) = 0;
01933 #ifdef XORP_ENABLE_ASYNC_SERVER
01934     typedef
01935     XorpCallback1<void, const XrlCmdError &>::RefPtr
01936     Rip01SetUpdateIntervalRF;
01937 
01938     class Rip01SetUpdateIntervalCB {
01939         Rip01SetUpdateIntervalRF cb;
01940 
01941     public:
01942         operator const Rip01SetUpdateIntervalRF& () const { return cb; }
01943         const Rip01SetUpdateIntervalRF& operator ->() const { return cb; }
01944         Rip01SetUpdateIntervalCB(const Rip01SetUpdateIntervalRF& 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 Rip01SetUpdateIntervalRsp :
01955       public Rip01SetUpdateIntervalCB {
01956         Rip01SetUpdateIntervalRsp(const Rip01SetUpdateIntervalRF& cb)
01957           : Rip01SetUpdateIntervalCB(cb) { }
01958 
01959     };
01960 
01961     virtual void async_rip_0_1_set_update_interval
01962        (
01963     const string&   ifname,
01964     const string&   vifname,
01965     const IPv4& addr,
01966     const uint32_t& t_secs,
01967     Rip01SetUpdateIntervalCB);
01968 #endif
01969 
01976     virtual XrlCmdError rip_0_1_update_interval(
01977     // Input values,
01978     const string&   ifname,
01979     const string&   vifname,
01980     const IPv4& 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     Rip01UpdateIntervalRF;
01988 
01989     class Rip01UpdateIntervalCB {
01990         Rip01UpdateIntervalRF cb;
01991 
01992     public:
01993         operator const Rip01UpdateIntervalRF& () const { return cb; }
01994         const Rip01UpdateIntervalRF& operator ->() const { return cb; }
01995         Rip01UpdateIntervalCB(const Rip01UpdateIntervalRF& 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 Rip01UpdateIntervalRsp :
02007       public Rip01UpdateIntervalCB {
02008         struct args_str {
02009             uint32_t t_secs;
02010         };
02011 
02012     private:
02013         args_str args;
02014 
02015     public:
02016         Rip01UpdateIntervalRsp(const Rip01UpdateIntervalRF& cb)
02017           : Rip01UpdateIntervalCB(cb) { }
02018 
02019         void respond() const {
02020             Rip01UpdateIntervalCB::
02021             respond(args.t_secs);
02022         }
02023 
02024         args_str* operator ->() {
02025             return &args;
02026         }
02027     };
02028 
02029     virtual void async_rip_0_1_update_interval
02030        (
02031     const string&   ifname,
02032     const string&   vifname,
02033     const IPv4& addr,
02034     Rip01UpdateIntervalCB);
02035 #endif
02036 
02043     virtual XrlCmdError rip_0_1_set_update_jitter(
02044     // Input values,
02045     const string&   ifname,
02046     const string&   vifname,
02047     const IPv4& addr,
02048     const uint32_t& t_jitter) = 0;
02049 #ifdef XORP_ENABLE_ASYNC_SERVER
02050     typedef
02051     XorpCallback1<void, const XrlCmdError &>::RefPtr
02052     Rip01SetUpdateJitterRF;
02053 
02054     class Rip01SetUpdateJitterCB {
02055         Rip01SetUpdateJitterRF cb;
02056 
02057     public:
02058         operator const Rip01SetUpdateJitterRF& () const { return cb; }
02059         const Rip01SetUpdateJitterRF& operator ->() const { return cb; }
02060         Rip01SetUpdateJitterCB(const Rip01SetUpdateJitterRF& 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 Rip01SetUpdateJitterRsp :
02071       public Rip01SetUpdateJitterCB {
02072         Rip01SetUpdateJitterRsp(const Rip01SetUpdateJitterRF& cb)
02073           : Rip01SetUpdateJitterCB(cb) { }
02074 
02075     };
02076 
02077     virtual void async_rip_0_1_set_update_jitter
02078        (
02079     const string&   ifname,
02080     const string&   vifname,
02081     const IPv4& addr,
02082     const uint32_t& t_jitter,
02083     Rip01SetUpdateJitterCB);
02084 #endif
02085 
02092     virtual XrlCmdError rip_0_1_update_jitter(
02093     // Input values,
02094     const string&   ifname,
02095     const string&   vifname,
02096     const IPv4& 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     Rip01UpdateJitterRF;
02104 
02105     class Rip01UpdateJitterCB {
02106         Rip01UpdateJitterRF cb;
02107 
02108     public:
02109         operator const Rip01UpdateJitterRF& () const { return cb; }
02110         const Rip01UpdateJitterRF& operator ->() const { return cb; }
02111         Rip01UpdateJitterCB(const Rip01UpdateJitterRF& 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 Rip01UpdateJitterRsp :
02123       public Rip01UpdateJitterCB {
02124         struct args_str {
02125             uint32_t t_jitter;
02126         };
02127 
02128     private:
02129         args_str args;
02130 
02131     public:
02132         Rip01UpdateJitterRsp(const Rip01UpdateJitterRF& cb)
02133           : Rip01UpdateJitterCB(cb) { }
02134 
02135         void respond() const {
02136             Rip01UpdateJitterCB::
02137             respond(args.t_jitter);
02138         }
02139 
02140         args_str* operator ->() {
02141             return &args;
02142         }
02143     };
02144 
02145     virtual void async_rip_0_1_update_jitter
02146        (
02147     const string&   ifname,
02148     const string&   vifname,
02149     const IPv4& addr,
02150     Rip01UpdateJitterCB);
02151 #endif
02152 
02158     virtual XrlCmdError rip_0_1_set_triggered_update_delay(
02159     // Input values,
02160     const string&   ifname,
02161     const string&   vifname,
02162     const IPv4& addr,
02163     const uint32_t& t_secs) = 0;
02164 #ifdef XORP_ENABLE_ASYNC_SERVER
02165     typedef
02166     XorpCallback1<void, const XrlCmdError &>::RefPtr
02167     Rip01SetTriggeredUpdateDelayRF;
02168 
02169     class Rip01SetTriggeredUpdateDelayCB {
02170         Rip01SetTriggeredUpdateDelayRF cb;
02171 
02172     public:
02173         operator const Rip01SetTriggeredUpdateDelayRF& () const { return cb; }
02174         const Rip01SetTriggeredUpdateDelayRF& operator ->() const { return cb; }
02175         Rip01SetTriggeredUpdateDelayCB(const Rip01SetTriggeredUpdateDelayRF& 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 Rip01SetTriggeredUpdateDelayRsp :
02186       public Rip01SetTriggeredUpdateDelayCB {
02187         Rip01SetTriggeredUpdateDelayRsp(const Rip01SetTriggeredUpdateDelayRF& cb)
02188           : Rip01SetTriggeredUpdateDelayCB(cb) { }
02189 
02190     };
02191 
02192     virtual void async_rip_0_1_set_triggered_update_delay
02193        (
02194     const string&   ifname,
02195     const string&   vifname,
02196     const IPv4& addr,
02197     const uint32_t& t_secs,
02198     Rip01SetTriggeredUpdateDelayCB);
02199 #endif
02200 
02206     virtual XrlCmdError rip_0_1_triggered_update_delay(
02207     // Input values,
02208     const string&   ifname,
02209     const string&   vifname,
02210     const IPv4& 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     Rip01TriggeredUpdateDelayRF;
02218 
02219     class Rip01TriggeredUpdateDelayCB {
02220         Rip01TriggeredUpdateDelayRF cb;
02221 
02222     public:
02223         operator const Rip01TriggeredUpdateDelayRF& () const { return cb; }
02224         const Rip01TriggeredUpdateDelayRF& operator ->() const { return cb; }
02225         Rip01TriggeredUpdateDelayCB(const Rip01TriggeredUpdateDelayRF& 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 Rip01TriggeredUpdateDelayRsp :
02237       public Rip01TriggeredUpdateDelayCB {
02238         struct args_str {
02239             uint32_t t_secs;
02240         };
02241 
02242     private:
02243         args_str args;
02244 
02245     public:
02246         Rip01TriggeredUpdateDelayRsp(const Rip01TriggeredUpdateDelayRF& cb)
02247           : Rip01TriggeredUpdateDelayCB(cb) { }
02248 
02249         void respond() const {
02250             Rip01TriggeredUpdateDelayCB::
02251             respond(args.t_secs);
02252         }
02253 
02254         args_str* operator ->() {
02255             return &args;
02256         }
02257     };
02258 
02259     virtual void async_rip_0_1_triggered_update_delay
02260        (
02261     const string&   ifname,
02262     const string&   vifname,
02263     const IPv4& addr,
02264     Rip01TriggeredUpdateDelayCB);
02265 #endif
02266 
02273     virtual XrlCmdError rip_0_1_set_triggered_update_jitter(
02274     // Input values,
02275     const string&   ifname,
02276     const string&   vifname,
02277     const IPv4& addr,
02278     const uint32_t& t_jitter) = 0;
02279 #ifdef XORP_ENABLE_ASYNC_SERVER
02280     typedef
02281     XorpCallback1<void, const XrlCmdError &>::RefPtr
02282     Rip01SetTriggeredUpdateJitterRF;
02283 
02284     class Rip01SetTriggeredUpdateJitterCB {
02285         Rip01SetTriggeredUpdateJitterRF cb;
02286 
02287     public:
02288         operator const Rip01SetTriggeredUpdateJitterRF& () const { return cb; }
02289         const Rip01SetTriggeredUpdateJitterRF& operator ->() const { return cb; }
02290         Rip01SetTriggeredUpdateJitterCB(const Rip01SetTriggeredUpdateJitterRF& 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 Rip01SetTriggeredUpdateJitterRsp :
02301       public Rip01SetTriggeredUpdateJitterCB {
02302         Rip01SetTriggeredUpdateJitterRsp(const Rip01SetTriggeredUpdateJitterRF& cb)
02303           : Rip01SetTriggeredUpdateJitterCB(cb) { }
02304 
02305     };
02306 
02307     virtual void async_rip_0_1_set_triggered_update_jitter
02308        (
02309     const string&   ifname,
02310     const string&   vifname,
02311     const IPv4& addr,
02312     const uint32_t& t_jitter,
02313     Rip01SetTriggeredUpdateJitterCB);
02314 #endif
02315 
02322     virtual XrlCmdError rip_0_1_triggered_update_jitter(
02323     // Input values,
02324     const string&   ifname,
02325     const string&   vifname,
02326     const IPv4& 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     Rip01TriggeredUpdateJitterRF;
02334 
02335     class Rip01TriggeredUpdateJitterCB {
02336         Rip01TriggeredUpdateJitterRF cb;
02337 
02338     public:
02339         operator const Rip01TriggeredUpdateJitterRF& () const { return cb; }
02340         const Rip01TriggeredUpdateJitterRF& operator ->() const { return cb; }
02341         Rip01TriggeredUpdateJitterCB(const Rip01TriggeredUpdateJitterRF& 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 Rip01TriggeredUpdateJitterRsp :
02353       public Rip01TriggeredUpdateJitterCB {
02354         struct args_str {
02355             uint32_t t_jitter;
02356         };
02357 
02358     private:
02359         args_str args;
02360 
02361     public:
02362         Rip01TriggeredUpdateJitterRsp(const Rip01TriggeredUpdateJitterRF& cb)
02363           : Rip01TriggeredUpdateJitterCB(cb) { }
02364 
02365         void respond() const {
02366             Rip01TriggeredUpdateJitterCB::
02367             respond(args.t_jitter);
02368         }
02369 
02370         args_str* operator ->() {
02371             return &args;
02372         }
02373     };
02374 
02375     virtual void async_rip_0_1_triggered_update_jitter
02376        (
02377     const string&   ifname,
02378     const string&   vifname,
02379     const IPv4& addr,
02380     Rip01TriggeredUpdateJitterCB);
02381 #endif
02382 
02388     virtual XrlCmdError rip_0_1_set_interpacket_delay(
02389     // Input values,
02390     const string&   ifname,
02391     const string&   vifname,
02392     const IPv4& addr,
02393     const uint32_t& t_msecs) = 0;
02394 #ifdef XORP_ENABLE_ASYNC_SERVER
02395     typedef
02396     XorpCallback1<void, const XrlCmdError &>::RefPtr
02397     Rip01SetInterpacketDelayRF;
02398 
02399     class Rip01SetInterpacketDelayCB {
02400         Rip01SetInterpacketDelayRF cb;
02401 
02402     public:
02403         operator const Rip01SetInterpacketDelayRF& () const { return cb; }
02404         const Rip01SetInterpacketDelayRF& operator ->() const { return cb; }
02405         Rip01SetInterpacketDelayCB(const Rip01SetInterpacketDelayRF& 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 Rip01SetInterpacketDelayRsp :
02416       public Rip01SetInterpacketDelayCB {
02417         Rip01SetInterpacketDelayRsp(const Rip01SetInterpacketDelayRF& cb)
02418           : Rip01SetInterpacketDelayCB(cb) { }
02419 
02420     };
02421 
02422     virtual void async_rip_0_1_set_interpacket_delay
02423        (
02424     const string&   ifname,
02425     const string&   vifname,
02426     const IPv4& addr,
02427     const uint32_t& t_msecs,
02428     Rip01SetInterpacketDelayCB);
02429 #endif
02430 
02436     virtual XrlCmdError rip_0_1_interpacket_delay(
02437     // Input values,
02438     const string&   ifname,
02439     const string&   vifname,
02440     const IPv4& 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     Rip01InterpacketDelayRF;
02448 
02449     class Rip01InterpacketDelayCB {
02450         Rip01InterpacketDelayRF cb;
02451 
02452     public:
02453         operator const Rip01InterpacketDelayRF& () const { return cb; }
02454         const Rip01InterpacketDelayRF& operator ->() const { return cb; }
02455         Rip01InterpacketDelayCB(const Rip01InterpacketDelayRF& 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 Rip01InterpacketDelayRsp :
02467       public Rip01InterpacketDelayCB {
02468         struct args_str {
02469             uint32_t t_msecs;
02470         };
02471 
02472     private:
02473         args_str args;
02474 
02475     public:
02476         Rip01InterpacketDelayRsp(const Rip01InterpacketDelayRF& cb)
02477           : Rip01InterpacketDelayCB(cb) { }
02478 
02479         void respond() const {
02480             Rip01InterpacketDelayCB::
02481             respond(args.t_msecs);
02482         }
02483 
02484         args_str* operator ->() {
02485             return &args;
02486         }
02487     };
02488 
02489     virtual void async_rip_0_1_interpacket_delay
02490        (
02491     const string&   ifname,
02492     const string&   vifname,
02493     const IPv4& addr,
02494     Rip01InterpacketDelayCB);
02495 #endif
02496 
02510     virtual XrlCmdError rip_0_1_set_simple_authentication_key(
02511     // Input values,
02512     const string&   ifname,
02513     const string&   vifname,
02514     const IPv4& addr,
02515     const string&   password) = 0;
02516 #ifdef XORP_ENABLE_ASYNC_SERVER
02517     typedef
02518     XorpCallback1<void, const XrlCmdError &>::RefPtr
02519     Rip01SetSimpleAuthenticationKeyRF;
02520 
02521     class Rip01SetSimpleAuthenticationKeyCB {
02522         Rip01SetSimpleAuthenticationKeyRF cb;
02523 
02524     public:
02525         operator const Rip01SetSimpleAuthenticationKeyRF& () const { return cb; }
02526         const Rip01SetSimpleAuthenticationKeyRF& operator ->() const { return cb; }
02527         Rip01SetSimpleAuthenticationKeyCB(const Rip01SetSimpleAuthenticationKeyRF& cb)
02528           : cb(cb) { }
02529 
02530         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02531 
02532         void respond() const {
02533             cb->dispatch(XrlCmdError::OKAY());
02534         }
02535     };
02536 
02537     struct Rip01SetSimpleAuthenticationKeyRsp :
02538       public Rip01SetSimpleAuthenticationKeyCB {
02539         Rip01SetSimpleAuthenticationKeyRsp(const Rip01SetSimpleAuthenticationKeyRF& cb)
02540           : Rip01SetSimpleAuthenticationKeyCB(cb) { }
02541 
02542     };
02543 
02544     virtual void async_rip_0_1_set_simple_authentication_key
02545        (
02546     const string&   ifname,
02547     const string&   vifname,
02548     const IPv4& addr,
02549     const string&   password,
02550     Rip01SetSimpleAuthenticationKeyCB);
02551 #endif
02552 
02564     virtual XrlCmdError rip_0_1_delete_simple_authentication_key(
02565     // Input values,
02566     const string&   ifname,
02567     const string&   vifname,
02568     const IPv4& addr) = 0;
02569 #ifdef XORP_ENABLE_ASYNC_SERVER
02570     typedef
02571     XorpCallback1<void, const XrlCmdError &>::RefPtr
02572     Rip01DeleteSimpleAuthenticationKeyRF;
02573 
02574     class Rip01DeleteSimpleAuthenticationKeyCB {
02575         Rip01DeleteSimpleAuthenticationKeyRF cb;
02576 
02577     public:
02578         operator const Rip01DeleteSimpleAuthenticationKeyRF& () const { return cb; }
02579         const Rip01DeleteSimpleAuthenticationKeyRF& operator ->() const { return cb; }
02580         Rip01DeleteSimpleAuthenticationKeyCB(const Rip01DeleteSimpleAuthenticationKeyRF& cb)
02581           : cb(cb) { }
02582 
02583         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02584 
02585         void respond() const {
02586             cb->dispatch(XrlCmdError::OKAY());
02587         }
02588     };
02589 
02590     struct Rip01DeleteSimpleAuthenticationKeyRsp :
02591       public Rip01DeleteSimpleAuthenticationKeyCB {
02592         Rip01DeleteSimpleAuthenticationKeyRsp(const Rip01DeleteSimpleAuthenticationKeyRF& cb)
02593           : Rip01DeleteSimpleAuthenticationKeyCB(cb) { }
02594 
02595     };
02596 
02597     virtual void async_rip_0_1_delete_simple_authentication_key
02598        (
02599     const string&   ifname,
02600     const string&   vifname,
02601     const IPv4& addr,
02602     Rip01DeleteSimpleAuthenticationKeyCB);
02603 #endif
02604 
02624     virtual XrlCmdError rip_0_1_set_md5_authentication_key(
02625     // Input values,
02626     const string&   ifname,
02627     const string&   vifname,
02628     const IPv4& addr,
02629     const uint32_t& key_id,
02630     const string&   password,
02631     const string&   start_time,
02632     const string&   end_time) = 0;
02633 #ifdef XORP_ENABLE_ASYNC_SERVER
02634     typedef
02635     XorpCallback1<void, const XrlCmdError &>::RefPtr
02636     Rip01SetMd5AuthenticationKeyRF;
02637 
02638     class Rip01SetMd5AuthenticationKeyCB {
02639         Rip01SetMd5AuthenticationKeyRF cb;
02640 
02641     public:
02642         operator const Rip01SetMd5AuthenticationKeyRF& () const { return cb; }
02643         const Rip01SetMd5AuthenticationKeyRF& operator ->() const { return cb; }
02644         Rip01SetMd5AuthenticationKeyCB(const Rip01SetMd5AuthenticationKeyRF& cb)
02645           : cb(cb) { }
02646 
02647         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02648 
02649         void respond() const {
02650             cb->dispatch(XrlCmdError::OKAY());
02651         }
02652     };
02653 
02654     struct Rip01SetMd5AuthenticationKeyRsp :
02655       public Rip01SetMd5AuthenticationKeyCB {
02656         Rip01SetMd5AuthenticationKeyRsp(const Rip01SetMd5AuthenticationKeyRF& cb)
02657           : Rip01SetMd5AuthenticationKeyCB(cb) { }
02658 
02659     };
02660 
02661     virtual void async_rip_0_1_set_md5_authentication_key
02662        (
02663     const string&   ifname,
02664     const string&   vifname,
02665     const IPv4& addr,
02666     const uint32_t& key_id,
02667     const string&   password,
02668     const string&   start_time,
02669     const string&   end_time,
02670     Rip01SetMd5AuthenticationKeyCB);
02671 #endif
02672 
02686     virtual XrlCmdError rip_0_1_delete_md5_authentication_key(
02687     // Input values,
02688     const string&   ifname,
02689     const string&   vifname,
02690     const IPv4& addr,
02691     const uint32_t& key_id) = 0;
02692 #ifdef XORP_ENABLE_ASYNC_SERVER
02693     typedef
02694     XorpCallback1<void, const XrlCmdError &>::RefPtr
02695     Rip01DeleteMd5AuthenticationKeyRF;
02696 
02697     class Rip01DeleteMd5AuthenticationKeyCB {
02698         Rip01DeleteMd5AuthenticationKeyRF cb;
02699 
02700     public:
02701         operator const Rip01DeleteMd5AuthenticationKeyRF& () const { return cb; }
02702         const Rip01DeleteMd5AuthenticationKeyRF& operator ->() const { return cb; }
02703         Rip01DeleteMd5AuthenticationKeyCB(const Rip01DeleteMd5AuthenticationKeyRF& cb)
02704           : cb(cb) { }
02705 
02706         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02707 
02708         void respond() const {
02709             cb->dispatch(XrlCmdError::OKAY());
02710         }
02711     };
02712 
02713     struct Rip01DeleteMd5AuthenticationKeyRsp :
02714       public Rip01DeleteMd5AuthenticationKeyCB {
02715         Rip01DeleteMd5AuthenticationKeyRsp(const Rip01DeleteMd5AuthenticationKeyRF& cb)
02716           : Rip01DeleteMd5AuthenticationKeyCB(cb) { }
02717 
02718     };
02719 
02720     virtual void async_rip_0_1_delete_md5_authentication_key
02721        (
02722     const string&   ifname,
02723     const string&   vifname,
02724     const IPv4& addr,
02725     const uint32_t& key_id,
02726     Rip01DeleteMd5AuthenticationKeyCB);
02727 #endif
02728 
02740     virtual XrlCmdError rip_0_1_rip_address_status(
02741     // Input values,
02742     const string&   ifname,
02743     const string&   vifname,
02744     const IPv4& addr,
02745     // Output values,
02746     string& status) = 0;
02747 #ifdef XORP_ENABLE_ASYNC_SERVER
02748     typedef
02749     XorpCallback2<void, const XrlCmdError &,
02750     const string*>::RefPtr
02751     Rip01RipAddressStatusRF;
02752 
02753     class Rip01RipAddressStatusCB {
02754         Rip01RipAddressStatusRF cb;
02755 
02756     public:
02757         operator const Rip01RipAddressStatusRF& () const { return cb; }
02758         const Rip01RipAddressStatusRF& operator ->() const { return cb; }
02759         Rip01RipAddressStatusCB(const Rip01RipAddressStatusRF& cb)
02760           : cb(cb) { }
02761 
02762         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02763 
02764         void respond(const string& arg_status) const {
02765             cb->dispatch(XrlCmdError::OKAY(),
02766                          &arg_status);
02767         }
02768     };
02769 
02770     struct Rip01RipAddressStatusRsp :
02771       public Rip01RipAddressStatusCB {
02772         struct args_str {
02773             string status;
02774         };
02775 
02776     private:
02777         args_str args;
02778 
02779     public:
02780         Rip01RipAddressStatusRsp(const Rip01RipAddressStatusRF& cb)
02781           : Rip01RipAddressStatusCB(cb) { }
02782 
02783         void respond() const {
02784             Rip01RipAddressStatusCB::
02785             respond(args.status);
02786         }
02787 
02788         args_str* operator ->() {
02789             return &args;
02790         }
02791     };
02792 
02793     virtual void async_rip_0_1_rip_address_status
02794        (
02795     const string&   ifname,
02796     const string&   vifname,
02797     const IPv4& addr,
02798     Rip01RipAddressStatusCB);
02799 #endif
02800 
02806     virtual XrlCmdError rip_0_1_get_all_addresses(
02807     // Output values,
02808     XrlAtomList&    ifnames,
02809     XrlAtomList&    vifnames,
02810     XrlAtomList&    addrs) = 0;
02811 #ifdef XORP_ENABLE_ASYNC_SERVER
02812     typedef
02813     XorpCallback4<void, const XrlCmdError &,
02814     const XrlAtomList*,
02815     const XrlAtomList*,
02816     const XrlAtomList*>::RefPtr
02817     Rip01GetAllAddressesRF;
02818 
02819     class Rip01GetAllAddressesCB {
02820         Rip01GetAllAddressesRF cb;
02821 
02822     public:
02823         operator const Rip01GetAllAddressesRF& () const { return cb; }
02824         const Rip01GetAllAddressesRF& operator ->() const { return cb; }
02825         Rip01GetAllAddressesCB(const Rip01GetAllAddressesRF& cb)
02826           : cb(cb) { }
02827 
02828         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL); }
02829 
02830         void respond(const XrlAtomList& arg_ifnames,
02831                      const XrlAtomList& arg_vifnames,
02832                      const XrlAtomList& arg_addrs) const {
02833             cb->dispatch(XrlCmdError::OKAY(),
02834                          &arg_ifnames,
02835                          &arg_vifnames,
02836                          &arg_addrs);
02837         }
02838     };
02839 
02840     struct Rip01GetAllAddressesRsp :
02841       public Rip01GetAllAddressesCB {
02842         struct args_str {
02843             XrlAtomList ifnames;
02844             XrlAtomList vifnames;
02845             XrlAtomList addrs;
02846         };
02847 
02848     private:
02849         args_str args;
02850 
02851     public:
02852         Rip01GetAllAddressesRsp(const Rip01GetAllAddressesRF& cb)
02853           : Rip01GetAllAddressesCB(cb) { }
02854 
02855         void respond() const {
02856             Rip01GetAllAddressesCB::
02857             respond(args.ifnames,
02858                         args.vifnames,
02859                         args.addrs);
02860         }
02861 
02862         args_str* operator ->() {
02863             return &args;
02864         }
02865     };
02866 
02867     virtual void async_rip_0_1_get_all_addresses
02868        (
02869     Rip01GetAllAddressesCB);
02870 #endif
02871 
02877     virtual XrlCmdError rip_0_1_get_counters(
02878     // Input values,
02879     const string&   ifname,
02880     const string&   vifname,
02881     const IPv4& addr,
02882     // Output values,
02883     XrlAtomList&    counter_descriptions,
02884     XrlAtomList&    counter_values) = 0;
02885 #ifdef XORP_ENABLE_ASYNC_SERVER
02886     typedef
02887     XorpCallback3<void, const XrlCmdError &,
02888     const XrlAtomList*,
02889     const XrlAtomList*>::RefPtr
02890     Rip01GetCountersRF;
02891 
02892     class Rip01GetCountersCB {
02893         Rip01GetCountersRF cb;
02894 
02895     public:
02896         operator const Rip01GetCountersRF& () const { return cb; }
02897         const Rip01GetCountersRF& operator ->() const { return cb; }
02898         Rip01GetCountersCB(const Rip01GetCountersRF& cb)
02899           : cb(cb) { }
02900 
02901         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL); }
02902 
02903         void respond(const XrlAtomList& arg_counter_descriptions,
02904                      const XrlAtomList& arg_counter_values) const {
02905             cb->dispatch(XrlCmdError::OKAY(),
02906                          &arg_counter_descriptions,
02907                          &arg_counter_values);
02908         }
02909     };
02910 
02911     struct Rip01GetCountersRsp :
02912       public Rip01GetCountersCB {
02913         struct args_str {
02914             XrlAtomList counter_descriptions;
02915             XrlAtomList counter_values;
02916         };
02917 
02918     private:
02919         args_str args;
02920 
02921     public:
02922         Rip01GetCountersRsp(const Rip01GetCountersRF& cb)
02923           : Rip01GetCountersCB(cb) { }
02924 
02925         void respond() const {
02926             Rip01GetCountersCB::
02927             respond(args.counter_descriptions,
02928                         args.counter_values);
02929         }
02930 
02931         args_str* operator ->() {
02932             return &args;
02933         }
02934     };
02935 
02936     virtual void async_rip_0_1_get_counters
02937        (
02938     const string&   ifname,
02939     const string&   vifname,
02940     const IPv4& addr,
02941     Rip01GetCountersCB);
02942 #endif
02943 
02949     virtual XrlCmdError rip_0_1_get_peers(
02950     // Input values,
02951     const string&   ifname,
02952     const string&   vifname,
02953     const IPv4& addr,
02954     // Output values,
02955     XrlAtomList&    peers) = 0;
02956 #ifdef XORP_ENABLE_ASYNC_SERVER
02957     typedef
02958     XorpCallback2<void, const XrlCmdError &,
02959     const XrlAtomList*>::RefPtr
02960     Rip01GetPeersRF;
02961 
02962     class Rip01GetPeersCB {
02963         Rip01GetPeersRF cb;
02964 
02965     public:
02966         operator const Rip01GetPeersRF& () const { return cb; }
02967         const Rip01GetPeersRF& operator ->() const { return cb; }
02968         Rip01GetPeersCB(const Rip01GetPeersRF& cb)
02969           : cb(cb) { }
02970 
02971         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02972 
02973         void respond(const XrlAtomList& arg_peers) const {
02974             cb->dispatch(XrlCmdError::OKAY(),
02975                          &arg_peers);
02976         }
02977     };
02978 
02979     struct Rip01GetPeersRsp :
02980       public Rip01GetPeersCB {
02981         struct args_str {
02982             XrlAtomList peers;
02983         };
02984 
02985     private:
02986         args_str args;
02987 
02988     public:
02989         Rip01GetPeersRsp(const Rip01GetPeersRF& cb)
02990           : Rip01GetPeersCB(cb) { }
02991 
02992         void respond() const {
02993             Rip01GetPeersCB::
02994             respond(args.peers);
02995         }
02996 
02997         args_str* operator ->() {
02998             return &args;
02999         }
03000     };
03001 
03002     virtual void async_rip_0_1_get_peers
03003        (
03004     const string&   ifname,
03005     const string&   vifname,
03006     const IPv4& addr,
03007     Rip01GetPeersCB);
03008 #endif
03009 
03016     virtual XrlCmdError rip_0_1_get_all_peers(
03017     // Output values,
03018     XrlAtomList&    peers,
03019     XrlAtomList&    ifnames,
03020     XrlAtomList&    vifnames,
03021     XrlAtomList&    addrs) = 0;
03022 #ifdef XORP_ENABLE_ASYNC_SERVER
03023     typedef
03024     XorpCallback5<void, const XrlCmdError &,
03025     const XrlAtomList*,
03026     const XrlAtomList*,
03027     const XrlAtomList*,
03028     const XrlAtomList*>::RefPtr
03029     Rip01GetAllPeersRF;
03030 
03031     class Rip01GetAllPeersCB {
03032         Rip01GetAllPeersRF cb;
03033 
03034     public:
03035         operator const Rip01GetAllPeersRF& () const { return cb; }
03036         const Rip01GetAllPeersRF& operator ->() const { return cb; }
03037         Rip01GetAllPeersCB(const Rip01GetAllPeersRF& cb)
03038           : cb(cb) { }
03039 
03040         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL); }
03041 
03042         void respond(const XrlAtomList& arg_peers,
03043                      const XrlAtomList& arg_ifnames,
03044                      const XrlAtomList& arg_vifnames,
03045                      const XrlAtomList& arg_addrs) const {
03046             cb->dispatch(XrlCmdError::OKAY(),
03047                          &arg_peers,
03048                          &arg_ifnames,
03049                          &arg_vifnames,
03050                          &arg_addrs);
03051         }
03052     };
03053 
03054     struct Rip01GetAllPeersRsp :
03055       public Rip01GetAllPeersCB {
03056         struct args_str {
03057             XrlAtomList peers;
03058             XrlAtomList ifnames;
03059             XrlAtomList vifnames;
03060             XrlAtomList addrs;
03061         };
03062 
03063     private:
03064         args_str args;
03065 
03066     public:
03067         Rip01GetAllPeersRsp(const Rip01GetAllPeersRF& cb)
03068           : Rip01GetAllPeersCB(cb) { }
03069 
03070         void respond() const {
03071             Rip01GetAllPeersCB::
03072             respond(args.peers,
03073                         args.ifnames,
03074                         args.vifnames,
03075                         args.addrs);
03076         }
03077 
03078         args_str* operator ->() {
03079             return &args;
03080         }
03081     };
03082 
03083     virtual void async_rip_0_1_get_all_peers
03084        (
03085     Rip01GetAllPeersCB);
03086 #endif
03087 
03099     virtual XrlCmdError rip_0_1_get_peer_counters(
03100     // Input values,
03101     const string&   ifname,
03102     const string&   vifname,
03103     const IPv4& addr,
03104     const IPv4& peer,
03105     // Output values,
03106     XrlAtomList&    counter_descriptions,
03107     XrlAtomList&    counter_values,
03108     uint32_t&   peer_last_active) = 0;
03109 #ifdef XORP_ENABLE_ASYNC_SERVER
03110     typedef
03111     XorpCallback4<void, const XrlCmdError &,
03112     const XrlAtomList*,
03113     const XrlAtomList*,
03114     const uint32_t*>::RefPtr
03115     Rip01GetPeerCountersRF;
03116 
03117     class Rip01GetPeerCountersCB {
03118         Rip01GetPeerCountersRF cb;
03119 
03120     public:
03121         operator const Rip01GetPeerCountersRF& () const { return cb; }
03122         const Rip01GetPeerCountersRF& operator ->() const { return cb; }
03123         Rip01GetPeerCountersCB(const Rip01GetPeerCountersRF& cb)
03124           : cb(cb) { }
03125 
03126         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL); }
03127 
03128         void respond(const XrlAtomList& arg_counter_descriptions,
03129                      const XrlAtomList& arg_counter_values,
03130                      const uint32_t& arg_peer_last_active) const {
03131             cb->dispatch(XrlCmdError::OKAY(),
03132                          &arg_counter_descriptions,
03133                          &arg_counter_values,
03134                          &arg_peer_last_active);
03135         }
03136     };
03137 
03138     struct Rip01GetPeerCountersRsp :
03139       public Rip01GetPeerCountersCB {
03140         struct args_str {
03141             XrlAtomList counter_descriptions;
03142             XrlAtomList counter_values;
03143             uint32_t peer_last_active;
03144         };
03145 
03146     private:
03147         args_str args;
03148 
03149     public:
03150         Rip01GetPeerCountersRsp(const Rip01GetPeerCountersRF& cb)
03151           : Rip01GetPeerCountersCB(cb) { }
03152 
03153         void respond() const {
03154             Rip01GetPeerCountersCB::
03155             respond(args.counter_descriptions,
03156                         args.counter_values,
03157                         args.peer_last_active);
03158         }
03159 
03160         args_str* operator ->() {
03161             return &args;
03162         }
03163     };
03164 
03165     virtual void async_rip_0_1_get_peer_counters
03166        (
03167     const string&   ifname,
03168     const string&   vifname,
03169     const IPv4& addr,
03170     const IPv4& peer,
03171     Rip01GetPeerCountersCB);
03172 #endif
03173 
03183     virtual XrlCmdError rip_0_1_trace(
03184     // Input values,
03185     const string&   tvar,
03186     const bool& enable) = 0;
03187 #ifdef XORP_ENABLE_ASYNC_SERVER
03188     typedef
03189     XorpCallback1<void, const XrlCmdError &>::RefPtr
03190     Rip01TraceRF;
03191 
03192     class Rip01TraceCB {
03193         Rip01TraceRF cb;
03194 
03195     public:
03196         operator const Rip01TraceRF& () const { return cb; }
03197         const Rip01TraceRF& operator ->() const { return cb; }
03198         Rip01TraceCB(const Rip01TraceRF& cb)
03199           : cb(cb) { }
03200 
03201         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03202 
03203         void respond() const {
03204             cb->dispatch(XrlCmdError::OKAY());
03205         }
03206     };
03207 
03208     struct Rip01TraceRsp :
03209       public Rip01TraceCB {
03210         Rip01TraceRsp(const Rip01TraceRF& cb)
03211           : Rip01TraceCB(cb) { }
03212 
03213     };
03214 
03215     virtual void async_rip_0_1_trace
03216        (
03217     const string&   tvar,
03218     const bool& enable,
03219     Rip01TraceCB);
03220 #endif
03221 
03243     virtual XrlCmdError socket4_user_0_1_recv_event(
03244     // Input values,
03245     const string&   sockid,
03246     const string&   if_name,
03247     const string&   vif_name,
03248     const IPv4& src_host,
03249     const uint32_t& src_port,
03250     const vector<uint8_t>&  data) = 0;
03251 #ifdef XORP_ENABLE_ASYNC_SERVER
03252     typedef
03253     XorpCallback1<void, const XrlCmdError &>::RefPtr
03254     Socket4User01RecvEventRF;
03255 
03256     class Socket4User01RecvEventCB {
03257         Socket4User01RecvEventRF cb;
03258 
03259     public:
03260         operator const Socket4User01RecvEventRF& () const { return cb; }
03261         const Socket4User01RecvEventRF& operator ->() const { return cb; }
03262         Socket4User01RecvEventCB(const Socket4User01RecvEventRF& cb)
03263           : cb(cb) { }
03264 
03265         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03266 
03267         void respond() const {
03268             cb->dispatch(XrlCmdError::OKAY());
03269         }
03270     };
03271 
03272     struct Socket4User01RecvEventRsp :
03273       public Socket4User01RecvEventCB {
03274         Socket4User01RecvEventRsp(const Socket4User01RecvEventRF& cb)
03275           : Socket4User01RecvEventCB(cb) { }
03276 
03277     };
03278 
03279     virtual void async_socket4_user_0_1_recv_event
03280        (
03281     const string&   sockid,
03282     const string&   if_name,
03283     const string&   vif_name,
03284     const IPv4& src_host,
03285     const uint32_t& src_port,
03286     const vector<uint8_t>&  data,
03287     Socket4User01RecvEventCB);
03288 #endif
03289 
03310     virtual XrlCmdError socket4_user_0_1_inbound_connect_event(
03311     // Input values,
03312     const string&   sockid,
03313     const IPv4& src_host,
03314     const uint32_t& src_port,
03315     const string&   new_sockid,
03316     // Output values,
03317     bool&   accept) = 0;
03318 #ifdef XORP_ENABLE_ASYNC_SERVER
03319     typedef
03320     XorpCallback2<void, const XrlCmdError &,
03321     const bool*>::RefPtr
03322     Socket4User01InboundConnectEventRF;
03323 
03324     class Socket4User01InboundConnectEventCB {
03325         Socket4User01InboundConnectEventRF cb;
03326 
03327     public:
03328         operator const Socket4User01InboundConnectEventRF& () const { return cb; }
03329         const Socket4User01InboundConnectEventRF& operator ->() const { return cb; }
03330         Socket4User01InboundConnectEventCB(const Socket4User01InboundConnectEventRF& cb)
03331           : cb(cb) { }
03332 
03333         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
03334 
03335         void respond(const bool& arg_accept) const {
03336             cb->dispatch(XrlCmdError::OKAY(),
03337                          &arg_accept);
03338         }
03339     };
03340 
03341     struct Socket4User01InboundConnectEventRsp :
03342       public Socket4User01InboundConnectEventCB {
03343         struct args_str {
03344             bool accept;
03345         };
03346 
03347     private:
03348         args_str args;
03349 
03350     public:
03351         Socket4User01InboundConnectEventRsp(const Socket4User01InboundConnectEventRF& cb)
03352           : Socket4User01InboundConnectEventCB(cb) { }
03353 
03354         void respond() const {
03355             Socket4User01InboundConnectEventCB::
03356             respond(args.accept);
03357         }
03358 
03359         args_str* operator ->() {
03360             return &args;
03361         }
03362     };
03363 
03364     virtual void async_socket4_user_0_1_inbound_connect_event
03365        (
03366     const string&   sockid,
03367     const IPv4& src_host,
03368     const uint32_t& src_port,
03369     const string&   new_sockid,
03370     Socket4User01InboundConnectEventCB);
03371 #endif
03372 
03384     virtual XrlCmdError socket4_user_0_1_outgoing_connect_event(
03385     // Input values,
03386     const string&   sockid) = 0;
03387 #ifdef XORP_ENABLE_ASYNC_SERVER
03388     typedef
03389     XorpCallback1<void, const XrlCmdError &>::RefPtr
03390     Socket4User01OutgoingConnectEventRF;
03391 
03392     class Socket4User01OutgoingConnectEventCB {
03393         Socket4User01OutgoingConnectEventRF cb;
03394 
03395     public:
03396         operator const Socket4User01OutgoingConnectEventRF& () const { return cb; }
03397         const Socket4User01OutgoingConnectEventRF& operator ->() const { return cb; }
03398         Socket4User01OutgoingConnectEventCB(const Socket4User01OutgoingConnectEventRF& cb)
03399           : cb(cb) { }
03400 
03401         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03402 
03403         void respond() const {
03404             cb->dispatch(XrlCmdError::OKAY());
03405         }
03406     };
03407 
03408     struct Socket4User01OutgoingConnectEventRsp :
03409       public Socket4User01OutgoingConnectEventCB {
03410         Socket4User01OutgoingConnectEventRsp(const Socket4User01OutgoingConnectEventRF& cb)
03411           : Socket4User01OutgoingConnectEventCB(cb) { }
03412 
03413     };
03414 
03415     virtual void async_socket4_user_0_1_outgoing_connect_event
03416        (
03417     const string&   sockid,
03418     Socket4User01OutgoingConnectEventCB);
03419 #endif
03420 
03433     virtual XrlCmdError socket4_user_0_1_error_event(
03434     // Input values,
03435     const string&   sockid,
03436     const string&   error,
03437     const bool& fatal) = 0;
03438 #ifdef XORP_ENABLE_ASYNC_SERVER
03439     typedef
03440     XorpCallback1<void, const XrlCmdError &>::RefPtr
03441     Socket4User01ErrorEventRF;
03442 
03443     class Socket4User01ErrorEventCB {
03444         Socket4User01ErrorEventRF cb;
03445 
03446     public:
03447         operator const Socket4User01ErrorEventRF& () const { return cb; }
03448         const Socket4User01ErrorEventRF& operator ->() const { return cb; }
03449         Socket4User01ErrorEventCB(const Socket4User01ErrorEventRF& cb)
03450           : cb(cb) { }
03451 
03452         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03453 
03454         void respond() const {
03455             cb->dispatch(XrlCmdError::OKAY());
03456         }
03457     };
03458 
03459     struct Socket4User01ErrorEventRsp :
03460       public Socket4User01ErrorEventCB {
03461         Socket4User01ErrorEventRsp(const Socket4User01ErrorEventRF& cb)
03462           : Socket4User01ErrorEventCB(cb) { }
03463 
03464     };
03465 
03466     virtual void async_socket4_user_0_1_error_event
03467        (
03468     const string&   sockid,
03469     const string&   error,
03470     const bool& fatal,
03471     Socket4User01ErrorEventCB);
03472 #endif
03473 
03484     virtual XrlCmdError socket4_user_0_1_disconnect_event(
03485     // Input values,
03486     const string&   sockid) = 0;
03487 #ifdef XORP_ENABLE_ASYNC_SERVER
03488     typedef
03489     XorpCallback1<void, const XrlCmdError &>::RefPtr
03490     Socket4User01DisconnectEventRF;
03491 
03492     class Socket4User01DisconnectEventCB {
03493         Socket4User01DisconnectEventRF cb;
03494 
03495     public:
03496         operator const Socket4User01DisconnectEventRF& () const { return cb; }
03497         const Socket4User01DisconnectEventRF& operator ->() const { return cb; }
03498         Socket4User01DisconnectEventCB(const Socket4User01DisconnectEventRF& cb)
03499           : cb(cb) { }
03500 
03501         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03502 
03503         void respond() const {
03504             cb->dispatch(XrlCmdError::OKAY());
03505         }
03506     };
03507 
03508     struct Socket4User01DisconnectEventRsp :
03509       public Socket4User01DisconnectEventCB {
03510         Socket4User01DisconnectEventRsp(const Socket4User01DisconnectEventRF& cb)
03511           : Socket4User01DisconnectEventCB(cb) { }
03512 
03513     };
03514 
03515     virtual void async_socket4_user_0_1_disconnect_event
03516        (
03517     const string&   sockid,
03518     Socket4User01DisconnectEventCB);
03519 #endif
03520 
03521 private:
03522     XrlCmdRT handle_common_0_1_get_target_name(const XrlArgs& in, XrlCmdOT out);
03523 #ifdef XORP_ENABLE_ASYNC_SERVER
03524     void callback_common_0_1_get_target_name
03525        (const XrlCmdError &e,
03526     const string* arg_name,
03527         XrlRespCallback);
03528 #endif
03529 
03530     XrlCmdRT handle_common_0_1_get_version(const XrlArgs& in, XrlCmdOT out);
03531 #ifdef XORP_ENABLE_ASYNC_SERVER
03532     void callback_common_0_1_get_version
03533        (const XrlCmdError &e,
03534     const string* arg_version,
03535         XrlRespCallback);
03536 #endif
03537 
03538     XrlCmdRT handle_common_0_1_get_status(const XrlArgs& in, XrlCmdOT out);
03539 #ifdef XORP_ENABLE_ASYNC_SERVER
03540     void callback_common_0_1_get_status
03541        (const XrlCmdError &e,
03542     const uint32_t* arg_status,
03543     const string* arg_reason,
03544         XrlRespCallback);
03545 #endif
03546 
03547     XrlCmdRT handle_common_0_1_shutdown(const XrlArgs& in, XrlCmdOT out);
03548 #ifdef XORP_ENABLE_ASYNC_SERVER
03549     void callback_common_0_1_shutdown
03550        (const XrlCmdError &e,
03551         XrlRespCallback);
03552 #endif
03553 
03554     XrlCmdRT handle_common_0_1_startup(const XrlArgs& in, XrlCmdOT out);
03555 #ifdef XORP_ENABLE_ASYNC_SERVER
03556     void callback_common_0_1_startup
03557        (const XrlCmdError &e,
03558         XrlRespCallback);
03559 #endif
03560 
03561     XrlCmdRT handle_finder_event_observer_0_1_xrl_target_birth(const XrlArgs& in, XrlCmdOT out);
03562 #ifdef XORP_ENABLE_ASYNC_SERVER
03563     void callback_finder_event_observer_0_1_xrl_target_birth
03564        (const XrlCmdError &e,
03565         XrlRespCallback);
03566 #endif
03567 
03568     XrlCmdRT handle_finder_event_observer_0_1_xrl_target_death(const XrlArgs& in, XrlCmdOT out);
03569 #ifdef XORP_ENABLE_ASYNC_SERVER
03570     void callback_finder_event_observer_0_1_xrl_target_death
03571        (const XrlCmdError &e,
03572         XrlRespCallback);
03573 #endif
03574 
03575     XrlCmdRT handle_policy_backend_0_1_configure(const XrlArgs& in, XrlCmdOT out);
03576 #ifdef XORP_ENABLE_ASYNC_SERVER
03577     void callback_policy_backend_0_1_configure
03578        (const XrlCmdError &e,
03579         XrlRespCallback);
03580 #endif
03581 
03582     XrlCmdRT handle_policy_backend_0_1_reset(const XrlArgs& in, XrlCmdOT out);
03583 #ifdef XORP_ENABLE_ASYNC_SERVER
03584     void callback_policy_backend_0_1_reset
03585        (const XrlCmdError &e,
03586         XrlRespCallback);
03587 #endif
03588 
03589     XrlCmdRT handle_policy_backend_0_1_push_routes(const XrlArgs& in, XrlCmdOT out);
03590 #ifdef XORP_ENABLE_ASYNC_SERVER
03591     void callback_policy_backend_0_1_push_routes
03592        (const XrlCmdError &e,
03593         XrlRespCallback);
03594 #endif
03595 
03596     XrlCmdRT handle_policy_redist4_0_1_add_route4(const XrlArgs& in, XrlCmdOT out);
03597 #ifdef XORP_ENABLE_ASYNC_SERVER
03598     void callback_policy_redist4_0_1_add_route4
03599        (const XrlCmdError &e,
03600         XrlRespCallback);
03601 #endif
03602 
03603     XrlCmdRT handle_policy_redist4_0_1_delete_route4(const XrlArgs& in, XrlCmdOT out);
03604 #ifdef XORP_ENABLE_ASYNC_SERVER
03605     void callback_policy_redist4_0_1_delete_route4
03606        (const XrlCmdError &e,
03607         XrlRespCallback);
03608 #endif
03609 
03610     XrlCmdRT handle_rip_0_1_add_rip_address(const XrlArgs& in, XrlCmdOT out);
03611 #ifdef XORP_ENABLE_ASYNC_SERVER
03612     void callback_rip_0_1_add_rip_address
03613        (const XrlCmdError &e,
03614         XrlRespCallback);
03615 #endif
03616 
03617     XrlCmdRT handle_rip_0_1_remove_rip_address(const XrlArgs& in, XrlCmdOT out);
03618 #ifdef XORP_ENABLE_ASYNC_SERVER
03619     void callback_rip_0_1_remove_rip_address
03620        (const XrlCmdError &e,
03621         XrlRespCallback);
03622 #endif
03623 
03624     XrlCmdRT handle_rip_0_1_set_rip_address_enabled(const XrlArgs& in, XrlCmdOT out);
03625 #ifdef XORP_ENABLE_ASYNC_SERVER
03626     void callback_rip_0_1_set_rip_address_enabled
03627        (const XrlCmdError &e,
03628         XrlRespCallback);
03629 #endif
03630 
03631     XrlCmdRT handle_rip_0_1_rip_address_enabled(const XrlArgs& in, XrlCmdOT out);
03632 #ifdef XORP_ENABLE_ASYNC_SERVER
03633     void callback_rip_0_1_rip_address_enabled
03634        (const XrlCmdError &e,
03635     const bool* arg_enabled,
03636         XrlRespCallback);
03637 #endif
03638 
03639     XrlCmdRT handle_rip_0_1_set_cost(const XrlArgs& in, XrlCmdOT out);
03640 #ifdef XORP_ENABLE_ASYNC_SERVER
03641     void callback_rip_0_1_set_cost
03642        (const XrlCmdError &e,
03643         XrlRespCallback);
03644 #endif
03645 
03646     XrlCmdRT handle_rip_0_1_cost(const XrlArgs& in, XrlCmdOT out);
03647 #ifdef XORP_ENABLE_ASYNC_SERVER
03648     void callback_rip_0_1_cost
03649        (const XrlCmdError &e,
03650     const uint32_t* arg_cost,
03651         XrlRespCallback);
03652 #endif
03653 
03654     XrlCmdRT handle_rip_0_1_set_horizon(const XrlArgs& in, XrlCmdOT out);
03655 #ifdef XORP_ENABLE_ASYNC_SERVER
03656     void callback_rip_0_1_set_horizon
03657        (const XrlCmdError &e,
03658         XrlRespCallback);
03659 #endif
03660 
03661     XrlCmdRT handle_rip_0_1_horizon(const XrlArgs& in, XrlCmdOT out);
03662 #ifdef XORP_ENABLE_ASYNC_SERVER
03663     void callback_rip_0_1_horizon
03664        (const XrlCmdError &e,
03665     const string* arg_horizon,
03666         XrlRespCallback);
03667 #endif
03668 
03669     XrlCmdRT handle_rip_0_1_set_passive(const XrlArgs& in, XrlCmdOT out);
03670 #ifdef XORP_ENABLE_ASYNC_SERVER
03671     void callback_rip_0_1_set_passive
03672        (const XrlCmdError &e,
03673         XrlRespCallback);
03674 #endif
03675 
03676     XrlCmdRT handle_rip_0_1_passive(const XrlArgs& in, XrlCmdOT out);
03677 #ifdef XORP_ENABLE_ASYNC_SERVER
03678     void callback_rip_0_1_passive
03679        (const XrlCmdError &e,
03680     const bool* arg_passive,
03681         XrlRespCallback);
03682 #endif
03683 
03684     XrlCmdRT handle_rip_0_1_set_accept_non_rip_requests(const XrlArgs& in, XrlCmdOT out);
03685 #ifdef XORP_ENABLE_ASYNC_SERVER
03686     void callback_rip_0_1_set_accept_non_rip_requests
03687        (const XrlCmdError &e,
03688         XrlRespCallback);
03689 #endif
03690 
03691     XrlCmdRT handle_rip_0_1_accept_non_rip_requests(const XrlArgs& in, XrlCmdOT out);
03692 #ifdef XORP_ENABLE_ASYNC_SERVER
03693     void callback_rip_0_1_accept_non_rip_requests
03694        (const XrlCmdError &e,
03695     const bool* arg_accept,
03696         XrlRespCallback);
03697 #endif
03698 
03699     XrlCmdRT handle_rip_0_1_set_accept_default_route(const XrlArgs& in, XrlCmdOT out);
03700 #ifdef XORP_ENABLE_ASYNC_SERVER
03701     void callback_rip_0_1_set_accept_default_route
03702        (const XrlCmdError &e,
03703         XrlRespCallback);
03704 #endif
03705 
03706     XrlCmdRT handle_rip_0_1_accept_default_route(const XrlArgs& in, XrlCmdOT out);
03707 #ifdef XORP_ENABLE_ASYNC_SERVER
03708     void callback_rip_0_1_accept_default_route
03709        (const XrlCmdError &e,
03710     const bool* arg_accept,
03711         XrlRespCallback);
03712 #endif
03713 
03714     XrlCmdRT handle_rip_0_1_set_advertise_default_route(const XrlArgs& in, XrlCmdOT out);
03715 #ifdef XORP_ENABLE_ASYNC_SERVER
03716     void callback_rip_0_1_set_advertise_default_route
03717        (const XrlCmdError &e,
03718         XrlRespCallback);
03719 #endif
03720 
03721     XrlCmdRT handle_rip_0_1_advertise_default_route(const XrlArgs& in, XrlCmdOT out);
03722 #ifdef XORP_ENABLE_ASYNC_SERVER
03723     void callback_rip_0_1_advertise_default_route
03724        (const XrlCmdError &e,
03725     const bool* arg_advertise,
03726         XrlRespCallback);
03727 #endif
03728 
03729     XrlCmdRT handle_rip_0_1_set_route_timeout(const XrlArgs& in, XrlCmdOT out);
03730 #ifdef XORP_ENABLE_ASYNC_SERVER
03731     void callback_rip_0_1_set_route_timeout
03732        (const XrlCmdError &e,
03733         XrlRespCallback);
03734 #endif
03735 
03736     XrlCmdRT handle_rip_0_1_route_timeout(const XrlArgs& in, XrlCmdOT out);
03737 #ifdef XORP_ENABLE_ASYNC_SERVER
03738     void callback_rip_0_1_route_timeout
03739        (const XrlCmdError &e,
03740     const uint32_t* arg_t_secs,
03741         XrlRespCallback);
03742 #endif
03743 
03744     XrlCmdRT handle_rip_0_1_set_deletion_delay(const XrlArgs& in, XrlCmdOT out);
03745 #ifdef XORP_ENABLE_ASYNC_SERVER
03746     void callback_rip_0_1_set_deletion_delay
03747        (const XrlCmdError &e,
03748         XrlRespCallback);
03749 #endif
03750 
03751     XrlCmdRT handle_rip_0_1_deletion_delay(const XrlArgs& in, XrlCmdOT out);
03752 #ifdef XORP_ENABLE_ASYNC_SERVER
03753     void callback_rip_0_1_deletion_delay
03754        (const XrlCmdError &e,
03755     const uint32_t* arg_t_secs,
03756         XrlRespCallback);
03757 #endif
03758 
03759     XrlCmdRT handle_rip_0_1_set_request_interval(const XrlArgs& in, XrlCmdOT out);
03760 #ifdef XORP_ENABLE_ASYNC_SERVER
03761     void callback_rip_0_1_set_request_interval
03762        (const XrlCmdError &e,
03763         XrlRespCallback);
03764 #endif
03765 
03766     XrlCmdRT handle_rip_0_1_request_interval(const XrlArgs& in, XrlCmdOT out);
03767 #ifdef XORP_ENABLE_ASYNC_SERVER
03768     void callback_rip_0_1_request_interval
03769        (const XrlCmdError &e,
03770     const uint32_t* arg_t_secs,
03771         XrlRespCallback);
03772 #endif
03773 
03774     XrlCmdRT handle_rip_0_1_set_update_interval(const XrlArgs& in, XrlCmdOT out);
03775 #ifdef XORP_ENABLE_ASYNC_SERVER
03776     void callback_rip_0_1_set_update_interval
03777        (const XrlCmdError &e,
03778         XrlRespCallback);
03779 #endif
03780 
03781     XrlCmdRT handle_rip_0_1_update_interval(const XrlArgs& in, XrlCmdOT out);
03782 #ifdef XORP_ENABLE_ASYNC_SERVER
03783     void callback_rip_0_1_update_interval
03784        (const XrlCmdError &e,
03785     const uint32_t* arg_t_secs,
03786         XrlRespCallback);
03787 #endif
03788 
03789     XrlCmdRT handle_rip_0_1_set_update_jitter(const XrlArgs& in, XrlCmdOT out);
03790 #ifdef XORP_ENABLE_ASYNC_SERVER
03791     void callback_rip_0_1_set_update_jitter
03792        (const XrlCmdError &e,
03793         XrlRespCallback);
03794 #endif
03795 
03796     XrlCmdRT handle_rip_0_1_update_jitter(const XrlArgs& in, XrlCmdOT out);
03797 #ifdef XORP_ENABLE_ASYNC_SERVER
03798     void callback_rip_0_1_update_jitter
03799        (const XrlCmdError &e,
03800     const uint32_t* arg_t_jitter,
03801         XrlRespCallback);
03802 #endif
03803 
03804     XrlCmdRT handle_rip_0_1_set_triggered_update_delay(const XrlArgs& in, XrlCmdOT out);
03805 #ifdef XORP_ENABLE_ASYNC_SERVER
03806     void callback_rip_0_1_set_triggered_update_delay
03807        (const XrlCmdError &e,
03808         XrlRespCallback);
03809 #endif
03810 
03811     XrlCmdRT handle_rip_0_1_triggered_update_delay(const XrlArgs& in, XrlCmdOT out);
03812 #ifdef XORP_ENABLE_ASYNC_SERVER
03813     void callback_rip_0_1_triggered_update_delay
03814        (const XrlCmdError &e,
03815     const uint32_t* arg_t_secs,
03816         XrlRespCallback);
03817 #endif
03818 
03819     XrlCmdRT handle_rip_0_1_set_triggered_update_jitter(const XrlArgs& in, XrlCmdOT out);
03820 #ifdef XORP_ENABLE_ASYNC_SERVER
03821     void callback_rip_0_1_set_triggered_update_jitter
03822        (const XrlCmdError &e,
03823         XrlRespCallback);
03824 #endif
03825 
03826     XrlCmdRT handle_rip_0_1_triggered_update_jitter(const XrlArgs& in, XrlCmdOT out);
03827 #ifdef XORP_ENABLE_ASYNC_SERVER
03828     void callback_rip_0_1_triggered_update_jitter
03829        (const XrlCmdError &e,
03830     const uint32_t* arg_t_jitter,
03831         XrlRespCallback);
03832 #endif
03833 
03834     XrlCmdRT handle_rip_0_1_set_interpacket_delay(const XrlArgs& in, XrlCmdOT out);
03835 #ifdef XORP_ENABLE_ASYNC_SERVER
03836     void callback_rip_0_1_set_interpacket_delay
03837        (const XrlCmdError &e,
03838         XrlRespCallback);
03839 #endif
03840 
03841     XrlCmdRT handle_rip_0_1_interpacket_delay(const XrlArgs& in, XrlCmdOT out);
03842 #ifdef XORP_ENABLE_ASYNC_SERVER
03843     void callback_rip_0_1_interpacket_delay
03844        (const XrlCmdError &e,
03845     const uint32_t* arg_t_msecs,
03846         XrlRespCallback);
03847 #endif
03848 
03849     XrlCmdRT handle_rip_0_1_set_simple_authentication_key(const XrlArgs& in, XrlCmdOT out);
03850 #ifdef XORP_ENABLE_ASYNC_SERVER
03851     void callback_rip_0_1_set_simple_authentication_key
03852        (const XrlCmdError &e,
03853         XrlRespCallback);
03854 #endif
03855 
03856     XrlCmdRT handle_rip_0_1_delete_simple_authentication_key(const XrlArgs& in, XrlCmdOT out);
03857 #ifdef XORP_ENABLE_ASYNC_SERVER
03858     void callback_rip_0_1_delete_simple_authentication_key
03859        (const XrlCmdError &e,
03860         XrlRespCallback);
03861 #endif
03862 
03863     XrlCmdRT handle_rip_0_1_set_md5_authentication_key(const XrlArgs& in, XrlCmdOT out);
03864 #ifdef XORP_ENABLE_ASYNC_SERVER
03865     void callback_rip_0_1_set_md5_authentication_key
03866        (const XrlCmdError &e,
03867         XrlRespCallback);
03868 #endif
03869 
03870     XrlCmdRT handle_rip_0_1_delete_md5_authentication_key(const XrlArgs& in, XrlCmdOT out);
03871 #ifdef XORP_ENABLE_ASYNC_SERVER
03872     void callback_rip_0_1_delete_md5_authentication_key
03873        (const XrlCmdError &e,
03874         XrlRespCallback);
03875 #endif
03876 
03877     XrlCmdRT handle_rip_0_1_rip_address_status(const XrlArgs& in, XrlCmdOT out);
03878 #ifdef XORP_ENABLE_ASYNC_SERVER
03879     void callback_rip_0_1_rip_address_status
03880        (const XrlCmdError &e,
03881     const string* arg_status,
03882         XrlRespCallback);
03883 #endif
03884 
03885     XrlCmdRT handle_rip_0_1_get_all_addresses(const XrlArgs& in, XrlCmdOT out);
03886 #ifdef XORP_ENABLE_ASYNC_SERVER
03887     void callback_rip_0_1_get_all_addresses
03888        (const XrlCmdError &e,
03889     const XrlAtomList* arg_ifnames,
03890     const XrlAtomList* arg_vifnames,
03891     const XrlAtomList* arg_addrs,
03892         XrlRespCallback);
03893 #endif
03894 
03895     XrlCmdRT handle_rip_0_1_get_counters(const XrlArgs& in, XrlCmdOT out);
03896 #ifdef XORP_ENABLE_ASYNC_SERVER
03897     void callback_rip_0_1_get_counters
03898        (const XrlCmdError &e,
03899     const XrlAtomList* arg_counter_descriptions,
03900     const XrlAtomList* arg_counter_values,
03901         XrlRespCallback);
03902 #endif
03903 
03904     XrlCmdRT handle_rip_0_1_get_peers(const XrlArgs& in, XrlCmdOT out);
03905 #ifdef XORP_ENABLE_ASYNC_SERVER
03906     void callback_rip_0_1_get_peers
03907        (const XrlCmdError &e,
03908     const XrlAtomList* arg_peers,
03909         XrlRespCallback);
03910 #endif
03911 
03912     XrlCmdRT handle_rip_0_1_get_all_peers(const XrlArgs& in, XrlCmdOT out);
03913 #ifdef XORP_ENABLE_ASYNC_SERVER
03914     void callback_rip_0_1_get_all_peers
03915        (const XrlCmdError &e,
03916     const XrlAtomList* arg_peers,
03917     const XrlAtomList* arg_ifnames,
03918     const XrlAtomList* arg_vifnames,
03919     const XrlAtomList* arg_addrs,
03920         XrlRespCallback);
03921 #endif
03922 
03923     XrlCmdRT handle_rip_0_1_get_peer_counters(const XrlArgs& in, XrlCmdOT out);
03924 #ifdef XORP_ENABLE_ASYNC_SERVER
03925     void callback_rip_0_1_get_peer_counters
03926        (const XrlCmdError &e,
03927     const XrlAtomList* arg_counter_descriptions,
03928     const XrlAtomList* arg_counter_values,
03929     const uint32_t* arg_peer_last_active,
03930         XrlRespCallback);
03931 #endif
03932 
03933     XrlCmdRT handle_rip_0_1_trace(const XrlArgs& in, XrlCmdOT out);
03934 #ifdef XORP_ENABLE_ASYNC_SERVER
03935     void callback_rip_0_1_trace
03936        (const XrlCmdError &e,
03937         XrlRespCallback);
03938 #endif
03939 
03940     XrlCmdRT handle_socket4_user_0_1_recv_event(const XrlArgs& in, XrlCmdOT out);
03941 #ifdef XORP_ENABLE_ASYNC_SERVER
03942     void callback_socket4_user_0_1_recv_event
03943        (const XrlCmdError &e,
03944         XrlRespCallback);
03945 #endif
03946 
03947     XrlCmdRT handle_socket4_user_0_1_inbound_connect_event(const XrlArgs& in, XrlCmdOT out);
03948 #ifdef XORP_ENABLE_ASYNC_SERVER
03949     void callback_socket4_user_0_1_inbound_connect_event
03950        (const XrlCmdError &e,
03951     const bool* arg_accept,
03952         XrlRespCallback);
03953 #endif
03954 
03955     XrlCmdRT handle_socket4_user_0_1_outgoing_connect_event(const XrlArgs& in, XrlCmdOT out);
03956 #ifdef XORP_ENABLE_ASYNC_SERVER
03957     void callback_socket4_user_0_1_outgoing_connect_event
03958        (const XrlCmdError &e,
03959         XrlRespCallback);
03960 #endif
03961 
03962     XrlCmdRT handle_socket4_user_0_1_error_event(const XrlArgs& in, XrlCmdOT out);
03963 #ifdef XORP_ENABLE_ASYNC_SERVER
03964     void callback_socket4_user_0_1_error_event
03965        (const XrlCmdError &e,
03966         XrlRespCallback);
03967 #endif
03968 
03969     XrlCmdRT handle_socket4_user_0_1_disconnect_event(const XrlArgs& in, XrlCmdOT out);
03970 #ifdef XORP_ENABLE_ASYNC_SERVER
03971     void callback_socket4_user_0_1_disconnect_event
03972        (const XrlCmdError &e,
03973         XrlRespCallback);
03974 #endif
03975 
03976     void add_handlers();
03977     void remove_handlers();
03978 
03979     struct handler_table {
03980         const char *name;
03981         XrlCmdRT (XrlRipTargetBase::*method)(const XrlArgs&, XrlCmdOT);
03982     };
03983 
03984     static const struct handler_table handlers[];
03985     static const size_t num_handlers;
03986 };
03987 
03988 #endif // __XRL_TARGETS_RIP_BASE_HH__
 All Classes Namespaces Functions Variables Typedefs Enumerations