xorp

rib_base.hh

00001 /*
00002  * obj/i386-pc-mingw32/xrl/targets/rib_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_RIB_BASE_HH__
00016 #define __XRL_TARGETS_RIB_BASE_HH__
00017 
00018 #undef XORP_LIBRARY_NAME
00019 #define XORP_LIBRARY_NAME "XrlRibTarget"
00020 
00021 #include "libxorp/xlog.h"
00022 #include "libxipc/xrl_cmd_map.hh"
00023 
00024 class XrlRibTargetBase {
00025 protected:
00026     XrlCmdMap* _cmds;
00027 
00028 public:
00036     XrlRibTargetBase(XrlCmdMap* cmds = 0);
00037 
00043     virtual ~XrlRibTargetBase();
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 "rib/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 
00562     virtual XrlCmdError rib_0_1_enable_rib() = 0;
00563 #ifdef XORP_ENABLE_ASYNC_SERVER
00564     typedef
00565     XorpCallback1<void, const XrlCmdError &>::RefPtr
00566     Rib01EnableRibRF;
00567 
00568     class Rib01EnableRibCB {
00569         Rib01EnableRibRF cb;
00570 
00571     public:
00572         operator const Rib01EnableRibRF& () const { return cb; }
00573         const Rib01EnableRibRF& operator ->() const { return cb; }
00574         Rib01EnableRibCB(const Rib01EnableRibRF& cb)
00575           : cb(cb) { }
00576 
00577         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00578 
00579         void respond() const {
00580             cb->dispatch(XrlCmdError::OKAY());
00581         }
00582     };
00583 
00584     struct Rib01EnableRibRsp :
00585       public Rib01EnableRibCB {
00586         Rib01EnableRibRsp(const Rib01EnableRibRF& cb)
00587           : Rib01EnableRibCB(cb) { }
00588 
00589     };
00590 
00591     virtual void async_rib_0_1_enable_rib
00592        (
00593     Rib01EnableRibCB);
00594 #endif
00595 
00596     virtual XrlCmdError rib_0_1_disable_rib() = 0;
00597 #ifdef XORP_ENABLE_ASYNC_SERVER
00598     typedef
00599     XorpCallback1<void, const XrlCmdError &>::RefPtr
00600     Rib01DisableRibRF;
00601 
00602     class Rib01DisableRibCB {
00603         Rib01DisableRibRF cb;
00604 
00605     public:
00606         operator const Rib01DisableRibRF& () const { return cb; }
00607         const Rib01DisableRibRF& operator ->() const { return cb; }
00608         Rib01DisableRibCB(const Rib01DisableRibRF& cb)
00609           : cb(cb) { }
00610 
00611         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00612 
00613         void respond() const {
00614             cb->dispatch(XrlCmdError::OKAY());
00615         }
00616     };
00617 
00618     struct Rib01DisableRibRsp :
00619       public Rib01DisableRibCB {
00620         Rib01DisableRibRsp(const Rib01DisableRibRF& cb)
00621           : Rib01DisableRibCB(cb) { }
00622 
00623     };
00624 
00625     virtual void async_rib_0_1_disable_rib
00626        (
00627     Rib01DisableRibCB);
00628 #endif
00629 
00630     virtual XrlCmdError rib_0_1_start_rib() = 0;
00631 #ifdef XORP_ENABLE_ASYNC_SERVER
00632     typedef
00633     XorpCallback1<void, const XrlCmdError &>::RefPtr
00634     Rib01StartRibRF;
00635 
00636     class Rib01StartRibCB {
00637         Rib01StartRibRF cb;
00638 
00639     public:
00640         operator const Rib01StartRibRF& () const { return cb; }
00641         const Rib01StartRibRF& operator ->() const { return cb; }
00642         Rib01StartRibCB(const Rib01StartRibRF& cb)
00643           : cb(cb) { }
00644 
00645         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00646 
00647         void respond() const {
00648             cb->dispatch(XrlCmdError::OKAY());
00649         }
00650     };
00651 
00652     struct Rib01StartRibRsp :
00653       public Rib01StartRibCB {
00654         Rib01StartRibRsp(const Rib01StartRibRF& cb)
00655           : Rib01StartRibCB(cb) { }
00656 
00657     };
00658 
00659     virtual void async_rib_0_1_start_rib
00660        (
00661     Rib01StartRibCB);
00662 #endif
00663 
00664     virtual XrlCmdError rib_0_1_stop_rib() = 0;
00665 #ifdef XORP_ENABLE_ASYNC_SERVER
00666     typedef
00667     XorpCallback1<void, const XrlCmdError &>::RefPtr
00668     Rib01StopRibRF;
00669 
00670     class Rib01StopRibCB {
00671         Rib01StopRibRF cb;
00672 
00673     public:
00674         operator const Rib01StopRibRF& () const { return cb; }
00675         const Rib01StopRibRF& operator ->() const { return cb; }
00676         Rib01StopRibCB(const Rib01StopRibRF& cb)
00677           : cb(cb) { }
00678 
00679         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00680 
00681         void respond() const {
00682             cb->dispatch(XrlCmdError::OKAY());
00683         }
00684     };
00685 
00686     struct Rib01StopRibRsp :
00687       public Rib01StopRibCB {
00688         Rib01StopRibRsp(const Rib01StopRibRF& cb)
00689           : Rib01StopRibCB(cb) { }
00690 
00691     };
00692 
00693     virtual void async_rib_0_1_stop_rib
00694        (
00695     Rib01StopRibCB);
00696 #endif
00697 
00703     virtual XrlCmdError rib_0_1_make_errors_fatal() = 0;
00704 #ifdef XORP_ENABLE_ASYNC_SERVER
00705     typedef
00706     XorpCallback1<void, const XrlCmdError &>::RefPtr
00707     Rib01MakeErrorsFatalRF;
00708 
00709     class Rib01MakeErrorsFatalCB {
00710         Rib01MakeErrorsFatalRF cb;
00711 
00712     public:
00713         operator const Rib01MakeErrorsFatalRF& () const { return cb; }
00714         const Rib01MakeErrorsFatalRF& operator ->() const { return cb; }
00715         Rib01MakeErrorsFatalCB(const Rib01MakeErrorsFatalRF& cb)
00716           : cb(cb) { }
00717 
00718         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00719 
00720         void respond() const {
00721             cb->dispatch(XrlCmdError::OKAY());
00722         }
00723     };
00724 
00725     struct Rib01MakeErrorsFatalRsp :
00726       public Rib01MakeErrorsFatalCB {
00727         Rib01MakeErrorsFatalRsp(const Rib01MakeErrorsFatalRF& cb)
00728           : Rib01MakeErrorsFatalCB(cb) { }
00729 
00730     };
00731 
00732     virtual void async_rib_0_1_make_errors_fatal
00733        (
00734     Rib01MakeErrorsFatalCB);
00735 #endif
00736 
00764     virtual XrlCmdError rib_0_1_get_registered_protocols(
00765     // Input values,
00766     const bool& ipv4,
00767     const bool& ipv6,
00768     const bool& unicast,
00769     const bool& multicast,
00770     // Output values,
00771     XrlAtomList&    ipv4_unicast_protocols,
00772     XrlAtomList&    ipv6_unicast_protocols,
00773     XrlAtomList&    ipv4_multicast_protocols,
00774     XrlAtomList&    ipv6_multicast_protocols) = 0;
00775 #ifdef XORP_ENABLE_ASYNC_SERVER
00776     typedef
00777     XorpCallback5<void, const XrlCmdError &,
00778     const XrlAtomList*,
00779     const XrlAtomList*,
00780     const XrlAtomList*,
00781     const XrlAtomList*>::RefPtr
00782     Rib01GetRegisteredProtocolsRF;
00783 
00784     class Rib01GetRegisteredProtocolsCB {
00785         Rib01GetRegisteredProtocolsRF cb;
00786 
00787     public:
00788         operator const Rib01GetRegisteredProtocolsRF& () const { return cb; }
00789         const Rib01GetRegisteredProtocolsRF& operator ->() const { return cb; }
00790         Rib01GetRegisteredProtocolsCB(const Rib01GetRegisteredProtocolsRF& cb)
00791           : cb(cb) { }
00792 
00793         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL); }
00794 
00795         void respond(const XrlAtomList& arg_ipv4_unicast_protocols,
00796                      const XrlAtomList& arg_ipv6_unicast_protocols,
00797                      const XrlAtomList& arg_ipv4_multicast_protocols,
00798                      const XrlAtomList& arg_ipv6_multicast_protocols) const {
00799             cb->dispatch(XrlCmdError::OKAY(),
00800                          &arg_ipv4_unicast_protocols,
00801                          &arg_ipv6_unicast_protocols,
00802                          &arg_ipv4_multicast_protocols,
00803                          &arg_ipv6_multicast_protocols);
00804         }
00805     };
00806 
00807     struct Rib01GetRegisteredProtocolsRsp :
00808       public Rib01GetRegisteredProtocolsCB {
00809         struct args_str {
00810             XrlAtomList ipv4_unicast_protocols;
00811             XrlAtomList ipv6_unicast_protocols;
00812             XrlAtomList ipv4_multicast_protocols;
00813             XrlAtomList ipv6_multicast_protocols;
00814         };
00815 
00816     private:
00817         args_str args;
00818 
00819     public:
00820         Rib01GetRegisteredProtocolsRsp(const Rib01GetRegisteredProtocolsRF& cb)
00821           : Rib01GetRegisteredProtocolsCB(cb) { }
00822 
00823         void respond() const {
00824             Rib01GetRegisteredProtocolsCB::
00825             respond(args.ipv4_unicast_protocols,
00826                         args.ipv6_unicast_protocols,
00827                         args.ipv4_multicast_protocols,
00828                         args.ipv6_multicast_protocols);
00829         }
00830 
00831         args_str* operator ->() {
00832             return &args;
00833         }
00834     };
00835 
00836     virtual void async_rib_0_1_get_registered_protocols
00837        (
00838     const bool& ipv4,
00839     const bool& ipv6,
00840     const bool& unicast,
00841     const bool& multicast,
00842     Rib01GetRegisteredProtocolsCB);
00843 #endif
00844 
00860     virtual XrlCmdError rib_0_1_add_igp_table4(
00861     // Input values,
00862     const string&   protocol,
00863     const string&   target_class,
00864     const string&   target_instance,
00865     const bool& unicast,
00866     const bool& multicast) = 0;
00867 #ifdef XORP_ENABLE_ASYNC_SERVER
00868     typedef
00869     XorpCallback1<void, const XrlCmdError &>::RefPtr
00870     Rib01AddIgpTable4RF;
00871 
00872     class Rib01AddIgpTable4CB {
00873         Rib01AddIgpTable4RF cb;
00874 
00875     public:
00876         operator const Rib01AddIgpTable4RF& () const { return cb; }
00877         const Rib01AddIgpTable4RF& operator ->() const { return cb; }
00878         Rib01AddIgpTable4CB(const Rib01AddIgpTable4RF& cb)
00879           : cb(cb) { }
00880 
00881         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00882 
00883         void respond() const {
00884             cb->dispatch(XrlCmdError::OKAY());
00885         }
00886     };
00887 
00888     struct Rib01AddIgpTable4Rsp :
00889       public Rib01AddIgpTable4CB {
00890         Rib01AddIgpTable4Rsp(const Rib01AddIgpTable4RF& cb)
00891           : Rib01AddIgpTable4CB(cb) { }
00892 
00893     };
00894 
00895     virtual void async_rib_0_1_add_igp_table4
00896        (
00897     const string&   protocol,
00898     const string&   target_class,
00899     const string&   target_instance,
00900     const bool& unicast,
00901     const bool& multicast,
00902     Rib01AddIgpTable4CB);
00903 #endif
00904 
00905     virtual XrlCmdError rib_0_1_delete_igp_table4(
00906     // Input values,
00907     const string&   protocol,
00908     const string&   target_class,
00909     const string&   target_instance,
00910     const bool& unicast,
00911     const bool& multicast) = 0;
00912 #ifdef XORP_ENABLE_ASYNC_SERVER
00913     typedef
00914     XorpCallback1<void, const XrlCmdError &>::RefPtr
00915     Rib01DeleteIgpTable4RF;
00916 
00917     class Rib01DeleteIgpTable4CB {
00918         Rib01DeleteIgpTable4RF cb;
00919 
00920     public:
00921         operator const Rib01DeleteIgpTable4RF& () const { return cb; }
00922         const Rib01DeleteIgpTable4RF& operator ->() const { return cb; }
00923         Rib01DeleteIgpTable4CB(const Rib01DeleteIgpTable4RF& cb)
00924           : cb(cb) { }
00925 
00926         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00927 
00928         void respond() const {
00929             cb->dispatch(XrlCmdError::OKAY());
00930         }
00931     };
00932 
00933     struct Rib01DeleteIgpTable4Rsp :
00934       public Rib01DeleteIgpTable4CB {
00935         Rib01DeleteIgpTable4Rsp(const Rib01DeleteIgpTable4RF& cb)
00936           : Rib01DeleteIgpTable4CB(cb) { }
00937 
00938     };
00939 
00940     virtual void async_rib_0_1_delete_igp_table4
00941        (
00942     const string&   protocol,
00943     const string&   target_class,
00944     const string&   target_instance,
00945     const bool& unicast,
00946     const bool& multicast,
00947     Rib01DeleteIgpTable4CB);
00948 #endif
00949 
00950     virtual XrlCmdError rib_0_1_add_egp_table4(
00951     // Input values,
00952     const string&   protocol,
00953     const string&   target_class,
00954     const string&   target_instance,
00955     const bool& unicast,
00956     const bool& multicast) = 0;
00957 #ifdef XORP_ENABLE_ASYNC_SERVER
00958     typedef
00959     XorpCallback1<void, const XrlCmdError &>::RefPtr
00960     Rib01AddEgpTable4RF;
00961 
00962     class Rib01AddEgpTable4CB {
00963         Rib01AddEgpTable4RF cb;
00964 
00965     public:
00966         operator const Rib01AddEgpTable4RF& () const { return cb; }
00967         const Rib01AddEgpTable4RF& operator ->() const { return cb; }
00968         Rib01AddEgpTable4CB(const Rib01AddEgpTable4RF& cb)
00969           : cb(cb) { }
00970 
00971         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00972 
00973         void respond() const {
00974             cb->dispatch(XrlCmdError::OKAY());
00975         }
00976     };
00977 
00978     struct Rib01AddEgpTable4Rsp :
00979       public Rib01AddEgpTable4CB {
00980         Rib01AddEgpTable4Rsp(const Rib01AddEgpTable4RF& cb)
00981           : Rib01AddEgpTable4CB(cb) { }
00982 
00983     };
00984 
00985     virtual void async_rib_0_1_add_egp_table4
00986        (
00987     const string&   protocol,
00988     const string&   target_class,
00989     const string&   target_instance,
00990     const bool& unicast,
00991     const bool& multicast,
00992     Rib01AddEgpTable4CB);
00993 #endif
00994 
00995     virtual XrlCmdError rib_0_1_delete_egp_table4(
00996     // Input values,
00997     const string&   protocol,
00998     const string&   target_class,
00999     const string&   target_instance,
01000     const bool& unicast,
01001     const bool& multicast) = 0;
01002 #ifdef XORP_ENABLE_ASYNC_SERVER
01003     typedef
01004     XorpCallback1<void, const XrlCmdError &>::RefPtr
01005     Rib01DeleteEgpTable4RF;
01006 
01007     class Rib01DeleteEgpTable4CB {
01008         Rib01DeleteEgpTable4RF cb;
01009 
01010     public:
01011         operator const Rib01DeleteEgpTable4RF& () const { return cb; }
01012         const Rib01DeleteEgpTable4RF& operator ->() const { return cb; }
01013         Rib01DeleteEgpTable4CB(const Rib01DeleteEgpTable4RF& cb)
01014           : cb(cb) { }
01015 
01016         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01017 
01018         void respond() const {
01019             cb->dispatch(XrlCmdError::OKAY());
01020         }
01021     };
01022 
01023     struct Rib01DeleteEgpTable4Rsp :
01024       public Rib01DeleteEgpTable4CB {
01025         Rib01DeleteEgpTable4Rsp(const Rib01DeleteEgpTable4RF& cb)
01026           : Rib01DeleteEgpTable4CB(cb) { }
01027 
01028     };
01029 
01030     virtual void async_rib_0_1_delete_egp_table4
01031        (
01032     const string&   protocol,
01033     const string&   target_class,
01034     const string&   target_instance,
01035     const bool& unicast,
01036     const bool& multicast,
01037     Rib01DeleteEgpTable4CB);
01038 #endif
01039 
01060     virtual XrlCmdError rib_0_1_add_route4(
01061     // Input values,
01062     const string&   protocol,
01063     const bool& unicast,
01064     const bool& multicast,
01065     const IPv4Net&  network,
01066     const IPv4& nexthop,
01067     const uint32_t& metric,
01068     const XrlAtomList&  policytags) = 0;
01069 #ifdef XORP_ENABLE_ASYNC_SERVER
01070     typedef
01071     XorpCallback1<void, const XrlCmdError &>::RefPtr
01072     Rib01AddRoute4RF;
01073 
01074     class Rib01AddRoute4CB {
01075         Rib01AddRoute4RF cb;
01076 
01077     public:
01078         operator const Rib01AddRoute4RF& () const { return cb; }
01079         const Rib01AddRoute4RF& operator ->() const { return cb; }
01080         Rib01AddRoute4CB(const Rib01AddRoute4RF& cb)
01081           : cb(cb) { }
01082 
01083         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01084 
01085         void respond() const {
01086             cb->dispatch(XrlCmdError::OKAY());
01087         }
01088     };
01089 
01090     struct Rib01AddRoute4Rsp :
01091       public Rib01AddRoute4CB {
01092         Rib01AddRoute4Rsp(const Rib01AddRoute4RF& cb)
01093           : Rib01AddRoute4CB(cb) { }
01094 
01095     };
01096 
01097     virtual void async_rib_0_1_add_route4
01098        (
01099     const string&   protocol,
01100     const bool& unicast,
01101     const bool& multicast,
01102     const IPv4Net&  network,
01103     const IPv4& nexthop,
01104     const uint32_t& metric,
01105     const XrlAtomList&  policytags,
01106     Rib01AddRoute4CB);
01107 #endif
01108 
01109     virtual XrlCmdError rib_0_1_replace_route4(
01110     // Input values,
01111     const string&   protocol,
01112     const bool& unicast,
01113     const bool& multicast,
01114     const IPv4Net&  network,
01115     const IPv4& nexthop,
01116     const uint32_t& metric,
01117     const XrlAtomList&  policytags) = 0;
01118 #ifdef XORP_ENABLE_ASYNC_SERVER
01119     typedef
01120     XorpCallback1<void, const XrlCmdError &>::RefPtr
01121     Rib01ReplaceRoute4RF;
01122 
01123     class Rib01ReplaceRoute4CB {
01124         Rib01ReplaceRoute4RF cb;
01125 
01126     public:
01127         operator const Rib01ReplaceRoute4RF& () const { return cb; }
01128         const Rib01ReplaceRoute4RF& operator ->() const { return cb; }
01129         Rib01ReplaceRoute4CB(const Rib01ReplaceRoute4RF& cb)
01130           : cb(cb) { }
01131 
01132         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01133 
01134         void respond() const {
01135             cb->dispatch(XrlCmdError::OKAY());
01136         }
01137     };
01138 
01139     struct Rib01ReplaceRoute4Rsp :
01140       public Rib01ReplaceRoute4CB {
01141         Rib01ReplaceRoute4Rsp(const Rib01ReplaceRoute4RF& cb)
01142           : Rib01ReplaceRoute4CB(cb) { }
01143 
01144     };
01145 
01146     virtual void async_rib_0_1_replace_route4
01147        (
01148     const string&   protocol,
01149     const bool& unicast,
01150     const bool& multicast,
01151     const IPv4Net&  network,
01152     const IPv4& nexthop,
01153     const uint32_t& metric,
01154     const XrlAtomList&  policytags,
01155     Rib01ReplaceRoute4CB);
01156 #endif
01157 
01158     virtual XrlCmdError rib_0_1_delete_route4(
01159     // Input values,
01160     const string&   protocol,
01161     const bool& unicast,
01162     const bool& multicast,
01163     const IPv4Net&  network) = 0;
01164 #ifdef XORP_ENABLE_ASYNC_SERVER
01165     typedef
01166     XorpCallback1<void, const XrlCmdError &>::RefPtr
01167     Rib01DeleteRoute4RF;
01168 
01169     class Rib01DeleteRoute4CB {
01170         Rib01DeleteRoute4RF cb;
01171 
01172     public:
01173         operator const Rib01DeleteRoute4RF& () const { return cb; }
01174         const Rib01DeleteRoute4RF& operator ->() const { return cb; }
01175         Rib01DeleteRoute4CB(const Rib01DeleteRoute4RF& cb)
01176           : cb(cb) { }
01177 
01178         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01179 
01180         void respond() const {
01181             cb->dispatch(XrlCmdError::OKAY());
01182         }
01183     };
01184 
01185     struct Rib01DeleteRoute4Rsp :
01186       public Rib01DeleteRoute4CB {
01187         Rib01DeleteRoute4Rsp(const Rib01DeleteRoute4RF& cb)
01188           : Rib01DeleteRoute4CB(cb) { }
01189 
01190     };
01191 
01192     virtual void async_rib_0_1_delete_route4
01193        (
01194     const string&   protocol,
01195     const bool& unicast,
01196     const bool& multicast,
01197     const IPv4Net&  network,
01198     Rib01DeleteRoute4CB);
01199 #endif
01200 
01228     virtual XrlCmdError rib_0_1_add_interface_route4(
01229     // Input values,
01230     const string&   protocol,
01231     const bool& unicast,
01232     const bool& multicast,
01233     const IPv4Net&  network,
01234     const IPv4& nexthop,
01235     const string&   ifname,
01236     const string&   vifname,
01237     const uint32_t& metric,
01238     const XrlAtomList&  policytags) = 0;
01239 #ifdef XORP_ENABLE_ASYNC_SERVER
01240     typedef
01241     XorpCallback1<void, const XrlCmdError &>::RefPtr
01242     Rib01AddInterfaceRoute4RF;
01243 
01244     class Rib01AddInterfaceRoute4CB {
01245         Rib01AddInterfaceRoute4RF cb;
01246 
01247     public:
01248         operator const Rib01AddInterfaceRoute4RF& () const { return cb; }
01249         const Rib01AddInterfaceRoute4RF& operator ->() const { return cb; }
01250         Rib01AddInterfaceRoute4CB(const Rib01AddInterfaceRoute4RF& cb)
01251           : cb(cb) { }
01252 
01253         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01254 
01255         void respond() const {
01256             cb->dispatch(XrlCmdError::OKAY());
01257         }
01258     };
01259 
01260     struct Rib01AddInterfaceRoute4Rsp :
01261       public Rib01AddInterfaceRoute4CB {
01262         Rib01AddInterfaceRoute4Rsp(const Rib01AddInterfaceRoute4RF& cb)
01263           : Rib01AddInterfaceRoute4CB(cb) { }
01264 
01265     };
01266 
01267     virtual void async_rib_0_1_add_interface_route4
01268        (
01269     const string&   protocol,
01270     const bool& unicast,
01271     const bool& multicast,
01272     const IPv4Net&  network,
01273     const IPv4& nexthop,
01274     const string&   ifname,
01275     const string&   vifname,
01276     const uint32_t& metric,
01277     const XrlAtomList&  policytags,
01278     Rib01AddInterfaceRoute4CB);
01279 #endif
01280 
01281     virtual XrlCmdError rib_0_1_replace_interface_route4(
01282     // Input values,
01283     const string&   protocol,
01284     const bool& unicast,
01285     const bool& multicast,
01286     const IPv4Net&  network,
01287     const IPv4& nexthop,
01288     const string&   ifname,
01289     const string&   vifname,
01290     const uint32_t& metric,
01291     const XrlAtomList&  policytags) = 0;
01292 #ifdef XORP_ENABLE_ASYNC_SERVER
01293     typedef
01294     XorpCallback1<void, const XrlCmdError &>::RefPtr
01295     Rib01ReplaceInterfaceRoute4RF;
01296 
01297     class Rib01ReplaceInterfaceRoute4CB {
01298         Rib01ReplaceInterfaceRoute4RF cb;
01299 
01300     public:
01301         operator const Rib01ReplaceInterfaceRoute4RF& () const { return cb; }
01302         const Rib01ReplaceInterfaceRoute4RF& operator ->() const { return cb; }
01303         Rib01ReplaceInterfaceRoute4CB(const Rib01ReplaceInterfaceRoute4RF& cb)
01304           : cb(cb) { }
01305 
01306         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01307 
01308         void respond() const {
01309             cb->dispatch(XrlCmdError::OKAY());
01310         }
01311     };
01312 
01313     struct Rib01ReplaceInterfaceRoute4Rsp :
01314       public Rib01ReplaceInterfaceRoute4CB {
01315         Rib01ReplaceInterfaceRoute4Rsp(const Rib01ReplaceInterfaceRoute4RF& cb)
01316           : Rib01ReplaceInterfaceRoute4CB(cb) { }
01317 
01318     };
01319 
01320     virtual void async_rib_0_1_replace_interface_route4
01321        (
01322     const string&   protocol,
01323     const bool& unicast,
01324     const bool& multicast,
01325     const IPv4Net&  network,
01326     const IPv4& nexthop,
01327     const string&   ifname,
01328     const string&   vifname,
01329     const uint32_t& metric,
01330     const XrlAtomList&  policytags,
01331     Rib01ReplaceInterfaceRoute4CB);
01332 #endif
01333 
01349     virtual XrlCmdError rib_0_1_lookup_route_by_dest4(
01350     // Input values,
01351     const IPv4& addr,
01352     const bool& unicast,
01353     const bool& multicast,
01354     // Output values,
01355     IPv4&   nexthop) = 0;
01356 #ifdef XORP_ENABLE_ASYNC_SERVER
01357     typedef
01358     XorpCallback2<void, const XrlCmdError &,
01359     const IPv4*>::RefPtr
01360     Rib01LookupRouteByDest4RF;
01361 
01362     class Rib01LookupRouteByDest4CB {
01363         Rib01LookupRouteByDest4RF cb;
01364 
01365     public:
01366         operator const Rib01LookupRouteByDest4RF& () const { return cb; }
01367         const Rib01LookupRouteByDest4RF& operator ->() const { return cb; }
01368         Rib01LookupRouteByDest4CB(const Rib01LookupRouteByDest4RF& cb)
01369           : cb(cb) { }
01370 
01371         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01372 
01373         void respond(const IPv4& arg_nexthop) const {
01374             cb->dispatch(XrlCmdError::OKAY(),
01375                          &arg_nexthop);
01376         }
01377     };
01378 
01379     struct Rib01LookupRouteByDest4Rsp :
01380       public Rib01LookupRouteByDest4CB {
01381         struct args_str {
01382             IPv4 nexthop;
01383         };
01384 
01385     private:
01386         args_str args;
01387 
01388     public:
01389         Rib01LookupRouteByDest4Rsp(const Rib01LookupRouteByDest4RF& cb)
01390           : Rib01LookupRouteByDest4CB(cb) { }
01391 
01392         void respond() const {
01393             Rib01LookupRouteByDest4CB::
01394             respond(args.nexthop);
01395         }
01396 
01397         args_str* operator ->() {
01398             return &args;
01399         }
01400     };
01401 
01402     virtual void async_rib_0_1_lookup_route_by_dest4
01403        (
01404     const IPv4& addr,
01405     const bool& unicast,
01406     const bool& multicast,
01407     Rib01LookupRouteByDest4CB);
01408 #endif
01409 
01418     virtual XrlCmdError rib_0_1_new_vif(
01419     // Input values,
01420     const string&   name) = 0;
01421 #ifdef XORP_ENABLE_ASYNC_SERVER
01422     typedef
01423     XorpCallback1<void, const XrlCmdError &>::RefPtr
01424     Rib01NewVifRF;
01425 
01426     class Rib01NewVifCB {
01427         Rib01NewVifRF cb;
01428 
01429     public:
01430         operator const Rib01NewVifRF& () const { return cb; }
01431         const Rib01NewVifRF& operator ->() const { return cb; }
01432         Rib01NewVifCB(const Rib01NewVifRF& cb)
01433           : cb(cb) { }
01434 
01435         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01436 
01437         void respond() const {
01438             cb->dispatch(XrlCmdError::OKAY());
01439         }
01440     };
01441 
01442     struct Rib01NewVifRsp :
01443       public Rib01NewVifCB {
01444         Rib01NewVifRsp(const Rib01NewVifRF& cb)
01445           : Rib01NewVifCB(cb) { }
01446 
01447     };
01448 
01449     virtual void async_rib_0_1_new_vif
01450        (
01451     const string&   name,
01452     Rib01NewVifCB);
01453 #endif
01454 
01467     virtual XrlCmdError rib_0_1_add_vif_addr4(
01468     // Input values,
01469     const string&   name,
01470     const IPv4& addr,
01471     const IPv4Net&  subnet) = 0;
01472 #ifdef XORP_ENABLE_ASYNC_SERVER
01473     typedef
01474     XorpCallback1<void, const XrlCmdError &>::RefPtr
01475     Rib01AddVifAddr4RF;
01476 
01477     class Rib01AddVifAddr4CB {
01478         Rib01AddVifAddr4RF cb;
01479 
01480     public:
01481         operator const Rib01AddVifAddr4RF& () const { return cb; }
01482         const Rib01AddVifAddr4RF& operator ->() const { return cb; }
01483         Rib01AddVifAddr4CB(const Rib01AddVifAddr4RF& cb)
01484           : cb(cb) { }
01485 
01486         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01487 
01488         void respond() const {
01489             cb->dispatch(XrlCmdError::OKAY());
01490         }
01491     };
01492 
01493     struct Rib01AddVifAddr4Rsp :
01494       public Rib01AddVifAddr4CB {
01495         Rib01AddVifAddr4Rsp(const Rib01AddVifAddr4RF& cb)
01496           : Rib01AddVifAddr4CB(cb) { }
01497 
01498     };
01499 
01500     virtual void async_rib_0_1_add_vif_addr4
01501        (
01502     const string&   name,
01503     const IPv4& addr,
01504     const IPv4Net&  subnet,
01505     Rib01AddVifAddr4CB);
01506 #endif
01507 
01530     virtual XrlCmdError rib_0_1_redist_enable4(
01531     // Input values,
01532     const string&   to_xrl_target,
01533     const string&   from_protocol,
01534     const bool& unicast,
01535     const bool& multicast,
01536     const IPv4Net&  network_prefix,
01537     const string&   cookie) = 0;
01538 #ifdef XORP_ENABLE_ASYNC_SERVER
01539     typedef
01540     XorpCallback1<void, const XrlCmdError &>::RefPtr
01541     Rib01RedistEnable4RF;
01542 
01543     class Rib01RedistEnable4CB {
01544         Rib01RedistEnable4RF cb;
01545 
01546     public:
01547         operator const Rib01RedistEnable4RF& () const { return cb; }
01548         const Rib01RedistEnable4RF& operator ->() const { return cb; }
01549         Rib01RedistEnable4CB(const Rib01RedistEnable4RF& cb)
01550           : cb(cb) { }
01551 
01552         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01553 
01554         void respond() const {
01555             cb->dispatch(XrlCmdError::OKAY());
01556         }
01557     };
01558 
01559     struct Rib01RedistEnable4Rsp :
01560       public Rib01RedistEnable4CB {
01561         Rib01RedistEnable4Rsp(const Rib01RedistEnable4RF& cb)
01562           : Rib01RedistEnable4CB(cb) { }
01563 
01564     };
01565 
01566     virtual void async_rib_0_1_redist_enable4
01567        (
01568     const string&   to_xrl_target,
01569     const string&   from_protocol,
01570     const bool& unicast,
01571     const bool& multicast,
01572     const IPv4Net&  network_prefix,
01573     const string&   cookie,
01574     Rib01RedistEnable4CB);
01575 #endif
01576 
01593     virtual XrlCmdError rib_0_1_redist_disable4(
01594     // Input values,
01595     const string&   to_xrl_target,
01596     const string&   from_protocol,
01597     const bool& unicast,
01598     const bool& multicast,
01599     const string&   cookie) = 0;
01600 #ifdef XORP_ENABLE_ASYNC_SERVER
01601     typedef
01602     XorpCallback1<void, const XrlCmdError &>::RefPtr
01603     Rib01RedistDisable4RF;
01604 
01605     class Rib01RedistDisable4CB {
01606         Rib01RedistDisable4RF cb;
01607 
01608     public:
01609         operator const Rib01RedistDisable4RF& () const { return cb; }
01610         const Rib01RedistDisable4RF& operator ->() const { return cb; }
01611         Rib01RedistDisable4CB(const Rib01RedistDisable4RF& cb)
01612           : cb(cb) { }
01613 
01614         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01615 
01616         void respond() const {
01617             cb->dispatch(XrlCmdError::OKAY());
01618         }
01619     };
01620 
01621     struct Rib01RedistDisable4Rsp :
01622       public Rib01RedistDisable4CB {
01623         Rib01RedistDisable4Rsp(const Rib01RedistDisable4RF& cb)
01624           : Rib01RedistDisable4CB(cb) { }
01625 
01626     };
01627 
01628     virtual void async_rib_0_1_redist_disable4
01629        (
01630     const string&   to_xrl_target,
01631     const string&   from_protocol,
01632     const bool& unicast,
01633     const bool& multicast,
01634     const string&   cookie,
01635     Rib01RedistDisable4CB);
01636 #endif
01637 
01661     virtual XrlCmdError rib_0_1_redist_transaction_enable4(
01662     // Input values,
01663     const string&   to_xrl_target,
01664     const string&   from_protocol,
01665     const bool& unicast,
01666     const bool& multicast,
01667     const IPv4Net&  network_prefix,
01668     const string&   cookie) = 0;
01669 #ifdef XORP_ENABLE_ASYNC_SERVER
01670     typedef
01671     XorpCallback1<void, const XrlCmdError &>::RefPtr
01672     Rib01RedistTransactionEnable4RF;
01673 
01674     class Rib01RedistTransactionEnable4CB {
01675         Rib01RedistTransactionEnable4RF cb;
01676 
01677     public:
01678         operator const Rib01RedistTransactionEnable4RF& () const { return cb; }
01679         const Rib01RedistTransactionEnable4RF& operator ->() const { return cb; }
01680         Rib01RedistTransactionEnable4CB(const Rib01RedistTransactionEnable4RF& cb)
01681           : cb(cb) { }
01682 
01683         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01684 
01685         void respond() const {
01686             cb->dispatch(XrlCmdError::OKAY());
01687         }
01688     };
01689 
01690     struct Rib01RedistTransactionEnable4Rsp :
01691       public Rib01RedistTransactionEnable4CB {
01692         Rib01RedistTransactionEnable4Rsp(const Rib01RedistTransactionEnable4RF& cb)
01693           : Rib01RedistTransactionEnable4CB(cb) { }
01694 
01695     };
01696 
01697     virtual void async_rib_0_1_redist_transaction_enable4
01698        (
01699     const string&   to_xrl_target,
01700     const string&   from_protocol,
01701     const bool& unicast,
01702     const bool& multicast,
01703     const IPv4Net&  network_prefix,
01704     const string&   cookie,
01705     Rib01RedistTransactionEnable4CB);
01706 #endif
01707 
01726     virtual XrlCmdError rib_0_1_redist_transaction_disable4(
01727     // Input values,
01728     const string&   to_xrl_target,
01729     const string&   from_protocol,
01730     const bool& unicast,
01731     const bool& multicast,
01732     const string&   cookie) = 0;
01733 #ifdef XORP_ENABLE_ASYNC_SERVER
01734     typedef
01735     XorpCallback1<void, const XrlCmdError &>::RefPtr
01736     Rib01RedistTransactionDisable4RF;
01737 
01738     class Rib01RedistTransactionDisable4CB {
01739         Rib01RedistTransactionDisable4RF cb;
01740 
01741     public:
01742         operator const Rib01RedistTransactionDisable4RF& () const { return cb; }
01743         const Rib01RedistTransactionDisable4RF& operator ->() const { return cb; }
01744         Rib01RedistTransactionDisable4CB(const Rib01RedistTransactionDisable4RF& cb)
01745           : cb(cb) { }
01746 
01747         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01748 
01749         void respond() const {
01750             cb->dispatch(XrlCmdError::OKAY());
01751         }
01752     };
01753 
01754     struct Rib01RedistTransactionDisable4Rsp :
01755       public Rib01RedistTransactionDisable4CB {
01756         Rib01RedistTransactionDisable4Rsp(const Rib01RedistTransactionDisable4RF& cb)
01757           : Rib01RedistTransactionDisable4CB(cb) { }
01758 
01759     };
01760 
01761     virtual void async_rib_0_1_redist_transaction_disable4
01762        (
01763     const string&   to_xrl_target,
01764     const string&   from_protocol,
01765     const bool& unicast,
01766     const bool& multicast,
01767     const string&   cookie,
01768     Rib01RedistTransactionDisable4CB);
01769 #endif
01770 
01801     virtual XrlCmdError rib_0_1_register_interest4(
01802     // Input values,
01803     const string&   target,
01804     const IPv4& addr,
01805     // Output values,
01806     bool&   resolves,
01807     IPv4&   base_addr,
01808     uint32_t&   prefix_len,
01809     uint32_t&   real_prefix_len,
01810     IPv4&   nexthop,
01811     uint32_t&   metric) = 0;
01812 #ifdef XORP_ENABLE_ASYNC_SERVER
01813     typedef
01814     XorpCallback7<void, const XrlCmdError &,
01815     const bool*,
01816     const IPv4*,
01817     const uint32_t*,
01818     const uint32_t*,
01819     const IPv4*,
01820     const uint32_t*>::RefPtr
01821     Rib01RegisterInterest4RF;
01822 
01823     class Rib01RegisterInterest4CB {
01824         Rib01RegisterInterest4RF cb;
01825 
01826     public:
01827         operator const Rib01RegisterInterest4RF& () const { return cb; }
01828         const Rib01RegisterInterest4RF& operator ->() const { return cb; }
01829         Rib01RegisterInterest4CB(const Rib01RegisterInterest4RF& cb)
01830           : cb(cb) { }
01831 
01832         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL, NULL, NULL); }
01833 
01834         void respond(const bool& arg_resolves,
01835                      const IPv4& arg_base_addr,
01836                      const uint32_t& arg_prefix_len,
01837                      const uint32_t& arg_real_prefix_len,
01838                      const IPv4& arg_nexthop,
01839                      const uint32_t& arg_metric) const {
01840             cb->dispatch(XrlCmdError::OKAY(),
01841                          &arg_resolves,
01842                          &arg_base_addr,
01843                          &arg_prefix_len,
01844                          &arg_real_prefix_len,
01845                          &arg_nexthop,
01846                          &arg_metric);
01847         }
01848     };
01849 
01850     struct Rib01RegisterInterest4Rsp :
01851       public Rib01RegisterInterest4CB {
01852         struct args_str {
01853             bool resolves;
01854             IPv4 base_addr;
01855             uint32_t prefix_len;
01856             uint32_t real_prefix_len;
01857             IPv4 nexthop;
01858             uint32_t metric;
01859         };
01860 
01861     private:
01862         args_str args;
01863 
01864     public:
01865         Rib01RegisterInterest4Rsp(const Rib01RegisterInterest4RF& cb)
01866           : Rib01RegisterInterest4CB(cb) { }
01867 
01868         void respond() const {
01869             Rib01RegisterInterest4CB::
01870             respond(args.resolves,
01871                         args.base_addr,
01872                         args.prefix_len,
01873                         args.real_prefix_len,
01874                         args.nexthop,
01875                         args.metric);
01876         }
01877 
01878         args_str* operator ->() {
01879             return &args;
01880         }
01881     };
01882 
01883     virtual void async_rib_0_1_register_interest4
01884        (
01885     const string&   target,
01886     const IPv4& addr,
01887     Rib01RegisterInterest4CB);
01888 #endif
01889 
01903     virtual XrlCmdError rib_0_1_deregister_interest4(
01904     // Input values,
01905     const string&   target,
01906     const IPv4& addr,
01907     const uint32_t& prefix_len) = 0;
01908 #ifdef XORP_ENABLE_ASYNC_SERVER
01909     typedef
01910     XorpCallback1<void, const XrlCmdError &>::RefPtr
01911     Rib01DeregisterInterest4RF;
01912 
01913     class Rib01DeregisterInterest4CB {
01914         Rib01DeregisterInterest4RF cb;
01915 
01916     public:
01917         operator const Rib01DeregisterInterest4RF& () const { return cb; }
01918         const Rib01DeregisterInterest4RF& operator ->() const { return cb; }
01919         Rib01DeregisterInterest4CB(const Rib01DeregisterInterest4RF& cb)
01920           : cb(cb) { }
01921 
01922         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01923 
01924         void respond() const {
01925             cb->dispatch(XrlCmdError::OKAY());
01926         }
01927     };
01928 
01929     struct Rib01DeregisterInterest4Rsp :
01930       public Rib01DeregisterInterest4CB {
01931         Rib01DeregisterInterest4Rsp(const Rib01DeregisterInterest4RF& cb)
01932           : Rib01DeregisterInterest4CB(cb) { }
01933 
01934     };
01935 
01936     virtual void async_rib_0_1_deregister_interest4
01937        (
01938     const string&   target,
01939     const IPv4& addr,
01940     const uint32_t& prefix_len,
01941     Rib01DeregisterInterest4CB);
01942 #endif
01943 
01953     virtual XrlCmdError rib_0_1_insert_policy_redist_tags(
01954     // Input values,
01955     const string&   protocol,
01956     const XrlAtomList&  policytags) = 0;
01957 #ifdef XORP_ENABLE_ASYNC_SERVER
01958     typedef
01959     XorpCallback1<void, const XrlCmdError &>::RefPtr
01960     Rib01InsertPolicyRedistTagsRF;
01961 
01962     class Rib01InsertPolicyRedistTagsCB {
01963         Rib01InsertPolicyRedistTagsRF cb;
01964 
01965     public:
01966         operator const Rib01InsertPolicyRedistTagsRF& () const { return cb; }
01967         const Rib01InsertPolicyRedistTagsRF& operator ->() const { return cb; }
01968         Rib01InsertPolicyRedistTagsCB(const Rib01InsertPolicyRedistTagsRF& cb)
01969           : cb(cb) { }
01970 
01971         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01972 
01973         void respond() const {
01974             cb->dispatch(XrlCmdError::OKAY());
01975         }
01976     };
01977 
01978     struct Rib01InsertPolicyRedistTagsRsp :
01979       public Rib01InsertPolicyRedistTagsCB {
01980         Rib01InsertPolicyRedistTagsRsp(const Rib01InsertPolicyRedistTagsRF& cb)
01981           : Rib01InsertPolicyRedistTagsCB(cb) { }
01982 
01983     };
01984 
01985     virtual void async_rib_0_1_insert_policy_redist_tags
01986        (
01987     const string&   protocol,
01988     const XrlAtomList&  policytags,
01989     Rib01InsertPolicyRedistTagsCB);
01990 #endif
01991 
01998     virtual XrlCmdError rib_0_1_reset_policy_redist_tags() = 0;
01999 #ifdef XORP_ENABLE_ASYNC_SERVER
02000     typedef
02001     XorpCallback1<void, const XrlCmdError &>::RefPtr
02002     Rib01ResetPolicyRedistTagsRF;
02003 
02004     class Rib01ResetPolicyRedistTagsCB {
02005         Rib01ResetPolicyRedistTagsRF cb;
02006 
02007     public:
02008         operator const Rib01ResetPolicyRedistTagsRF& () const { return cb; }
02009         const Rib01ResetPolicyRedistTagsRF& operator ->() const { return cb; }
02010         Rib01ResetPolicyRedistTagsCB(const Rib01ResetPolicyRedistTagsRF& cb)
02011           : cb(cb) { }
02012 
02013         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02014 
02015         void respond() const {
02016             cb->dispatch(XrlCmdError::OKAY());
02017         }
02018     };
02019 
02020     struct Rib01ResetPolicyRedistTagsRsp :
02021       public Rib01ResetPolicyRedistTagsCB {
02022         Rib01ResetPolicyRedistTagsRsp(const Rib01ResetPolicyRedistTagsRF& cb)
02023           : Rib01ResetPolicyRedistTagsCB(cb) { }
02024 
02025     };
02026 
02027     virtual void async_rib_0_1_reset_policy_redist_tags
02028        (
02029     Rib01ResetPolicyRedistTagsCB);
02030 #endif
02031 
02049     virtual XrlCmdError rib_0_1_get_protocol_admin_distances(
02050     // Input values,
02051     const bool& ipv4,
02052     const bool& unicast,
02053     // Output values,
02054     XrlAtomList&    protocols,
02055     XrlAtomList&    admin_distances) = 0;
02056 #ifdef XORP_ENABLE_ASYNC_SERVER
02057     typedef
02058     XorpCallback3<void, const XrlCmdError &,
02059     const XrlAtomList*,
02060     const XrlAtomList*>::RefPtr
02061     Rib01GetProtocolAdminDistancesRF;
02062 
02063     class Rib01GetProtocolAdminDistancesCB {
02064         Rib01GetProtocolAdminDistancesRF cb;
02065 
02066     public:
02067         operator const Rib01GetProtocolAdminDistancesRF& () const { return cb; }
02068         const Rib01GetProtocolAdminDistancesRF& operator ->() const { return cb; }
02069         Rib01GetProtocolAdminDistancesCB(const Rib01GetProtocolAdminDistancesRF& cb)
02070           : cb(cb) { }
02071 
02072         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL); }
02073 
02074         void respond(const XrlAtomList& arg_protocols,
02075                      const XrlAtomList& arg_admin_distances) const {
02076             cb->dispatch(XrlCmdError::OKAY(),
02077                          &arg_protocols,
02078                          &arg_admin_distances);
02079         }
02080     };
02081 
02082     struct Rib01GetProtocolAdminDistancesRsp :
02083       public Rib01GetProtocolAdminDistancesCB {
02084         struct args_str {
02085             XrlAtomList protocols;
02086             XrlAtomList admin_distances;
02087         };
02088 
02089     private:
02090         args_str args;
02091 
02092     public:
02093         Rib01GetProtocolAdminDistancesRsp(const Rib01GetProtocolAdminDistancesRF& cb)
02094           : Rib01GetProtocolAdminDistancesCB(cb) { }
02095 
02096         void respond() const {
02097             Rib01GetProtocolAdminDistancesCB::
02098             respond(args.protocols,
02099                         args.admin_distances);
02100         }
02101 
02102         args_str* operator ->() {
02103             return &args;
02104         }
02105     };
02106 
02107     virtual void async_rib_0_1_get_protocol_admin_distances
02108        (
02109     const bool& ipv4,
02110     const bool& unicast,
02111     Rib01GetProtocolAdminDistancesCB);
02112 #endif
02113 
02130     virtual XrlCmdError rib_0_1_get_protocol_admin_distance(
02131     // Input values,
02132     const string&   protocol,
02133     const bool& ipv4,
02134     const bool& unicast,
02135     // Output values,
02136     uint32_t&   admin_distance) = 0;
02137 #ifdef XORP_ENABLE_ASYNC_SERVER
02138     typedef
02139     XorpCallback2<void, const XrlCmdError &,
02140     const uint32_t*>::RefPtr
02141     Rib01GetProtocolAdminDistanceRF;
02142 
02143     class Rib01GetProtocolAdminDistanceCB {
02144         Rib01GetProtocolAdminDistanceRF cb;
02145 
02146     public:
02147         operator const Rib01GetProtocolAdminDistanceRF& () const { return cb; }
02148         const Rib01GetProtocolAdminDistanceRF& operator ->() const { return cb; }
02149         Rib01GetProtocolAdminDistanceCB(const Rib01GetProtocolAdminDistanceRF& cb)
02150           : cb(cb) { }
02151 
02152         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02153 
02154         void respond(const uint32_t& arg_admin_distance) const {
02155             cb->dispatch(XrlCmdError::OKAY(),
02156                          &arg_admin_distance);
02157         }
02158     };
02159 
02160     struct Rib01GetProtocolAdminDistanceRsp :
02161       public Rib01GetProtocolAdminDistanceCB {
02162         struct args_str {
02163             uint32_t admin_distance;
02164         };
02165 
02166     private:
02167         args_str args;
02168 
02169     public:
02170         Rib01GetProtocolAdminDistanceRsp(const Rib01GetProtocolAdminDistanceRF& cb)
02171           : Rib01GetProtocolAdminDistanceCB(cb) { }
02172 
02173         void respond() const {
02174             Rib01GetProtocolAdminDistanceCB::
02175             respond(args.admin_distance);
02176         }
02177 
02178         args_str* operator ->() {
02179             return &args;
02180         }
02181     };
02182 
02183     virtual void async_rib_0_1_get_protocol_admin_distance
02184        (
02185     const string&   protocol,
02186     const bool& ipv4,
02187     const bool& unicast,
02188     Rib01GetProtocolAdminDistanceCB);
02189 #endif
02190 
02208     virtual XrlCmdError rib_0_1_set_protocol_admin_distance(
02209     // Input values,
02210     const string&   protocol,
02211     const bool& ipv4,
02212     const bool& ipv6,
02213     const bool& unicast,
02214     const bool& multicast,
02215     const uint32_t& admin_distance) = 0;
02216 #ifdef XORP_ENABLE_ASYNC_SERVER
02217     typedef
02218     XorpCallback1<void, const XrlCmdError &>::RefPtr
02219     Rib01SetProtocolAdminDistanceRF;
02220 
02221     class Rib01SetProtocolAdminDistanceCB {
02222         Rib01SetProtocolAdminDistanceRF cb;
02223 
02224     public:
02225         operator const Rib01SetProtocolAdminDistanceRF& () const { return cb; }
02226         const Rib01SetProtocolAdminDistanceRF& operator ->() const { return cb; }
02227         Rib01SetProtocolAdminDistanceCB(const Rib01SetProtocolAdminDistanceRF& cb)
02228           : cb(cb) { }
02229 
02230         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02231 
02232         void respond() const {
02233             cb->dispatch(XrlCmdError::OKAY());
02234         }
02235     };
02236 
02237     struct Rib01SetProtocolAdminDistanceRsp :
02238       public Rib01SetProtocolAdminDistanceCB {
02239         Rib01SetProtocolAdminDistanceRsp(const Rib01SetProtocolAdminDistanceRF& cb)
02240           : Rib01SetProtocolAdminDistanceCB(cb) { }
02241 
02242     };
02243 
02244     virtual void async_rib_0_1_set_protocol_admin_distance
02245        (
02246     const string&   protocol,
02247     const bool& ipv4,
02248     const bool& ipv6,
02249     const bool& unicast,
02250     const bool& multicast,
02251     const uint32_t& admin_distance,
02252     Rib01SetProtocolAdminDistanceCB);
02253 #endif
02254 
02255     virtual XrlCmdError rib_0_1_add_igp_table6(
02256     // Input values,
02257     const string&   protocol,
02258     const string&   target_class,
02259     const string&   target_instance,
02260     const bool& unicast,
02261     const bool& multicast) = 0;
02262 #ifdef XORP_ENABLE_ASYNC_SERVER
02263     typedef
02264     XorpCallback1<void, const XrlCmdError &>::RefPtr
02265     Rib01AddIgpTable6RF;
02266 
02267     class Rib01AddIgpTable6CB {
02268         Rib01AddIgpTable6RF cb;
02269 
02270     public:
02271         operator const Rib01AddIgpTable6RF& () const { return cb; }
02272         const Rib01AddIgpTable6RF& operator ->() const { return cb; }
02273         Rib01AddIgpTable6CB(const Rib01AddIgpTable6RF& cb)
02274           : cb(cb) { }
02275 
02276         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02277 
02278         void respond() const {
02279             cb->dispatch(XrlCmdError::OKAY());
02280         }
02281     };
02282 
02283     struct Rib01AddIgpTable6Rsp :
02284       public Rib01AddIgpTable6CB {
02285         Rib01AddIgpTable6Rsp(const Rib01AddIgpTable6RF& cb)
02286           : Rib01AddIgpTable6CB(cb) { }
02287 
02288     };
02289 
02290     virtual void async_rib_0_1_add_igp_table6
02291        (
02292     const string&   protocol,
02293     const string&   target_class,
02294     const string&   target_instance,
02295     const bool& unicast,
02296     const bool& multicast,
02297     Rib01AddIgpTable6CB);
02298 #endif
02299 
02300     virtual XrlCmdError rib_0_1_delete_igp_table6(
02301     // Input values,
02302     const string&   protocol,
02303     const string&   target_class,
02304     const string&   target_instance,
02305     const bool& unicast,
02306     const bool& multicast) = 0;
02307 #ifdef XORP_ENABLE_ASYNC_SERVER
02308     typedef
02309     XorpCallback1<void, const XrlCmdError &>::RefPtr
02310     Rib01DeleteIgpTable6RF;
02311 
02312     class Rib01DeleteIgpTable6CB {
02313         Rib01DeleteIgpTable6RF cb;
02314 
02315     public:
02316         operator const Rib01DeleteIgpTable6RF& () const { return cb; }
02317         const Rib01DeleteIgpTable6RF& operator ->() const { return cb; }
02318         Rib01DeleteIgpTable6CB(const Rib01DeleteIgpTable6RF& cb)
02319           : cb(cb) { }
02320 
02321         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02322 
02323         void respond() const {
02324             cb->dispatch(XrlCmdError::OKAY());
02325         }
02326     };
02327 
02328     struct Rib01DeleteIgpTable6Rsp :
02329       public Rib01DeleteIgpTable6CB {
02330         Rib01DeleteIgpTable6Rsp(const Rib01DeleteIgpTable6RF& cb)
02331           : Rib01DeleteIgpTable6CB(cb) { }
02332 
02333     };
02334 
02335     virtual void async_rib_0_1_delete_igp_table6
02336        (
02337     const string&   protocol,
02338     const string&   target_class,
02339     const string&   target_instance,
02340     const bool& unicast,
02341     const bool& multicast,
02342     Rib01DeleteIgpTable6CB);
02343 #endif
02344 
02345     virtual XrlCmdError rib_0_1_add_egp_table6(
02346     // Input values,
02347     const string&   protocol,
02348     const string&   target_class,
02349     const string&   target_instance,
02350     const bool& unicast,
02351     const bool& multicast) = 0;
02352 #ifdef XORP_ENABLE_ASYNC_SERVER
02353     typedef
02354     XorpCallback1<void, const XrlCmdError &>::RefPtr
02355     Rib01AddEgpTable6RF;
02356 
02357     class Rib01AddEgpTable6CB {
02358         Rib01AddEgpTable6RF cb;
02359 
02360     public:
02361         operator const Rib01AddEgpTable6RF& () const { return cb; }
02362         const Rib01AddEgpTable6RF& operator ->() const { return cb; }
02363         Rib01AddEgpTable6CB(const Rib01AddEgpTable6RF& cb)
02364           : cb(cb) { }
02365 
02366         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02367 
02368         void respond() const {
02369             cb->dispatch(XrlCmdError::OKAY());
02370         }
02371     };
02372 
02373     struct Rib01AddEgpTable6Rsp :
02374       public Rib01AddEgpTable6CB {
02375         Rib01AddEgpTable6Rsp(const Rib01AddEgpTable6RF& cb)
02376           : Rib01AddEgpTable6CB(cb) { }
02377 
02378     };
02379 
02380     virtual void async_rib_0_1_add_egp_table6
02381        (
02382     const string&   protocol,
02383     const string&   target_class,
02384     const string&   target_instance,
02385     const bool& unicast,
02386     const bool& multicast,
02387     Rib01AddEgpTable6CB);
02388 #endif
02389 
02390     virtual XrlCmdError rib_0_1_delete_egp_table6(
02391     // Input values,
02392     const string&   protocol,
02393     const string&   target_class,
02394     const string&   target_instance,
02395     const bool& unicast,
02396     const bool& multicast) = 0;
02397 #ifdef XORP_ENABLE_ASYNC_SERVER
02398     typedef
02399     XorpCallback1<void, const XrlCmdError &>::RefPtr
02400     Rib01DeleteEgpTable6RF;
02401 
02402     class Rib01DeleteEgpTable6CB {
02403         Rib01DeleteEgpTable6RF cb;
02404 
02405     public:
02406         operator const Rib01DeleteEgpTable6RF& () const { return cb; }
02407         const Rib01DeleteEgpTable6RF& operator ->() const { return cb; }
02408         Rib01DeleteEgpTable6CB(const Rib01DeleteEgpTable6RF& cb)
02409           : cb(cb) { }
02410 
02411         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02412 
02413         void respond() const {
02414             cb->dispatch(XrlCmdError::OKAY());
02415         }
02416     };
02417 
02418     struct Rib01DeleteEgpTable6Rsp :
02419       public Rib01DeleteEgpTable6CB {
02420         Rib01DeleteEgpTable6Rsp(const Rib01DeleteEgpTable6RF& cb)
02421           : Rib01DeleteEgpTable6CB(cb) { }
02422 
02423     };
02424 
02425     virtual void async_rib_0_1_delete_egp_table6
02426        (
02427     const string&   protocol,
02428     const string&   target_class,
02429     const string&   target_instance,
02430     const bool& unicast,
02431     const bool& multicast,
02432     Rib01DeleteEgpTable6CB);
02433 #endif
02434 
02435     virtual XrlCmdError rib_0_1_add_route6(
02436     // Input values,
02437     const string&   protocol,
02438     const bool& unicast,
02439     const bool& multicast,
02440     const IPv6Net&  network,
02441     const IPv6& nexthop,
02442     const uint32_t& metric,
02443     const XrlAtomList&  policytags) = 0;
02444 #ifdef XORP_ENABLE_ASYNC_SERVER
02445     typedef
02446     XorpCallback1<void, const XrlCmdError &>::RefPtr
02447     Rib01AddRoute6RF;
02448 
02449     class Rib01AddRoute6CB {
02450         Rib01AddRoute6RF cb;
02451 
02452     public:
02453         operator const Rib01AddRoute6RF& () const { return cb; }
02454         const Rib01AddRoute6RF& operator ->() const { return cb; }
02455         Rib01AddRoute6CB(const Rib01AddRoute6RF& cb)
02456           : cb(cb) { }
02457 
02458         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02459 
02460         void respond() const {
02461             cb->dispatch(XrlCmdError::OKAY());
02462         }
02463     };
02464 
02465     struct Rib01AddRoute6Rsp :
02466       public Rib01AddRoute6CB {
02467         Rib01AddRoute6Rsp(const Rib01AddRoute6RF& cb)
02468           : Rib01AddRoute6CB(cb) { }
02469 
02470     };
02471 
02472     virtual void async_rib_0_1_add_route6
02473        (
02474     const string&   protocol,
02475     const bool& unicast,
02476     const bool& multicast,
02477     const IPv6Net&  network,
02478     const IPv6& nexthop,
02479     const uint32_t& metric,
02480     const XrlAtomList&  policytags,
02481     Rib01AddRoute6CB);
02482 #endif
02483 
02484     virtual XrlCmdError rib_0_1_replace_route6(
02485     // Input values,
02486     const string&   protocol,
02487     const bool& unicast,
02488     const bool& multicast,
02489     const IPv6Net&  network,
02490     const IPv6& nexthop,
02491     const uint32_t& metric,
02492     const XrlAtomList&  policytags) = 0;
02493 #ifdef XORP_ENABLE_ASYNC_SERVER
02494     typedef
02495     XorpCallback1<void, const XrlCmdError &>::RefPtr
02496     Rib01ReplaceRoute6RF;
02497 
02498     class Rib01ReplaceRoute6CB {
02499         Rib01ReplaceRoute6RF cb;
02500 
02501     public:
02502         operator const Rib01ReplaceRoute6RF& () const { return cb; }
02503         const Rib01ReplaceRoute6RF& operator ->() const { return cb; }
02504         Rib01ReplaceRoute6CB(const Rib01ReplaceRoute6RF& cb)
02505           : cb(cb) { }
02506 
02507         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02508 
02509         void respond() const {
02510             cb->dispatch(XrlCmdError::OKAY());
02511         }
02512     };
02513 
02514     struct Rib01ReplaceRoute6Rsp :
02515       public Rib01ReplaceRoute6CB {
02516         Rib01ReplaceRoute6Rsp(const Rib01ReplaceRoute6RF& cb)
02517           : Rib01ReplaceRoute6CB(cb) { }
02518 
02519     };
02520 
02521     virtual void async_rib_0_1_replace_route6
02522        (
02523     const string&   protocol,
02524     const bool& unicast,
02525     const bool& multicast,
02526     const IPv6Net&  network,
02527     const IPv6& nexthop,
02528     const uint32_t& metric,
02529     const XrlAtomList&  policytags,
02530     Rib01ReplaceRoute6CB);
02531 #endif
02532 
02533     virtual XrlCmdError rib_0_1_delete_route6(
02534     // Input values,
02535     const string&   protocol,
02536     const bool& unicast,
02537     const bool& multicast,
02538     const IPv6Net&  network) = 0;
02539 #ifdef XORP_ENABLE_ASYNC_SERVER
02540     typedef
02541     XorpCallback1<void, const XrlCmdError &>::RefPtr
02542     Rib01DeleteRoute6RF;
02543 
02544     class Rib01DeleteRoute6CB {
02545         Rib01DeleteRoute6RF cb;
02546 
02547     public:
02548         operator const Rib01DeleteRoute6RF& () const { return cb; }
02549         const Rib01DeleteRoute6RF& operator ->() const { return cb; }
02550         Rib01DeleteRoute6CB(const Rib01DeleteRoute6RF& cb)
02551           : cb(cb) { }
02552 
02553         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02554 
02555         void respond() const {
02556             cb->dispatch(XrlCmdError::OKAY());
02557         }
02558     };
02559 
02560     struct Rib01DeleteRoute6Rsp :
02561       public Rib01DeleteRoute6CB {
02562         Rib01DeleteRoute6Rsp(const Rib01DeleteRoute6RF& cb)
02563           : Rib01DeleteRoute6CB(cb) { }
02564 
02565     };
02566 
02567     virtual void async_rib_0_1_delete_route6
02568        (
02569     const string&   protocol,
02570     const bool& unicast,
02571     const bool& multicast,
02572     const IPv6Net&  network,
02573     Rib01DeleteRoute6CB);
02574 #endif
02575 
02576     virtual XrlCmdError rib_0_1_add_interface_route6(
02577     // Input values,
02578     const string&   protocol,
02579     const bool& unicast,
02580     const bool& multicast,
02581     const IPv6Net&  network,
02582     const IPv6& nexthop,
02583     const string&   ifname,
02584     const string&   vifname,
02585     const uint32_t& metric,
02586     const XrlAtomList&  policytags) = 0;
02587 #ifdef XORP_ENABLE_ASYNC_SERVER
02588     typedef
02589     XorpCallback1<void, const XrlCmdError &>::RefPtr
02590     Rib01AddInterfaceRoute6RF;
02591 
02592     class Rib01AddInterfaceRoute6CB {
02593         Rib01AddInterfaceRoute6RF cb;
02594 
02595     public:
02596         operator const Rib01AddInterfaceRoute6RF& () const { return cb; }
02597         const Rib01AddInterfaceRoute6RF& operator ->() const { return cb; }
02598         Rib01AddInterfaceRoute6CB(const Rib01AddInterfaceRoute6RF& cb)
02599           : cb(cb) { }
02600 
02601         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02602 
02603         void respond() const {
02604             cb->dispatch(XrlCmdError::OKAY());
02605         }
02606     };
02607 
02608     struct Rib01AddInterfaceRoute6Rsp :
02609       public Rib01AddInterfaceRoute6CB {
02610         Rib01AddInterfaceRoute6Rsp(const Rib01AddInterfaceRoute6RF& cb)
02611           : Rib01AddInterfaceRoute6CB(cb) { }
02612 
02613     };
02614 
02615     virtual void async_rib_0_1_add_interface_route6
02616        (
02617     const string&   protocol,
02618     const bool& unicast,
02619     const bool& multicast,
02620     const IPv6Net&  network,
02621     const IPv6& nexthop,
02622     const string&   ifname,
02623     const string&   vifname,
02624     const uint32_t& metric,
02625     const XrlAtomList&  policytags,
02626     Rib01AddInterfaceRoute6CB);
02627 #endif
02628 
02629     virtual XrlCmdError rib_0_1_replace_interface_route6(
02630     // Input values,
02631     const string&   protocol,
02632     const bool& unicast,
02633     const bool& multicast,
02634     const IPv6Net&  network,
02635     const IPv6& nexthop,
02636     const string&   ifname,
02637     const string&   vifname,
02638     const uint32_t& metric,
02639     const XrlAtomList&  policytags) = 0;
02640 #ifdef XORP_ENABLE_ASYNC_SERVER
02641     typedef
02642     XorpCallback1<void, const XrlCmdError &>::RefPtr
02643     Rib01ReplaceInterfaceRoute6RF;
02644 
02645     class Rib01ReplaceInterfaceRoute6CB {
02646         Rib01ReplaceInterfaceRoute6RF cb;
02647 
02648     public:
02649         operator const Rib01ReplaceInterfaceRoute6RF& () const { return cb; }
02650         const Rib01ReplaceInterfaceRoute6RF& operator ->() const { return cb; }
02651         Rib01ReplaceInterfaceRoute6CB(const Rib01ReplaceInterfaceRoute6RF& cb)
02652           : cb(cb) { }
02653 
02654         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02655 
02656         void respond() const {
02657             cb->dispatch(XrlCmdError::OKAY());
02658         }
02659     };
02660 
02661     struct Rib01ReplaceInterfaceRoute6Rsp :
02662       public Rib01ReplaceInterfaceRoute6CB {
02663         Rib01ReplaceInterfaceRoute6Rsp(const Rib01ReplaceInterfaceRoute6RF& cb)
02664           : Rib01ReplaceInterfaceRoute6CB(cb) { }
02665 
02666     };
02667 
02668     virtual void async_rib_0_1_replace_interface_route6
02669        (
02670     const string&   protocol,
02671     const bool& unicast,
02672     const bool& multicast,
02673     const IPv6Net&  network,
02674     const IPv6& nexthop,
02675     const string&   ifname,
02676     const string&   vifname,
02677     const uint32_t& metric,
02678     const XrlAtomList&  policytags,
02679     Rib01ReplaceInterfaceRoute6CB);
02680 #endif
02681 
02697     virtual XrlCmdError rib_0_1_lookup_route_by_dest6(
02698     // Input values,
02699     const IPv6& addr,
02700     const bool& unicast,
02701     const bool& multicast,
02702     // Output values,
02703     IPv6&   nexthop) = 0;
02704 #ifdef XORP_ENABLE_ASYNC_SERVER
02705     typedef
02706     XorpCallback2<void, const XrlCmdError &,
02707     const IPv6*>::RefPtr
02708     Rib01LookupRouteByDest6RF;
02709 
02710     class Rib01LookupRouteByDest6CB {
02711         Rib01LookupRouteByDest6RF cb;
02712 
02713     public:
02714         operator const Rib01LookupRouteByDest6RF& () const { return cb; }
02715         const Rib01LookupRouteByDest6RF& operator ->() const { return cb; }
02716         Rib01LookupRouteByDest6CB(const Rib01LookupRouteByDest6RF& cb)
02717           : cb(cb) { }
02718 
02719         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02720 
02721         void respond(const IPv6& arg_nexthop) const {
02722             cb->dispatch(XrlCmdError::OKAY(),
02723                          &arg_nexthop);
02724         }
02725     };
02726 
02727     struct Rib01LookupRouteByDest6Rsp :
02728       public Rib01LookupRouteByDest6CB {
02729         struct args_str {
02730             IPv6 nexthop;
02731         };
02732 
02733     private:
02734         args_str args;
02735 
02736     public:
02737         Rib01LookupRouteByDest6Rsp(const Rib01LookupRouteByDest6RF& cb)
02738           : Rib01LookupRouteByDest6CB(cb) { }
02739 
02740         void respond() const {
02741             Rib01LookupRouteByDest6CB::
02742             respond(args.nexthop);
02743         }
02744 
02745         args_str* operator ->() {
02746             return &args;
02747         }
02748     };
02749 
02750     virtual void async_rib_0_1_lookup_route_by_dest6
02751        (
02752     const IPv6& addr,
02753     const bool& unicast,
02754     const bool& multicast,
02755     Rib01LookupRouteByDest6CB);
02756 #endif
02757 
02758     virtual XrlCmdError rib_0_1_add_vif_addr6(
02759     // Input values,
02760     const string&   name,
02761     const IPv6& addr,
02762     const IPv6Net&  subnet) = 0;
02763 #ifdef XORP_ENABLE_ASYNC_SERVER
02764     typedef
02765     XorpCallback1<void, const XrlCmdError &>::RefPtr
02766     Rib01AddVifAddr6RF;
02767 
02768     class Rib01AddVifAddr6CB {
02769         Rib01AddVifAddr6RF cb;
02770 
02771     public:
02772         operator const Rib01AddVifAddr6RF& () const { return cb; }
02773         const Rib01AddVifAddr6RF& operator ->() const { return cb; }
02774         Rib01AddVifAddr6CB(const Rib01AddVifAddr6RF& cb)
02775           : cb(cb) { }
02776 
02777         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02778 
02779         void respond() const {
02780             cb->dispatch(XrlCmdError::OKAY());
02781         }
02782     };
02783 
02784     struct Rib01AddVifAddr6Rsp :
02785       public Rib01AddVifAddr6CB {
02786         Rib01AddVifAddr6Rsp(const Rib01AddVifAddr6RF& cb)
02787           : Rib01AddVifAddr6CB(cb) { }
02788 
02789     };
02790 
02791     virtual void async_rib_0_1_add_vif_addr6
02792        (
02793     const string&   name,
02794     const IPv6& addr,
02795     const IPv6Net&  subnet,
02796     Rib01AddVifAddr6CB);
02797 #endif
02798 
02821     virtual XrlCmdError rib_0_1_redist_enable6(
02822     // Input values,
02823     const string&   to_xrl_target,
02824     const string&   from_protocol,
02825     const bool& unicast,
02826     const bool& multicast,
02827     const IPv6Net&  network_prefix,
02828     const string&   cookie) = 0;
02829 #ifdef XORP_ENABLE_ASYNC_SERVER
02830     typedef
02831     XorpCallback1<void, const XrlCmdError &>::RefPtr
02832     Rib01RedistEnable6RF;
02833 
02834     class Rib01RedistEnable6CB {
02835         Rib01RedistEnable6RF cb;
02836 
02837     public:
02838         operator const Rib01RedistEnable6RF& () const { return cb; }
02839         const Rib01RedistEnable6RF& operator ->() const { return cb; }
02840         Rib01RedistEnable6CB(const Rib01RedistEnable6RF& cb)
02841           : cb(cb) { }
02842 
02843         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02844 
02845         void respond() const {
02846             cb->dispatch(XrlCmdError::OKAY());
02847         }
02848     };
02849 
02850     struct Rib01RedistEnable6Rsp :
02851       public Rib01RedistEnable6CB {
02852         Rib01RedistEnable6Rsp(const Rib01RedistEnable6RF& cb)
02853           : Rib01RedistEnable6CB(cb) { }
02854 
02855     };
02856 
02857     virtual void async_rib_0_1_redist_enable6
02858        (
02859     const string&   to_xrl_target,
02860     const string&   from_protocol,
02861     const bool& unicast,
02862     const bool& multicast,
02863     const IPv6Net&  network_prefix,
02864     const string&   cookie,
02865     Rib01RedistEnable6CB);
02866 #endif
02867 
02884     virtual XrlCmdError rib_0_1_redist_disable6(
02885     // Input values,
02886     const string&   to_xrl_target,
02887     const string&   from_protocol,
02888     const bool& unicast,
02889     const bool& multicast,
02890     const string&   cookie) = 0;
02891 #ifdef XORP_ENABLE_ASYNC_SERVER
02892     typedef
02893     XorpCallback1<void, const XrlCmdError &>::RefPtr
02894     Rib01RedistDisable6RF;
02895 
02896     class Rib01RedistDisable6CB {
02897         Rib01RedistDisable6RF cb;
02898 
02899     public:
02900         operator const Rib01RedistDisable6RF& () const { return cb; }
02901         const Rib01RedistDisable6RF& operator ->() const { return cb; }
02902         Rib01RedistDisable6CB(const Rib01RedistDisable6RF& cb)
02903           : cb(cb) { }
02904 
02905         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02906 
02907         void respond() const {
02908             cb->dispatch(XrlCmdError::OKAY());
02909         }
02910     };
02911 
02912     struct Rib01RedistDisable6Rsp :
02913       public Rib01RedistDisable6CB {
02914         Rib01RedistDisable6Rsp(const Rib01RedistDisable6RF& cb)
02915           : Rib01RedistDisable6CB(cb) { }
02916 
02917     };
02918 
02919     virtual void async_rib_0_1_redist_disable6
02920        (
02921     const string&   to_xrl_target,
02922     const string&   from_protocol,
02923     const bool& unicast,
02924     const bool& multicast,
02925     const string&   cookie,
02926     Rib01RedistDisable6CB);
02927 #endif
02928 
02952     virtual XrlCmdError rib_0_1_redist_transaction_enable6(
02953     // Input values,
02954     const string&   to_xrl_target,
02955     const string&   from_protocol,
02956     const bool& unicast,
02957     const bool& multicast,
02958     const IPv6Net&  network_prefix,
02959     const string&   cookie) = 0;
02960 #ifdef XORP_ENABLE_ASYNC_SERVER
02961     typedef
02962     XorpCallback1<void, const XrlCmdError &>::RefPtr
02963     Rib01RedistTransactionEnable6RF;
02964 
02965     class Rib01RedistTransactionEnable6CB {
02966         Rib01RedistTransactionEnable6RF cb;
02967 
02968     public:
02969         operator const Rib01RedistTransactionEnable6RF& () const { return cb; }
02970         const Rib01RedistTransactionEnable6RF& operator ->() const { return cb; }
02971         Rib01RedistTransactionEnable6CB(const Rib01RedistTransactionEnable6RF& cb)
02972           : cb(cb) { }
02973 
02974         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02975 
02976         void respond() const {
02977             cb->dispatch(XrlCmdError::OKAY());
02978         }
02979     };
02980 
02981     struct Rib01RedistTransactionEnable6Rsp :
02982       public Rib01RedistTransactionEnable6CB {
02983         Rib01RedistTransactionEnable6Rsp(const Rib01RedistTransactionEnable6RF& cb)
02984           : Rib01RedistTransactionEnable6CB(cb) { }
02985 
02986     };
02987 
02988     virtual void async_rib_0_1_redist_transaction_enable6
02989        (
02990     const string&   to_xrl_target,
02991     const string&   from_protocol,
02992     const bool& unicast,
02993     const bool& multicast,
02994     const IPv6Net&  network_prefix,
02995     const string&   cookie,
02996     Rib01RedistTransactionEnable6CB);
02997 #endif
02998 
03017     virtual XrlCmdError rib_0_1_redist_transaction_disable6(
03018     // Input values,
03019     const string&   to_xrl_target,
03020     const string&   from_protocol,
03021     const bool& unicast,
03022     const bool& multicast,
03023     const string&   cookie) = 0;
03024 #ifdef XORP_ENABLE_ASYNC_SERVER
03025     typedef
03026     XorpCallback1<void, const XrlCmdError &>::RefPtr
03027     Rib01RedistTransactionDisable6RF;
03028 
03029     class Rib01RedistTransactionDisable6CB {
03030         Rib01RedistTransactionDisable6RF cb;
03031 
03032     public:
03033         operator const Rib01RedistTransactionDisable6RF& () const { return cb; }
03034         const Rib01RedistTransactionDisable6RF& operator ->() const { return cb; }
03035         Rib01RedistTransactionDisable6CB(const Rib01RedistTransactionDisable6RF& cb)
03036           : cb(cb) { }
03037 
03038         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03039 
03040         void respond() const {
03041             cb->dispatch(XrlCmdError::OKAY());
03042         }
03043     };
03044 
03045     struct Rib01RedistTransactionDisable6Rsp :
03046       public Rib01RedistTransactionDisable6CB {
03047         Rib01RedistTransactionDisable6Rsp(const Rib01RedistTransactionDisable6RF& cb)
03048           : Rib01RedistTransactionDisable6CB(cb) { }
03049 
03050     };
03051 
03052     virtual void async_rib_0_1_redist_transaction_disable6
03053        (
03054     const string&   to_xrl_target,
03055     const string&   from_protocol,
03056     const bool& unicast,
03057     const bool& multicast,
03058     const string&   cookie,
03059     Rib01RedistTransactionDisable6CB);
03060 #endif
03061 
03092     virtual XrlCmdError rib_0_1_register_interest6(
03093     // Input values,
03094     const string&   target,
03095     const IPv6& addr,
03096     // Output values,
03097     bool&   resolves,
03098     IPv6&   base_addr,
03099     uint32_t&   prefix_len,
03100     uint32_t&   real_prefix_len,
03101     IPv6&   nexthop,
03102     uint32_t&   metric) = 0;
03103 #ifdef XORP_ENABLE_ASYNC_SERVER
03104     typedef
03105     XorpCallback7<void, const XrlCmdError &,
03106     const bool*,
03107     const IPv6*,
03108     const uint32_t*,
03109     const uint32_t*,
03110     const IPv6*,
03111     const uint32_t*>::RefPtr
03112     Rib01RegisterInterest6RF;
03113 
03114     class Rib01RegisterInterest6CB {
03115         Rib01RegisterInterest6RF cb;
03116 
03117     public:
03118         operator const Rib01RegisterInterest6RF& () const { return cb; }
03119         const Rib01RegisterInterest6RF& operator ->() const { return cb; }
03120         Rib01RegisterInterest6CB(const Rib01RegisterInterest6RF& cb)
03121           : cb(cb) { }
03122 
03123         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL, NULL, NULL); }
03124 
03125         void respond(const bool& arg_resolves,
03126                      const IPv6& arg_base_addr,
03127                      const uint32_t& arg_prefix_len,
03128                      const uint32_t& arg_real_prefix_len,
03129                      const IPv6& arg_nexthop,
03130                      const uint32_t& arg_metric) const {
03131             cb->dispatch(XrlCmdError::OKAY(),
03132                          &arg_resolves,
03133                          &arg_base_addr,
03134                          &arg_prefix_len,
03135                          &arg_real_prefix_len,
03136                          &arg_nexthop,
03137                          &arg_metric);
03138         }
03139     };
03140 
03141     struct Rib01RegisterInterest6Rsp :
03142       public Rib01RegisterInterest6CB {
03143         struct args_str {
03144             bool resolves;
03145             IPv6 base_addr;
03146             uint32_t prefix_len;
03147             uint32_t real_prefix_len;
03148             IPv6 nexthop;
03149             uint32_t metric;
03150         };
03151 
03152     private:
03153         args_str args;
03154 
03155     public:
03156         Rib01RegisterInterest6Rsp(const Rib01RegisterInterest6RF& cb)
03157           : Rib01RegisterInterest6CB(cb) { }
03158 
03159         void respond() const {
03160             Rib01RegisterInterest6CB::
03161             respond(args.resolves,
03162                         args.base_addr,
03163                         args.prefix_len,
03164                         args.real_prefix_len,
03165                         args.nexthop,
03166                         args.metric);
03167         }
03168 
03169         args_str* operator ->() {
03170             return &args;
03171         }
03172     };
03173 
03174     virtual void async_rib_0_1_register_interest6
03175        (
03176     const string&   target,
03177     const IPv6& addr,
03178     Rib01RegisterInterest6CB);
03179 #endif
03180 
03194     virtual XrlCmdError rib_0_1_deregister_interest6(
03195     // Input values,
03196     const string&   target,
03197     const IPv6& addr,
03198     const uint32_t& prefix_len) = 0;
03199 #ifdef XORP_ENABLE_ASYNC_SERVER
03200     typedef
03201     XorpCallback1<void, const XrlCmdError &>::RefPtr
03202     Rib01DeregisterInterest6RF;
03203 
03204     class Rib01DeregisterInterest6CB {
03205         Rib01DeregisterInterest6RF cb;
03206 
03207     public:
03208         operator const Rib01DeregisterInterest6RF& () const { return cb; }
03209         const Rib01DeregisterInterest6RF& operator ->() const { return cb; }
03210         Rib01DeregisterInterest6CB(const Rib01DeregisterInterest6RF& cb)
03211           : cb(cb) { }
03212 
03213         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03214 
03215         void respond() const {
03216             cb->dispatch(XrlCmdError::OKAY());
03217         }
03218     };
03219 
03220     struct Rib01DeregisterInterest6Rsp :
03221       public Rib01DeregisterInterest6CB {
03222         Rib01DeregisterInterest6Rsp(const Rib01DeregisterInterest6RF& cb)
03223           : Rib01DeregisterInterest6CB(cb) { }
03224 
03225     };
03226 
03227     virtual void async_rib_0_1_deregister_interest6
03228        (
03229     const string&   target,
03230     const IPv6& addr,
03231     const uint32_t& prefix_len,
03232     Rib01DeregisterInterest6CB);
03233 #endif
03234 
03242     virtual XrlCmdError profile_0_1_enable(
03243     // Input values,
03244     const string&   pname) = 0;
03245 #ifdef XORP_ENABLE_ASYNC_SERVER
03246     typedef
03247     XorpCallback1<void, const XrlCmdError &>::RefPtr
03248     Profile01EnableRF;
03249 
03250     class Profile01EnableCB {
03251         Profile01EnableRF cb;
03252 
03253     public:
03254         operator const Profile01EnableRF& () const { return cb; }
03255         const Profile01EnableRF& operator ->() const { return cb; }
03256         Profile01EnableCB(const Profile01EnableRF& cb)
03257           : cb(cb) { }
03258 
03259         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03260 
03261         void respond() const {
03262             cb->dispatch(XrlCmdError::OKAY());
03263         }
03264     };
03265 
03266     struct Profile01EnableRsp :
03267       public Profile01EnableCB {
03268         Profile01EnableRsp(const Profile01EnableRF& cb)
03269           : Profile01EnableCB(cb) { }
03270 
03271     };
03272 
03273     virtual void async_profile_0_1_enable
03274        (
03275     const string&   pname,
03276     Profile01EnableCB);
03277 #endif
03278 
03286     virtual XrlCmdError profile_0_1_disable(
03287     // Input values,
03288     const string&   pname) = 0;
03289 #ifdef XORP_ENABLE_ASYNC_SERVER
03290     typedef
03291     XorpCallback1<void, const XrlCmdError &>::RefPtr
03292     Profile01DisableRF;
03293 
03294     class Profile01DisableCB {
03295         Profile01DisableRF cb;
03296 
03297     public:
03298         operator const Profile01DisableRF& () const { return cb; }
03299         const Profile01DisableRF& operator ->() const { return cb; }
03300         Profile01DisableCB(const Profile01DisableRF& cb)
03301           : cb(cb) { }
03302 
03303         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03304 
03305         void respond() const {
03306             cb->dispatch(XrlCmdError::OKAY());
03307         }
03308     };
03309 
03310     struct Profile01DisableRsp :
03311       public Profile01DisableCB {
03312         Profile01DisableRsp(const Profile01DisableRF& cb)
03313           : Profile01DisableCB(cb) { }
03314 
03315     };
03316 
03317     virtual void async_profile_0_1_disable
03318        (
03319     const string&   pname,
03320     Profile01DisableCB);
03321 #endif
03322 
03332     virtual XrlCmdError profile_0_1_get_entries(
03333     // Input values,
03334     const string&   pname,
03335     const string&   instance_name) = 0;
03336 #ifdef XORP_ENABLE_ASYNC_SERVER
03337     typedef
03338     XorpCallback1<void, const XrlCmdError &>::RefPtr
03339     Profile01GetEntriesRF;
03340 
03341     class Profile01GetEntriesCB {
03342         Profile01GetEntriesRF cb;
03343 
03344     public:
03345         operator const Profile01GetEntriesRF& () const { return cb; }
03346         const Profile01GetEntriesRF& operator ->() const { return cb; }
03347         Profile01GetEntriesCB(const Profile01GetEntriesRF& cb)
03348           : cb(cb) { }
03349 
03350         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03351 
03352         void respond() const {
03353             cb->dispatch(XrlCmdError::OKAY());
03354         }
03355     };
03356 
03357     struct Profile01GetEntriesRsp :
03358       public Profile01GetEntriesCB {
03359         Profile01GetEntriesRsp(const Profile01GetEntriesRF& cb)
03360           : Profile01GetEntriesCB(cb) { }
03361 
03362     };
03363 
03364     virtual void async_profile_0_1_get_entries
03365        (
03366     const string&   pname,
03367     const string&   instance_name,
03368     Profile01GetEntriesCB);
03369 #endif
03370 
03378     virtual XrlCmdError profile_0_1_clear(
03379     // Input values,
03380     const string&   pname) = 0;
03381 #ifdef XORP_ENABLE_ASYNC_SERVER
03382     typedef
03383     XorpCallback1<void, const XrlCmdError &>::RefPtr
03384     Profile01ClearRF;
03385 
03386     class Profile01ClearCB {
03387         Profile01ClearRF cb;
03388 
03389     public:
03390         operator const Profile01ClearRF& () const { return cb; }
03391         const Profile01ClearRF& operator ->() const { return cb; }
03392         Profile01ClearCB(const Profile01ClearRF& cb)
03393           : cb(cb) { }
03394 
03395         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03396 
03397         void respond() const {
03398             cb->dispatch(XrlCmdError::OKAY());
03399         }
03400     };
03401 
03402     struct Profile01ClearRsp :
03403       public Profile01ClearCB {
03404         Profile01ClearRsp(const Profile01ClearRF& cb)
03405           : Profile01ClearCB(cb) { }
03406 
03407     };
03408 
03409     virtual void async_profile_0_1_clear
03410        (
03411     const string&   pname,
03412     Profile01ClearCB);
03413 #endif
03414 
03420     virtual XrlCmdError profile_0_1_list(
03421     // Output values,
03422     string& info) = 0;
03423 #ifdef XORP_ENABLE_ASYNC_SERVER
03424     typedef
03425     XorpCallback2<void, const XrlCmdError &,
03426     const string*>::RefPtr
03427     Profile01ListRF;
03428 
03429     class Profile01ListCB {
03430         Profile01ListRF cb;
03431 
03432     public:
03433         operator const Profile01ListRF& () const { return cb; }
03434         const Profile01ListRF& operator ->() const { return cb; }
03435         Profile01ListCB(const Profile01ListRF& cb)
03436           : cb(cb) { }
03437 
03438         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
03439 
03440         void respond(const string& arg_info) const {
03441             cb->dispatch(XrlCmdError::OKAY(),
03442                          &arg_info);
03443         }
03444     };
03445 
03446     struct Profile01ListRsp :
03447       public Profile01ListCB {
03448         struct args_str {
03449             string info;
03450         };
03451 
03452     private:
03453         args_str args;
03454 
03455     public:
03456         Profile01ListRsp(const Profile01ListRF& cb)
03457           : Profile01ListCB(cb) { }
03458 
03459         void respond() const {
03460             Profile01ListCB::
03461             respond(args.info);
03462         }
03463 
03464         args_str* operator ->() {
03465             return &args;
03466         }
03467     };
03468 
03469     virtual void async_profile_0_1_list
03470        (
03471     Profile01ListCB);
03472 #endif
03473 
03474 private:
03475     XrlCmdRT handle_common_0_1_get_target_name(const XrlArgs& in, XrlCmdOT out);
03476 #ifdef XORP_ENABLE_ASYNC_SERVER
03477     void callback_common_0_1_get_target_name
03478        (const XrlCmdError &e,
03479     const string* arg_name,
03480         XrlRespCallback);
03481 #endif
03482 
03483     XrlCmdRT handle_common_0_1_get_version(const XrlArgs& in, XrlCmdOT out);
03484 #ifdef XORP_ENABLE_ASYNC_SERVER
03485     void callback_common_0_1_get_version
03486        (const XrlCmdError &e,
03487     const string* arg_version,
03488         XrlRespCallback);
03489 #endif
03490 
03491     XrlCmdRT handle_common_0_1_get_status(const XrlArgs& in, XrlCmdOT out);
03492 #ifdef XORP_ENABLE_ASYNC_SERVER
03493     void callback_common_0_1_get_status
03494        (const XrlCmdError &e,
03495     const uint32_t* arg_status,
03496     const string* arg_reason,
03497         XrlRespCallback);
03498 #endif
03499 
03500     XrlCmdRT handle_common_0_1_shutdown(const XrlArgs& in, XrlCmdOT out);
03501 #ifdef XORP_ENABLE_ASYNC_SERVER
03502     void callback_common_0_1_shutdown
03503        (const XrlCmdError &e,
03504         XrlRespCallback);
03505 #endif
03506 
03507     XrlCmdRT handle_common_0_1_startup(const XrlArgs& in, XrlCmdOT out);
03508 #ifdef XORP_ENABLE_ASYNC_SERVER
03509     void callback_common_0_1_startup
03510        (const XrlCmdError &e,
03511         XrlRespCallback);
03512 #endif
03513 
03514     XrlCmdRT handle_finder_event_observer_0_1_xrl_target_birth(const XrlArgs& in, XrlCmdOT out);
03515 #ifdef XORP_ENABLE_ASYNC_SERVER
03516     void callback_finder_event_observer_0_1_xrl_target_birth
03517        (const XrlCmdError &e,
03518         XrlRespCallback);
03519 #endif
03520 
03521     XrlCmdRT handle_finder_event_observer_0_1_xrl_target_death(const XrlArgs& in, XrlCmdOT out);
03522 #ifdef XORP_ENABLE_ASYNC_SERVER
03523     void callback_finder_event_observer_0_1_xrl_target_death
03524        (const XrlCmdError &e,
03525         XrlRespCallback);
03526 #endif
03527 
03528     XrlCmdRT handle_policy_backend_0_1_configure(const XrlArgs& in, XrlCmdOT out);
03529 #ifdef XORP_ENABLE_ASYNC_SERVER
03530     void callback_policy_backend_0_1_configure
03531        (const XrlCmdError &e,
03532         XrlRespCallback);
03533 #endif
03534 
03535     XrlCmdRT handle_policy_backend_0_1_reset(const XrlArgs& in, XrlCmdOT out);
03536 #ifdef XORP_ENABLE_ASYNC_SERVER
03537     void callback_policy_backend_0_1_reset
03538        (const XrlCmdError &e,
03539         XrlRespCallback);
03540 #endif
03541 
03542     XrlCmdRT handle_policy_backend_0_1_push_routes(const XrlArgs& in, XrlCmdOT out);
03543 #ifdef XORP_ENABLE_ASYNC_SERVER
03544     void callback_policy_backend_0_1_push_routes
03545        (const XrlCmdError &e,
03546         XrlRespCallback);
03547 #endif
03548 
03549     XrlCmdRT handle_rib_0_1_enable_rib(const XrlArgs& in, XrlCmdOT out);
03550 #ifdef XORP_ENABLE_ASYNC_SERVER
03551     void callback_rib_0_1_enable_rib
03552        (const XrlCmdError &e,
03553         XrlRespCallback);
03554 #endif
03555 
03556     XrlCmdRT handle_rib_0_1_disable_rib(const XrlArgs& in, XrlCmdOT out);
03557 #ifdef XORP_ENABLE_ASYNC_SERVER
03558     void callback_rib_0_1_disable_rib
03559        (const XrlCmdError &e,
03560         XrlRespCallback);
03561 #endif
03562 
03563     XrlCmdRT handle_rib_0_1_start_rib(const XrlArgs& in, XrlCmdOT out);
03564 #ifdef XORP_ENABLE_ASYNC_SERVER
03565     void callback_rib_0_1_start_rib
03566        (const XrlCmdError &e,
03567         XrlRespCallback);
03568 #endif
03569 
03570     XrlCmdRT handle_rib_0_1_stop_rib(const XrlArgs& in, XrlCmdOT out);
03571 #ifdef XORP_ENABLE_ASYNC_SERVER
03572     void callback_rib_0_1_stop_rib
03573        (const XrlCmdError &e,
03574         XrlRespCallback);
03575 #endif
03576 
03577     XrlCmdRT handle_rib_0_1_make_errors_fatal(const XrlArgs& in, XrlCmdOT out);
03578 #ifdef XORP_ENABLE_ASYNC_SERVER
03579     void callback_rib_0_1_make_errors_fatal
03580        (const XrlCmdError &e,
03581         XrlRespCallback);
03582 #endif
03583 
03584     XrlCmdRT handle_rib_0_1_get_registered_protocols(const XrlArgs& in, XrlCmdOT out);
03585 #ifdef XORP_ENABLE_ASYNC_SERVER
03586     void callback_rib_0_1_get_registered_protocols
03587        (const XrlCmdError &e,
03588     const XrlAtomList* arg_ipv4_unicast_protocols,
03589     const XrlAtomList* arg_ipv6_unicast_protocols,
03590     const XrlAtomList* arg_ipv4_multicast_protocols,
03591     const XrlAtomList* arg_ipv6_multicast_protocols,
03592         XrlRespCallback);
03593 #endif
03594 
03595     XrlCmdRT handle_rib_0_1_add_igp_table4(const XrlArgs& in, XrlCmdOT out);
03596 #ifdef XORP_ENABLE_ASYNC_SERVER
03597     void callback_rib_0_1_add_igp_table4
03598        (const XrlCmdError &e,
03599         XrlRespCallback);
03600 #endif
03601 
03602     XrlCmdRT handle_rib_0_1_delete_igp_table4(const XrlArgs& in, XrlCmdOT out);
03603 #ifdef XORP_ENABLE_ASYNC_SERVER
03604     void callback_rib_0_1_delete_igp_table4
03605        (const XrlCmdError &e,
03606         XrlRespCallback);
03607 #endif
03608 
03609     XrlCmdRT handle_rib_0_1_add_egp_table4(const XrlArgs& in, XrlCmdOT out);
03610 #ifdef XORP_ENABLE_ASYNC_SERVER
03611     void callback_rib_0_1_add_egp_table4
03612        (const XrlCmdError &e,
03613         XrlRespCallback);
03614 #endif
03615 
03616     XrlCmdRT handle_rib_0_1_delete_egp_table4(const XrlArgs& in, XrlCmdOT out);
03617 #ifdef XORP_ENABLE_ASYNC_SERVER
03618     void callback_rib_0_1_delete_egp_table4
03619        (const XrlCmdError &e,
03620         XrlRespCallback);
03621 #endif
03622 
03623     XrlCmdRT handle_rib_0_1_add_route4(const XrlArgs& in, XrlCmdOT out);
03624 #ifdef XORP_ENABLE_ASYNC_SERVER
03625     void callback_rib_0_1_add_route4
03626        (const XrlCmdError &e,
03627         XrlRespCallback);
03628 #endif
03629 
03630     XrlCmdRT handle_rib_0_1_replace_route4(const XrlArgs& in, XrlCmdOT out);
03631 #ifdef XORP_ENABLE_ASYNC_SERVER
03632     void callback_rib_0_1_replace_route4
03633        (const XrlCmdError &e,
03634         XrlRespCallback);
03635 #endif
03636 
03637     XrlCmdRT handle_rib_0_1_delete_route4(const XrlArgs& in, XrlCmdOT out);
03638 #ifdef XORP_ENABLE_ASYNC_SERVER
03639     void callback_rib_0_1_delete_route4
03640        (const XrlCmdError &e,
03641         XrlRespCallback);
03642 #endif
03643 
03644     XrlCmdRT handle_rib_0_1_add_interface_route4(const XrlArgs& in, XrlCmdOT out);
03645 #ifdef XORP_ENABLE_ASYNC_SERVER
03646     void callback_rib_0_1_add_interface_route4
03647        (const XrlCmdError &e,
03648         XrlRespCallback);
03649 #endif
03650 
03651     XrlCmdRT handle_rib_0_1_replace_interface_route4(const XrlArgs& in, XrlCmdOT out);
03652 #ifdef XORP_ENABLE_ASYNC_SERVER
03653     void callback_rib_0_1_replace_interface_route4
03654        (const XrlCmdError &e,
03655         XrlRespCallback);
03656 #endif
03657 
03658     XrlCmdRT handle_rib_0_1_lookup_route_by_dest4(const XrlArgs& in, XrlCmdOT out);
03659 #ifdef XORP_ENABLE_ASYNC_SERVER
03660     void callback_rib_0_1_lookup_route_by_dest4
03661        (const XrlCmdError &e,
03662     const IPv4* arg_nexthop,
03663         XrlRespCallback);
03664 #endif
03665 
03666     XrlCmdRT handle_rib_0_1_new_vif(const XrlArgs& in, XrlCmdOT out);
03667 #ifdef XORP_ENABLE_ASYNC_SERVER
03668     void callback_rib_0_1_new_vif
03669        (const XrlCmdError &e,
03670         XrlRespCallback);
03671 #endif
03672 
03673     XrlCmdRT handle_rib_0_1_add_vif_addr4(const XrlArgs& in, XrlCmdOT out);
03674 #ifdef XORP_ENABLE_ASYNC_SERVER
03675     void callback_rib_0_1_add_vif_addr4
03676        (const XrlCmdError &e,
03677         XrlRespCallback);
03678 #endif
03679 
03680     XrlCmdRT handle_rib_0_1_redist_enable4(const XrlArgs& in, XrlCmdOT out);
03681 #ifdef XORP_ENABLE_ASYNC_SERVER
03682     void callback_rib_0_1_redist_enable4
03683        (const XrlCmdError &e,
03684         XrlRespCallback);
03685 #endif
03686 
03687     XrlCmdRT handle_rib_0_1_redist_disable4(const XrlArgs& in, XrlCmdOT out);
03688 #ifdef XORP_ENABLE_ASYNC_SERVER
03689     void callback_rib_0_1_redist_disable4
03690        (const XrlCmdError &e,
03691         XrlRespCallback);
03692 #endif
03693 
03694     XrlCmdRT handle_rib_0_1_redist_transaction_enable4(const XrlArgs& in, XrlCmdOT out);
03695 #ifdef XORP_ENABLE_ASYNC_SERVER
03696     void callback_rib_0_1_redist_transaction_enable4
03697        (const XrlCmdError &e,
03698         XrlRespCallback);
03699 #endif
03700 
03701     XrlCmdRT handle_rib_0_1_redist_transaction_disable4(const XrlArgs& in, XrlCmdOT out);
03702 #ifdef XORP_ENABLE_ASYNC_SERVER
03703     void callback_rib_0_1_redist_transaction_disable4
03704        (const XrlCmdError &e,
03705         XrlRespCallback);
03706 #endif
03707 
03708     XrlCmdRT handle_rib_0_1_register_interest4(const XrlArgs& in, XrlCmdOT out);
03709 #ifdef XORP_ENABLE_ASYNC_SERVER
03710     void callback_rib_0_1_register_interest4
03711        (const XrlCmdError &e,
03712     const bool* arg_resolves,
03713     const IPv4* arg_base_addr,
03714     const uint32_t* arg_prefix_len,
03715     const uint32_t* arg_real_prefix_len,
03716     const IPv4* arg_nexthop,
03717     const uint32_t* arg_metric,
03718         XrlRespCallback);
03719 #endif
03720 
03721     XrlCmdRT handle_rib_0_1_deregister_interest4(const XrlArgs& in, XrlCmdOT out);
03722 #ifdef XORP_ENABLE_ASYNC_SERVER
03723     void callback_rib_0_1_deregister_interest4
03724        (const XrlCmdError &e,
03725         XrlRespCallback);
03726 #endif
03727 
03728     XrlCmdRT handle_rib_0_1_insert_policy_redist_tags(const XrlArgs& in, XrlCmdOT out);
03729 #ifdef XORP_ENABLE_ASYNC_SERVER
03730     void callback_rib_0_1_insert_policy_redist_tags
03731        (const XrlCmdError &e,
03732         XrlRespCallback);
03733 #endif
03734 
03735     XrlCmdRT handle_rib_0_1_reset_policy_redist_tags(const XrlArgs& in, XrlCmdOT out);
03736 #ifdef XORP_ENABLE_ASYNC_SERVER
03737     void callback_rib_0_1_reset_policy_redist_tags
03738        (const XrlCmdError &e,
03739         XrlRespCallback);
03740 #endif
03741 
03742     XrlCmdRT handle_rib_0_1_get_protocol_admin_distances(const XrlArgs& in, XrlCmdOT out);
03743 #ifdef XORP_ENABLE_ASYNC_SERVER
03744     void callback_rib_0_1_get_protocol_admin_distances
03745        (const XrlCmdError &e,
03746     const XrlAtomList* arg_protocols,
03747     const XrlAtomList* arg_admin_distances,
03748         XrlRespCallback);
03749 #endif
03750 
03751     XrlCmdRT handle_rib_0_1_get_protocol_admin_distance(const XrlArgs& in, XrlCmdOT out);
03752 #ifdef XORP_ENABLE_ASYNC_SERVER
03753     void callback_rib_0_1_get_protocol_admin_distance
03754        (const XrlCmdError &e,
03755     const uint32_t* arg_admin_distance,
03756         XrlRespCallback);
03757 #endif
03758 
03759     XrlCmdRT handle_rib_0_1_set_protocol_admin_distance(const XrlArgs& in, XrlCmdOT out);
03760 #ifdef XORP_ENABLE_ASYNC_SERVER
03761     void callback_rib_0_1_set_protocol_admin_distance
03762        (const XrlCmdError &e,
03763         XrlRespCallback);
03764 #endif
03765 
03766     XrlCmdRT handle_rib_0_1_add_igp_table6(const XrlArgs& in, XrlCmdOT out);
03767 #ifdef XORP_ENABLE_ASYNC_SERVER
03768     void callback_rib_0_1_add_igp_table6
03769        (const XrlCmdError &e,
03770         XrlRespCallback);
03771 #endif
03772 
03773     XrlCmdRT handle_rib_0_1_delete_igp_table6(const XrlArgs& in, XrlCmdOT out);
03774 #ifdef XORP_ENABLE_ASYNC_SERVER
03775     void callback_rib_0_1_delete_igp_table6
03776        (const XrlCmdError &e,
03777         XrlRespCallback);
03778 #endif
03779 
03780     XrlCmdRT handle_rib_0_1_add_egp_table6(const XrlArgs& in, XrlCmdOT out);
03781 #ifdef XORP_ENABLE_ASYNC_SERVER
03782     void callback_rib_0_1_add_egp_table6
03783        (const XrlCmdError &e,
03784         XrlRespCallback);
03785 #endif
03786 
03787     XrlCmdRT handle_rib_0_1_delete_egp_table6(const XrlArgs& in, XrlCmdOT out);
03788 #ifdef XORP_ENABLE_ASYNC_SERVER
03789     void callback_rib_0_1_delete_egp_table6
03790        (const XrlCmdError &e,
03791         XrlRespCallback);
03792 #endif
03793 
03794     XrlCmdRT handle_rib_0_1_add_route6(const XrlArgs& in, XrlCmdOT out);
03795 #ifdef XORP_ENABLE_ASYNC_SERVER
03796     void callback_rib_0_1_add_route6
03797        (const XrlCmdError &e,
03798         XrlRespCallback);
03799 #endif
03800 
03801     XrlCmdRT handle_rib_0_1_replace_route6(const XrlArgs& in, XrlCmdOT out);
03802 #ifdef XORP_ENABLE_ASYNC_SERVER
03803     void callback_rib_0_1_replace_route6
03804        (const XrlCmdError &e,
03805         XrlRespCallback);
03806 #endif
03807 
03808     XrlCmdRT handle_rib_0_1_delete_route6(const XrlArgs& in, XrlCmdOT out);
03809 #ifdef XORP_ENABLE_ASYNC_SERVER
03810     void callback_rib_0_1_delete_route6
03811        (const XrlCmdError &e,
03812         XrlRespCallback);
03813 #endif
03814 
03815     XrlCmdRT handle_rib_0_1_add_interface_route6(const XrlArgs& in, XrlCmdOT out);
03816 #ifdef XORP_ENABLE_ASYNC_SERVER
03817     void callback_rib_0_1_add_interface_route6
03818        (const XrlCmdError &e,
03819         XrlRespCallback);
03820 #endif
03821 
03822     XrlCmdRT handle_rib_0_1_replace_interface_route6(const XrlArgs& in, XrlCmdOT out);
03823 #ifdef XORP_ENABLE_ASYNC_SERVER
03824     void callback_rib_0_1_replace_interface_route6
03825        (const XrlCmdError &e,
03826         XrlRespCallback);
03827 #endif
03828 
03829     XrlCmdRT handle_rib_0_1_lookup_route_by_dest6(const XrlArgs& in, XrlCmdOT out);
03830 #ifdef XORP_ENABLE_ASYNC_SERVER
03831     void callback_rib_0_1_lookup_route_by_dest6
03832        (const XrlCmdError &e,
03833     const IPv6* arg_nexthop,
03834         XrlRespCallback);
03835 #endif
03836 
03837     XrlCmdRT handle_rib_0_1_add_vif_addr6(const XrlArgs& in, XrlCmdOT out);
03838 #ifdef XORP_ENABLE_ASYNC_SERVER
03839     void callback_rib_0_1_add_vif_addr6
03840        (const XrlCmdError &e,
03841         XrlRespCallback);
03842 #endif
03843 
03844     XrlCmdRT handle_rib_0_1_redist_enable6(const XrlArgs& in, XrlCmdOT out);
03845 #ifdef XORP_ENABLE_ASYNC_SERVER
03846     void callback_rib_0_1_redist_enable6
03847        (const XrlCmdError &e,
03848         XrlRespCallback);
03849 #endif
03850 
03851     XrlCmdRT handle_rib_0_1_redist_disable6(const XrlArgs& in, XrlCmdOT out);
03852 #ifdef XORP_ENABLE_ASYNC_SERVER
03853     void callback_rib_0_1_redist_disable6
03854        (const XrlCmdError &e,
03855         XrlRespCallback);
03856 #endif
03857 
03858     XrlCmdRT handle_rib_0_1_redist_transaction_enable6(const XrlArgs& in, XrlCmdOT out);
03859 #ifdef XORP_ENABLE_ASYNC_SERVER
03860     void callback_rib_0_1_redist_transaction_enable6
03861        (const XrlCmdError &e,
03862         XrlRespCallback);
03863 #endif
03864 
03865     XrlCmdRT handle_rib_0_1_redist_transaction_disable6(const XrlArgs& in, XrlCmdOT out);
03866 #ifdef XORP_ENABLE_ASYNC_SERVER
03867     void callback_rib_0_1_redist_transaction_disable6
03868        (const XrlCmdError &e,
03869         XrlRespCallback);
03870 #endif
03871 
03872     XrlCmdRT handle_rib_0_1_register_interest6(const XrlArgs& in, XrlCmdOT out);
03873 #ifdef XORP_ENABLE_ASYNC_SERVER
03874     void callback_rib_0_1_register_interest6
03875        (const XrlCmdError &e,
03876     const bool* arg_resolves,
03877     const IPv6* arg_base_addr,
03878     const uint32_t* arg_prefix_len,
03879     const uint32_t* arg_real_prefix_len,
03880     const IPv6* arg_nexthop,
03881     const uint32_t* arg_metric,
03882         XrlRespCallback);
03883 #endif
03884 
03885     XrlCmdRT handle_rib_0_1_deregister_interest6(const XrlArgs& in, XrlCmdOT out);
03886 #ifdef XORP_ENABLE_ASYNC_SERVER
03887     void callback_rib_0_1_deregister_interest6
03888        (const XrlCmdError &e,
03889         XrlRespCallback);
03890 #endif
03891 
03892     XrlCmdRT handle_profile_0_1_enable(const XrlArgs& in, XrlCmdOT out);
03893 #ifdef XORP_ENABLE_ASYNC_SERVER
03894     void callback_profile_0_1_enable
03895        (const XrlCmdError &e,
03896         XrlRespCallback);
03897 #endif
03898 
03899     XrlCmdRT handle_profile_0_1_disable(const XrlArgs& in, XrlCmdOT out);
03900 #ifdef XORP_ENABLE_ASYNC_SERVER
03901     void callback_profile_0_1_disable
03902        (const XrlCmdError &e,
03903         XrlRespCallback);
03904 #endif
03905 
03906     XrlCmdRT handle_profile_0_1_get_entries(const XrlArgs& in, XrlCmdOT out);
03907 #ifdef XORP_ENABLE_ASYNC_SERVER
03908     void callback_profile_0_1_get_entries
03909        (const XrlCmdError &e,
03910         XrlRespCallback);
03911 #endif
03912 
03913     XrlCmdRT handle_profile_0_1_clear(const XrlArgs& in, XrlCmdOT out);
03914 #ifdef XORP_ENABLE_ASYNC_SERVER
03915     void callback_profile_0_1_clear
03916        (const XrlCmdError &e,
03917         XrlRespCallback);
03918 #endif
03919 
03920     XrlCmdRT handle_profile_0_1_list(const XrlArgs& in, XrlCmdOT out);
03921 #ifdef XORP_ENABLE_ASYNC_SERVER
03922     void callback_profile_0_1_list
03923        (const XrlCmdError &e,
03924     const string* arg_info,
03925         XrlRespCallback);
03926 #endif
03927 
03928     void add_handlers();
03929     void remove_handlers();
03930 
03931     struct handler_table {
03932         const char *name;
03933         XrlCmdRT (XrlRibTargetBase::*method)(const XrlArgs&, XrlCmdOT);
03934     };
03935 
03936     static const struct handler_table handlers[];
03937     static const size_t num_handlers;
03938 };
03939 
03940 #endif // __XRL_TARGETS_RIB_BASE_HH__
 All Classes Namespaces Functions Variables Typedefs Enumerations