xorp

bgp_base.hh

00001 /*
00002  * obj/i386-pc-mingw32/xrl/targets/bgp_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_BGP_BASE_HH__
00016 #define __XRL_TARGETS_BGP_BASE_HH__
00017 
00018 #undef XORP_LIBRARY_NAME
00019 #define XORP_LIBRARY_NAME "XrlBgpTarget"
00020 
00021 #include "libxorp/xlog.h"
00022 #include "libxipc/xrl_cmd_map.hh"
00023 
00024 class XrlBgpTargetBase {
00025 protected:
00026     XrlCmdMap* _cmds;
00027 
00028 public:
00036     XrlBgpTargetBase(XrlCmdMap* cmds = 0);
00037 
00043     virtual ~XrlBgpTargetBase();
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 "bgp/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 
00335     virtual XrlCmdError bgp_0_3_get_bgp_version(
00336     // Output values,
00337     uint32_t&   version) = 0;
00338 #ifdef XORP_ENABLE_ASYNC_SERVER
00339     typedef
00340     XorpCallback2<void, const XrlCmdError &,
00341     const uint32_t*>::RefPtr
00342     Bgp03GetBgpVersionRF;
00343 
00344     class Bgp03GetBgpVersionCB {
00345         Bgp03GetBgpVersionRF cb;
00346 
00347     public:
00348         operator const Bgp03GetBgpVersionRF& () const { return cb; }
00349         const Bgp03GetBgpVersionRF& operator ->() const { return cb; }
00350         Bgp03GetBgpVersionCB(const Bgp03GetBgpVersionRF& cb)
00351           : cb(cb) { }
00352 
00353         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00354 
00355         void respond(const uint32_t& arg_version) const {
00356             cb->dispatch(XrlCmdError::OKAY(),
00357                          &arg_version);
00358         }
00359     };
00360 
00361     struct Bgp03GetBgpVersionRsp :
00362       public Bgp03GetBgpVersionCB {
00363         struct args_str {
00364             uint32_t version;
00365         };
00366 
00367     private:
00368         args_str args;
00369 
00370     public:
00371         Bgp03GetBgpVersionRsp(const Bgp03GetBgpVersionRF& cb)
00372           : Bgp03GetBgpVersionCB(cb) { }
00373 
00374         void respond() const {
00375             Bgp03GetBgpVersionCB::
00376             respond(args.version);
00377         }
00378 
00379         args_str* operator ->() {
00380             return &args;
00381         }
00382     };
00383 
00384     virtual void async_bgp_0_3_get_bgp_version
00385        (
00386     Bgp03GetBgpVersionCB);
00387 #endif
00388 
00396     virtual XrlCmdError bgp_0_3_local_config(
00397     // Input values,
00398     const string&   as,
00399     const IPv4& id,
00400     const bool& use_4byte_asnums) = 0;
00401 #ifdef XORP_ENABLE_ASYNC_SERVER
00402     typedef
00403     XorpCallback1<void, const XrlCmdError &>::RefPtr
00404     Bgp03LocalConfigRF;
00405 
00406     class Bgp03LocalConfigCB {
00407         Bgp03LocalConfigRF cb;
00408 
00409     public:
00410         operator const Bgp03LocalConfigRF& () const { return cb; }
00411         const Bgp03LocalConfigRF& operator ->() const { return cb; }
00412         Bgp03LocalConfigCB(const Bgp03LocalConfigRF& cb)
00413           : cb(cb) { }
00414 
00415         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00416 
00417         void respond() const {
00418             cb->dispatch(XrlCmdError::OKAY());
00419         }
00420     };
00421 
00422     struct Bgp03LocalConfigRsp :
00423       public Bgp03LocalConfigCB {
00424         Bgp03LocalConfigRsp(const Bgp03LocalConfigRF& cb)
00425           : Bgp03LocalConfigCB(cb) { }
00426 
00427     };
00428 
00429     virtual void async_bgp_0_3_local_config
00430        (
00431     const string&   as,
00432     const IPv4& id,
00433     const bool& use_4byte_asnums,
00434     Bgp03LocalConfigCB);
00435 #endif
00436 
00444     virtual XrlCmdError bgp_0_3_set_local_as(
00445     // Input values,
00446     const string&   as) = 0;
00447 #ifdef XORP_ENABLE_ASYNC_SERVER
00448     typedef
00449     XorpCallback1<void, const XrlCmdError &>::RefPtr
00450     Bgp03SetLocalAsRF;
00451 
00452     class Bgp03SetLocalAsCB {
00453         Bgp03SetLocalAsRF cb;
00454 
00455     public:
00456         operator const Bgp03SetLocalAsRF& () const { return cb; }
00457         const Bgp03SetLocalAsRF& operator ->() const { return cb; }
00458         Bgp03SetLocalAsCB(const Bgp03SetLocalAsRF& cb)
00459           : cb(cb) { }
00460 
00461         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00462 
00463         void respond() const {
00464             cb->dispatch(XrlCmdError::OKAY());
00465         }
00466     };
00467 
00468     struct Bgp03SetLocalAsRsp :
00469       public Bgp03SetLocalAsCB {
00470         Bgp03SetLocalAsRsp(const Bgp03SetLocalAsRF& cb)
00471           : Bgp03SetLocalAsCB(cb) { }
00472 
00473     };
00474 
00475     virtual void async_bgp_0_3_set_local_as
00476        (
00477     const string&   as,
00478     Bgp03SetLocalAsCB);
00479 #endif
00480 
00488     virtual XrlCmdError bgp_0_3_set_4byte_as_support(
00489     // Input values,
00490     const bool& enable) = 0;
00491 #ifdef XORP_ENABLE_ASYNC_SERVER
00492     typedef
00493     XorpCallback1<void, const XrlCmdError &>::RefPtr
00494     Bgp03Set4ByteAsSupportRF;
00495 
00496     class Bgp03Set4ByteAsSupportCB {
00497         Bgp03Set4ByteAsSupportRF cb;
00498 
00499     public:
00500         operator const Bgp03Set4ByteAsSupportRF& () const { return cb; }
00501         const Bgp03Set4ByteAsSupportRF& operator ->() const { return cb; }
00502         Bgp03Set4ByteAsSupportCB(const Bgp03Set4ByteAsSupportRF& cb)
00503           : cb(cb) { }
00504 
00505         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00506 
00507         void respond() const {
00508             cb->dispatch(XrlCmdError::OKAY());
00509         }
00510     };
00511 
00512     struct Bgp03Set4ByteAsSupportRsp :
00513       public Bgp03Set4ByteAsSupportCB {
00514         Bgp03Set4ByteAsSupportRsp(const Bgp03Set4ByteAsSupportRF& cb)
00515           : Bgp03Set4ByteAsSupportCB(cb) { }
00516 
00517     };
00518 
00519     virtual void async_bgp_0_3_set_4byte_as_support
00520        (
00521     const bool& enable,
00522     Bgp03Set4ByteAsSupportCB);
00523 #endif
00524 
00530     virtual XrlCmdError bgp_0_3_get_local_as(
00531     // Output values,
00532     string& as) = 0;
00533 #ifdef XORP_ENABLE_ASYNC_SERVER
00534     typedef
00535     XorpCallback2<void, const XrlCmdError &,
00536     const string*>::RefPtr
00537     Bgp03GetLocalAsRF;
00538 
00539     class Bgp03GetLocalAsCB {
00540         Bgp03GetLocalAsRF cb;
00541 
00542     public:
00543         operator const Bgp03GetLocalAsRF& () const { return cb; }
00544         const Bgp03GetLocalAsRF& operator ->() const { return cb; }
00545         Bgp03GetLocalAsCB(const Bgp03GetLocalAsRF& cb)
00546           : cb(cb) { }
00547 
00548         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00549 
00550         void respond(const string& arg_as) const {
00551             cb->dispatch(XrlCmdError::OKAY(),
00552                          &arg_as);
00553         }
00554     };
00555 
00556     struct Bgp03GetLocalAsRsp :
00557       public Bgp03GetLocalAsCB {
00558         struct args_str {
00559             string as;
00560         };
00561 
00562     private:
00563         args_str args;
00564 
00565     public:
00566         Bgp03GetLocalAsRsp(const Bgp03GetLocalAsRF& cb)
00567           : Bgp03GetLocalAsCB(cb) { }
00568 
00569         void respond() const {
00570             Bgp03GetLocalAsCB::
00571             respond(args.as);
00572         }
00573 
00574         args_str* operator ->() {
00575             return &args;
00576         }
00577     };
00578 
00579     virtual void async_bgp_0_3_get_local_as
00580        (
00581     Bgp03GetLocalAsCB);
00582 #endif
00583 
00591     virtual XrlCmdError bgp_0_3_set_bgp_id(
00592     // Input values,
00593     const IPv4& id) = 0;
00594 #ifdef XORP_ENABLE_ASYNC_SERVER
00595     typedef
00596     XorpCallback1<void, const XrlCmdError &>::RefPtr
00597     Bgp03SetBgpIdRF;
00598 
00599     class Bgp03SetBgpIdCB {
00600         Bgp03SetBgpIdRF cb;
00601 
00602     public:
00603         operator const Bgp03SetBgpIdRF& () const { return cb; }
00604         const Bgp03SetBgpIdRF& operator ->() const { return cb; }
00605         Bgp03SetBgpIdCB(const Bgp03SetBgpIdRF& cb)
00606           : cb(cb) { }
00607 
00608         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00609 
00610         void respond() const {
00611             cb->dispatch(XrlCmdError::OKAY());
00612         }
00613     };
00614 
00615     struct Bgp03SetBgpIdRsp :
00616       public Bgp03SetBgpIdCB {
00617         Bgp03SetBgpIdRsp(const Bgp03SetBgpIdRF& cb)
00618           : Bgp03SetBgpIdCB(cb) { }
00619 
00620     };
00621 
00622     virtual void async_bgp_0_3_set_bgp_id
00623        (
00624     const IPv4& id,
00625     Bgp03SetBgpIdCB);
00626 #endif
00627 
00633     virtual XrlCmdError bgp_0_3_get_bgp_id(
00634     // Output values,
00635     IPv4&   id) = 0;
00636 #ifdef XORP_ENABLE_ASYNC_SERVER
00637     typedef
00638     XorpCallback2<void, const XrlCmdError &,
00639     const IPv4*>::RefPtr
00640     Bgp03GetBgpIdRF;
00641 
00642     class Bgp03GetBgpIdCB {
00643         Bgp03GetBgpIdRF cb;
00644 
00645     public:
00646         operator const Bgp03GetBgpIdRF& () const { return cb; }
00647         const Bgp03GetBgpIdRF& operator ->() const { return cb; }
00648         Bgp03GetBgpIdCB(const Bgp03GetBgpIdRF& cb)
00649           : cb(cb) { }
00650 
00651         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00652 
00653         void respond(const IPv4& arg_id) const {
00654             cb->dispatch(XrlCmdError::OKAY(),
00655                          &arg_id);
00656         }
00657     };
00658 
00659     struct Bgp03GetBgpIdRsp :
00660       public Bgp03GetBgpIdCB {
00661         struct args_str {
00662             IPv4 id;
00663         };
00664 
00665     private:
00666         args_str args;
00667 
00668     public:
00669         Bgp03GetBgpIdRsp(const Bgp03GetBgpIdRF& cb)
00670           : Bgp03GetBgpIdCB(cb) { }
00671 
00672         void respond() const {
00673             Bgp03GetBgpIdCB::
00674             respond(args.id);
00675         }
00676 
00677         args_str* operator ->() {
00678             return &args;
00679         }
00680     };
00681 
00682     virtual void async_bgp_0_3_get_bgp_id
00683        (
00684     Bgp03GetBgpIdCB);
00685 #endif
00686 
00696     virtual XrlCmdError bgp_0_3_set_confederation_identifier(
00697     // Input values,
00698     const string&   as,
00699     const bool& disable) = 0;
00700 #ifdef XORP_ENABLE_ASYNC_SERVER
00701     typedef
00702     XorpCallback1<void, const XrlCmdError &>::RefPtr
00703     Bgp03SetConfederationIdentifierRF;
00704 
00705     class Bgp03SetConfederationIdentifierCB {
00706         Bgp03SetConfederationIdentifierRF cb;
00707 
00708     public:
00709         operator const Bgp03SetConfederationIdentifierRF& () const { return cb; }
00710         const Bgp03SetConfederationIdentifierRF& operator ->() const { return cb; }
00711         Bgp03SetConfederationIdentifierCB(const Bgp03SetConfederationIdentifierRF& cb)
00712           : cb(cb) { }
00713 
00714         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00715 
00716         void respond() const {
00717             cb->dispatch(XrlCmdError::OKAY());
00718         }
00719     };
00720 
00721     struct Bgp03SetConfederationIdentifierRsp :
00722       public Bgp03SetConfederationIdentifierCB {
00723         Bgp03SetConfederationIdentifierRsp(const Bgp03SetConfederationIdentifierRF& cb)
00724           : Bgp03SetConfederationIdentifierCB(cb) { }
00725 
00726     };
00727 
00728     virtual void async_bgp_0_3_set_confederation_identifier
00729        (
00730     const string&   as,
00731     const bool& disable,
00732     Bgp03SetConfederationIdentifierCB);
00733 #endif
00734 
00744     virtual XrlCmdError bgp_0_3_set_cluster_id(
00745     // Input values,
00746     const IPv4& cluster_id,
00747     const bool& disable) = 0;
00748 #ifdef XORP_ENABLE_ASYNC_SERVER
00749     typedef
00750     XorpCallback1<void, const XrlCmdError &>::RefPtr
00751     Bgp03SetClusterIdRF;
00752 
00753     class Bgp03SetClusterIdCB {
00754         Bgp03SetClusterIdRF cb;
00755 
00756     public:
00757         operator const Bgp03SetClusterIdRF& () const { return cb; }
00758         const Bgp03SetClusterIdRF& operator ->() const { return cb; }
00759         Bgp03SetClusterIdCB(const Bgp03SetClusterIdRF& cb)
00760           : cb(cb) { }
00761 
00762         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00763 
00764         void respond() const {
00765             cb->dispatch(XrlCmdError::OKAY());
00766         }
00767     };
00768 
00769     struct Bgp03SetClusterIdRsp :
00770       public Bgp03SetClusterIdCB {
00771         Bgp03SetClusterIdRsp(const Bgp03SetClusterIdRF& cb)
00772           : Bgp03SetClusterIdCB(cb) { }
00773 
00774     };
00775 
00776     virtual void async_bgp_0_3_set_cluster_id
00777        (
00778     const IPv4& cluster_id,
00779     const bool& disable,
00780     Bgp03SetClusterIdCB);
00781 #endif
00782 
00794     virtual XrlCmdError bgp_0_3_set_damping(
00795     // Input values,
00796     const uint32_t& half_life,
00797     const uint32_t& max_suppress,
00798     const uint32_t& reuse,
00799     const uint32_t& suppress,
00800     const bool& disable) = 0;
00801 #ifdef XORP_ENABLE_ASYNC_SERVER
00802     typedef
00803     XorpCallback1<void, const XrlCmdError &>::RefPtr
00804     Bgp03SetDampingRF;
00805 
00806     class Bgp03SetDampingCB {
00807         Bgp03SetDampingRF cb;
00808 
00809     public:
00810         operator const Bgp03SetDampingRF& () const { return cb; }
00811         const Bgp03SetDampingRF& operator ->() const { return cb; }
00812         Bgp03SetDampingCB(const Bgp03SetDampingRF& cb)
00813           : cb(cb) { }
00814 
00815         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00816 
00817         void respond() const {
00818             cb->dispatch(XrlCmdError::OKAY());
00819         }
00820     };
00821 
00822     struct Bgp03SetDampingRsp :
00823       public Bgp03SetDampingCB {
00824         Bgp03SetDampingRsp(const Bgp03SetDampingRF& cb)
00825           : Bgp03SetDampingCB(cb) { }
00826 
00827     };
00828 
00829     virtual void async_bgp_0_3_set_damping
00830        (
00831     const uint32_t& half_life,
00832     const uint32_t& max_suppress,
00833     const uint32_t& reuse,
00834     const uint32_t& suppress,
00835     const bool& disable,
00836     Bgp03SetDampingCB);
00837 #endif
00838 
00851     virtual XrlCmdError bgp_0_3_add_peer(
00852     // Input values,
00853     const string&   local_dev,
00854     const string&   local_ip,
00855     const uint32_t& local_port,
00856     const string&   peer_ip,
00857     const uint32_t& peer_port,
00858     const string&   as,
00859     const IPv4& next_hop,
00860     const uint32_t& holdtime) = 0;
00861 #ifdef XORP_ENABLE_ASYNC_SERVER
00862     typedef
00863     XorpCallback1<void, const XrlCmdError &>::RefPtr
00864     Bgp03AddPeerRF;
00865 
00866     class Bgp03AddPeerCB {
00867         Bgp03AddPeerRF cb;
00868 
00869     public:
00870         operator const Bgp03AddPeerRF& () const { return cb; }
00871         const Bgp03AddPeerRF& operator ->() const { return cb; }
00872         Bgp03AddPeerCB(const Bgp03AddPeerRF& cb)
00873           : cb(cb) { }
00874 
00875         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00876 
00877         void respond() const {
00878             cb->dispatch(XrlCmdError::OKAY());
00879         }
00880     };
00881 
00882     struct Bgp03AddPeerRsp :
00883       public Bgp03AddPeerCB {
00884         Bgp03AddPeerRsp(const Bgp03AddPeerRF& cb)
00885           : Bgp03AddPeerCB(cb) { }
00886 
00887     };
00888 
00889     virtual void async_bgp_0_3_add_peer
00890        (
00891     const string&   local_dev,
00892     const string&   local_ip,
00893     const uint32_t& local_port,
00894     const string&   peer_ip,
00895     const uint32_t& peer_port,
00896     const string&   as,
00897     const IPv4& next_hop,
00898     const uint32_t& holdtime,
00899     Bgp03AddPeerCB);
00900 #endif
00901 
00907     virtual XrlCmdError bgp_0_3_delete_peer(
00908     // Input values,
00909     const string&   local_ip,
00910     const uint32_t& local_port,
00911     const string&   peer_ip,
00912     const uint32_t& peer_port) = 0;
00913 #ifdef XORP_ENABLE_ASYNC_SERVER
00914     typedef
00915     XorpCallback1<void, const XrlCmdError &>::RefPtr
00916     Bgp03DeletePeerRF;
00917 
00918     class Bgp03DeletePeerCB {
00919         Bgp03DeletePeerRF cb;
00920 
00921     public:
00922         operator const Bgp03DeletePeerRF& () const { return cb; }
00923         const Bgp03DeletePeerRF& operator ->() const { return cb; }
00924         Bgp03DeletePeerCB(const Bgp03DeletePeerRF& cb)
00925           : cb(cb) { }
00926 
00927         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00928 
00929         void respond() const {
00930             cb->dispatch(XrlCmdError::OKAY());
00931         }
00932     };
00933 
00934     struct Bgp03DeletePeerRsp :
00935       public Bgp03DeletePeerCB {
00936         Bgp03DeletePeerRsp(const Bgp03DeletePeerRF& cb)
00937           : Bgp03DeletePeerCB(cb) { }
00938 
00939     };
00940 
00941     virtual void async_bgp_0_3_delete_peer
00942        (
00943     const string&   local_ip,
00944     const uint32_t& local_port,
00945     const string&   peer_ip,
00946     const uint32_t& peer_port,
00947     Bgp03DeletePeerCB);
00948 #endif
00949 
00955     virtual XrlCmdError bgp_0_3_enable_peer(
00956     // Input values,
00957     const string&   local_ip,
00958     const uint32_t& local_port,
00959     const string&   peer_ip,
00960     const uint32_t& peer_port) = 0;
00961 #ifdef XORP_ENABLE_ASYNC_SERVER
00962     typedef
00963     XorpCallback1<void, const XrlCmdError &>::RefPtr
00964     Bgp03EnablePeerRF;
00965 
00966     class Bgp03EnablePeerCB {
00967         Bgp03EnablePeerRF cb;
00968 
00969     public:
00970         operator const Bgp03EnablePeerRF& () const { return cb; }
00971         const Bgp03EnablePeerRF& operator ->() const { return cb; }
00972         Bgp03EnablePeerCB(const Bgp03EnablePeerRF& cb)
00973           : cb(cb) { }
00974 
00975         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00976 
00977         void respond() const {
00978             cb->dispatch(XrlCmdError::OKAY());
00979         }
00980     };
00981 
00982     struct Bgp03EnablePeerRsp :
00983       public Bgp03EnablePeerCB {
00984         Bgp03EnablePeerRsp(const Bgp03EnablePeerRF& cb)
00985           : Bgp03EnablePeerCB(cb) { }
00986 
00987     };
00988 
00989     virtual void async_bgp_0_3_enable_peer
00990        (
00991     const string&   local_ip,
00992     const uint32_t& local_port,
00993     const string&   peer_ip,
00994     const uint32_t& peer_port,
00995     Bgp03EnablePeerCB);
00996 #endif
00997 
01003     virtual XrlCmdError bgp_0_3_disable_peer(
01004     // Input values,
01005     const string&   local_ip,
01006     const uint32_t& local_port,
01007     const string&   peer_ip,
01008     const uint32_t& peer_port) = 0;
01009 #ifdef XORP_ENABLE_ASYNC_SERVER
01010     typedef
01011     XorpCallback1<void, const XrlCmdError &>::RefPtr
01012     Bgp03DisablePeerRF;
01013 
01014     class Bgp03DisablePeerCB {
01015         Bgp03DisablePeerRF cb;
01016 
01017     public:
01018         operator const Bgp03DisablePeerRF& () const { return cb; }
01019         const Bgp03DisablePeerRF& operator ->() const { return cb; }
01020         Bgp03DisablePeerCB(const Bgp03DisablePeerRF& cb)
01021           : cb(cb) { }
01022 
01023         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01024 
01025         void respond() const {
01026             cb->dispatch(XrlCmdError::OKAY());
01027         }
01028     };
01029 
01030     struct Bgp03DisablePeerRsp :
01031       public Bgp03DisablePeerCB {
01032         Bgp03DisablePeerRsp(const Bgp03DisablePeerRF& cb)
01033           : Bgp03DisablePeerCB(cb) { }
01034 
01035     };
01036 
01037     virtual void async_bgp_0_3_disable_peer
01038        (
01039     const string&   local_ip,
01040     const uint32_t& local_port,
01041     const string&   peer_ip,
01042     const uint32_t& peer_port,
01043     Bgp03DisablePeerCB);
01044 #endif
01045 
01063     virtual XrlCmdError bgp_0_3_change_local_ip(
01064     // Input values,
01065     const string&   local_ip,
01066     const uint32_t& local_port,
01067     const string&   peer_ip,
01068     const uint32_t& peer_port,
01069     const string&   new_local_ip,
01070     const string&   new_local_dev) = 0;
01071 #ifdef XORP_ENABLE_ASYNC_SERVER
01072     typedef
01073     XorpCallback1<void, const XrlCmdError &>::RefPtr
01074     Bgp03ChangeLocalIpRF;
01075 
01076     class Bgp03ChangeLocalIpCB {
01077         Bgp03ChangeLocalIpRF cb;
01078 
01079     public:
01080         operator const Bgp03ChangeLocalIpRF& () const { return cb; }
01081         const Bgp03ChangeLocalIpRF& operator ->() const { return cb; }
01082         Bgp03ChangeLocalIpCB(const Bgp03ChangeLocalIpRF& cb)
01083           : cb(cb) { }
01084 
01085         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01086 
01087         void respond() const {
01088             cb->dispatch(XrlCmdError::OKAY());
01089         }
01090     };
01091 
01092     struct Bgp03ChangeLocalIpRsp :
01093       public Bgp03ChangeLocalIpCB {
01094         Bgp03ChangeLocalIpRsp(const Bgp03ChangeLocalIpRF& cb)
01095           : Bgp03ChangeLocalIpCB(cb) { }
01096 
01097     };
01098 
01099     virtual void async_bgp_0_3_change_local_ip
01100        (
01101     const string&   local_ip,
01102     const uint32_t& local_port,
01103     const string&   peer_ip,
01104     const uint32_t& peer_port,
01105     const string&   new_local_ip,
01106     const string&   new_local_dev,
01107     Bgp03ChangeLocalIpCB);
01108 #endif
01109 
01125     virtual XrlCmdError bgp_0_3_change_local_port(
01126     // Input values,
01127     const string&   local_ip,
01128     const uint32_t& local_port,
01129     const string&   peer_ip,
01130     const uint32_t& peer_port,
01131     const uint32_t& new_local_port) = 0;
01132 #ifdef XORP_ENABLE_ASYNC_SERVER
01133     typedef
01134     XorpCallback1<void, const XrlCmdError &>::RefPtr
01135     Bgp03ChangeLocalPortRF;
01136 
01137     class Bgp03ChangeLocalPortCB {
01138         Bgp03ChangeLocalPortRF cb;
01139 
01140     public:
01141         operator const Bgp03ChangeLocalPortRF& () const { return cb; }
01142         const Bgp03ChangeLocalPortRF& operator ->() const { return cb; }
01143         Bgp03ChangeLocalPortCB(const Bgp03ChangeLocalPortRF& cb)
01144           : cb(cb) { }
01145 
01146         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01147 
01148         void respond() const {
01149             cb->dispatch(XrlCmdError::OKAY());
01150         }
01151     };
01152 
01153     struct Bgp03ChangeLocalPortRsp :
01154       public Bgp03ChangeLocalPortCB {
01155         Bgp03ChangeLocalPortRsp(const Bgp03ChangeLocalPortRF& cb)
01156           : Bgp03ChangeLocalPortCB(cb) { }
01157 
01158     };
01159 
01160     virtual void async_bgp_0_3_change_local_port
01161        (
01162     const string&   local_ip,
01163     const uint32_t& local_port,
01164     const string&   peer_ip,
01165     const uint32_t& peer_port,
01166     const uint32_t& new_local_port,
01167     Bgp03ChangeLocalPortCB);
01168 #endif
01169 
01183     virtual XrlCmdError bgp_0_3_change_peer_port(
01184     // Input values,
01185     const string&   local_ip,
01186     const uint32_t& local_port,
01187     const string&   peer_ip,
01188     const uint32_t& peer_port,
01189     const uint32_t& new_peer_port) = 0;
01190 #ifdef XORP_ENABLE_ASYNC_SERVER
01191     typedef
01192     XorpCallback1<void, const XrlCmdError &>::RefPtr
01193     Bgp03ChangePeerPortRF;
01194 
01195     class Bgp03ChangePeerPortCB {
01196         Bgp03ChangePeerPortRF cb;
01197 
01198     public:
01199         operator const Bgp03ChangePeerPortRF& () const { return cb; }
01200         const Bgp03ChangePeerPortRF& operator ->() const { return cb; }
01201         Bgp03ChangePeerPortCB(const Bgp03ChangePeerPortRF& cb)
01202           : cb(cb) { }
01203 
01204         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01205 
01206         void respond() const {
01207             cb->dispatch(XrlCmdError::OKAY());
01208         }
01209     };
01210 
01211     struct Bgp03ChangePeerPortRsp :
01212       public Bgp03ChangePeerPortCB {
01213         Bgp03ChangePeerPortRsp(const Bgp03ChangePeerPortRF& cb)
01214           : Bgp03ChangePeerPortCB(cb) { }
01215 
01216     };
01217 
01218     virtual void async_bgp_0_3_change_peer_port
01219        (
01220     const string&   local_ip,
01221     const uint32_t& local_port,
01222     const string&   peer_ip,
01223     const uint32_t& peer_port,
01224     const uint32_t& new_peer_port,
01225     Bgp03ChangePeerPortCB);
01226 #endif
01227 
01235     virtual XrlCmdError bgp_0_3_set_peer_as(
01236     // Input values,
01237     const string&   local_ip,
01238     const uint32_t& local_port,
01239     const string&   peer_ip,
01240     const uint32_t& peer_port,
01241     const string&   peer_as) = 0;
01242 #ifdef XORP_ENABLE_ASYNC_SERVER
01243     typedef
01244     XorpCallback1<void, const XrlCmdError &>::RefPtr
01245     Bgp03SetPeerAsRF;
01246 
01247     class Bgp03SetPeerAsCB {
01248         Bgp03SetPeerAsRF cb;
01249 
01250     public:
01251         operator const Bgp03SetPeerAsRF& () const { return cb; }
01252         const Bgp03SetPeerAsRF& operator ->() const { return cb; }
01253         Bgp03SetPeerAsCB(const Bgp03SetPeerAsRF& cb)
01254           : cb(cb) { }
01255 
01256         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01257 
01258         void respond() const {
01259             cb->dispatch(XrlCmdError::OKAY());
01260         }
01261     };
01262 
01263     struct Bgp03SetPeerAsRsp :
01264       public Bgp03SetPeerAsCB {
01265         Bgp03SetPeerAsRsp(const Bgp03SetPeerAsRF& cb)
01266           : Bgp03SetPeerAsCB(cb) { }
01267 
01268     };
01269 
01270     virtual void async_bgp_0_3_set_peer_as
01271        (
01272     const string&   local_ip,
01273     const uint32_t& local_port,
01274     const string&   peer_ip,
01275     const uint32_t& peer_port,
01276     const string&   peer_as,
01277     Bgp03SetPeerAsCB);
01278 #endif
01279 
01288     virtual XrlCmdError bgp_0_3_set_holdtime(
01289     // Input values,
01290     const string&   local_ip,
01291     const uint32_t& local_port,
01292     const string&   peer_ip,
01293     const uint32_t& peer_port,
01294     const uint32_t& holdtime) = 0;
01295 #ifdef XORP_ENABLE_ASYNC_SERVER
01296     typedef
01297     XorpCallback1<void, const XrlCmdError &>::RefPtr
01298     Bgp03SetHoldtimeRF;
01299 
01300     class Bgp03SetHoldtimeCB {
01301         Bgp03SetHoldtimeRF cb;
01302 
01303     public:
01304         operator const Bgp03SetHoldtimeRF& () const { return cb; }
01305         const Bgp03SetHoldtimeRF& operator ->() const { return cb; }
01306         Bgp03SetHoldtimeCB(const Bgp03SetHoldtimeRF& cb)
01307           : cb(cb) { }
01308 
01309         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01310 
01311         void respond() const {
01312             cb->dispatch(XrlCmdError::OKAY());
01313         }
01314     };
01315 
01316     struct Bgp03SetHoldtimeRsp :
01317       public Bgp03SetHoldtimeCB {
01318         Bgp03SetHoldtimeRsp(const Bgp03SetHoldtimeRF& cb)
01319           : Bgp03SetHoldtimeCB(cb) { }
01320 
01321     };
01322 
01323     virtual void async_bgp_0_3_set_holdtime
01324        (
01325     const string&   local_ip,
01326     const uint32_t& local_port,
01327     const string&   peer_ip,
01328     const uint32_t& peer_port,
01329     const uint32_t& holdtime,
01330     Bgp03SetHoldtimeCB);
01331 #endif
01332 
01340     virtual XrlCmdError bgp_0_3_set_delay_open_time(
01341     // Input values,
01342     const string&   local_ip,
01343     const uint32_t& local_port,
01344     const string&   peer_ip,
01345     const uint32_t& peer_port,
01346     const uint32_t& delay_open_time) = 0;
01347 #ifdef XORP_ENABLE_ASYNC_SERVER
01348     typedef
01349     XorpCallback1<void, const XrlCmdError &>::RefPtr
01350     Bgp03SetDelayOpenTimeRF;
01351 
01352     class Bgp03SetDelayOpenTimeCB {
01353         Bgp03SetDelayOpenTimeRF cb;
01354 
01355     public:
01356         operator const Bgp03SetDelayOpenTimeRF& () const { return cb; }
01357         const Bgp03SetDelayOpenTimeRF& operator ->() const { return cb; }
01358         Bgp03SetDelayOpenTimeCB(const Bgp03SetDelayOpenTimeRF& cb)
01359           : cb(cb) { }
01360 
01361         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01362 
01363         void respond() const {
01364             cb->dispatch(XrlCmdError::OKAY());
01365         }
01366     };
01367 
01368     struct Bgp03SetDelayOpenTimeRsp :
01369       public Bgp03SetDelayOpenTimeCB {
01370         Bgp03SetDelayOpenTimeRsp(const Bgp03SetDelayOpenTimeRF& cb)
01371           : Bgp03SetDelayOpenTimeCB(cb) { }
01372 
01373     };
01374 
01375     virtual void async_bgp_0_3_set_delay_open_time
01376        (
01377     const string&   local_ip,
01378     const uint32_t& local_port,
01379     const string&   peer_ip,
01380     const uint32_t& peer_port,
01381     const uint32_t& delay_open_time,
01382     Bgp03SetDelayOpenTimeCB);
01383 #endif
01384 
01393     virtual XrlCmdError bgp_0_3_set_route_reflector_client(
01394     // Input values,
01395     const string&   local_ip,
01396     const uint32_t& local_port,
01397     const string&   peer_ip,
01398     const uint32_t& peer_port,
01399     const bool& state) = 0;
01400 #ifdef XORP_ENABLE_ASYNC_SERVER
01401     typedef
01402     XorpCallback1<void, const XrlCmdError &>::RefPtr
01403     Bgp03SetRouteReflectorClientRF;
01404 
01405     class Bgp03SetRouteReflectorClientCB {
01406         Bgp03SetRouteReflectorClientRF cb;
01407 
01408     public:
01409         operator const Bgp03SetRouteReflectorClientRF& () const { return cb; }
01410         const Bgp03SetRouteReflectorClientRF& operator ->() const { return cb; }
01411         Bgp03SetRouteReflectorClientCB(const Bgp03SetRouteReflectorClientRF& cb)
01412           : cb(cb) { }
01413 
01414         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01415 
01416         void respond() const {
01417             cb->dispatch(XrlCmdError::OKAY());
01418         }
01419     };
01420 
01421     struct Bgp03SetRouteReflectorClientRsp :
01422       public Bgp03SetRouteReflectorClientCB {
01423         Bgp03SetRouteReflectorClientRsp(const Bgp03SetRouteReflectorClientRF& cb)
01424           : Bgp03SetRouteReflectorClientCB(cb) { }
01425 
01426     };
01427 
01428     virtual void async_bgp_0_3_set_route_reflector_client
01429        (
01430     const string&   local_ip,
01431     const uint32_t& local_port,
01432     const string&   peer_ip,
01433     const uint32_t& peer_port,
01434     const bool& state,
01435     Bgp03SetRouteReflectorClientCB);
01436 #endif
01437 
01445     virtual XrlCmdError bgp_0_3_set_confederation_member(
01446     // Input values,
01447     const string&   local_ip,
01448     const uint32_t& local_port,
01449     const string&   peer_ip,
01450     const uint32_t& peer_port,
01451     const bool& state) = 0;
01452 #ifdef XORP_ENABLE_ASYNC_SERVER
01453     typedef
01454     XorpCallback1<void, const XrlCmdError &>::RefPtr
01455     Bgp03SetConfederationMemberRF;
01456 
01457     class Bgp03SetConfederationMemberCB {
01458         Bgp03SetConfederationMemberRF cb;
01459 
01460     public:
01461         operator const Bgp03SetConfederationMemberRF& () const { return cb; }
01462         const Bgp03SetConfederationMemberRF& operator ->() const { return cb; }
01463         Bgp03SetConfederationMemberCB(const Bgp03SetConfederationMemberRF& cb)
01464           : cb(cb) { }
01465 
01466         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01467 
01468         void respond() const {
01469             cb->dispatch(XrlCmdError::OKAY());
01470         }
01471     };
01472 
01473     struct Bgp03SetConfederationMemberRsp :
01474       public Bgp03SetConfederationMemberCB {
01475         Bgp03SetConfederationMemberRsp(const Bgp03SetConfederationMemberRF& cb)
01476           : Bgp03SetConfederationMemberCB(cb) { }
01477 
01478     };
01479 
01480     virtual void async_bgp_0_3_set_confederation_member
01481        (
01482     const string&   local_ip,
01483     const uint32_t& local_port,
01484     const string&   peer_ip,
01485     const uint32_t& peer_port,
01486     const bool& state,
01487     Bgp03SetConfederationMemberCB);
01488 #endif
01489 
01499     virtual XrlCmdError bgp_0_3_set_prefix_limit(
01500     // Input values,
01501     const string&   local_ip,
01502     const uint32_t& local_port,
01503     const string&   peer_ip,
01504     const uint32_t& peer_port,
01505     const uint32_t& maximum,
01506     const bool& state) = 0;
01507 #ifdef XORP_ENABLE_ASYNC_SERVER
01508     typedef
01509     XorpCallback1<void, const XrlCmdError &>::RefPtr
01510     Bgp03SetPrefixLimitRF;
01511 
01512     class Bgp03SetPrefixLimitCB {
01513         Bgp03SetPrefixLimitRF cb;
01514 
01515     public:
01516         operator const Bgp03SetPrefixLimitRF& () const { return cb; }
01517         const Bgp03SetPrefixLimitRF& operator ->() const { return cb; }
01518         Bgp03SetPrefixLimitCB(const Bgp03SetPrefixLimitRF& cb)
01519           : cb(cb) { }
01520 
01521         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01522 
01523         void respond() const {
01524             cb->dispatch(XrlCmdError::OKAY());
01525         }
01526     };
01527 
01528     struct Bgp03SetPrefixLimitRsp :
01529       public Bgp03SetPrefixLimitCB {
01530         Bgp03SetPrefixLimitRsp(const Bgp03SetPrefixLimitRF& cb)
01531           : Bgp03SetPrefixLimitCB(cb) { }
01532 
01533     };
01534 
01535     virtual void async_bgp_0_3_set_prefix_limit
01536        (
01537     const string&   local_ip,
01538     const uint32_t& local_port,
01539     const string&   peer_ip,
01540     const uint32_t& peer_port,
01541     const uint32_t& maximum,
01542     const bool& state,
01543     Bgp03SetPrefixLimitCB);
01544 #endif
01545 
01553     virtual XrlCmdError bgp_0_3_set_nexthop4(
01554     // Input values,
01555     const string&   local_ip,
01556     const uint32_t& local_port,
01557     const string&   peer_ip,
01558     const uint32_t& peer_port,
01559     const IPv4& next_hop) = 0;
01560 #ifdef XORP_ENABLE_ASYNC_SERVER
01561     typedef
01562     XorpCallback1<void, const XrlCmdError &>::RefPtr
01563     Bgp03SetNexthop4RF;
01564 
01565     class Bgp03SetNexthop4CB {
01566         Bgp03SetNexthop4RF cb;
01567 
01568     public:
01569         operator const Bgp03SetNexthop4RF& () const { return cb; }
01570         const Bgp03SetNexthop4RF& operator ->() const { return cb; }
01571         Bgp03SetNexthop4CB(const Bgp03SetNexthop4RF& cb)
01572           : cb(cb) { }
01573 
01574         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01575 
01576         void respond() const {
01577             cb->dispatch(XrlCmdError::OKAY());
01578         }
01579     };
01580 
01581     struct Bgp03SetNexthop4Rsp :
01582       public Bgp03SetNexthop4CB {
01583         Bgp03SetNexthop4Rsp(const Bgp03SetNexthop4RF& cb)
01584           : Bgp03SetNexthop4CB(cb) { }
01585 
01586     };
01587 
01588     virtual void async_bgp_0_3_set_nexthop4
01589        (
01590     const string&   local_ip,
01591     const uint32_t& local_port,
01592     const string&   peer_ip,
01593     const uint32_t& peer_port,
01594     const IPv4& next_hop,
01595     Bgp03SetNexthop4CB);
01596 #endif
01597 
01605     virtual XrlCmdError bgp_0_3_set_peer_state(
01606     // Input values,
01607     const string&   local_ip,
01608     const uint32_t& local_port,
01609     const string&   peer_ip,
01610     const uint32_t& peer_port,
01611     const bool& toggle) = 0;
01612 #ifdef XORP_ENABLE_ASYNC_SERVER
01613     typedef
01614     XorpCallback1<void, const XrlCmdError &>::RefPtr
01615     Bgp03SetPeerStateRF;
01616 
01617     class Bgp03SetPeerStateCB {
01618         Bgp03SetPeerStateRF cb;
01619 
01620     public:
01621         operator const Bgp03SetPeerStateRF& () const { return cb; }
01622         const Bgp03SetPeerStateRF& operator ->() const { return cb; }
01623         Bgp03SetPeerStateCB(const Bgp03SetPeerStateRF& cb)
01624           : cb(cb) { }
01625 
01626         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01627 
01628         void respond() const {
01629             cb->dispatch(XrlCmdError::OKAY());
01630         }
01631     };
01632 
01633     struct Bgp03SetPeerStateRsp :
01634       public Bgp03SetPeerStateCB {
01635         Bgp03SetPeerStateRsp(const Bgp03SetPeerStateRF& cb)
01636           : Bgp03SetPeerStateCB(cb) { }
01637 
01638     };
01639 
01640     virtual void async_bgp_0_3_set_peer_state
01641        (
01642     const string&   local_ip,
01643     const uint32_t& local_port,
01644     const string&   peer_ip,
01645     const uint32_t& peer_port,
01646     const bool& toggle,
01647     Bgp03SetPeerStateCB);
01648 #endif
01649 
01657     virtual XrlCmdError bgp_0_3_set_peer_md5_password(
01658     // Input values,
01659     const string&   local_ip,
01660     const uint32_t& local_port,
01661     const string&   peer_ip,
01662     const uint32_t& peer_port,
01663     const string&   password) = 0;
01664 #ifdef XORP_ENABLE_ASYNC_SERVER
01665     typedef
01666     XorpCallback1<void, const XrlCmdError &>::RefPtr
01667     Bgp03SetPeerMd5PasswordRF;
01668 
01669     class Bgp03SetPeerMd5PasswordCB {
01670         Bgp03SetPeerMd5PasswordRF cb;
01671 
01672     public:
01673         operator const Bgp03SetPeerMd5PasswordRF& () const { return cb; }
01674         const Bgp03SetPeerMd5PasswordRF& operator ->() const { return cb; }
01675         Bgp03SetPeerMd5PasswordCB(const Bgp03SetPeerMd5PasswordRF& cb)
01676           : cb(cb) { }
01677 
01678         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01679 
01680         void respond() const {
01681             cb->dispatch(XrlCmdError::OKAY());
01682         }
01683     };
01684 
01685     struct Bgp03SetPeerMd5PasswordRsp :
01686       public Bgp03SetPeerMd5PasswordCB {
01687         Bgp03SetPeerMd5PasswordRsp(const Bgp03SetPeerMd5PasswordRF& cb)
01688           : Bgp03SetPeerMd5PasswordCB(cb) { }
01689 
01690     };
01691 
01692     virtual void async_bgp_0_3_set_peer_md5_password
01693        (
01694     const string&   local_ip,
01695     const uint32_t& local_port,
01696     const string&   peer_ip,
01697     const uint32_t& peer_port,
01698     const string&   password,
01699     Bgp03SetPeerMd5PasswordCB);
01700 #endif
01701 
01707     virtual XrlCmdError bgp_0_3_activate(
01708     // Input values,
01709     const string&   local_ip,
01710     const uint32_t& local_port,
01711     const string&   peer_ip,
01712     const uint32_t& peer_port) = 0;
01713 #ifdef XORP_ENABLE_ASYNC_SERVER
01714     typedef
01715     XorpCallback1<void, const XrlCmdError &>::RefPtr
01716     Bgp03ActivateRF;
01717 
01718     class Bgp03ActivateCB {
01719         Bgp03ActivateRF cb;
01720 
01721     public:
01722         operator const Bgp03ActivateRF& () const { return cb; }
01723         const Bgp03ActivateRF& operator ->() const { return cb; }
01724         Bgp03ActivateCB(const Bgp03ActivateRF& cb)
01725           : cb(cb) { }
01726 
01727         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01728 
01729         void respond() const {
01730             cb->dispatch(XrlCmdError::OKAY());
01731         }
01732     };
01733 
01734     struct Bgp03ActivateRsp :
01735       public Bgp03ActivateCB {
01736         Bgp03ActivateRsp(const Bgp03ActivateRF& cb)
01737           : Bgp03ActivateCB(cb) { }
01738 
01739     };
01740 
01741     virtual void async_bgp_0_3_activate
01742        (
01743     const string&   local_ip,
01744     const uint32_t& local_port,
01745     const string&   peer_ip,
01746     const uint32_t& peer_port,
01747     Bgp03ActivateCB);
01748 #endif
01749 
01755     virtual XrlCmdError bgp_0_3_set_parameter(
01756     // Input values,
01757     const string&   local_ip,
01758     const uint32_t& local_port,
01759     const string&   peer_ip,
01760     const uint32_t& peer_port,
01761     const string&   parameter,
01762     const bool& toggle) = 0;
01763 #ifdef XORP_ENABLE_ASYNC_SERVER
01764     typedef
01765     XorpCallback1<void, const XrlCmdError &>::RefPtr
01766     Bgp03SetParameterRF;
01767 
01768     class Bgp03SetParameterCB {
01769         Bgp03SetParameterRF cb;
01770 
01771     public:
01772         operator const Bgp03SetParameterRF& () const { return cb; }
01773         const Bgp03SetParameterRF& operator ->() const { return cb; }
01774         Bgp03SetParameterCB(const Bgp03SetParameterRF& cb)
01775           : cb(cb) { }
01776 
01777         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01778 
01779         void respond() const {
01780             cb->dispatch(XrlCmdError::OKAY());
01781         }
01782     };
01783 
01784     struct Bgp03SetParameterRsp :
01785       public Bgp03SetParameterCB {
01786         Bgp03SetParameterRsp(const Bgp03SetParameterRF& cb)
01787           : Bgp03SetParameterCB(cb) { }
01788 
01789     };
01790 
01791     virtual void async_bgp_0_3_set_parameter
01792        (
01793     const string&   local_ip,
01794     const uint32_t& local_port,
01795     const string&   peer_ip,
01796     const uint32_t& peer_port,
01797     const string&   parameter,
01798     const bool& toggle,
01799     Bgp03SetParameterCB);
01800 #endif
01801 
01808     virtual XrlCmdError bgp_0_3_next_hop_rewrite_filter(
01809     // Input values,
01810     const string&   local_ip,
01811     const uint32_t& local_port,
01812     const string&   peer_ip,
01813     const uint32_t& peer_port,
01814     const IPv4& next_hop) = 0;
01815 #ifdef XORP_ENABLE_ASYNC_SERVER
01816     typedef
01817     XorpCallback1<void, const XrlCmdError &>::RefPtr
01818     Bgp03NextHopRewriteFilterRF;
01819 
01820     class Bgp03NextHopRewriteFilterCB {
01821         Bgp03NextHopRewriteFilterRF cb;
01822 
01823     public:
01824         operator const Bgp03NextHopRewriteFilterRF& () const { return cb; }
01825         const Bgp03NextHopRewriteFilterRF& operator ->() const { return cb; }
01826         Bgp03NextHopRewriteFilterCB(const Bgp03NextHopRewriteFilterRF& cb)
01827           : cb(cb) { }
01828 
01829         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01830 
01831         void respond() const {
01832             cb->dispatch(XrlCmdError::OKAY());
01833         }
01834     };
01835 
01836     struct Bgp03NextHopRewriteFilterRsp :
01837       public Bgp03NextHopRewriteFilterCB {
01838         Bgp03NextHopRewriteFilterRsp(const Bgp03NextHopRewriteFilterRF& cb)
01839           : Bgp03NextHopRewriteFilterCB(cb) { }
01840 
01841     };
01842 
01843     virtual void async_bgp_0_3_next_hop_rewrite_filter
01844        (
01845     const string&   local_ip,
01846     const uint32_t& local_port,
01847     const string&   peer_ip,
01848     const uint32_t& peer_port,
01849     const IPv4& next_hop,
01850     Bgp03NextHopRewriteFilterCB);
01851 #endif
01852 
01866     virtual XrlCmdError bgp_0_3_originate_route4(
01867     // Input values,
01868     const IPv4Net&  nlri,
01869     const IPv4& next_hop,
01870     const bool& unicast,
01871     const bool& multicast) = 0;
01872 #ifdef XORP_ENABLE_ASYNC_SERVER
01873     typedef
01874     XorpCallback1<void, const XrlCmdError &>::RefPtr
01875     Bgp03OriginateRoute4RF;
01876 
01877     class Bgp03OriginateRoute4CB {
01878         Bgp03OriginateRoute4RF cb;
01879 
01880     public:
01881         operator const Bgp03OriginateRoute4RF& () const { return cb; }
01882         const Bgp03OriginateRoute4RF& operator ->() const { return cb; }
01883         Bgp03OriginateRoute4CB(const Bgp03OriginateRoute4RF& cb)
01884           : cb(cb) { }
01885 
01886         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01887 
01888         void respond() const {
01889             cb->dispatch(XrlCmdError::OKAY());
01890         }
01891     };
01892 
01893     struct Bgp03OriginateRoute4Rsp :
01894       public Bgp03OriginateRoute4CB {
01895         Bgp03OriginateRoute4Rsp(const Bgp03OriginateRoute4RF& cb)
01896           : Bgp03OriginateRoute4CB(cb) { }
01897 
01898     };
01899 
01900     virtual void async_bgp_0_3_originate_route4
01901        (
01902     const IPv4Net&  nlri,
01903     const IPv4& next_hop,
01904     const bool& unicast,
01905     const bool& multicast,
01906     Bgp03OriginateRoute4CB);
01907 #endif
01908 
01920     virtual XrlCmdError bgp_0_3_withdraw_route4(
01921     // Input values,
01922     const IPv4Net&  nlri,
01923     const bool& unicast,
01924     const bool& multicast) = 0;
01925 #ifdef XORP_ENABLE_ASYNC_SERVER
01926     typedef
01927     XorpCallback1<void, const XrlCmdError &>::RefPtr
01928     Bgp03WithdrawRoute4RF;
01929 
01930     class Bgp03WithdrawRoute4CB {
01931         Bgp03WithdrawRoute4RF cb;
01932 
01933     public:
01934         operator const Bgp03WithdrawRoute4RF& () const { return cb; }
01935         const Bgp03WithdrawRoute4RF& operator ->() const { return cb; }
01936         Bgp03WithdrawRoute4CB(const Bgp03WithdrawRoute4RF& cb)
01937           : cb(cb) { }
01938 
01939         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01940 
01941         void respond() const {
01942             cb->dispatch(XrlCmdError::OKAY());
01943         }
01944     };
01945 
01946     struct Bgp03WithdrawRoute4Rsp :
01947       public Bgp03WithdrawRoute4CB {
01948         Bgp03WithdrawRoute4Rsp(const Bgp03WithdrawRoute4RF& cb)
01949           : Bgp03WithdrawRoute4CB(cb) { }
01950 
01951     };
01952 
01953     virtual void async_bgp_0_3_withdraw_route4
01954        (
01955     const IPv4Net&  nlri,
01956     const bool& unicast,
01957     const bool& multicast,
01958     Bgp03WithdrawRoute4CB);
01959 #endif
01960 
01970     virtual XrlCmdError bgp_0_3_trace(
01971     // Input values,
01972     const string&   tvar,
01973     const bool& enable) = 0;
01974 #ifdef XORP_ENABLE_ASYNC_SERVER
01975     typedef
01976     XorpCallback1<void, const XrlCmdError &>::RefPtr
01977     Bgp03TraceRF;
01978 
01979     class Bgp03TraceCB {
01980         Bgp03TraceRF cb;
01981 
01982     public:
01983         operator const Bgp03TraceRF& () const { return cb; }
01984         const Bgp03TraceRF& operator ->() const { return cb; }
01985         Bgp03TraceCB(const Bgp03TraceRF& cb)
01986           : cb(cb) { }
01987 
01988         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01989 
01990         void respond() const {
01991             cb->dispatch(XrlCmdError::OKAY());
01992         }
01993     };
01994 
01995     struct Bgp03TraceRsp :
01996       public Bgp03TraceCB {
01997         Bgp03TraceRsp(const Bgp03TraceRF& cb)
01998           : Bgp03TraceCB(cb) { }
01999 
02000     };
02001 
02002     virtual void async_bgp_0_3_trace
02003        (
02004     const string&   tvar,
02005     const bool& enable,
02006     Bgp03TraceCB);
02007 #endif
02008 
02021     virtual XrlCmdError bgp_0_3_get_peer_list_start(
02022     // Output values,
02023     uint32_t&   token,
02024     bool&   more) = 0;
02025 #ifdef XORP_ENABLE_ASYNC_SERVER
02026     typedef
02027     XorpCallback3<void, const XrlCmdError &,
02028     const uint32_t*,
02029     const bool*>::RefPtr
02030     Bgp03GetPeerListStartRF;
02031 
02032     class Bgp03GetPeerListStartCB {
02033         Bgp03GetPeerListStartRF cb;
02034 
02035     public:
02036         operator const Bgp03GetPeerListStartRF& () const { return cb; }
02037         const Bgp03GetPeerListStartRF& operator ->() const { return cb; }
02038         Bgp03GetPeerListStartCB(const Bgp03GetPeerListStartRF& cb)
02039           : cb(cb) { }
02040 
02041         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL); }
02042 
02043         void respond(const uint32_t& arg_token,
02044                      const bool& arg_more) const {
02045             cb->dispatch(XrlCmdError::OKAY(),
02046                          &arg_token,
02047                          &arg_more);
02048         }
02049     };
02050 
02051     struct Bgp03GetPeerListStartRsp :
02052       public Bgp03GetPeerListStartCB {
02053         struct args_str {
02054             uint32_t token;
02055             bool more;
02056         };
02057 
02058     private:
02059         args_str args;
02060 
02061     public:
02062         Bgp03GetPeerListStartRsp(const Bgp03GetPeerListStartRF& cb)
02063           : Bgp03GetPeerListStartCB(cb) { }
02064 
02065         void respond() const {
02066             Bgp03GetPeerListStartCB::
02067             respond(args.token,
02068                         args.more);
02069         }
02070 
02071         args_str* operator ->() {
02072             return &args;
02073         }
02074     };
02075 
02076     virtual void async_bgp_0_3_get_peer_list_start
02077        (
02078     Bgp03GetPeerListStartCB);
02079 #endif
02080 
02091     virtual XrlCmdError bgp_0_3_get_peer_list_next(
02092     // Input values,
02093     const uint32_t& token,
02094     // Output values,
02095     string& local_ip,
02096     uint32_t&   local_port,
02097     string& peer_ip,
02098     uint32_t&   peer_port,
02099     bool&   more) = 0;
02100 #ifdef XORP_ENABLE_ASYNC_SERVER
02101     typedef
02102     XorpCallback6<void, const XrlCmdError &,
02103     const string*,
02104     const uint32_t*,
02105     const string*,
02106     const uint32_t*,
02107     const bool*>::RefPtr
02108     Bgp03GetPeerListNextRF;
02109 
02110     class Bgp03GetPeerListNextCB {
02111         Bgp03GetPeerListNextRF cb;
02112 
02113     public:
02114         operator const Bgp03GetPeerListNextRF& () const { return cb; }
02115         const Bgp03GetPeerListNextRF& operator ->() const { return cb; }
02116         Bgp03GetPeerListNextCB(const Bgp03GetPeerListNextRF& cb)
02117           : cb(cb) { }
02118 
02119         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL, NULL); }
02120 
02121         void respond(const string& arg_local_ip,
02122                      const uint32_t& arg_local_port,
02123                      const string& arg_peer_ip,
02124                      const uint32_t& arg_peer_port,
02125                      const bool& arg_more) const {
02126             cb->dispatch(XrlCmdError::OKAY(),
02127                          &arg_local_ip,
02128                          &arg_local_port,
02129                          &arg_peer_ip,
02130                          &arg_peer_port,
02131                          &arg_more);
02132         }
02133     };
02134 
02135     struct Bgp03GetPeerListNextRsp :
02136       public Bgp03GetPeerListNextCB {
02137         struct args_str {
02138             string local_ip;
02139             uint32_t local_port;
02140             string peer_ip;
02141             uint32_t peer_port;
02142             bool more;
02143         };
02144 
02145     private:
02146         args_str args;
02147 
02148     public:
02149         Bgp03GetPeerListNextRsp(const Bgp03GetPeerListNextRF& cb)
02150           : Bgp03GetPeerListNextCB(cb) { }
02151 
02152         void respond() const {
02153             Bgp03GetPeerListNextCB::
02154             respond(args.local_ip,
02155                         args.local_port,
02156                         args.peer_ip,
02157                         args.peer_port,
02158                         args.more);
02159         }
02160 
02161         args_str* operator ->() {
02162             return &args;
02163         }
02164     };
02165 
02166     virtual void async_bgp_0_3_get_peer_list_next
02167        (
02168     const uint32_t& token,
02169     Bgp03GetPeerListNextCB);
02170 #endif
02171 
02172     virtual XrlCmdError bgp_0_3_get_peer_id(
02173     // Input values,
02174     const string&   local_ip,
02175     const uint32_t& local_port,
02176     const string&   peer_ip,
02177     const uint32_t& peer_port,
02178     // Output values,
02179     IPv4&   peer_id) = 0;
02180 #ifdef XORP_ENABLE_ASYNC_SERVER
02181     typedef
02182     XorpCallback2<void, const XrlCmdError &,
02183     const IPv4*>::RefPtr
02184     Bgp03GetPeerIdRF;
02185 
02186     class Bgp03GetPeerIdCB {
02187         Bgp03GetPeerIdRF cb;
02188 
02189     public:
02190         operator const Bgp03GetPeerIdRF& () const { return cb; }
02191         const Bgp03GetPeerIdRF& operator ->() const { return cb; }
02192         Bgp03GetPeerIdCB(const Bgp03GetPeerIdRF& cb)
02193           : cb(cb) { }
02194 
02195         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02196 
02197         void respond(const IPv4& arg_peer_id) const {
02198             cb->dispatch(XrlCmdError::OKAY(),
02199                          &arg_peer_id);
02200         }
02201     };
02202 
02203     struct Bgp03GetPeerIdRsp :
02204       public Bgp03GetPeerIdCB {
02205         struct args_str {
02206             IPv4 peer_id;
02207         };
02208 
02209     private:
02210         args_str args;
02211 
02212     public:
02213         Bgp03GetPeerIdRsp(const Bgp03GetPeerIdRF& cb)
02214           : Bgp03GetPeerIdCB(cb) { }
02215 
02216         void respond() const {
02217             Bgp03GetPeerIdCB::
02218             respond(args.peer_id);
02219         }
02220 
02221         args_str* operator ->() {
02222             return &args;
02223         }
02224     };
02225 
02226     virtual void async_bgp_0_3_get_peer_id
02227        (
02228     const string&   local_ip,
02229     const uint32_t& local_port,
02230     const string&   peer_ip,
02231     const uint32_t& peer_port,
02232     Bgp03GetPeerIdCB);
02233 #endif
02234 
02235     virtual XrlCmdError bgp_0_3_get_peer_status(
02236     // Input values,
02237     const string&   local_ip,
02238     const uint32_t& local_port,
02239     const string&   peer_ip,
02240     const uint32_t& peer_port,
02241     // Output values,
02242     uint32_t&   peer_state,
02243     uint32_t&   admin_status) = 0;
02244 #ifdef XORP_ENABLE_ASYNC_SERVER
02245     typedef
02246     XorpCallback3<void, const XrlCmdError &,
02247     const uint32_t*,
02248     const uint32_t*>::RefPtr
02249     Bgp03GetPeerStatusRF;
02250 
02251     class Bgp03GetPeerStatusCB {
02252         Bgp03GetPeerStatusRF cb;
02253 
02254     public:
02255         operator const Bgp03GetPeerStatusRF& () const { return cb; }
02256         const Bgp03GetPeerStatusRF& operator ->() const { return cb; }
02257         Bgp03GetPeerStatusCB(const Bgp03GetPeerStatusRF& cb)
02258           : cb(cb) { }
02259 
02260         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL); }
02261 
02262         void respond(const uint32_t& arg_peer_state,
02263                      const uint32_t& arg_admin_status) const {
02264             cb->dispatch(XrlCmdError::OKAY(),
02265                          &arg_peer_state,
02266                          &arg_admin_status);
02267         }
02268     };
02269 
02270     struct Bgp03GetPeerStatusRsp :
02271       public Bgp03GetPeerStatusCB {
02272         struct args_str {
02273             uint32_t peer_state;
02274             uint32_t admin_status;
02275         };
02276 
02277     private:
02278         args_str args;
02279 
02280     public:
02281         Bgp03GetPeerStatusRsp(const Bgp03GetPeerStatusRF& cb)
02282           : Bgp03GetPeerStatusCB(cb) { }
02283 
02284         void respond() const {
02285             Bgp03GetPeerStatusCB::
02286             respond(args.peer_state,
02287                         args.admin_status);
02288         }
02289 
02290         args_str* operator ->() {
02291             return &args;
02292         }
02293     };
02294 
02295     virtual void async_bgp_0_3_get_peer_status
02296        (
02297     const string&   local_ip,
02298     const uint32_t& local_port,
02299     const string&   peer_ip,
02300     const uint32_t& peer_port,
02301     Bgp03GetPeerStatusCB);
02302 #endif
02303 
02304     virtual XrlCmdError bgp_0_3_get_peer_negotiated_version(
02305     // Input values,
02306     const string&   local_ip,
02307     const uint32_t& local_port,
02308     const string&   peer_ip,
02309     const uint32_t& peer_port,
02310     // Output values,
02311     int32_t&    neg_version) = 0;
02312 #ifdef XORP_ENABLE_ASYNC_SERVER
02313     typedef
02314     XorpCallback2<void, const XrlCmdError &,
02315     const int32_t*>::RefPtr
02316     Bgp03GetPeerNegotiatedVersionRF;
02317 
02318     class Bgp03GetPeerNegotiatedVersionCB {
02319         Bgp03GetPeerNegotiatedVersionRF cb;
02320 
02321     public:
02322         operator const Bgp03GetPeerNegotiatedVersionRF& () const { return cb; }
02323         const Bgp03GetPeerNegotiatedVersionRF& operator ->() const { return cb; }
02324         Bgp03GetPeerNegotiatedVersionCB(const Bgp03GetPeerNegotiatedVersionRF& cb)
02325           : cb(cb) { }
02326 
02327         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02328 
02329         void respond(const int32_t& arg_neg_version) const {
02330             cb->dispatch(XrlCmdError::OKAY(),
02331                          &arg_neg_version);
02332         }
02333     };
02334 
02335     struct Bgp03GetPeerNegotiatedVersionRsp :
02336       public Bgp03GetPeerNegotiatedVersionCB {
02337         struct args_str {
02338             int32_t neg_version;
02339         };
02340 
02341     private:
02342         args_str args;
02343 
02344     public:
02345         Bgp03GetPeerNegotiatedVersionRsp(const Bgp03GetPeerNegotiatedVersionRF& cb)
02346           : Bgp03GetPeerNegotiatedVersionCB(cb) { }
02347 
02348         void respond() const {
02349             Bgp03GetPeerNegotiatedVersionCB::
02350             respond(args.neg_version);
02351         }
02352 
02353         args_str* operator ->() {
02354             return &args;
02355         }
02356     };
02357 
02358     virtual void async_bgp_0_3_get_peer_negotiated_version
02359        (
02360     const string&   local_ip,
02361     const uint32_t& local_port,
02362     const string&   peer_ip,
02363     const uint32_t& peer_port,
02364     Bgp03GetPeerNegotiatedVersionCB);
02365 #endif
02366 
02367     virtual XrlCmdError bgp_0_3_get_peer_as(
02368     // Input values,
02369     const string&   local_ip,
02370     const uint32_t& local_port,
02371     const string&   peer_ip,
02372     const uint32_t& peer_port,
02373     // Output values,
02374     string& peer_as) = 0;
02375 #ifdef XORP_ENABLE_ASYNC_SERVER
02376     typedef
02377     XorpCallback2<void, const XrlCmdError &,
02378     const string*>::RefPtr
02379     Bgp03GetPeerAsRF;
02380 
02381     class Bgp03GetPeerAsCB {
02382         Bgp03GetPeerAsRF cb;
02383 
02384     public:
02385         operator const Bgp03GetPeerAsRF& () const { return cb; }
02386         const Bgp03GetPeerAsRF& operator ->() const { return cb; }
02387         Bgp03GetPeerAsCB(const Bgp03GetPeerAsRF& cb)
02388           : cb(cb) { }
02389 
02390         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02391 
02392         void respond(const string& arg_peer_as) const {
02393             cb->dispatch(XrlCmdError::OKAY(),
02394                          &arg_peer_as);
02395         }
02396     };
02397 
02398     struct Bgp03GetPeerAsRsp :
02399       public Bgp03GetPeerAsCB {
02400         struct args_str {
02401             string peer_as;
02402         };
02403 
02404     private:
02405         args_str args;
02406 
02407     public:
02408         Bgp03GetPeerAsRsp(const Bgp03GetPeerAsRF& cb)
02409           : Bgp03GetPeerAsCB(cb) { }
02410 
02411         void respond() const {
02412             Bgp03GetPeerAsCB::
02413             respond(args.peer_as);
02414         }
02415 
02416         args_str* operator ->() {
02417             return &args;
02418         }
02419     };
02420 
02421     virtual void async_bgp_0_3_get_peer_as
02422        (
02423     const string&   local_ip,
02424     const uint32_t& local_port,
02425     const string&   peer_ip,
02426     const uint32_t& peer_port,
02427     Bgp03GetPeerAsCB);
02428 #endif
02429 
02430     virtual XrlCmdError bgp_0_3_get_peer_msg_stats(
02431     // Input values,
02432     const string&   local_ip,
02433     const uint32_t& local_port,
02434     const string&   peer_ip,
02435     const uint32_t& peer_port,
02436     // Output values,
02437     uint32_t&   in_updates,
02438     uint32_t&   out_updates,
02439     uint32_t&   in_msgs,
02440     uint32_t&   out_msgs,
02441     uint32_t&   last_error,
02442     uint32_t&   in_update_elapsed) = 0;
02443 #ifdef XORP_ENABLE_ASYNC_SERVER
02444     typedef
02445     XorpCallback7<void, const XrlCmdError &,
02446     const uint32_t*,
02447     const uint32_t*,
02448     const uint32_t*,
02449     const uint32_t*,
02450     const uint32_t*,
02451     const uint32_t*>::RefPtr
02452     Bgp03GetPeerMsgStatsRF;
02453 
02454     class Bgp03GetPeerMsgStatsCB {
02455         Bgp03GetPeerMsgStatsRF cb;
02456 
02457     public:
02458         operator const Bgp03GetPeerMsgStatsRF& () const { return cb; }
02459         const Bgp03GetPeerMsgStatsRF& operator ->() const { return cb; }
02460         Bgp03GetPeerMsgStatsCB(const Bgp03GetPeerMsgStatsRF& cb)
02461           : cb(cb) { }
02462 
02463         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL, NULL, NULL); }
02464 
02465         void respond(const uint32_t& arg_in_updates,
02466                      const uint32_t& arg_out_updates,
02467                      const uint32_t& arg_in_msgs,
02468                      const uint32_t& arg_out_msgs,
02469                      const uint32_t& arg_last_error,
02470                      const uint32_t& arg_in_update_elapsed) const {
02471             cb->dispatch(XrlCmdError::OKAY(),
02472                          &arg_in_updates,
02473                          &arg_out_updates,
02474                          &arg_in_msgs,
02475                          &arg_out_msgs,
02476                          &arg_last_error,
02477                          &arg_in_update_elapsed);
02478         }
02479     };
02480 
02481     struct Bgp03GetPeerMsgStatsRsp :
02482       public Bgp03GetPeerMsgStatsCB {
02483         struct args_str {
02484             uint32_t in_updates;
02485             uint32_t out_updates;
02486             uint32_t in_msgs;
02487             uint32_t out_msgs;
02488             uint32_t last_error;
02489             uint32_t in_update_elapsed;
02490         };
02491 
02492     private:
02493         args_str args;
02494 
02495     public:
02496         Bgp03GetPeerMsgStatsRsp(const Bgp03GetPeerMsgStatsRF& cb)
02497           : Bgp03GetPeerMsgStatsCB(cb) { }
02498 
02499         void respond() const {
02500             Bgp03GetPeerMsgStatsCB::
02501             respond(args.in_updates,
02502                         args.out_updates,
02503                         args.in_msgs,
02504                         args.out_msgs,
02505                         args.last_error,
02506                         args.in_update_elapsed);
02507         }
02508 
02509         args_str* operator ->() {
02510             return &args;
02511         }
02512     };
02513 
02514     virtual void async_bgp_0_3_get_peer_msg_stats
02515        (
02516     const string&   local_ip,
02517     const uint32_t& local_port,
02518     const string&   peer_ip,
02519     const uint32_t& peer_port,
02520     Bgp03GetPeerMsgStatsCB);
02521 #endif
02522 
02523     virtual XrlCmdError bgp_0_3_get_peer_established_stats(
02524     // Input values,
02525     const string&   local_ip,
02526     const uint32_t& local_port,
02527     const string&   peer_ip,
02528     const uint32_t& peer_port,
02529     // Output values,
02530     uint32_t&   transitions,
02531     uint32_t&   established_time) = 0;
02532 #ifdef XORP_ENABLE_ASYNC_SERVER
02533     typedef
02534     XorpCallback3<void, const XrlCmdError &,
02535     const uint32_t*,
02536     const uint32_t*>::RefPtr
02537     Bgp03GetPeerEstablishedStatsRF;
02538 
02539     class Bgp03GetPeerEstablishedStatsCB {
02540         Bgp03GetPeerEstablishedStatsRF cb;
02541 
02542     public:
02543         operator const Bgp03GetPeerEstablishedStatsRF& () const { return cb; }
02544         const Bgp03GetPeerEstablishedStatsRF& operator ->() const { return cb; }
02545         Bgp03GetPeerEstablishedStatsCB(const Bgp03GetPeerEstablishedStatsRF& cb)
02546           : cb(cb) { }
02547 
02548         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL); }
02549 
02550         void respond(const uint32_t& arg_transitions,
02551                      const uint32_t& arg_established_time) const {
02552             cb->dispatch(XrlCmdError::OKAY(),
02553                          &arg_transitions,
02554                          &arg_established_time);
02555         }
02556     };
02557 
02558     struct Bgp03GetPeerEstablishedStatsRsp :
02559       public Bgp03GetPeerEstablishedStatsCB {
02560         struct args_str {
02561             uint32_t transitions;
02562             uint32_t established_time;
02563         };
02564 
02565     private:
02566         args_str args;
02567 
02568     public:
02569         Bgp03GetPeerEstablishedStatsRsp(const Bgp03GetPeerEstablishedStatsRF& cb)
02570           : Bgp03GetPeerEstablishedStatsCB(cb) { }
02571 
02572         void respond() const {
02573             Bgp03GetPeerEstablishedStatsCB::
02574             respond(args.transitions,
02575                         args.established_time);
02576         }
02577 
02578         args_str* operator ->() {
02579             return &args;
02580         }
02581     };
02582 
02583     virtual void async_bgp_0_3_get_peer_established_stats
02584        (
02585     const string&   local_ip,
02586     const uint32_t& local_port,
02587     const string&   peer_ip,
02588     const uint32_t& peer_port,
02589     Bgp03GetPeerEstablishedStatsCB);
02590 #endif
02591 
02592     virtual XrlCmdError bgp_0_3_get_peer_timer_config(
02593     // Input values,
02594     const string&   local_ip,
02595     const uint32_t& local_port,
02596     const string&   peer_ip,
02597     const uint32_t& peer_port,
02598     // Output values,
02599     uint32_t&   retry_interval,
02600     uint32_t&   hold_time,
02601     uint32_t&   keep_alive,
02602     uint32_t&   hold_time_conf,
02603     uint32_t&   keep_alive_conf,
02604     uint32_t&   min_as_orgination_interval,
02605     uint32_t&   min_route_adv_interval) = 0;
02606 #ifdef XORP_ENABLE_ASYNC_SERVER
02607     typedef
02608     XorpCallback8<void, const XrlCmdError &,
02609     const uint32_t*,
02610     const uint32_t*,
02611     const uint32_t*,
02612     const uint32_t*,
02613     const uint32_t*,
02614     const uint32_t*,
02615     const uint32_t*>::RefPtr
02616     Bgp03GetPeerTimerConfigRF;
02617 
02618     class Bgp03GetPeerTimerConfigCB {
02619         Bgp03GetPeerTimerConfigRF cb;
02620 
02621     public:
02622         operator const Bgp03GetPeerTimerConfigRF& () const { return cb; }
02623         const Bgp03GetPeerTimerConfigRF& operator ->() const { return cb; }
02624         Bgp03GetPeerTimerConfigCB(const Bgp03GetPeerTimerConfigRF& cb)
02625           : cb(cb) { }
02626 
02627         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL, NULL, NULL, NULL); }
02628 
02629         void respond(const uint32_t& arg_retry_interval,
02630                      const uint32_t& arg_hold_time,
02631                      const uint32_t& arg_keep_alive,
02632                      const uint32_t& arg_hold_time_conf,
02633                      const uint32_t& arg_keep_alive_conf,
02634                      const uint32_t& arg_min_as_orgination_interval,
02635                      const uint32_t& arg_min_route_adv_interval) const {
02636             cb->dispatch(XrlCmdError::OKAY(),
02637                          &arg_retry_interval,
02638                          &arg_hold_time,
02639                          &arg_keep_alive,
02640                          &arg_hold_time_conf,
02641                          &arg_keep_alive_conf,
02642                          &arg_min_as_orgination_interval,
02643                          &arg_min_route_adv_interval);
02644         }
02645     };
02646 
02647     struct Bgp03GetPeerTimerConfigRsp :
02648       public Bgp03GetPeerTimerConfigCB {
02649         struct args_str {
02650             uint32_t retry_interval;
02651             uint32_t hold_time;
02652             uint32_t keep_alive;
02653             uint32_t hold_time_conf;
02654             uint32_t keep_alive_conf;
02655             uint32_t min_as_orgination_interval;
02656             uint32_t min_route_adv_interval;
02657         };
02658 
02659     private:
02660         args_str args;
02661 
02662     public:
02663         Bgp03GetPeerTimerConfigRsp(const Bgp03GetPeerTimerConfigRF& cb)
02664           : Bgp03GetPeerTimerConfigCB(cb) { }
02665 
02666         void respond() const {
02667             Bgp03GetPeerTimerConfigCB::
02668             respond(args.retry_interval,
02669                         args.hold_time,
02670                         args.keep_alive,
02671                         args.hold_time_conf,
02672                         args.keep_alive_conf,
02673                         args.min_as_orgination_interval,
02674                         args.min_route_adv_interval);
02675         }
02676 
02677         args_str* operator ->() {
02678             return &args;
02679         }
02680     };
02681 
02682     virtual void async_bgp_0_3_get_peer_timer_config
02683        (
02684     const string&   local_ip,
02685     const uint32_t& local_port,
02686     const string&   peer_ip,
02687     const uint32_t& peer_port,
02688     Bgp03GetPeerTimerConfigCB);
02689 #endif
02690 
02698     virtual XrlCmdError bgp_0_3_register_rib(
02699     // Input values,
02700     const string&   name) = 0;
02701 #ifdef XORP_ENABLE_ASYNC_SERVER
02702     typedef
02703     XorpCallback1<void, const XrlCmdError &>::RefPtr
02704     Bgp03RegisterRibRF;
02705 
02706     class Bgp03RegisterRibCB {
02707         Bgp03RegisterRibRF cb;
02708 
02709     public:
02710         operator const Bgp03RegisterRibRF& () const { return cb; }
02711         const Bgp03RegisterRibRF& operator ->() const { return cb; }
02712         Bgp03RegisterRibCB(const Bgp03RegisterRibRF& cb)
02713           : cb(cb) { }
02714 
02715         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02716 
02717         void respond() const {
02718             cb->dispatch(XrlCmdError::OKAY());
02719         }
02720     };
02721 
02722     struct Bgp03RegisterRibRsp :
02723       public Bgp03RegisterRibCB {
02724         Bgp03RegisterRibRsp(const Bgp03RegisterRibRF& cb)
02725           : Bgp03RegisterRibCB(cb) { }
02726 
02727     };
02728 
02729     virtual void async_bgp_0_3_register_rib
02730        (
02731     const string&   name,
02732     Bgp03RegisterRibCB);
02733 #endif
02734 
02751     virtual XrlCmdError bgp_0_3_get_v4_route_list_start(
02752     // Input values,
02753     const IPv4Net&  net,
02754     const bool& unicast,
02755     const bool& multicast,
02756     // Output values,
02757     uint32_t&   token) = 0;
02758 #ifdef XORP_ENABLE_ASYNC_SERVER
02759     typedef
02760     XorpCallback2<void, const XrlCmdError &,
02761     const uint32_t*>::RefPtr
02762     Bgp03GetV4RouteListStartRF;
02763 
02764     class Bgp03GetV4RouteListStartCB {
02765         Bgp03GetV4RouteListStartRF cb;
02766 
02767     public:
02768         operator const Bgp03GetV4RouteListStartRF& () const { return cb; }
02769         const Bgp03GetV4RouteListStartRF& operator ->() const { return cb; }
02770         Bgp03GetV4RouteListStartCB(const Bgp03GetV4RouteListStartRF& cb)
02771           : cb(cb) { }
02772 
02773         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02774 
02775         void respond(const uint32_t& arg_token) const {
02776             cb->dispatch(XrlCmdError::OKAY(),
02777                          &arg_token);
02778         }
02779     };
02780 
02781     struct Bgp03GetV4RouteListStartRsp :
02782       public Bgp03GetV4RouteListStartCB {
02783         struct args_str {
02784             uint32_t token;
02785         };
02786 
02787     private:
02788         args_str args;
02789 
02790     public:
02791         Bgp03GetV4RouteListStartRsp(const Bgp03GetV4RouteListStartRF& cb)
02792           : Bgp03GetV4RouteListStartCB(cb) { }
02793 
02794         void respond() const {
02795             Bgp03GetV4RouteListStartCB::
02796             respond(args.token);
02797         }
02798 
02799         args_str* operator ->() {
02800             return &args;
02801         }
02802     };
02803 
02804     virtual void async_bgp_0_3_get_v4_route_list_start
02805        (
02806     const IPv4Net&  net,
02807     const bool& unicast,
02808     const bool& multicast,
02809     Bgp03GetV4RouteListStartCB);
02810 #endif
02811 
02818     virtual XrlCmdError bgp_0_3_get_v4_route_list_next(
02819     // Input values,
02820     const uint32_t& token,
02821     // Output values,
02822     IPv4&   peer_id,
02823     IPv4Net&    net,
02824     uint32_t&   best_and_origin,
02825     vector<uint8_t>&    aspath,
02826     IPv4&   nexthop,
02827     int32_t&    med,
02828     int32_t&    localpref,
02829     int32_t&    atomic_agg,
02830     vector<uint8_t>&    aggregator,
02831     int32_t&    calc_localpref,
02832     vector<uint8_t>&    attr_unknown,
02833     bool&   valid,
02834     bool&   unicast,
02835     bool&   multicast) = 0;
02836 #ifdef XORP_ENABLE_ASYNC_SERVER
02837     typedef
02838     XorpCallback15<void, const XrlCmdError &,
02839     const IPv4*,
02840     const IPv4Net*,
02841     const uint32_t*,
02842     const vector<uint8_t>*,
02843     const IPv4*,
02844     const int32_t*,
02845     const int32_t*,
02846     const int32_t*,
02847     const vector<uint8_t>*,
02848     const int32_t*,
02849     const vector<uint8_t>*,
02850     const bool*,
02851     const bool*,
02852     const bool*>::RefPtr
02853     Bgp03GetV4RouteListNextRF;
02854 
02855     class Bgp03GetV4RouteListNextCB {
02856         Bgp03GetV4RouteListNextRF cb;
02857 
02858     public:
02859         operator const Bgp03GetV4RouteListNextRF& () const { return cb; }
02860         const Bgp03GetV4RouteListNextRF& operator ->() const { return cb; }
02861         Bgp03GetV4RouteListNextCB(const Bgp03GetV4RouteListNextRF& cb)
02862           : cb(cb) { }
02863 
02864         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); }
02865 
02866         void respond(const IPv4& arg_peer_id,
02867                      const IPv4Net& arg_net,
02868                      const uint32_t& arg_best_and_origin,
02869                      const vector<uint8_t>& arg_aspath,
02870                      const IPv4& arg_nexthop,
02871                      const int32_t& arg_med,
02872                      const int32_t& arg_localpref,
02873                      const int32_t& arg_atomic_agg,
02874                      const vector<uint8_t>& arg_aggregator,
02875                      const int32_t& arg_calc_localpref,
02876                      const vector<uint8_t>& arg_attr_unknown,
02877                      const bool& arg_valid,
02878                      const bool& arg_unicast,
02879                      const bool& arg_multicast) const {
02880             cb->dispatch(XrlCmdError::OKAY(),
02881                          &arg_peer_id,
02882                          &arg_net,
02883                          &arg_best_and_origin,
02884                          &arg_aspath,
02885                          &arg_nexthop,
02886                          &arg_med,
02887                          &arg_localpref,
02888                          &arg_atomic_agg,
02889                          &arg_aggregator,
02890                          &arg_calc_localpref,
02891                          &arg_attr_unknown,
02892                          &arg_valid,
02893                          &arg_unicast,
02894                          &arg_multicast);
02895         }
02896     };
02897 
02898     struct Bgp03GetV4RouteListNextRsp :
02899       public Bgp03GetV4RouteListNextCB {
02900         struct args_str {
02901             IPv4 peer_id;
02902             IPv4Net net;
02903             uint32_t best_and_origin;
02904             vector<uint8_t> aspath;
02905             IPv4 nexthop;
02906             int32_t med;
02907             int32_t localpref;
02908             int32_t atomic_agg;
02909             vector<uint8_t> aggregator;
02910             int32_t calc_localpref;
02911             vector<uint8_t> attr_unknown;
02912             bool valid;
02913             bool unicast;
02914             bool multicast;
02915         };
02916 
02917     private:
02918         args_str args;
02919 
02920     public:
02921         Bgp03GetV4RouteListNextRsp(const Bgp03GetV4RouteListNextRF& cb)
02922           : Bgp03GetV4RouteListNextCB(cb) { }
02923 
02924         void respond() const {
02925             Bgp03GetV4RouteListNextCB::
02926             respond(args.peer_id,
02927                         args.net,
02928                         args.best_and_origin,
02929                         args.aspath,
02930                         args.nexthop,
02931                         args.med,
02932                         args.localpref,
02933                         args.atomic_agg,
02934                         args.aggregator,
02935                         args.calc_localpref,
02936                         args.attr_unknown,
02937                         args.valid,
02938                         args.unicast,
02939                         args.multicast);
02940         }
02941 
02942         args_str* operator ->() {
02943             return &args;
02944         }
02945     };
02946 
02947     virtual void async_bgp_0_3_get_v4_route_list_next
02948        (
02949     const uint32_t& token,
02950     Bgp03GetV4RouteListNextCB);
02951 #endif
02952 
02960     virtual XrlCmdError bgp_0_3_set_nexthop6(
02961     // Input values,
02962     const string&   local_ip,
02963     const uint32_t& local_port,
02964     const string&   peer_ip,
02965     const uint32_t& peer_port,
02966     const IPv6& next_hop) = 0;
02967 #ifdef XORP_ENABLE_ASYNC_SERVER
02968     typedef
02969     XorpCallback1<void, const XrlCmdError &>::RefPtr
02970     Bgp03SetNexthop6RF;
02971 
02972     class Bgp03SetNexthop6CB {
02973         Bgp03SetNexthop6RF cb;
02974 
02975     public:
02976         operator const Bgp03SetNexthop6RF& () const { return cb; }
02977         const Bgp03SetNexthop6RF& operator ->() const { return cb; }
02978         Bgp03SetNexthop6CB(const Bgp03SetNexthop6RF& cb)
02979           : cb(cb) { }
02980 
02981         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02982 
02983         void respond() const {
02984             cb->dispatch(XrlCmdError::OKAY());
02985         }
02986     };
02987 
02988     struct Bgp03SetNexthop6Rsp :
02989       public Bgp03SetNexthop6CB {
02990         Bgp03SetNexthop6Rsp(const Bgp03SetNexthop6RF& cb)
02991           : Bgp03SetNexthop6CB(cb) { }
02992 
02993     };
02994 
02995     virtual void async_bgp_0_3_set_nexthop6
02996        (
02997     const string&   local_ip,
02998     const uint32_t& local_port,
02999     const string&   peer_ip,
03000     const uint32_t& peer_port,
03001     const IPv6& next_hop,
03002     Bgp03SetNexthop6CB);
03003 #endif
03004 
03012     virtual XrlCmdError bgp_0_3_get_nexthop6(
03013     // Input values,
03014     const string&   local_ip,
03015     const uint32_t& local_port,
03016     const string&   peer_ip,
03017     const uint32_t& peer_port,
03018     // Output values,
03019     IPv6&   next_hop) = 0;
03020 #ifdef XORP_ENABLE_ASYNC_SERVER
03021     typedef
03022     XorpCallback2<void, const XrlCmdError &,
03023     const IPv6*>::RefPtr
03024     Bgp03GetNexthop6RF;
03025 
03026     class Bgp03GetNexthop6CB {
03027         Bgp03GetNexthop6RF cb;
03028 
03029     public:
03030         operator const Bgp03GetNexthop6RF& () const { return cb; }
03031         const Bgp03GetNexthop6RF& operator ->() const { return cb; }
03032         Bgp03GetNexthop6CB(const Bgp03GetNexthop6RF& cb)
03033           : cb(cb) { }
03034 
03035         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
03036 
03037         void respond(const IPv6& arg_next_hop) const {
03038             cb->dispatch(XrlCmdError::OKAY(),
03039                          &arg_next_hop);
03040         }
03041     };
03042 
03043     struct Bgp03GetNexthop6Rsp :
03044       public Bgp03GetNexthop6CB {
03045         struct args_str {
03046             IPv6 next_hop;
03047         };
03048 
03049     private:
03050         args_str args;
03051 
03052     public:
03053         Bgp03GetNexthop6Rsp(const Bgp03GetNexthop6RF& cb)
03054           : Bgp03GetNexthop6CB(cb) { }
03055 
03056         void respond() const {
03057             Bgp03GetNexthop6CB::
03058             respond(args.next_hop);
03059         }
03060 
03061         args_str* operator ->() {
03062             return &args;
03063         }
03064     };
03065 
03066     virtual void async_bgp_0_3_get_nexthop6
03067        (
03068     const string&   local_ip,
03069     const uint32_t& local_port,
03070     const string&   peer_ip,
03071     const uint32_t& peer_port,
03072     Bgp03GetNexthop6CB);
03073 #endif
03074 
03086     virtual XrlCmdError bgp_0_3_withdraw_route6(
03087     // Input values,
03088     const IPv6Net&  nlri,
03089     const bool& unicast,
03090     const bool& multicast) = 0;
03091 #ifdef XORP_ENABLE_ASYNC_SERVER
03092     typedef
03093     XorpCallback1<void, const XrlCmdError &>::RefPtr
03094     Bgp03WithdrawRoute6RF;
03095 
03096     class Bgp03WithdrawRoute6CB {
03097         Bgp03WithdrawRoute6RF cb;
03098 
03099     public:
03100         operator const Bgp03WithdrawRoute6RF& () const { return cb; }
03101         const Bgp03WithdrawRoute6RF& operator ->() const { return cb; }
03102         Bgp03WithdrawRoute6CB(const Bgp03WithdrawRoute6RF& cb)
03103           : cb(cb) { }
03104 
03105         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03106 
03107         void respond() const {
03108             cb->dispatch(XrlCmdError::OKAY());
03109         }
03110     };
03111 
03112     struct Bgp03WithdrawRoute6Rsp :
03113       public Bgp03WithdrawRoute6CB {
03114         Bgp03WithdrawRoute6Rsp(const Bgp03WithdrawRoute6RF& cb)
03115           : Bgp03WithdrawRoute6CB(cb) { }
03116 
03117     };
03118 
03119     virtual void async_bgp_0_3_withdraw_route6
03120        (
03121     const IPv6Net&  nlri,
03122     const bool& unicast,
03123     const bool& multicast,
03124     Bgp03WithdrawRoute6CB);
03125 #endif
03126 
03143     virtual XrlCmdError bgp_0_3_get_v6_route_list_start(
03144     // Input values,
03145     const IPv6Net&  net,
03146     const bool& unicast,
03147     const bool& multicast,
03148     // Output values,
03149     uint32_t&   token) = 0;
03150 #ifdef XORP_ENABLE_ASYNC_SERVER
03151     typedef
03152     XorpCallback2<void, const XrlCmdError &,
03153     const uint32_t*>::RefPtr
03154     Bgp03GetV6RouteListStartRF;
03155 
03156     class Bgp03GetV6RouteListStartCB {
03157         Bgp03GetV6RouteListStartRF cb;
03158 
03159     public:
03160         operator const Bgp03GetV6RouteListStartRF& () const { return cb; }
03161         const Bgp03GetV6RouteListStartRF& operator ->() const { return cb; }
03162         Bgp03GetV6RouteListStartCB(const Bgp03GetV6RouteListStartRF& cb)
03163           : cb(cb) { }
03164 
03165         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
03166 
03167         void respond(const uint32_t& arg_token) const {
03168             cb->dispatch(XrlCmdError::OKAY(),
03169                          &arg_token);
03170         }
03171     };
03172 
03173     struct Bgp03GetV6RouteListStartRsp :
03174       public Bgp03GetV6RouteListStartCB {
03175         struct args_str {
03176             uint32_t token;
03177         };
03178 
03179     private:
03180         args_str args;
03181 
03182     public:
03183         Bgp03GetV6RouteListStartRsp(const Bgp03GetV6RouteListStartRF& cb)
03184           : Bgp03GetV6RouteListStartCB(cb) { }
03185 
03186         void respond() const {
03187             Bgp03GetV6RouteListStartCB::
03188             respond(args.token);
03189         }
03190 
03191         args_str* operator ->() {
03192             return &args;
03193         }
03194     };
03195 
03196     virtual void async_bgp_0_3_get_v6_route_list_start
03197        (
03198     const IPv6Net&  net,
03199     const bool& unicast,
03200     const bool& multicast,
03201     Bgp03GetV6RouteListStartCB);
03202 #endif
03203 
03217     virtual XrlCmdError bgp_0_3_originate_route6(
03218     // Input values,
03219     const IPv6Net&  nlri,
03220     const IPv6& next_hop,
03221     const bool& unicast,
03222     const bool& multicast) = 0;
03223 #ifdef XORP_ENABLE_ASYNC_SERVER
03224     typedef
03225     XorpCallback1<void, const XrlCmdError &>::RefPtr
03226     Bgp03OriginateRoute6RF;
03227 
03228     class Bgp03OriginateRoute6CB {
03229         Bgp03OriginateRoute6RF cb;
03230 
03231     public:
03232         operator const Bgp03OriginateRoute6RF& () const { return cb; }
03233         const Bgp03OriginateRoute6RF& operator ->() const { return cb; }
03234         Bgp03OriginateRoute6CB(const Bgp03OriginateRoute6RF& cb)
03235           : cb(cb) { }
03236 
03237         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03238 
03239         void respond() const {
03240             cb->dispatch(XrlCmdError::OKAY());
03241         }
03242     };
03243 
03244     struct Bgp03OriginateRoute6Rsp :
03245       public Bgp03OriginateRoute6CB {
03246         Bgp03OriginateRoute6Rsp(const Bgp03OriginateRoute6RF& cb)
03247           : Bgp03OriginateRoute6CB(cb) { }
03248 
03249     };
03250 
03251     virtual void async_bgp_0_3_originate_route6
03252        (
03253     const IPv6Net&  nlri,
03254     const IPv6& next_hop,
03255     const bool& unicast,
03256     const bool& multicast,
03257     Bgp03OriginateRoute6CB);
03258 #endif
03259 
03266     virtual XrlCmdError bgp_0_3_get_v6_route_list_next(
03267     // Input values,
03268     const uint32_t& token,
03269     // Output values,
03270     IPv4&   peer_id,
03271     IPv6Net&    net,
03272     uint32_t&   best_and_origin,
03273     vector<uint8_t>&    aspath,
03274     IPv6&   nexthop,
03275     int32_t&    med,
03276     int32_t&    localpref,
03277     int32_t&    atomic_agg,
03278     vector<uint8_t>&    aggregator,
03279     int32_t&    calc_localpref,
03280     vector<uint8_t>&    attr_unknown,
03281     bool&   valid,
03282     bool&   unicast,
03283     bool&   multicast) = 0;
03284 #ifdef XORP_ENABLE_ASYNC_SERVER
03285     typedef
03286     XorpCallback15<void, const XrlCmdError &,
03287     const IPv4*,
03288     const IPv6Net*,
03289     const uint32_t*,
03290     const vector<uint8_t>*,
03291     const IPv6*,
03292     const int32_t*,
03293     const int32_t*,
03294     const int32_t*,
03295     const vector<uint8_t>*,
03296     const int32_t*,
03297     const vector<uint8_t>*,
03298     const bool*,
03299     const bool*,
03300     const bool*>::RefPtr
03301     Bgp03GetV6RouteListNextRF;
03302 
03303     class Bgp03GetV6RouteListNextCB {
03304         Bgp03GetV6RouteListNextRF cb;
03305 
03306     public:
03307         operator const Bgp03GetV6RouteListNextRF& () const { return cb; }
03308         const Bgp03GetV6RouteListNextRF& operator ->() const { return cb; }
03309         Bgp03GetV6RouteListNextCB(const Bgp03GetV6RouteListNextRF& cb)
03310           : cb(cb) { }
03311 
03312         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); }
03313 
03314         void respond(const IPv4& arg_peer_id,
03315                      const IPv6Net& arg_net,
03316                      const uint32_t& arg_best_and_origin,
03317                      const vector<uint8_t>& arg_aspath,
03318                      const IPv6& arg_nexthop,
03319                      const int32_t& arg_med,
03320                      const int32_t& arg_localpref,
03321                      const int32_t& arg_atomic_agg,
03322                      const vector<uint8_t>& arg_aggregator,
03323                      const int32_t& arg_calc_localpref,
03324                      const vector<uint8_t>& arg_attr_unknown,
03325                      const bool& arg_valid,
03326                      const bool& arg_unicast,
03327                      const bool& arg_multicast) const {
03328             cb->dispatch(XrlCmdError::OKAY(),
03329                          &arg_peer_id,
03330                          &arg_net,
03331                          &arg_best_and_origin,
03332                          &arg_aspath,
03333                          &arg_nexthop,
03334                          &arg_med,
03335                          &arg_localpref,
03336                          &arg_atomic_agg,
03337                          &arg_aggregator,
03338                          &arg_calc_localpref,
03339                          &arg_attr_unknown,
03340                          &arg_valid,
03341                          &arg_unicast,
03342                          &arg_multicast);
03343         }
03344     };
03345 
03346     struct Bgp03GetV6RouteListNextRsp :
03347       public Bgp03GetV6RouteListNextCB {
03348         struct args_str {
03349             IPv4 peer_id;
03350             IPv6Net net;
03351             uint32_t best_and_origin;
03352             vector<uint8_t> aspath;
03353             IPv6 nexthop;
03354             int32_t med;
03355             int32_t localpref;
03356             int32_t atomic_agg;
03357             vector<uint8_t> aggregator;
03358             int32_t calc_localpref;
03359             vector<uint8_t> attr_unknown;
03360             bool valid;
03361             bool unicast;
03362             bool multicast;
03363         };
03364 
03365     private:
03366         args_str args;
03367 
03368     public:
03369         Bgp03GetV6RouteListNextRsp(const Bgp03GetV6RouteListNextRF& cb)
03370           : Bgp03GetV6RouteListNextCB(cb) { }
03371 
03372         void respond() const {
03373             Bgp03GetV6RouteListNextCB::
03374             respond(args.peer_id,
03375                         args.net,
03376                         args.best_and_origin,
03377                         args.aspath,
03378                         args.nexthop,
03379                         args.med,
03380                         args.localpref,
03381                         args.atomic_agg,
03382                         args.aggregator,
03383                         args.calc_localpref,
03384                         args.attr_unknown,
03385                         args.valid,
03386                         args.unicast,
03387                         args.multicast);
03388         }
03389 
03390         args_str* operator ->() {
03391             return &args;
03392         }
03393     };
03394 
03395     virtual void async_bgp_0_3_get_v6_route_list_next
03396        (
03397     const uint32_t& token,
03398     Bgp03GetV6RouteListNextCB);
03399 #endif
03400 
03410     virtual XrlCmdError finder_event_observer_0_1_xrl_target_birth(
03411     // Input values,
03412     const string&   target_class,
03413     const string&   target_instance) = 0;
03414 #ifdef XORP_ENABLE_ASYNC_SERVER
03415     typedef
03416     XorpCallback1<void, const XrlCmdError &>::RefPtr
03417     FinderEventObserver01XrlTargetBirthRF;
03418 
03419     class FinderEventObserver01XrlTargetBirthCB {
03420         FinderEventObserver01XrlTargetBirthRF cb;
03421 
03422     public:
03423         operator const FinderEventObserver01XrlTargetBirthRF& () const { return cb; }
03424         const FinderEventObserver01XrlTargetBirthRF& operator ->() const { return cb; }
03425         FinderEventObserver01XrlTargetBirthCB(const FinderEventObserver01XrlTargetBirthRF& cb)
03426           : cb(cb) { }
03427 
03428         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03429 
03430         void respond() const {
03431             cb->dispatch(XrlCmdError::OKAY());
03432         }
03433     };
03434 
03435     struct FinderEventObserver01XrlTargetBirthRsp :
03436       public FinderEventObserver01XrlTargetBirthCB {
03437         FinderEventObserver01XrlTargetBirthRsp(const FinderEventObserver01XrlTargetBirthRF& cb)
03438           : FinderEventObserver01XrlTargetBirthCB(cb) { }
03439 
03440     };
03441 
03442     virtual void async_finder_event_observer_0_1_xrl_target_birth
03443        (
03444     const string&   target_class,
03445     const string&   target_instance,
03446     FinderEventObserver01XrlTargetBirthCB);
03447 #endif
03448 
03458     virtual XrlCmdError finder_event_observer_0_1_xrl_target_death(
03459     // Input values,
03460     const string&   target_class,
03461     const string&   target_instance) = 0;
03462 #ifdef XORP_ENABLE_ASYNC_SERVER
03463     typedef
03464     XorpCallback1<void, const XrlCmdError &>::RefPtr
03465     FinderEventObserver01XrlTargetDeathRF;
03466 
03467     class FinderEventObserver01XrlTargetDeathCB {
03468         FinderEventObserver01XrlTargetDeathRF cb;
03469 
03470     public:
03471         operator const FinderEventObserver01XrlTargetDeathRF& () const { return cb; }
03472         const FinderEventObserver01XrlTargetDeathRF& operator ->() const { return cb; }
03473         FinderEventObserver01XrlTargetDeathCB(const FinderEventObserver01XrlTargetDeathRF& cb)
03474           : cb(cb) { }
03475 
03476         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03477 
03478         void respond() const {
03479             cb->dispatch(XrlCmdError::OKAY());
03480         }
03481     };
03482 
03483     struct FinderEventObserver01XrlTargetDeathRsp :
03484       public FinderEventObserver01XrlTargetDeathCB {
03485         FinderEventObserver01XrlTargetDeathRsp(const FinderEventObserver01XrlTargetDeathRF& cb)
03486           : FinderEventObserver01XrlTargetDeathCB(cb) { }
03487 
03488     };
03489 
03490     virtual void async_finder_event_observer_0_1_xrl_target_death
03491        (
03492     const string&   target_class,
03493     const string&   target_instance,
03494     FinderEventObserver01XrlTargetDeathCB);
03495 #endif
03496 
03506     virtual XrlCmdError policy_backend_0_1_configure(
03507     // Input values,
03508     const uint32_t& filter,
03509     const string&   conf) = 0;
03510 #ifdef XORP_ENABLE_ASYNC_SERVER
03511     typedef
03512     XorpCallback1<void, const XrlCmdError &>::RefPtr
03513     PolicyBackend01ConfigureRF;
03514 
03515     class PolicyBackend01ConfigureCB {
03516         PolicyBackend01ConfigureRF cb;
03517 
03518     public:
03519         operator const PolicyBackend01ConfigureRF& () const { return cb; }
03520         const PolicyBackend01ConfigureRF& operator ->() const { return cb; }
03521         PolicyBackend01ConfigureCB(const PolicyBackend01ConfigureRF& cb)
03522           : cb(cb) { }
03523 
03524         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03525 
03526         void respond() const {
03527             cb->dispatch(XrlCmdError::OKAY());
03528         }
03529     };
03530 
03531     struct PolicyBackend01ConfigureRsp :
03532       public PolicyBackend01ConfigureCB {
03533         PolicyBackend01ConfigureRsp(const PolicyBackend01ConfigureRF& cb)
03534           : PolicyBackend01ConfigureCB(cb) { }
03535 
03536     };
03537 
03538     virtual void async_policy_backend_0_1_configure
03539        (
03540     const uint32_t& filter,
03541     const string&   conf,
03542     PolicyBackend01ConfigureCB);
03543 #endif
03544 
03552     virtual XrlCmdError policy_backend_0_1_reset(
03553     // Input values,
03554     const uint32_t& filter) = 0;
03555 #ifdef XORP_ENABLE_ASYNC_SERVER
03556     typedef
03557     XorpCallback1<void, const XrlCmdError &>::RefPtr
03558     PolicyBackend01ResetRF;
03559 
03560     class PolicyBackend01ResetCB {
03561         PolicyBackend01ResetRF cb;
03562 
03563     public:
03564         operator const PolicyBackend01ResetRF& () const { return cb; }
03565         const PolicyBackend01ResetRF& operator ->() const { return cb; }
03566         PolicyBackend01ResetCB(const PolicyBackend01ResetRF& cb)
03567           : cb(cb) { }
03568 
03569         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03570 
03571         void respond() const {
03572             cb->dispatch(XrlCmdError::OKAY());
03573         }
03574     };
03575 
03576     struct PolicyBackend01ResetRsp :
03577       public PolicyBackend01ResetCB {
03578         PolicyBackend01ResetRsp(const PolicyBackend01ResetRF& cb)
03579           : PolicyBackend01ResetCB(cb) { }
03580 
03581     };
03582 
03583     virtual void async_policy_backend_0_1_reset
03584        (
03585     const uint32_t& filter,
03586     PolicyBackend01ResetCB);
03587 #endif
03588 
03594     virtual XrlCmdError policy_backend_0_1_push_routes() = 0;
03595 #ifdef XORP_ENABLE_ASYNC_SERVER
03596     typedef
03597     XorpCallback1<void, const XrlCmdError &>::RefPtr
03598     PolicyBackend01PushRoutesRF;
03599 
03600     class PolicyBackend01PushRoutesCB {
03601         PolicyBackend01PushRoutesRF cb;
03602 
03603     public:
03604         operator const PolicyBackend01PushRoutesRF& () const { return cb; }
03605         const PolicyBackend01PushRoutesRF& operator ->() const { return cb; }
03606         PolicyBackend01PushRoutesCB(const PolicyBackend01PushRoutesRF& cb)
03607           : cb(cb) { }
03608 
03609         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03610 
03611         void respond() const {
03612             cb->dispatch(XrlCmdError::OKAY());
03613         }
03614     };
03615 
03616     struct PolicyBackend01PushRoutesRsp :
03617       public PolicyBackend01PushRoutesCB {
03618         PolicyBackend01PushRoutesRsp(const PolicyBackend01PushRoutesRF& cb)
03619           : PolicyBackend01PushRoutesCB(cb) { }
03620 
03621     };
03622 
03623     virtual void async_policy_backend_0_1_push_routes
03624        (
03625     PolicyBackend01PushRoutesCB);
03626 #endif
03627 
03645     virtual XrlCmdError policy_redist4_0_1_add_route4(
03646     // Input values,
03647     const IPv4Net&  network,
03648     const bool& unicast,
03649     const bool& multicast,
03650     const IPv4& nexthop,
03651     const uint32_t& metric,
03652     const XrlAtomList&  policytags) = 0;
03653 #ifdef XORP_ENABLE_ASYNC_SERVER
03654     typedef
03655     XorpCallback1<void, const XrlCmdError &>::RefPtr
03656     PolicyRedist401AddRoute4RF;
03657 
03658     class PolicyRedist401AddRoute4CB {
03659         PolicyRedist401AddRoute4RF cb;
03660 
03661     public:
03662         operator const PolicyRedist401AddRoute4RF& () const { return cb; }
03663         const PolicyRedist401AddRoute4RF& operator ->() const { return cb; }
03664         PolicyRedist401AddRoute4CB(const PolicyRedist401AddRoute4RF& cb)
03665           : cb(cb) { }
03666 
03667         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03668 
03669         void respond() const {
03670             cb->dispatch(XrlCmdError::OKAY());
03671         }
03672     };
03673 
03674     struct PolicyRedist401AddRoute4Rsp :
03675       public PolicyRedist401AddRoute4CB {
03676         PolicyRedist401AddRoute4Rsp(const PolicyRedist401AddRoute4RF& cb)
03677           : PolicyRedist401AddRoute4CB(cb) { }
03678 
03679     };
03680 
03681     virtual void async_policy_redist4_0_1_add_route4
03682        (
03683     const IPv4Net&  network,
03684     const bool& unicast,
03685     const bool& multicast,
03686     const IPv4& nexthop,
03687     const uint32_t& metric,
03688     const XrlAtomList&  policytags,
03689     PolicyRedist401AddRoute4CB);
03690 #endif
03691 
03703     virtual XrlCmdError policy_redist4_0_1_delete_route4(
03704     // Input values,
03705     const IPv4Net&  network,
03706     const bool& unicast,
03707     const bool& multicast) = 0;
03708 #ifdef XORP_ENABLE_ASYNC_SERVER
03709     typedef
03710     XorpCallback1<void, const XrlCmdError &>::RefPtr
03711     PolicyRedist401DeleteRoute4RF;
03712 
03713     class PolicyRedist401DeleteRoute4CB {
03714         PolicyRedist401DeleteRoute4RF cb;
03715 
03716     public:
03717         operator const PolicyRedist401DeleteRoute4RF& () const { return cb; }
03718         const PolicyRedist401DeleteRoute4RF& operator ->() const { return cb; }
03719         PolicyRedist401DeleteRoute4CB(const PolicyRedist401DeleteRoute4RF& cb)
03720           : cb(cb) { }
03721 
03722         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03723 
03724         void respond() const {
03725             cb->dispatch(XrlCmdError::OKAY());
03726         }
03727     };
03728 
03729     struct PolicyRedist401DeleteRoute4Rsp :
03730       public PolicyRedist401DeleteRoute4CB {
03731         PolicyRedist401DeleteRoute4Rsp(const PolicyRedist401DeleteRoute4RF& cb)
03732           : PolicyRedist401DeleteRoute4CB(cb) { }
03733 
03734     };
03735 
03736     virtual void async_policy_redist4_0_1_delete_route4
03737        (
03738     const IPv4Net&  network,
03739     const bool& unicast,
03740     const bool& multicast,
03741     PolicyRedist401DeleteRoute4CB);
03742 #endif
03743 
03764     virtual XrlCmdError rib_client_0_1_route_info_changed4(
03765     // Input values,
03766     const IPv4& addr,
03767     const uint32_t& prefix_len,
03768     const IPv4& nexthop,
03769     const uint32_t& metric,
03770     const uint32_t& admin_distance,
03771     const string&   protocol_origin) = 0;
03772 #ifdef XORP_ENABLE_ASYNC_SERVER
03773     typedef
03774     XorpCallback1<void, const XrlCmdError &>::RefPtr
03775     RibClient01RouteInfoChanged4RF;
03776 
03777     class RibClient01RouteInfoChanged4CB {
03778         RibClient01RouteInfoChanged4RF cb;
03779 
03780     public:
03781         operator const RibClient01RouteInfoChanged4RF& () const { return cb; }
03782         const RibClient01RouteInfoChanged4RF& operator ->() const { return cb; }
03783         RibClient01RouteInfoChanged4CB(const RibClient01RouteInfoChanged4RF& cb)
03784           : cb(cb) { }
03785 
03786         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03787 
03788         void respond() const {
03789             cb->dispatch(XrlCmdError::OKAY());
03790         }
03791     };
03792 
03793     struct RibClient01RouteInfoChanged4Rsp :
03794       public RibClient01RouteInfoChanged4CB {
03795         RibClient01RouteInfoChanged4Rsp(const RibClient01RouteInfoChanged4RF& cb)
03796           : RibClient01RouteInfoChanged4CB(cb) { }
03797 
03798     };
03799 
03800     virtual void async_rib_client_0_1_route_info_changed4
03801        (
03802     const IPv4& addr,
03803     const uint32_t& prefix_len,
03804     const IPv4& nexthop,
03805     const uint32_t& metric,
03806     const uint32_t& admin_distance,
03807     const string&   protocol_origin,
03808     RibClient01RouteInfoChanged4CB);
03809 #endif
03810 
03822     virtual XrlCmdError rib_client_0_1_route_info_invalid4(
03823     // Input values,
03824     const IPv4& addr,
03825     const uint32_t& prefix_len) = 0;
03826 #ifdef XORP_ENABLE_ASYNC_SERVER
03827     typedef
03828     XorpCallback1<void, const XrlCmdError &>::RefPtr
03829     RibClient01RouteInfoInvalid4RF;
03830 
03831     class RibClient01RouteInfoInvalid4CB {
03832         RibClient01RouteInfoInvalid4RF cb;
03833 
03834     public:
03835         operator const RibClient01RouteInfoInvalid4RF& () const { return cb; }
03836         const RibClient01RouteInfoInvalid4RF& operator ->() const { return cb; }
03837         RibClient01RouteInfoInvalid4CB(const RibClient01RouteInfoInvalid4RF& cb)
03838           : cb(cb) { }
03839 
03840         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03841 
03842         void respond() const {
03843             cb->dispatch(XrlCmdError::OKAY());
03844         }
03845     };
03846 
03847     struct RibClient01RouteInfoInvalid4Rsp :
03848       public RibClient01RouteInfoInvalid4CB {
03849         RibClient01RouteInfoInvalid4Rsp(const RibClient01RouteInfoInvalid4RF& cb)
03850           : RibClient01RouteInfoInvalid4CB(cb) { }
03851 
03852     };
03853 
03854     virtual void async_rib_client_0_1_route_info_invalid4
03855        (
03856     const IPv4& addr,
03857     const uint32_t& prefix_len,
03858     RibClient01RouteInfoInvalid4CB);
03859 #endif
03860 
03861     virtual XrlCmdError rib_client_0_1_route_info_changed6(
03862     // Input values,
03863     const IPv6& addr,
03864     const uint32_t& prefix_len,
03865     const IPv6& nexthop,
03866     const uint32_t& metric,
03867     const uint32_t& admin_distance,
03868     const string&   protocol_origin) = 0;
03869 #ifdef XORP_ENABLE_ASYNC_SERVER
03870     typedef
03871     XorpCallback1<void, const XrlCmdError &>::RefPtr
03872     RibClient01RouteInfoChanged6RF;
03873 
03874     class RibClient01RouteInfoChanged6CB {
03875         RibClient01RouteInfoChanged6RF cb;
03876 
03877     public:
03878         operator const RibClient01RouteInfoChanged6RF& () const { return cb; }
03879         const RibClient01RouteInfoChanged6RF& operator ->() const { return cb; }
03880         RibClient01RouteInfoChanged6CB(const RibClient01RouteInfoChanged6RF& cb)
03881           : cb(cb) { }
03882 
03883         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03884 
03885         void respond() const {
03886             cb->dispatch(XrlCmdError::OKAY());
03887         }
03888     };
03889 
03890     struct RibClient01RouteInfoChanged6Rsp :
03891       public RibClient01RouteInfoChanged6CB {
03892         RibClient01RouteInfoChanged6Rsp(const RibClient01RouteInfoChanged6RF& cb)
03893           : RibClient01RouteInfoChanged6CB(cb) { }
03894 
03895     };
03896 
03897     virtual void async_rib_client_0_1_route_info_changed6
03898        (
03899     const IPv6& addr,
03900     const uint32_t& prefix_len,
03901     const IPv6& nexthop,
03902     const uint32_t& metric,
03903     const uint32_t& admin_distance,
03904     const string&   protocol_origin,
03905     RibClient01RouteInfoChanged6CB);
03906 #endif
03907 
03908     virtual XrlCmdError rib_client_0_1_route_info_invalid6(
03909     // Input values,
03910     const IPv6& addr,
03911     const uint32_t& prefix_len) = 0;
03912 #ifdef XORP_ENABLE_ASYNC_SERVER
03913     typedef
03914     XorpCallback1<void, const XrlCmdError &>::RefPtr
03915     RibClient01RouteInfoInvalid6RF;
03916 
03917     class RibClient01RouteInfoInvalid6CB {
03918         RibClient01RouteInfoInvalid6RF cb;
03919 
03920     public:
03921         operator const RibClient01RouteInfoInvalid6RF& () const { return cb; }
03922         const RibClient01RouteInfoInvalid6RF& operator ->() const { return cb; }
03923         RibClient01RouteInfoInvalid6CB(const RibClient01RouteInfoInvalid6RF& cb)
03924           : cb(cb) { }
03925 
03926         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03927 
03928         void respond() const {
03929             cb->dispatch(XrlCmdError::OKAY());
03930         }
03931     };
03932 
03933     struct RibClient01RouteInfoInvalid6Rsp :
03934       public RibClient01RouteInfoInvalid6CB {
03935         RibClient01RouteInfoInvalid6Rsp(const RibClient01RouteInfoInvalid6RF& cb)
03936           : RibClient01RouteInfoInvalid6CB(cb) { }
03937 
03938     };
03939 
03940     virtual void async_rib_client_0_1_route_info_invalid6
03941        (
03942     const IPv6& addr,
03943     const uint32_t& prefix_len,
03944     RibClient01RouteInfoInvalid6CB);
03945 #endif
03946 
03964     virtual XrlCmdError policy_redist6_0_1_add_route6(
03965     // Input values,
03966     const IPv6Net&  network,
03967     const bool& unicast,
03968     const bool& multicast,
03969     const IPv6& nexthop,
03970     const uint32_t& metric,
03971     const XrlAtomList&  policytags) = 0;
03972 #ifdef XORP_ENABLE_ASYNC_SERVER
03973     typedef
03974     XorpCallback1<void, const XrlCmdError &>::RefPtr
03975     PolicyRedist601AddRoute6RF;
03976 
03977     class PolicyRedist601AddRoute6CB {
03978         PolicyRedist601AddRoute6RF cb;
03979 
03980     public:
03981         operator const PolicyRedist601AddRoute6RF& () const { return cb; }
03982         const PolicyRedist601AddRoute6RF& operator ->() const { return cb; }
03983         PolicyRedist601AddRoute6CB(const PolicyRedist601AddRoute6RF& cb)
03984           : cb(cb) { }
03985 
03986         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03987 
03988         void respond() const {
03989             cb->dispatch(XrlCmdError::OKAY());
03990         }
03991     };
03992 
03993     struct PolicyRedist601AddRoute6Rsp :
03994       public PolicyRedist601AddRoute6CB {
03995         PolicyRedist601AddRoute6Rsp(const PolicyRedist601AddRoute6RF& cb)
03996           : PolicyRedist601AddRoute6CB(cb) { }
03997 
03998     };
03999 
04000     virtual void async_policy_redist6_0_1_add_route6
04001        (
04002     const IPv6Net&  network,
04003     const bool& unicast,
04004     const bool& multicast,
04005     const IPv6& nexthop,
04006     const uint32_t& metric,
04007     const XrlAtomList&  policytags,
04008     PolicyRedist601AddRoute6CB);
04009 #endif
04010 
04022     virtual XrlCmdError policy_redist6_0_1_delete_route6(
04023     // Input values,
04024     const IPv6Net&  network,
04025     const bool& unicast,
04026     const bool& multicast) = 0;
04027 #ifdef XORP_ENABLE_ASYNC_SERVER
04028     typedef
04029     XorpCallback1<void, const XrlCmdError &>::RefPtr
04030     PolicyRedist601DeleteRoute6RF;
04031 
04032     class PolicyRedist601DeleteRoute6CB {
04033         PolicyRedist601DeleteRoute6RF cb;
04034 
04035     public:
04036         operator const PolicyRedist601DeleteRoute6RF& () const { return cb; }
04037         const PolicyRedist601DeleteRoute6RF& operator ->() const { return cb; }
04038         PolicyRedist601DeleteRoute6CB(const PolicyRedist601DeleteRoute6RF& cb)
04039           : cb(cb) { }
04040 
04041         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
04042 
04043         void respond() const {
04044             cb->dispatch(XrlCmdError::OKAY());
04045         }
04046     };
04047 
04048     struct PolicyRedist601DeleteRoute6Rsp :
04049       public PolicyRedist601DeleteRoute6CB {
04050         PolicyRedist601DeleteRoute6Rsp(const PolicyRedist601DeleteRoute6RF& cb)
04051           : PolicyRedist601DeleteRoute6CB(cb) { }
04052 
04053     };
04054 
04055     virtual void async_policy_redist6_0_1_delete_route6
04056        (
04057     const IPv6Net&  network,
04058     const bool& unicast,
04059     const bool& multicast,
04060     PolicyRedist601DeleteRoute6CB);
04061 #endif
04062 
04070     virtual XrlCmdError profile_0_1_enable(
04071     // Input values,
04072     const string&   pname) = 0;
04073 #ifdef XORP_ENABLE_ASYNC_SERVER
04074     typedef
04075     XorpCallback1<void, const XrlCmdError &>::RefPtr
04076     Profile01EnableRF;
04077 
04078     class Profile01EnableCB {
04079         Profile01EnableRF cb;
04080 
04081     public:
04082         operator const Profile01EnableRF& () const { return cb; }
04083         const Profile01EnableRF& operator ->() const { return cb; }
04084         Profile01EnableCB(const Profile01EnableRF& cb)
04085           : cb(cb) { }
04086 
04087         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
04088 
04089         void respond() const {
04090             cb->dispatch(XrlCmdError::OKAY());
04091         }
04092     };
04093 
04094     struct Profile01EnableRsp :
04095       public Profile01EnableCB {
04096         Profile01EnableRsp(const Profile01EnableRF& cb)
04097           : Profile01EnableCB(cb) { }
04098 
04099     };
04100 
04101     virtual void async_profile_0_1_enable
04102        (
04103     const string&   pname,
04104     Profile01EnableCB);
04105 #endif
04106 
04114     virtual XrlCmdError profile_0_1_disable(
04115     // Input values,
04116     const string&   pname) = 0;
04117 #ifdef XORP_ENABLE_ASYNC_SERVER
04118     typedef
04119     XorpCallback1<void, const XrlCmdError &>::RefPtr
04120     Profile01DisableRF;
04121 
04122     class Profile01DisableCB {
04123         Profile01DisableRF cb;
04124 
04125     public:
04126         operator const Profile01DisableRF& () const { return cb; }
04127         const Profile01DisableRF& operator ->() const { return cb; }
04128         Profile01DisableCB(const Profile01DisableRF& cb)
04129           : cb(cb) { }
04130 
04131         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
04132 
04133         void respond() const {
04134             cb->dispatch(XrlCmdError::OKAY());
04135         }
04136     };
04137 
04138     struct Profile01DisableRsp :
04139       public Profile01DisableCB {
04140         Profile01DisableRsp(const Profile01DisableRF& cb)
04141           : Profile01DisableCB(cb) { }
04142 
04143     };
04144 
04145     virtual void async_profile_0_1_disable
04146        (
04147     const string&   pname,
04148     Profile01DisableCB);
04149 #endif
04150 
04160     virtual XrlCmdError profile_0_1_get_entries(
04161     // Input values,
04162     const string&   pname,
04163     const string&   instance_name) = 0;
04164 #ifdef XORP_ENABLE_ASYNC_SERVER
04165     typedef
04166     XorpCallback1<void, const XrlCmdError &>::RefPtr
04167     Profile01GetEntriesRF;
04168 
04169     class Profile01GetEntriesCB {
04170         Profile01GetEntriesRF cb;
04171 
04172     public:
04173         operator const Profile01GetEntriesRF& () const { return cb; }
04174         const Profile01GetEntriesRF& operator ->() const { return cb; }
04175         Profile01GetEntriesCB(const Profile01GetEntriesRF& cb)
04176           : cb(cb) { }
04177 
04178         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
04179 
04180         void respond() const {
04181             cb->dispatch(XrlCmdError::OKAY());
04182         }
04183     };
04184 
04185     struct Profile01GetEntriesRsp :
04186       public Profile01GetEntriesCB {
04187         Profile01GetEntriesRsp(const Profile01GetEntriesRF& cb)
04188           : Profile01GetEntriesCB(cb) { }
04189 
04190     };
04191 
04192     virtual void async_profile_0_1_get_entries
04193        (
04194     const string&   pname,
04195     const string&   instance_name,
04196     Profile01GetEntriesCB);
04197 #endif
04198 
04206     virtual XrlCmdError profile_0_1_clear(
04207     // Input values,
04208     const string&   pname) = 0;
04209 #ifdef XORP_ENABLE_ASYNC_SERVER
04210     typedef
04211     XorpCallback1<void, const XrlCmdError &>::RefPtr
04212     Profile01ClearRF;
04213 
04214     class Profile01ClearCB {
04215         Profile01ClearRF cb;
04216 
04217     public:
04218         operator const Profile01ClearRF& () const { return cb; }
04219         const Profile01ClearRF& operator ->() const { return cb; }
04220         Profile01ClearCB(const Profile01ClearRF& cb)
04221           : cb(cb) { }
04222 
04223         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
04224 
04225         void respond() const {
04226             cb->dispatch(XrlCmdError::OKAY());
04227         }
04228     };
04229 
04230     struct Profile01ClearRsp :
04231       public Profile01ClearCB {
04232         Profile01ClearRsp(const Profile01ClearRF& cb)
04233           : Profile01ClearCB(cb) { }
04234 
04235     };
04236 
04237     virtual void async_profile_0_1_clear
04238        (
04239     const string&   pname,
04240     Profile01ClearCB);
04241 #endif
04242 
04248     virtual XrlCmdError profile_0_1_list(
04249     // Output values,
04250     string& info) = 0;
04251 #ifdef XORP_ENABLE_ASYNC_SERVER
04252     typedef
04253     XorpCallback2<void, const XrlCmdError &,
04254     const string*>::RefPtr
04255     Profile01ListRF;
04256 
04257     class Profile01ListCB {
04258         Profile01ListRF cb;
04259 
04260     public:
04261         operator const Profile01ListRF& () const { return cb; }
04262         const Profile01ListRF& operator ->() const { return cb; }
04263         Profile01ListCB(const Profile01ListRF& cb)
04264           : cb(cb) { }
04265 
04266         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
04267 
04268         void respond(const string& arg_info) const {
04269             cb->dispatch(XrlCmdError::OKAY(),
04270                          &arg_info);
04271         }
04272     };
04273 
04274     struct Profile01ListRsp :
04275       public Profile01ListCB {
04276         struct args_str {
04277             string info;
04278         };
04279 
04280     private:
04281         args_str args;
04282 
04283     public:
04284         Profile01ListRsp(const Profile01ListRF& cb)
04285           : Profile01ListCB(cb) { }
04286 
04287         void respond() const {
04288             Profile01ListCB::
04289             respond(args.info);
04290         }
04291 
04292         args_str* operator ->() {
04293             return &args;
04294         }
04295     };
04296 
04297     virtual void async_profile_0_1_list
04298        (
04299     Profile01ListCB);
04300 #endif
04301 
04302 private:
04303     XrlCmdRT handle_common_0_1_get_target_name(const XrlArgs& in, XrlCmdOT out);
04304 #ifdef XORP_ENABLE_ASYNC_SERVER
04305     void callback_common_0_1_get_target_name
04306        (const XrlCmdError &e,
04307     const string* arg_name,
04308         XrlRespCallback);
04309 #endif
04310 
04311     XrlCmdRT handle_common_0_1_get_version(const XrlArgs& in, XrlCmdOT out);
04312 #ifdef XORP_ENABLE_ASYNC_SERVER
04313     void callback_common_0_1_get_version
04314        (const XrlCmdError &e,
04315     const string* arg_version,
04316         XrlRespCallback);
04317 #endif
04318 
04319     XrlCmdRT handle_common_0_1_get_status(const XrlArgs& in, XrlCmdOT out);
04320 #ifdef XORP_ENABLE_ASYNC_SERVER
04321     void callback_common_0_1_get_status
04322        (const XrlCmdError &e,
04323     const uint32_t* arg_status,
04324     const string* arg_reason,
04325         XrlRespCallback);
04326 #endif
04327 
04328     XrlCmdRT handle_common_0_1_shutdown(const XrlArgs& in, XrlCmdOT out);
04329 #ifdef XORP_ENABLE_ASYNC_SERVER
04330     void callback_common_0_1_shutdown
04331        (const XrlCmdError &e,
04332         XrlRespCallback);
04333 #endif
04334 
04335     XrlCmdRT handle_common_0_1_startup(const XrlArgs& in, XrlCmdOT out);
04336 #ifdef XORP_ENABLE_ASYNC_SERVER
04337     void callback_common_0_1_startup
04338        (const XrlCmdError &e,
04339         XrlRespCallback);
04340 #endif
04341 
04342     XrlCmdRT handle_bgp_0_3_get_bgp_version(const XrlArgs& in, XrlCmdOT out);
04343 #ifdef XORP_ENABLE_ASYNC_SERVER
04344     void callback_bgp_0_3_get_bgp_version
04345        (const XrlCmdError &e,
04346     const uint32_t* arg_version,
04347         XrlRespCallback);
04348 #endif
04349 
04350     XrlCmdRT handle_bgp_0_3_local_config(const XrlArgs& in, XrlCmdOT out);
04351 #ifdef XORP_ENABLE_ASYNC_SERVER
04352     void callback_bgp_0_3_local_config
04353        (const XrlCmdError &e,
04354         XrlRespCallback);
04355 #endif
04356 
04357     XrlCmdRT handle_bgp_0_3_set_local_as(const XrlArgs& in, XrlCmdOT out);
04358 #ifdef XORP_ENABLE_ASYNC_SERVER
04359     void callback_bgp_0_3_set_local_as
04360        (const XrlCmdError &e,
04361         XrlRespCallback);
04362 #endif
04363 
04364     XrlCmdRT handle_bgp_0_3_set_4byte_as_support(const XrlArgs& in, XrlCmdOT out);
04365 #ifdef XORP_ENABLE_ASYNC_SERVER
04366     void callback_bgp_0_3_set_4byte_as_support
04367        (const XrlCmdError &e,
04368         XrlRespCallback);
04369 #endif
04370 
04371     XrlCmdRT handle_bgp_0_3_get_local_as(const XrlArgs& in, XrlCmdOT out);
04372 #ifdef XORP_ENABLE_ASYNC_SERVER
04373     void callback_bgp_0_3_get_local_as
04374        (const XrlCmdError &e,
04375     const string* arg_as,
04376         XrlRespCallback);
04377 #endif
04378 
04379     XrlCmdRT handle_bgp_0_3_set_bgp_id(const XrlArgs& in, XrlCmdOT out);
04380 #ifdef XORP_ENABLE_ASYNC_SERVER
04381     void callback_bgp_0_3_set_bgp_id
04382        (const XrlCmdError &e,
04383         XrlRespCallback);
04384 #endif
04385 
04386     XrlCmdRT handle_bgp_0_3_get_bgp_id(const XrlArgs& in, XrlCmdOT out);
04387 #ifdef XORP_ENABLE_ASYNC_SERVER
04388     void callback_bgp_0_3_get_bgp_id
04389        (const XrlCmdError &e,
04390     const IPv4* arg_id,
04391         XrlRespCallback);
04392 #endif
04393 
04394     XrlCmdRT handle_bgp_0_3_set_confederation_identifier(const XrlArgs& in, XrlCmdOT out);
04395 #ifdef XORP_ENABLE_ASYNC_SERVER
04396     void callback_bgp_0_3_set_confederation_identifier
04397        (const XrlCmdError &e,
04398         XrlRespCallback);
04399 #endif
04400 
04401     XrlCmdRT handle_bgp_0_3_set_cluster_id(const XrlArgs& in, XrlCmdOT out);
04402 #ifdef XORP_ENABLE_ASYNC_SERVER
04403     void callback_bgp_0_3_set_cluster_id
04404        (const XrlCmdError &e,
04405         XrlRespCallback);
04406 #endif
04407 
04408     XrlCmdRT handle_bgp_0_3_set_damping(const XrlArgs& in, XrlCmdOT out);
04409 #ifdef XORP_ENABLE_ASYNC_SERVER
04410     void callback_bgp_0_3_set_damping
04411        (const XrlCmdError &e,
04412         XrlRespCallback);
04413 #endif
04414 
04415     XrlCmdRT handle_bgp_0_3_add_peer(const XrlArgs& in, XrlCmdOT out);
04416 #ifdef XORP_ENABLE_ASYNC_SERVER
04417     void callback_bgp_0_3_add_peer
04418        (const XrlCmdError &e,
04419         XrlRespCallback);
04420 #endif
04421 
04422     XrlCmdRT handle_bgp_0_3_delete_peer(const XrlArgs& in, XrlCmdOT out);
04423 #ifdef XORP_ENABLE_ASYNC_SERVER
04424     void callback_bgp_0_3_delete_peer
04425        (const XrlCmdError &e,
04426         XrlRespCallback);
04427 #endif
04428 
04429     XrlCmdRT handle_bgp_0_3_enable_peer(const XrlArgs& in, XrlCmdOT out);
04430 #ifdef XORP_ENABLE_ASYNC_SERVER
04431     void callback_bgp_0_3_enable_peer
04432        (const XrlCmdError &e,
04433         XrlRespCallback);
04434 #endif
04435 
04436     XrlCmdRT handle_bgp_0_3_disable_peer(const XrlArgs& in, XrlCmdOT out);
04437 #ifdef XORP_ENABLE_ASYNC_SERVER
04438     void callback_bgp_0_3_disable_peer
04439        (const XrlCmdError &e,
04440         XrlRespCallback);
04441 #endif
04442 
04443     XrlCmdRT handle_bgp_0_3_change_local_ip(const XrlArgs& in, XrlCmdOT out);
04444 #ifdef XORP_ENABLE_ASYNC_SERVER
04445     void callback_bgp_0_3_change_local_ip
04446        (const XrlCmdError &e,
04447         XrlRespCallback);
04448 #endif
04449 
04450     XrlCmdRT handle_bgp_0_3_change_local_port(const XrlArgs& in, XrlCmdOT out);
04451 #ifdef XORP_ENABLE_ASYNC_SERVER
04452     void callback_bgp_0_3_change_local_port
04453        (const XrlCmdError &e,
04454         XrlRespCallback);
04455 #endif
04456 
04457     XrlCmdRT handle_bgp_0_3_change_peer_port(const XrlArgs& in, XrlCmdOT out);
04458 #ifdef XORP_ENABLE_ASYNC_SERVER
04459     void callback_bgp_0_3_change_peer_port
04460        (const XrlCmdError &e,
04461         XrlRespCallback);
04462 #endif
04463 
04464     XrlCmdRT handle_bgp_0_3_set_peer_as(const XrlArgs& in, XrlCmdOT out);
04465 #ifdef XORP_ENABLE_ASYNC_SERVER
04466     void callback_bgp_0_3_set_peer_as
04467        (const XrlCmdError &e,
04468         XrlRespCallback);
04469 #endif
04470 
04471     XrlCmdRT handle_bgp_0_3_set_holdtime(const XrlArgs& in, XrlCmdOT out);
04472 #ifdef XORP_ENABLE_ASYNC_SERVER
04473     void callback_bgp_0_3_set_holdtime
04474        (const XrlCmdError &e,
04475         XrlRespCallback);
04476 #endif
04477 
04478     XrlCmdRT handle_bgp_0_3_set_delay_open_time(const XrlArgs& in, XrlCmdOT out);
04479 #ifdef XORP_ENABLE_ASYNC_SERVER
04480     void callback_bgp_0_3_set_delay_open_time
04481        (const XrlCmdError &e,
04482         XrlRespCallback);
04483 #endif
04484 
04485     XrlCmdRT handle_bgp_0_3_set_route_reflector_client(const XrlArgs& in, XrlCmdOT out);
04486 #ifdef XORP_ENABLE_ASYNC_SERVER
04487     void callback_bgp_0_3_set_route_reflector_client
04488        (const XrlCmdError &e,
04489         XrlRespCallback);
04490 #endif
04491 
04492     XrlCmdRT handle_bgp_0_3_set_confederation_member(const XrlArgs& in, XrlCmdOT out);
04493 #ifdef XORP_ENABLE_ASYNC_SERVER
04494     void callback_bgp_0_3_set_confederation_member
04495        (const XrlCmdError &e,
04496         XrlRespCallback);
04497 #endif
04498 
04499     XrlCmdRT handle_bgp_0_3_set_prefix_limit(const XrlArgs& in, XrlCmdOT out);
04500 #ifdef XORP_ENABLE_ASYNC_SERVER
04501     void callback_bgp_0_3_set_prefix_limit
04502        (const XrlCmdError &e,
04503         XrlRespCallback);
04504 #endif
04505 
04506     XrlCmdRT handle_bgp_0_3_set_nexthop4(const XrlArgs& in, XrlCmdOT out);
04507 #ifdef XORP_ENABLE_ASYNC_SERVER
04508     void callback_bgp_0_3_set_nexthop4
04509        (const XrlCmdError &e,
04510         XrlRespCallback);
04511 #endif
04512 
04513     XrlCmdRT handle_bgp_0_3_set_peer_state(const XrlArgs& in, XrlCmdOT out);
04514 #ifdef XORP_ENABLE_ASYNC_SERVER
04515     void callback_bgp_0_3_set_peer_state
04516        (const XrlCmdError &e,
04517         XrlRespCallback);
04518 #endif
04519 
04520     XrlCmdRT handle_bgp_0_3_set_peer_md5_password(const XrlArgs& in, XrlCmdOT out);
04521 #ifdef XORP_ENABLE_ASYNC_SERVER
04522     void callback_bgp_0_3_set_peer_md5_password
04523        (const XrlCmdError &e,
04524         XrlRespCallback);
04525 #endif
04526 
04527     XrlCmdRT handle_bgp_0_3_activate(const XrlArgs& in, XrlCmdOT out);
04528 #ifdef XORP_ENABLE_ASYNC_SERVER
04529     void callback_bgp_0_3_activate
04530        (const XrlCmdError &e,
04531         XrlRespCallback);
04532 #endif
04533 
04534     XrlCmdRT handle_bgp_0_3_set_parameter(const XrlArgs& in, XrlCmdOT out);
04535 #ifdef XORP_ENABLE_ASYNC_SERVER
04536     void callback_bgp_0_3_set_parameter
04537        (const XrlCmdError &e,
04538         XrlRespCallback);
04539 #endif
04540 
04541     XrlCmdRT handle_bgp_0_3_next_hop_rewrite_filter(const XrlArgs& in, XrlCmdOT out);
04542 #ifdef XORP_ENABLE_ASYNC_SERVER
04543     void callback_bgp_0_3_next_hop_rewrite_filter
04544        (const XrlCmdError &e,
04545         XrlRespCallback);
04546 #endif
04547 
04548     XrlCmdRT handle_bgp_0_3_originate_route4(const XrlArgs& in, XrlCmdOT out);
04549 #ifdef XORP_ENABLE_ASYNC_SERVER
04550     void callback_bgp_0_3_originate_route4
04551        (const XrlCmdError &e,
04552         XrlRespCallback);
04553 #endif
04554 
04555     XrlCmdRT handle_bgp_0_3_withdraw_route4(const XrlArgs& in, XrlCmdOT out);
04556 #ifdef XORP_ENABLE_ASYNC_SERVER
04557     void callback_bgp_0_3_withdraw_route4
04558        (const XrlCmdError &e,
04559         XrlRespCallback);
04560 #endif
04561 
04562     XrlCmdRT handle_bgp_0_3_trace(const XrlArgs& in, XrlCmdOT out);
04563 #ifdef XORP_ENABLE_ASYNC_SERVER
04564     void callback_bgp_0_3_trace
04565        (const XrlCmdError &e,
04566         XrlRespCallback);
04567 #endif
04568 
04569     XrlCmdRT handle_bgp_0_3_get_peer_list_start(const XrlArgs& in, XrlCmdOT out);
04570 #ifdef XORP_ENABLE_ASYNC_SERVER
04571     void callback_bgp_0_3_get_peer_list_start
04572        (const XrlCmdError &e,
04573     const uint32_t* arg_token,
04574     const bool* arg_more,
04575         XrlRespCallback);
04576 #endif
04577 
04578     XrlCmdRT handle_bgp_0_3_get_peer_list_next(const XrlArgs& in, XrlCmdOT out);
04579 #ifdef XORP_ENABLE_ASYNC_SERVER
04580     void callback_bgp_0_3_get_peer_list_next
04581        (const XrlCmdError &e,
04582     const string* arg_local_ip,
04583     const uint32_t* arg_local_port,
04584     const string* arg_peer_ip,
04585     const uint32_t* arg_peer_port,
04586     const bool* arg_more,
04587         XrlRespCallback);
04588 #endif
04589 
04590     XrlCmdRT handle_bgp_0_3_get_peer_id(const XrlArgs& in, XrlCmdOT out);
04591 #ifdef XORP_ENABLE_ASYNC_SERVER
04592     void callback_bgp_0_3_get_peer_id
04593        (const XrlCmdError &e,
04594     const IPv4* arg_peer_id,
04595         XrlRespCallback);
04596 #endif
04597 
04598     XrlCmdRT handle_bgp_0_3_get_peer_status(const XrlArgs& in, XrlCmdOT out);
04599 #ifdef XORP_ENABLE_ASYNC_SERVER
04600     void callback_bgp_0_3_get_peer_status
04601        (const XrlCmdError &e,
04602     const uint32_t* arg_peer_state,
04603     const uint32_t* arg_admin_status,
04604         XrlRespCallback);
04605 #endif
04606 
04607     XrlCmdRT handle_bgp_0_3_get_peer_negotiated_version(const XrlArgs& in, XrlCmdOT out);
04608 #ifdef XORP_ENABLE_ASYNC_SERVER
04609     void callback_bgp_0_3_get_peer_negotiated_version
04610        (const XrlCmdError &e,
04611     const int32_t* arg_neg_version,
04612         XrlRespCallback);
04613 #endif
04614 
04615     XrlCmdRT handle_bgp_0_3_get_peer_as(const XrlArgs& in, XrlCmdOT out);
04616 #ifdef XORP_ENABLE_ASYNC_SERVER
04617     void callback_bgp_0_3_get_peer_as
04618        (const XrlCmdError &e,
04619     const string* arg_peer_as,
04620         XrlRespCallback);
04621 #endif
04622 
04623     XrlCmdRT handle_bgp_0_3_get_peer_msg_stats(const XrlArgs& in, XrlCmdOT out);
04624 #ifdef XORP_ENABLE_ASYNC_SERVER
04625     void callback_bgp_0_3_get_peer_msg_stats
04626        (const XrlCmdError &e,
04627     const uint32_t* arg_in_updates,
04628     const uint32_t* arg_out_updates,
04629     const uint32_t* arg_in_msgs,
04630     const uint32_t* arg_out_msgs,
04631     const uint32_t* arg_last_error,
04632     const uint32_t* arg_in_update_elapsed,
04633         XrlRespCallback);
04634 #endif
04635 
04636     XrlCmdRT handle_bgp_0_3_get_peer_established_stats(const XrlArgs& in, XrlCmdOT out);
04637 #ifdef XORP_ENABLE_ASYNC_SERVER
04638     void callback_bgp_0_3_get_peer_established_stats
04639        (const XrlCmdError &e,
04640     const uint32_t* arg_transitions,
04641     const uint32_t* arg_established_time,
04642         XrlRespCallback);
04643 #endif
04644 
04645     XrlCmdRT handle_bgp_0_3_get_peer_timer_config(const XrlArgs& in, XrlCmdOT out);
04646 #ifdef XORP_ENABLE_ASYNC_SERVER
04647     void callback_bgp_0_3_get_peer_timer_config
04648        (const XrlCmdError &e,
04649     const uint32_t* arg_retry_interval,
04650     const uint32_t* arg_hold_time,
04651     const uint32_t* arg_keep_alive,
04652     const uint32_t* arg_hold_time_conf,
04653     const uint32_t* arg_keep_alive_conf,
04654     const uint32_t* arg_min_as_orgination_interval,
04655     const uint32_t* arg_min_route_adv_interval,
04656         XrlRespCallback);
04657 #endif
04658 
04659     XrlCmdRT handle_bgp_0_3_register_rib(const XrlArgs& in, XrlCmdOT out);
04660 #ifdef XORP_ENABLE_ASYNC_SERVER
04661     void callback_bgp_0_3_register_rib
04662        (const XrlCmdError &e,
04663         XrlRespCallback);
04664 #endif
04665 
04666     XrlCmdRT handle_bgp_0_3_get_v4_route_list_start(const XrlArgs& in, XrlCmdOT out);
04667 #ifdef XORP_ENABLE_ASYNC_SERVER
04668     void callback_bgp_0_3_get_v4_route_list_start
04669        (const XrlCmdError &e,
04670     const uint32_t* arg_token,
04671         XrlRespCallback);
04672 #endif
04673 
04674     XrlCmdRT handle_bgp_0_3_get_v4_route_list_next(const XrlArgs& in, XrlCmdOT out);
04675 #ifdef XORP_ENABLE_ASYNC_SERVER
04676     void callback_bgp_0_3_get_v4_route_list_next
04677        (const XrlCmdError &e,
04678     const IPv4* arg_peer_id,
04679     const IPv4Net* arg_net,
04680     const uint32_t* arg_best_and_origin,
04681     const vector<uint8_t>* arg_aspath,
04682     const IPv4* arg_nexthop,
04683     const int32_t* arg_med,
04684     const int32_t* arg_localpref,
04685     const int32_t* arg_atomic_agg,
04686     const vector<uint8_t>* arg_aggregator,
04687     const int32_t* arg_calc_localpref,
04688     const vector<uint8_t>* arg_attr_unknown,
04689     const bool* arg_valid,
04690     const bool* arg_unicast,
04691     const bool* arg_multicast,
04692         XrlRespCallback);
04693 #endif
04694 
04695     XrlCmdRT handle_bgp_0_3_set_nexthop6(const XrlArgs& in, XrlCmdOT out);
04696 #ifdef XORP_ENABLE_ASYNC_SERVER
04697     void callback_bgp_0_3_set_nexthop6
04698        (const XrlCmdError &e,
04699         XrlRespCallback);
04700 #endif
04701 
04702     XrlCmdRT handle_bgp_0_3_get_nexthop6(const XrlArgs& in, XrlCmdOT out);
04703 #ifdef XORP_ENABLE_ASYNC_SERVER
04704     void callback_bgp_0_3_get_nexthop6
04705        (const XrlCmdError &e,
04706     const IPv6* arg_next_hop,
04707         XrlRespCallback);
04708 #endif
04709 
04710     XrlCmdRT handle_bgp_0_3_withdraw_route6(const XrlArgs& in, XrlCmdOT out);
04711 #ifdef XORP_ENABLE_ASYNC_SERVER
04712     void callback_bgp_0_3_withdraw_route6
04713        (const XrlCmdError &e,
04714         XrlRespCallback);
04715 #endif
04716 
04717     XrlCmdRT handle_bgp_0_3_get_v6_route_list_start(const XrlArgs& in, XrlCmdOT out);
04718 #ifdef XORP_ENABLE_ASYNC_SERVER
04719     void callback_bgp_0_3_get_v6_route_list_start
04720        (const XrlCmdError &e,
04721     const uint32_t* arg_token,
04722         XrlRespCallback);
04723 #endif
04724 
04725     XrlCmdRT handle_bgp_0_3_originate_route6(const XrlArgs& in, XrlCmdOT out);
04726 #ifdef XORP_ENABLE_ASYNC_SERVER
04727     void callback_bgp_0_3_originate_route6
04728        (const XrlCmdError &e,
04729         XrlRespCallback);
04730 #endif
04731 
04732     XrlCmdRT handle_bgp_0_3_get_v6_route_list_next(const XrlArgs& in, XrlCmdOT out);
04733 #ifdef XORP_ENABLE_ASYNC_SERVER
04734     void callback_bgp_0_3_get_v6_route_list_next
04735        (const XrlCmdError &e,
04736     const IPv4* arg_peer_id,
04737     const IPv6Net* arg_net,
04738     const uint32_t* arg_best_and_origin,
04739     const vector<uint8_t>* arg_aspath,
04740     const IPv6* arg_nexthop,
04741     const int32_t* arg_med,
04742     const int32_t* arg_localpref,
04743     const int32_t* arg_atomic_agg,
04744     const vector<uint8_t>* arg_aggregator,
04745     const int32_t* arg_calc_localpref,
04746     const vector<uint8_t>* arg_attr_unknown,
04747     const bool* arg_valid,
04748     const bool* arg_unicast,
04749     const bool* arg_multicast,
04750         XrlRespCallback);
04751 #endif
04752 
04753     XrlCmdRT handle_finder_event_observer_0_1_xrl_target_birth(const XrlArgs& in, XrlCmdOT out);
04754 #ifdef XORP_ENABLE_ASYNC_SERVER
04755     void callback_finder_event_observer_0_1_xrl_target_birth
04756        (const XrlCmdError &e,
04757         XrlRespCallback);
04758 #endif
04759 
04760     XrlCmdRT handle_finder_event_observer_0_1_xrl_target_death(const XrlArgs& in, XrlCmdOT out);
04761 #ifdef XORP_ENABLE_ASYNC_SERVER
04762     void callback_finder_event_observer_0_1_xrl_target_death
04763        (const XrlCmdError &e,
04764         XrlRespCallback);
04765 #endif
04766 
04767     XrlCmdRT handle_policy_backend_0_1_configure(const XrlArgs& in, XrlCmdOT out);
04768 #ifdef XORP_ENABLE_ASYNC_SERVER
04769     void callback_policy_backend_0_1_configure
04770        (const XrlCmdError &e,
04771         XrlRespCallback);
04772 #endif
04773 
04774     XrlCmdRT handle_policy_backend_0_1_reset(const XrlArgs& in, XrlCmdOT out);
04775 #ifdef XORP_ENABLE_ASYNC_SERVER
04776     void callback_policy_backend_0_1_reset
04777        (const XrlCmdError &e,
04778         XrlRespCallback);
04779 #endif
04780 
04781     XrlCmdRT handle_policy_backend_0_1_push_routes(const XrlArgs& in, XrlCmdOT out);
04782 #ifdef XORP_ENABLE_ASYNC_SERVER
04783     void callback_policy_backend_0_1_push_routes
04784        (const XrlCmdError &e,
04785         XrlRespCallback);
04786 #endif
04787 
04788     XrlCmdRT handle_policy_redist4_0_1_add_route4(const XrlArgs& in, XrlCmdOT out);
04789 #ifdef XORP_ENABLE_ASYNC_SERVER
04790     void callback_policy_redist4_0_1_add_route4
04791        (const XrlCmdError &e,
04792         XrlRespCallback);
04793 #endif
04794 
04795     XrlCmdRT handle_policy_redist4_0_1_delete_route4(const XrlArgs& in, XrlCmdOT out);
04796 #ifdef XORP_ENABLE_ASYNC_SERVER
04797     void callback_policy_redist4_0_1_delete_route4
04798        (const XrlCmdError &e,
04799         XrlRespCallback);
04800 #endif
04801 
04802     XrlCmdRT handle_rib_client_0_1_route_info_changed4(const XrlArgs& in, XrlCmdOT out);
04803 #ifdef XORP_ENABLE_ASYNC_SERVER
04804     void callback_rib_client_0_1_route_info_changed4
04805        (const XrlCmdError &e,
04806         XrlRespCallback);
04807 #endif
04808 
04809     XrlCmdRT handle_rib_client_0_1_route_info_invalid4(const XrlArgs& in, XrlCmdOT out);
04810 #ifdef XORP_ENABLE_ASYNC_SERVER
04811     void callback_rib_client_0_1_route_info_invalid4
04812        (const XrlCmdError &e,
04813         XrlRespCallback);
04814 #endif
04815 
04816     XrlCmdRT handle_rib_client_0_1_route_info_changed6(const XrlArgs& in, XrlCmdOT out);
04817 #ifdef XORP_ENABLE_ASYNC_SERVER
04818     void callback_rib_client_0_1_route_info_changed6
04819        (const XrlCmdError &e,
04820         XrlRespCallback);
04821 #endif
04822 
04823     XrlCmdRT handle_rib_client_0_1_route_info_invalid6(const XrlArgs& in, XrlCmdOT out);
04824 #ifdef XORP_ENABLE_ASYNC_SERVER
04825     void callback_rib_client_0_1_route_info_invalid6
04826        (const XrlCmdError &e,
04827         XrlRespCallback);
04828 #endif
04829 
04830     XrlCmdRT handle_policy_redist6_0_1_add_route6(const XrlArgs& in, XrlCmdOT out);
04831 #ifdef XORP_ENABLE_ASYNC_SERVER
04832     void callback_policy_redist6_0_1_add_route6
04833        (const XrlCmdError &e,
04834         XrlRespCallback);
04835 #endif
04836 
04837     XrlCmdRT handle_policy_redist6_0_1_delete_route6(const XrlArgs& in, XrlCmdOT out);
04838 #ifdef XORP_ENABLE_ASYNC_SERVER
04839     void callback_policy_redist6_0_1_delete_route6
04840        (const XrlCmdError &e,
04841         XrlRespCallback);
04842 #endif
04843 
04844     XrlCmdRT handle_profile_0_1_enable(const XrlArgs& in, XrlCmdOT out);
04845 #ifdef XORP_ENABLE_ASYNC_SERVER
04846     void callback_profile_0_1_enable
04847        (const XrlCmdError &e,
04848         XrlRespCallback);
04849 #endif
04850 
04851     XrlCmdRT handle_profile_0_1_disable(const XrlArgs& in, XrlCmdOT out);
04852 #ifdef XORP_ENABLE_ASYNC_SERVER
04853     void callback_profile_0_1_disable
04854        (const XrlCmdError &e,
04855         XrlRespCallback);
04856 #endif
04857 
04858     XrlCmdRT handle_profile_0_1_get_entries(const XrlArgs& in, XrlCmdOT out);
04859 #ifdef XORP_ENABLE_ASYNC_SERVER
04860     void callback_profile_0_1_get_entries
04861        (const XrlCmdError &e,
04862         XrlRespCallback);
04863 #endif
04864 
04865     XrlCmdRT handle_profile_0_1_clear(const XrlArgs& in, XrlCmdOT out);
04866 #ifdef XORP_ENABLE_ASYNC_SERVER
04867     void callback_profile_0_1_clear
04868        (const XrlCmdError &e,
04869         XrlRespCallback);
04870 #endif
04871 
04872     XrlCmdRT handle_profile_0_1_list(const XrlArgs& in, XrlCmdOT out);
04873 #ifdef XORP_ENABLE_ASYNC_SERVER
04874     void callback_profile_0_1_list
04875        (const XrlCmdError &e,
04876     const string* arg_info,
04877         XrlRespCallback);
04878 #endif
04879 
04880     void add_handlers();
04881     void remove_handlers();
04882 
04883     struct handler_table {
04884         const char *name;
04885         XrlCmdRT (XrlBgpTargetBase::*method)(const XrlArgs&, XrlCmdOT);
04886     };
04887 
04888     static const struct handler_table handlers[];
04889     static const size_t num_handlers;
04890 };
04891 
04892 #endif // __XRL_TARGETS_BGP_BASE_HH__
 All Classes Namespaces Functions Variables Typedefs Enumerations