xorp

mfea_base.hh

00001 /*
00002  * obj/i386-pc-mingw32/xrl/targets/mfea_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_MFEA_BASE_HH__
00016 #define __XRL_TARGETS_MFEA_BASE_HH__
00017 
00018 #undef XORP_LIBRARY_NAME
00019 #define XORP_LIBRARY_NAME "XrlMfeaTarget"
00020 
00021 #include "libxorp/xlog.h"
00022 #include "libxipc/xrl_cmd_map.hh"
00023 
00024 class XrlMfeaTargetBase {
00025 protected:
00026     XrlCmdMap* _cmds;
00027 
00028 public:
00036     XrlMfeaTargetBase(XrlCmdMap* cmds = 0);
00037 
00043     virtual ~XrlMfeaTargetBase();
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 "mfea/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 
00353     virtual XrlCmdError cli_processor_0_1_process_command(
00354     // Input values,
00355     const string&   processor_name,
00356     const string&   cli_term_name,
00357     const uint32_t& cli_session_id,
00358     const string&   command_name,
00359     const string&   command_args,
00360     // Output values,
00361     string& ret_processor_name,
00362     string& ret_cli_term_name,
00363     uint32_t&   ret_cli_session_id,
00364     string& ret_command_output) = 0;
00365 #ifdef XORP_ENABLE_ASYNC_SERVER
00366     typedef
00367     XorpCallback5<void, const XrlCmdError &,
00368     const string*,
00369     const string*,
00370     const uint32_t*,
00371     const string*>::RefPtr
00372     CliProcessor01ProcessCommandRF;
00373 
00374     class CliProcessor01ProcessCommandCB {
00375         CliProcessor01ProcessCommandRF cb;
00376 
00377     public:
00378         operator const CliProcessor01ProcessCommandRF& () const { return cb; }
00379         const CliProcessor01ProcessCommandRF& operator ->() const { return cb; }
00380         CliProcessor01ProcessCommandCB(const CliProcessor01ProcessCommandRF& cb)
00381           : cb(cb) { }
00382 
00383         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL); }
00384 
00385         void respond(const string& arg_ret_processor_name,
00386                      const string& arg_ret_cli_term_name,
00387                      const uint32_t& arg_ret_cli_session_id,
00388                      const string& arg_ret_command_output) const {
00389             cb->dispatch(XrlCmdError::OKAY(),
00390                          &arg_ret_processor_name,
00391                          &arg_ret_cli_term_name,
00392                          &arg_ret_cli_session_id,
00393                          &arg_ret_command_output);
00394         }
00395     };
00396 
00397     struct CliProcessor01ProcessCommandRsp :
00398       public CliProcessor01ProcessCommandCB {
00399         struct args_str {
00400             string ret_processor_name;
00401             string ret_cli_term_name;
00402             uint32_t ret_cli_session_id;
00403             string ret_command_output;
00404         };
00405 
00406     private:
00407         args_str args;
00408 
00409     public:
00410         CliProcessor01ProcessCommandRsp(const CliProcessor01ProcessCommandRF& cb)
00411           : CliProcessor01ProcessCommandCB(cb) { }
00412 
00413         void respond() const {
00414             CliProcessor01ProcessCommandCB::
00415             respond(args.ret_processor_name,
00416                         args.ret_cli_term_name,
00417                         args.ret_cli_session_id,
00418                         args.ret_command_output);
00419         }
00420 
00421         args_str* operator ->() {
00422             return &args;
00423         }
00424     };
00425 
00426     virtual void async_cli_processor_0_1_process_command
00427        (
00428     const string&   processor_name,
00429     const string&   cli_term_name,
00430     const uint32_t& cli_session_id,
00431     const string&   command_name,
00432     const string&   command_args,
00433     CliProcessor01ProcessCommandCB);
00434 #endif
00435 
00441     virtual XrlCmdError ifmgr_replicator_0_1_register_ifmgr_mirror(
00442     // Input values,
00443     const string&   clientname) = 0;
00444 #ifdef XORP_ENABLE_ASYNC_SERVER
00445     typedef
00446     XorpCallback1<void, const XrlCmdError &>::RefPtr
00447     IfmgrReplicator01RegisterIfmgrMirrorRF;
00448 
00449     class IfmgrReplicator01RegisterIfmgrMirrorCB {
00450         IfmgrReplicator01RegisterIfmgrMirrorRF cb;
00451 
00452     public:
00453         operator const IfmgrReplicator01RegisterIfmgrMirrorRF& () const { return cb; }
00454         const IfmgrReplicator01RegisterIfmgrMirrorRF& operator ->() const { return cb; }
00455         IfmgrReplicator01RegisterIfmgrMirrorCB(const IfmgrReplicator01RegisterIfmgrMirrorRF& cb)
00456           : cb(cb) { }
00457 
00458         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00459 
00460         void respond() const {
00461             cb->dispatch(XrlCmdError::OKAY());
00462         }
00463     };
00464 
00465     struct IfmgrReplicator01RegisterIfmgrMirrorRsp :
00466       public IfmgrReplicator01RegisterIfmgrMirrorCB {
00467         IfmgrReplicator01RegisterIfmgrMirrorRsp(const IfmgrReplicator01RegisterIfmgrMirrorRF& cb)
00468           : IfmgrReplicator01RegisterIfmgrMirrorCB(cb) { }
00469 
00470     };
00471 
00472     virtual void async_ifmgr_replicator_0_1_register_ifmgr_mirror
00473        (
00474     const string&   clientname,
00475     IfmgrReplicator01RegisterIfmgrMirrorCB);
00476 #endif
00477 
00483     virtual XrlCmdError ifmgr_replicator_0_1_unregister_ifmgr_mirror(
00484     // Input values,
00485     const string&   clientname) = 0;
00486 #ifdef XORP_ENABLE_ASYNC_SERVER
00487     typedef
00488     XorpCallback1<void, const XrlCmdError &>::RefPtr
00489     IfmgrReplicator01UnregisterIfmgrMirrorRF;
00490 
00491     class IfmgrReplicator01UnregisterIfmgrMirrorCB {
00492         IfmgrReplicator01UnregisterIfmgrMirrorRF cb;
00493 
00494     public:
00495         operator const IfmgrReplicator01UnregisterIfmgrMirrorRF& () const { return cb; }
00496         const IfmgrReplicator01UnregisterIfmgrMirrorRF& operator ->() const { return cb; }
00497         IfmgrReplicator01UnregisterIfmgrMirrorCB(const IfmgrReplicator01UnregisterIfmgrMirrorRF& cb)
00498           : cb(cb) { }
00499 
00500         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00501 
00502         void respond() const {
00503             cb->dispatch(XrlCmdError::OKAY());
00504         }
00505     };
00506 
00507     struct IfmgrReplicator01UnregisterIfmgrMirrorRsp :
00508       public IfmgrReplicator01UnregisterIfmgrMirrorCB {
00509         IfmgrReplicator01UnregisterIfmgrMirrorRsp(const IfmgrReplicator01UnregisterIfmgrMirrorRF& cb)
00510           : IfmgrReplicator01UnregisterIfmgrMirrorCB(cb) { }
00511 
00512     };
00513 
00514     virtual void async_ifmgr_replicator_0_1_unregister_ifmgr_mirror
00515        (
00516     const string&   clientname,
00517     IfmgrReplicator01UnregisterIfmgrMirrorCB);
00518 #endif
00519 
00529     virtual XrlCmdError finder_event_observer_0_1_xrl_target_birth(
00530     // Input values,
00531     const string&   target_class,
00532     const string&   target_instance) = 0;
00533 #ifdef XORP_ENABLE_ASYNC_SERVER
00534     typedef
00535     XorpCallback1<void, const XrlCmdError &>::RefPtr
00536     FinderEventObserver01XrlTargetBirthRF;
00537 
00538     class FinderEventObserver01XrlTargetBirthCB {
00539         FinderEventObserver01XrlTargetBirthRF cb;
00540 
00541     public:
00542         operator const FinderEventObserver01XrlTargetBirthRF& () const { return cb; }
00543         const FinderEventObserver01XrlTargetBirthRF& operator ->() const { return cb; }
00544         FinderEventObserver01XrlTargetBirthCB(const FinderEventObserver01XrlTargetBirthRF& cb)
00545           : cb(cb) { }
00546 
00547         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00548 
00549         void respond() const {
00550             cb->dispatch(XrlCmdError::OKAY());
00551         }
00552     };
00553 
00554     struct FinderEventObserver01XrlTargetBirthRsp :
00555       public FinderEventObserver01XrlTargetBirthCB {
00556         FinderEventObserver01XrlTargetBirthRsp(const FinderEventObserver01XrlTargetBirthRF& cb)
00557           : FinderEventObserver01XrlTargetBirthCB(cb) { }
00558 
00559     };
00560 
00561     virtual void async_finder_event_observer_0_1_xrl_target_birth
00562        (
00563     const string&   target_class,
00564     const string&   target_instance,
00565     FinderEventObserver01XrlTargetBirthCB);
00566 #endif
00567 
00577     virtual XrlCmdError finder_event_observer_0_1_xrl_target_death(
00578     // Input values,
00579     const string&   target_class,
00580     const string&   target_instance) = 0;
00581 #ifdef XORP_ENABLE_ASYNC_SERVER
00582     typedef
00583     XorpCallback1<void, const XrlCmdError &>::RefPtr
00584     FinderEventObserver01XrlTargetDeathRF;
00585 
00586     class FinderEventObserver01XrlTargetDeathCB {
00587         FinderEventObserver01XrlTargetDeathRF cb;
00588 
00589     public:
00590         operator const FinderEventObserver01XrlTargetDeathRF& () const { return cb; }
00591         const FinderEventObserver01XrlTargetDeathRF& operator ->() const { return cb; }
00592         FinderEventObserver01XrlTargetDeathCB(const FinderEventObserver01XrlTargetDeathRF& cb)
00593           : cb(cb) { }
00594 
00595         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00596 
00597         void respond() const {
00598             cb->dispatch(XrlCmdError::OKAY());
00599         }
00600     };
00601 
00602     struct FinderEventObserver01XrlTargetDeathRsp :
00603       public FinderEventObserver01XrlTargetDeathCB {
00604         FinderEventObserver01XrlTargetDeathRsp(const FinderEventObserver01XrlTargetDeathRF& cb)
00605           : FinderEventObserver01XrlTargetDeathCB(cb) { }
00606 
00607     };
00608 
00609     virtual void async_finder_event_observer_0_1_xrl_target_death
00610        (
00611     const string&   target_class,
00612     const string&   target_instance,
00613     FinderEventObserver01XrlTargetDeathCB);
00614 #endif
00615 
00624     virtual XrlCmdError mfea_0_1_have_multicast_routing4(
00625     // Output values,
00626     bool&   result) = 0;
00627 #ifdef XORP_ENABLE_ASYNC_SERVER
00628     typedef
00629     XorpCallback2<void, const XrlCmdError &,
00630     const bool*>::RefPtr
00631     Mfea01HaveMulticastRouting4RF;
00632 
00633     class Mfea01HaveMulticastRouting4CB {
00634         Mfea01HaveMulticastRouting4RF cb;
00635 
00636     public:
00637         operator const Mfea01HaveMulticastRouting4RF& () const { return cb; }
00638         const Mfea01HaveMulticastRouting4RF& operator ->() const { return cb; }
00639         Mfea01HaveMulticastRouting4CB(const Mfea01HaveMulticastRouting4RF& cb)
00640           : cb(cb) { }
00641 
00642         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00643 
00644         void respond(const bool& arg_result) const {
00645             cb->dispatch(XrlCmdError::OKAY(),
00646                          &arg_result);
00647         }
00648     };
00649 
00650     struct Mfea01HaveMulticastRouting4Rsp :
00651       public Mfea01HaveMulticastRouting4CB {
00652         struct args_str {
00653             bool result;
00654         };
00655 
00656     private:
00657         args_str args;
00658 
00659     public:
00660         Mfea01HaveMulticastRouting4Rsp(const Mfea01HaveMulticastRouting4RF& cb)
00661           : Mfea01HaveMulticastRouting4CB(cb) { }
00662 
00663         void respond() const {
00664             Mfea01HaveMulticastRouting4CB::
00665             respond(args.result);
00666         }
00667 
00668         args_str* operator ->() {
00669             return &args;
00670         }
00671     };
00672 
00673     virtual void async_mfea_0_1_have_multicast_routing4
00674        (
00675     Mfea01HaveMulticastRouting4CB);
00676 #endif
00677 
00695     virtual XrlCmdError mfea_0_1_register_protocol4(
00696     // Input values,
00697     const string&   xrl_sender_name,
00698     const string&   if_name,
00699     const string&   vif_name,
00700     const uint32_t& ip_protocol) = 0;
00701 #ifdef XORP_ENABLE_ASYNC_SERVER
00702     typedef
00703     XorpCallback1<void, const XrlCmdError &>::RefPtr
00704     Mfea01RegisterProtocol4RF;
00705 
00706     class Mfea01RegisterProtocol4CB {
00707         Mfea01RegisterProtocol4RF cb;
00708 
00709     public:
00710         operator const Mfea01RegisterProtocol4RF& () const { return cb; }
00711         const Mfea01RegisterProtocol4RF& operator ->() const { return cb; }
00712         Mfea01RegisterProtocol4CB(const Mfea01RegisterProtocol4RF& cb)
00713           : cb(cb) { }
00714 
00715         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00716 
00717         void respond() const {
00718             cb->dispatch(XrlCmdError::OKAY());
00719         }
00720     };
00721 
00722     struct Mfea01RegisterProtocol4Rsp :
00723       public Mfea01RegisterProtocol4CB {
00724         Mfea01RegisterProtocol4Rsp(const Mfea01RegisterProtocol4RF& cb)
00725           : Mfea01RegisterProtocol4CB(cb) { }
00726 
00727     };
00728 
00729     virtual void async_mfea_0_1_register_protocol4
00730        (
00731     const string&   xrl_sender_name,
00732     const string&   if_name,
00733     const string&   vif_name,
00734     const uint32_t& ip_protocol,
00735     Mfea01RegisterProtocol4CB);
00736 #endif
00737 
00752     virtual XrlCmdError mfea_0_1_unregister_protocol4(
00753     // Input values,
00754     const string&   xrl_sender_name,
00755     const string&   if_name,
00756     const string&   vif_name) = 0;
00757 #ifdef XORP_ENABLE_ASYNC_SERVER
00758     typedef
00759     XorpCallback1<void, const XrlCmdError &>::RefPtr
00760     Mfea01UnregisterProtocol4RF;
00761 
00762     class Mfea01UnregisterProtocol4CB {
00763         Mfea01UnregisterProtocol4RF cb;
00764 
00765     public:
00766         operator const Mfea01UnregisterProtocol4RF& () const { return cb; }
00767         const Mfea01UnregisterProtocol4RF& operator ->() const { return cb; }
00768         Mfea01UnregisterProtocol4CB(const Mfea01UnregisterProtocol4RF& cb)
00769           : cb(cb) { }
00770 
00771         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00772 
00773         void respond() const {
00774             cb->dispatch(XrlCmdError::OKAY());
00775         }
00776     };
00777 
00778     struct Mfea01UnregisterProtocol4Rsp :
00779       public Mfea01UnregisterProtocol4CB {
00780         Mfea01UnregisterProtocol4Rsp(const Mfea01UnregisterProtocol4RF& cb)
00781           : Mfea01UnregisterProtocol4CB(cb) { }
00782 
00783     };
00784 
00785     virtual void async_mfea_0_1_unregister_protocol4
00786        (
00787     const string&   xrl_sender_name,
00788     const string&   if_name,
00789     const string&   vif_name,
00790     Mfea01UnregisterProtocol4CB);
00791 #endif
00792 
00817     virtual XrlCmdError mfea_0_1_add_mfc4(
00818     // Input values,
00819     const string&   xrl_sender_name,
00820     const IPv4& source_address,
00821     const IPv4& group_address,
00822     const uint32_t& iif_vif_index,
00823     const vector<uint8_t>&  oiflist,
00824     const vector<uint8_t>&  oiflist_disable_wrongvif,
00825     const uint32_t& max_vifs_oiflist,
00826     const IPv4& rp_address) = 0;
00827 #ifdef XORP_ENABLE_ASYNC_SERVER
00828     typedef
00829     XorpCallback1<void, const XrlCmdError &>::RefPtr
00830     Mfea01AddMfc4RF;
00831 
00832     class Mfea01AddMfc4CB {
00833         Mfea01AddMfc4RF cb;
00834 
00835     public:
00836         operator const Mfea01AddMfc4RF& () const { return cb; }
00837         const Mfea01AddMfc4RF& operator ->() const { return cb; }
00838         Mfea01AddMfc4CB(const Mfea01AddMfc4RF& cb)
00839           : cb(cb) { }
00840 
00841         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00842 
00843         void respond() const {
00844             cb->dispatch(XrlCmdError::OKAY());
00845         }
00846     };
00847 
00848     struct Mfea01AddMfc4Rsp :
00849       public Mfea01AddMfc4CB {
00850         Mfea01AddMfc4Rsp(const Mfea01AddMfc4RF& cb)
00851           : Mfea01AddMfc4CB(cb) { }
00852 
00853     };
00854 
00855     virtual void async_mfea_0_1_add_mfc4
00856        (
00857     const string&   xrl_sender_name,
00858     const IPv4& source_address,
00859     const IPv4& group_address,
00860     const uint32_t& iif_vif_index,
00861     const vector<uint8_t>&  oiflist,
00862     const vector<uint8_t>&  oiflist_disable_wrongvif,
00863     const uint32_t& max_vifs_oiflist,
00864     const IPv4& rp_address,
00865     Mfea01AddMfc4CB);
00866 #endif
00867 
00868     virtual XrlCmdError mfea_0_1_delete_mfc4(
00869     // Input values,
00870     const string&   xrl_sender_name,
00871     const IPv4& source_address,
00872     const IPv4& group_address) = 0;
00873 #ifdef XORP_ENABLE_ASYNC_SERVER
00874     typedef
00875     XorpCallback1<void, const XrlCmdError &>::RefPtr
00876     Mfea01DeleteMfc4RF;
00877 
00878     class Mfea01DeleteMfc4CB {
00879         Mfea01DeleteMfc4RF cb;
00880 
00881     public:
00882         operator const Mfea01DeleteMfc4RF& () const { return cb; }
00883         const Mfea01DeleteMfc4RF& operator ->() const { return cb; }
00884         Mfea01DeleteMfc4CB(const Mfea01DeleteMfc4RF& cb)
00885           : cb(cb) { }
00886 
00887         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00888 
00889         void respond() const {
00890             cb->dispatch(XrlCmdError::OKAY());
00891         }
00892     };
00893 
00894     struct Mfea01DeleteMfc4Rsp :
00895       public Mfea01DeleteMfc4CB {
00896         Mfea01DeleteMfc4Rsp(const Mfea01DeleteMfc4RF& cb)
00897           : Mfea01DeleteMfc4CB(cb) { }
00898 
00899     };
00900 
00901     virtual void async_mfea_0_1_delete_mfc4
00902        (
00903     const string&   xrl_sender_name,
00904     const IPv4& source_address,
00905     const IPv4& group_address,
00906     Mfea01DeleteMfc4CB);
00907 #endif
00908 
00942     virtual XrlCmdError mfea_0_1_add_dataflow_monitor4(
00943     // Input values,
00944     const string&   xrl_sender_name,
00945     const IPv4& source_address,
00946     const IPv4& group_address,
00947     const uint32_t& threshold_interval_sec,
00948     const uint32_t& threshold_interval_usec,
00949     const uint32_t& threshold_packets,
00950     const uint32_t& threshold_bytes,
00951     const bool& is_threshold_in_packets,
00952     const bool& is_threshold_in_bytes,
00953     const bool& is_geq_upcall,
00954     const bool& is_leq_upcall) = 0;
00955 #ifdef XORP_ENABLE_ASYNC_SERVER
00956     typedef
00957     XorpCallback1<void, const XrlCmdError &>::RefPtr
00958     Mfea01AddDataflowMonitor4RF;
00959 
00960     class Mfea01AddDataflowMonitor4CB {
00961         Mfea01AddDataflowMonitor4RF cb;
00962 
00963     public:
00964         operator const Mfea01AddDataflowMonitor4RF& () const { return cb; }
00965         const Mfea01AddDataflowMonitor4RF& operator ->() const { return cb; }
00966         Mfea01AddDataflowMonitor4CB(const Mfea01AddDataflowMonitor4RF& cb)
00967           : cb(cb) { }
00968 
00969         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00970 
00971         void respond() const {
00972             cb->dispatch(XrlCmdError::OKAY());
00973         }
00974     };
00975 
00976     struct Mfea01AddDataflowMonitor4Rsp :
00977       public Mfea01AddDataflowMonitor4CB {
00978         Mfea01AddDataflowMonitor4Rsp(const Mfea01AddDataflowMonitor4RF& cb)
00979           : Mfea01AddDataflowMonitor4CB(cb) { }
00980 
00981     };
00982 
00983     virtual void async_mfea_0_1_add_dataflow_monitor4
00984        (
00985     const string&   xrl_sender_name,
00986     const IPv4& source_address,
00987     const IPv4& group_address,
00988     const uint32_t& threshold_interval_sec,
00989     const uint32_t& threshold_interval_usec,
00990     const uint32_t& threshold_packets,
00991     const uint32_t& threshold_bytes,
00992     const bool& is_threshold_in_packets,
00993     const bool& is_threshold_in_bytes,
00994     const bool& is_geq_upcall,
00995     const bool& is_leq_upcall,
00996     Mfea01AddDataflowMonitor4CB);
00997 #endif
00998 
00999     virtual XrlCmdError mfea_0_1_delete_dataflow_monitor4(
01000     // Input values,
01001     const string&   xrl_sender_name,
01002     const IPv4& source_address,
01003     const IPv4& group_address,
01004     const uint32_t& threshold_interval_sec,
01005     const uint32_t& threshold_interval_usec,
01006     const uint32_t& threshold_packets,
01007     const uint32_t& threshold_bytes,
01008     const bool& is_threshold_in_packets,
01009     const bool& is_threshold_in_bytes,
01010     const bool& is_geq_upcall,
01011     const bool& is_leq_upcall) = 0;
01012 #ifdef XORP_ENABLE_ASYNC_SERVER
01013     typedef
01014     XorpCallback1<void, const XrlCmdError &>::RefPtr
01015     Mfea01DeleteDataflowMonitor4RF;
01016 
01017     class Mfea01DeleteDataflowMonitor4CB {
01018         Mfea01DeleteDataflowMonitor4RF cb;
01019 
01020     public:
01021         operator const Mfea01DeleteDataflowMonitor4RF& () const { return cb; }
01022         const Mfea01DeleteDataflowMonitor4RF& operator ->() const { return cb; }
01023         Mfea01DeleteDataflowMonitor4CB(const Mfea01DeleteDataflowMonitor4RF& cb)
01024           : cb(cb) { }
01025 
01026         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01027 
01028         void respond() const {
01029             cb->dispatch(XrlCmdError::OKAY());
01030         }
01031     };
01032 
01033     struct Mfea01DeleteDataflowMonitor4Rsp :
01034       public Mfea01DeleteDataflowMonitor4CB {
01035         Mfea01DeleteDataflowMonitor4Rsp(const Mfea01DeleteDataflowMonitor4RF& cb)
01036           : Mfea01DeleteDataflowMonitor4CB(cb) { }
01037 
01038     };
01039 
01040     virtual void async_mfea_0_1_delete_dataflow_monitor4
01041        (
01042     const string&   xrl_sender_name,
01043     const IPv4& source_address,
01044     const IPv4& group_address,
01045     const uint32_t& threshold_interval_sec,
01046     const uint32_t& threshold_interval_usec,
01047     const uint32_t& threshold_packets,
01048     const uint32_t& threshold_bytes,
01049     const bool& is_threshold_in_packets,
01050     const bool& is_threshold_in_bytes,
01051     const bool& is_geq_upcall,
01052     const bool& is_leq_upcall,
01053     Mfea01DeleteDataflowMonitor4CB);
01054 #endif
01055 
01056     virtual XrlCmdError mfea_0_1_delete_all_dataflow_monitor4(
01057     // Input values,
01058     const string&   xrl_sender_name,
01059     const IPv4& source_address,
01060     const IPv4& group_address) = 0;
01061 #ifdef XORP_ENABLE_ASYNC_SERVER
01062     typedef
01063     XorpCallback1<void, const XrlCmdError &>::RefPtr
01064     Mfea01DeleteAllDataflowMonitor4RF;
01065 
01066     class Mfea01DeleteAllDataflowMonitor4CB {
01067         Mfea01DeleteAllDataflowMonitor4RF cb;
01068 
01069     public:
01070         operator const Mfea01DeleteAllDataflowMonitor4RF& () const { return cb; }
01071         const Mfea01DeleteAllDataflowMonitor4RF& operator ->() const { return cb; }
01072         Mfea01DeleteAllDataflowMonitor4CB(const Mfea01DeleteAllDataflowMonitor4RF& cb)
01073           : cb(cb) { }
01074 
01075         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01076 
01077         void respond() const {
01078             cb->dispatch(XrlCmdError::OKAY());
01079         }
01080     };
01081 
01082     struct Mfea01DeleteAllDataflowMonitor4Rsp :
01083       public Mfea01DeleteAllDataflowMonitor4CB {
01084         Mfea01DeleteAllDataflowMonitor4Rsp(const Mfea01DeleteAllDataflowMonitor4RF& cb)
01085           : Mfea01DeleteAllDataflowMonitor4CB(cb) { }
01086 
01087     };
01088 
01089     virtual void async_mfea_0_1_delete_all_dataflow_monitor4
01090        (
01091     const string&   xrl_sender_name,
01092     const IPv4& source_address,
01093     const IPv4& group_address,
01094     Mfea01DeleteAllDataflowMonitor4CB);
01095 #endif
01096 
01106     virtual XrlCmdError mfea_0_1_enable_vif(
01107     // Input values,
01108     const string&   vif_name,
01109     const bool& enable) = 0;
01110 #ifdef XORP_ENABLE_ASYNC_SERVER
01111     typedef
01112     XorpCallback1<void, const XrlCmdError &>::RefPtr
01113     Mfea01EnableVifRF;
01114 
01115     class Mfea01EnableVifCB {
01116         Mfea01EnableVifRF cb;
01117 
01118     public:
01119         operator const Mfea01EnableVifRF& () const { return cb; }
01120         const Mfea01EnableVifRF& operator ->() const { return cb; }
01121         Mfea01EnableVifCB(const Mfea01EnableVifRF& cb)
01122           : cb(cb) { }
01123 
01124         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01125 
01126         void respond() const {
01127             cb->dispatch(XrlCmdError::OKAY());
01128         }
01129     };
01130 
01131     struct Mfea01EnableVifRsp :
01132       public Mfea01EnableVifCB {
01133         Mfea01EnableVifRsp(const Mfea01EnableVifRF& cb)
01134           : Mfea01EnableVifCB(cb) { }
01135 
01136     };
01137 
01138     virtual void async_mfea_0_1_enable_vif
01139        (
01140     const string&   vif_name,
01141     const bool& enable,
01142     Mfea01EnableVifCB);
01143 #endif
01144 
01145     virtual XrlCmdError mfea_0_1_start_vif(
01146     // Input values,
01147     const string&   vif_name) = 0;
01148 #ifdef XORP_ENABLE_ASYNC_SERVER
01149     typedef
01150     XorpCallback1<void, const XrlCmdError &>::RefPtr
01151     Mfea01StartVifRF;
01152 
01153     class Mfea01StartVifCB {
01154         Mfea01StartVifRF cb;
01155 
01156     public:
01157         operator const Mfea01StartVifRF& () const { return cb; }
01158         const Mfea01StartVifRF& operator ->() const { return cb; }
01159         Mfea01StartVifCB(const Mfea01StartVifRF& cb)
01160           : cb(cb) { }
01161 
01162         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01163 
01164         void respond() const {
01165             cb->dispatch(XrlCmdError::OKAY());
01166         }
01167     };
01168 
01169     struct Mfea01StartVifRsp :
01170       public Mfea01StartVifCB {
01171         Mfea01StartVifRsp(const Mfea01StartVifRF& cb)
01172           : Mfea01StartVifCB(cb) { }
01173 
01174     };
01175 
01176     virtual void async_mfea_0_1_start_vif
01177        (
01178     const string&   vif_name,
01179     Mfea01StartVifCB);
01180 #endif
01181 
01182     virtual XrlCmdError mfea_0_1_stop_vif(
01183     // Input values,
01184     const string&   vif_name) = 0;
01185 #ifdef XORP_ENABLE_ASYNC_SERVER
01186     typedef
01187     XorpCallback1<void, const XrlCmdError &>::RefPtr
01188     Mfea01StopVifRF;
01189 
01190     class Mfea01StopVifCB {
01191         Mfea01StopVifRF cb;
01192 
01193     public:
01194         operator const Mfea01StopVifRF& () const { return cb; }
01195         const Mfea01StopVifRF& operator ->() const { return cb; }
01196         Mfea01StopVifCB(const Mfea01StopVifRF& cb)
01197           : cb(cb) { }
01198 
01199         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01200 
01201         void respond() const {
01202             cb->dispatch(XrlCmdError::OKAY());
01203         }
01204     };
01205 
01206     struct Mfea01StopVifRsp :
01207       public Mfea01StopVifCB {
01208         Mfea01StopVifRsp(const Mfea01StopVifRF& cb)
01209           : Mfea01StopVifCB(cb) { }
01210 
01211     };
01212 
01213     virtual void async_mfea_0_1_stop_vif
01214        (
01215     const string&   vif_name,
01216     Mfea01StopVifCB);
01217 #endif
01218 
01226     virtual XrlCmdError mfea_0_1_enable_all_vifs(
01227     // Input values,
01228     const bool& enable) = 0;
01229 #ifdef XORP_ENABLE_ASYNC_SERVER
01230     typedef
01231     XorpCallback1<void, const XrlCmdError &>::RefPtr
01232     Mfea01EnableAllVifsRF;
01233 
01234     class Mfea01EnableAllVifsCB {
01235         Mfea01EnableAllVifsRF cb;
01236 
01237     public:
01238         operator const Mfea01EnableAllVifsRF& () const { return cb; }
01239         const Mfea01EnableAllVifsRF& operator ->() const { return cb; }
01240         Mfea01EnableAllVifsCB(const Mfea01EnableAllVifsRF& cb)
01241           : cb(cb) { }
01242 
01243         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01244 
01245         void respond() const {
01246             cb->dispatch(XrlCmdError::OKAY());
01247         }
01248     };
01249 
01250     struct Mfea01EnableAllVifsRsp :
01251       public Mfea01EnableAllVifsCB {
01252         Mfea01EnableAllVifsRsp(const Mfea01EnableAllVifsRF& cb)
01253           : Mfea01EnableAllVifsCB(cb) { }
01254 
01255     };
01256 
01257     virtual void async_mfea_0_1_enable_all_vifs
01258        (
01259     const bool& enable,
01260     Mfea01EnableAllVifsCB);
01261 #endif
01262 
01263     virtual XrlCmdError mfea_0_1_start_all_vifs() = 0;
01264 #ifdef XORP_ENABLE_ASYNC_SERVER
01265     typedef
01266     XorpCallback1<void, const XrlCmdError &>::RefPtr
01267     Mfea01StartAllVifsRF;
01268 
01269     class Mfea01StartAllVifsCB {
01270         Mfea01StartAllVifsRF cb;
01271 
01272     public:
01273         operator const Mfea01StartAllVifsRF& () const { return cb; }
01274         const Mfea01StartAllVifsRF& operator ->() const { return cb; }
01275         Mfea01StartAllVifsCB(const Mfea01StartAllVifsRF& cb)
01276           : cb(cb) { }
01277 
01278         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01279 
01280         void respond() const {
01281             cb->dispatch(XrlCmdError::OKAY());
01282         }
01283     };
01284 
01285     struct Mfea01StartAllVifsRsp :
01286       public Mfea01StartAllVifsCB {
01287         Mfea01StartAllVifsRsp(const Mfea01StartAllVifsRF& cb)
01288           : Mfea01StartAllVifsCB(cb) { }
01289 
01290     };
01291 
01292     virtual void async_mfea_0_1_start_all_vifs
01293        (
01294     Mfea01StartAllVifsCB);
01295 #endif
01296 
01297     virtual XrlCmdError mfea_0_1_stop_all_vifs() = 0;
01298 #ifdef XORP_ENABLE_ASYNC_SERVER
01299     typedef
01300     XorpCallback1<void, const XrlCmdError &>::RefPtr
01301     Mfea01StopAllVifsRF;
01302 
01303     class Mfea01StopAllVifsCB {
01304         Mfea01StopAllVifsRF cb;
01305 
01306     public:
01307         operator const Mfea01StopAllVifsRF& () const { return cb; }
01308         const Mfea01StopAllVifsRF& operator ->() const { return cb; }
01309         Mfea01StopAllVifsCB(const Mfea01StopAllVifsRF& cb)
01310           : cb(cb) { }
01311 
01312         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01313 
01314         void respond() const {
01315             cb->dispatch(XrlCmdError::OKAY());
01316         }
01317     };
01318 
01319     struct Mfea01StopAllVifsRsp :
01320       public Mfea01StopAllVifsCB {
01321         Mfea01StopAllVifsRsp(const Mfea01StopAllVifsRF& cb)
01322           : Mfea01StopAllVifsCB(cb) { }
01323 
01324     };
01325 
01326     virtual void async_mfea_0_1_stop_all_vifs
01327        (
01328     Mfea01StopAllVifsCB);
01329 #endif
01330 
01338     virtual XrlCmdError mfea_0_1_enable_mfea(
01339     // Input values,
01340     const bool& enable) = 0;
01341 #ifdef XORP_ENABLE_ASYNC_SERVER
01342     typedef
01343     XorpCallback1<void, const XrlCmdError &>::RefPtr
01344     Mfea01EnableMfeaRF;
01345 
01346     class Mfea01EnableMfeaCB {
01347         Mfea01EnableMfeaRF cb;
01348 
01349     public:
01350         operator const Mfea01EnableMfeaRF& () const { return cb; }
01351         const Mfea01EnableMfeaRF& operator ->() const { return cb; }
01352         Mfea01EnableMfeaCB(const Mfea01EnableMfeaRF& cb)
01353           : cb(cb) { }
01354 
01355         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01356 
01357         void respond() const {
01358             cb->dispatch(XrlCmdError::OKAY());
01359         }
01360     };
01361 
01362     struct Mfea01EnableMfeaRsp :
01363       public Mfea01EnableMfeaCB {
01364         Mfea01EnableMfeaRsp(const Mfea01EnableMfeaRF& cb)
01365           : Mfea01EnableMfeaCB(cb) { }
01366 
01367     };
01368 
01369     virtual void async_mfea_0_1_enable_mfea
01370        (
01371     const bool& enable,
01372     Mfea01EnableMfeaCB);
01373 #endif
01374 
01375     virtual XrlCmdError mfea_0_1_start_mfea() = 0;
01376 #ifdef XORP_ENABLE_ASYNC_SERVER
01377     typedef
01378     XorpCallback1<void, const XrlCmdError &>::RefPtr
01379     Mfea01StartMfeaRF;
01380 
01381     class Mfea01StartMfeaCB {
01382         Mfea01StartMfeaRF cb;
01383 
01384     public:
01385         operator const Mfea01StartMfeaRF& () const { return cb; }
01386         const Mfea01StartMfeaRF& operator ->() const { return cb; }
01387         Mfea01StartMfeaCB(const Mfea01StartMfeaRF& cb)
01388           : cb(cb) { }
01389 
01390         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01391 
01392         void respond() const {
01393             cb->dispatch(XrlCmdError::OKAY());
01394         }
01395     };
01396 
01397     struct Mfea01StartMfeaRsp :
01398       public Mfea01StartMfeaCB {
01399         Mfea01StartMfeaRsp(const Mfea01StartMfeaRF& cb)
01400           : Mfea01StartMfeaCB(cb) { }
01401 
01402     };
01403 
01404     virtual void async_mfea_0_1_start_mfea
01405        (
01406     Mfea01StartMfeaCB);
01407 #endif
01408 
01409     virtual XrlCmdError mfea_0_1_stop_mfea() = 0;
01410 #ifdef XORP_ENABLE_ASYNC_SERVER
01411     typedef
01412     XorpCallback1<void, const XrlCmdError &>::RefPtr
01413     Mfea01StopMfeaRF;
01414 
01415     class Mfea01StopMfeaCB {
01416         Mfea01StopMfeaRF cb;
01417 
01418     public:
01419         operator const Mfea01StopMfeaRF& () const { return cb; }
01420         const Mfea01StopMfeaRF& operator ->() const { return cb; }
01421         Mfea01StopMfeaCB(const Mfea01StopMfeaRF& cb)
01422           : cb(cb) { }
01423 
01424         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01425 
01426         void respond() const {
01427             cb->dispatch(XrlCmdError::OKAY());
01428         }
01429     };
01430 
01431     struct Mfea01StopMfeaRsp :
01432       public Mfea01StopMfeaCB {
01433         Mfea01StopMfeaRsp(const Mfea01StopMfeaRF& cb)
01434           : Mfea01StopMfeaCB(cb) { }
01435 
01436     };
01437 
01438     virtual void async_mfea_0_1_stop_mfea
01439        (
01440     Mfea01StopMfeaCB);
01441 #endif
01442 
01451     virtual XrlCmdError mfea_0_1_enable_cli(
01452     // Input values,
01453     const bool& enable) = 0;
01454 #ifdef XORP_ENABLE_ASYNC_SERVER
01455     typedef
01456     XorpCallback1<void, const XrlCmdError &>::RefPtr
01457     Mfea01EnableCliRF;
01458 
01459     class Mfea01EnableCliCB {
01460         Mfea01EnableCliRF cb;
01461 
01462     public:
01463         operator const Mfea01EnableCliRF& () const { return cb; }
01464         const Mfea01EnableCliRF& operator ->() const { return cb; }
01465         Mfea01EnableCliCB(const Mfea01EnableCliRF& cb)
01466           : cb(cb) { }
01467 
01468         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01469 
01470         void respond() const {
01471             cb->dispatch(XrlCmdError::OKAY());
01472         }
01473     };
01474 
01475     struct Mfea01EnableCliRsp :
01476       public Mfea01EnableCliCB {
01477         Mfea01EnableCliRsp(const Mfea01EnableCliRF& cb)
01478           : Mfea01EnableCliCB(cb) { }
01479 
01480     };
01481 
01482     virtual void async_mfea_0_1_enable_cli
01483        (
01484     const bool& enable,
01485     Mfea01EnableCliCB);
01486 #endif
01487 
01488     virtual XrlCmdError mfea_0_1_start_cli() = 0;
01489 #ifdef XORP_ENABLE_ASYNC_SERVER
01490     typedef
01491     XorpCallback1<void, const XrlCmdError &>::RefPtr
01492     Mfea01StartCliRF;
01493 
01494     class Mfea01StartCliCB {
01495         Mfea01StartCliRF cb;
01496 
01497     public:
01498         operator const Mfea01StartCliRF& () const { return cb; }
01499         const Mfea01StartCliRF& operator ->() const { return cb; }
01500         Mfea01StartCliCB(const Mfea01StartCliRF& cb)
01501           : cb(cb) { }
01502 
01503         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01504 
01505         void respond() const {
01506             cb->dispatch(XrlCmdError::OKAY());
01507         }
01508     };
01509 
01510     struct Mfea01StartCliRsp :
01511       public Mfea01StartCliCB {
01512         Mfea01StartCliRsp(const Mfea01StartCliRF& cb)
01513           : Mfea01StartCliCB(cb) { }
01514 
01515     };
01516 
01517     virtual void async_mfea_0_1_start_cli
01518        (
01519     Mfea01StartCliCB);
01520 #endif
01521 
01522     virtual XrlCmdError mfea_0_1_stop_cli() = 0;
01523 #ifdef XORP_ENABLE_ASYNC_SERVER
01524     typedef
01525     XorpCallback1<void, const XrlCmdError &>::RefPtr
01526     Mfea01StopCliRF;
01527 
01528     class Mfea01StopCliCB {
01529         Mfea01StopCliRF cb;
01530 
01531     public:
01532         operator const Mfea01StopCliRF& () const { return cb; }
01533         const Mfea01StopCliRF& operator ->() const { return cb; }
01534         Mfea01StopCliCB(const Mfea01StopCliRF& cb)
01535           : cb(cb) { }
01536 
01537         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01538 
01539         void respond() const {
01540             cb->dispatch(XrlCmdError::OKAY());
01541         }
01542     };
01543 
01544     struct Mfea01StopCliRsp :
01545       public Mfea01StopCliCB {
01546         Mfea01StopCliRsp(const Mfea01StopCliRF& cb)
01547           : Mfea01StopCliCB(cb) { }
01548 
01549     };
01550 
01551     virtual void async_mfea_0_1_stop_cli
01552        (
01553     Mfea01StopCliCB);
01554 #endif
01555 
01563     virtual XrlCmdError mfea_0_1_log_trace_all(
01564     // Input values,
01565     const bool& enable) = 0;
01566 #ifdef XORP_ENABLE_ASYNC_SERVER
01567     typedef
01568     XorpCallback1<void, const XrlCmdError &>::RefPtr
01569     Mfea01LogTraceAllRF;
01570 
01571     class Mfea01LogTraceAllCB {
01572         Mfea01LogTraceAllRF cb;
01573 
01574     public:
01575         operator const Mfea01LogTraceAllRF& () const { return cb; }
01576         const Mfea01LogTraceAllRF& operator ->() const { return cb; }
01577         Mfea01LogTraceAllCB(const Mfea01LogTraceAllRF& cb)
01578           : cb(cb) { }
01579 
01580         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01581 
01582         void respond() const {
01583             cb->dispatch(XrlCmdError::OKAY());
01584         }
01585     };
01586 
01587     struct Mfea01LogTraceAllRsp :
01588       public Mfea01LogTraceAllCB {
01589         Mfea01LogTraceAllRsp(const Mfea01LogTraceAllRF& cb)
01590           : Mfea01LogTraceAllCB(cb) { }
01591 
01592     };
01593 
01594     virtual void async_mfea_0_1_log_trace_all
01595        (
01596     const bool& enable,
01597     Mfea01LogTraceAllCB);
01598 #endif
01599 
01608     virtual XrlCmdError mfea_0_1_have_multicast_routing6(
01609     // Output values,
01610     bool&   result) = 0;
01611 #ifdef XORP_ENABLE_ASYNC_SERVER
01612     typedef
01613     XorpCallback2<void, const XrlCmdError &,
01614     const bool*>::RefPtr
01615     Mfea01HaveMulticastRouting6RF;
01616 
01617     class Mfea01HaveMulticastRouting6CB {
01618         Mfea01HaveMulticastRouting6RF cb;
01619 
01620     public:
01621         operator const Mfea01HaveMulticastRouting6RF& () const { return cb; }
01622         const Mfea01HaveMulticastRouting6RF& operator ->() const { return cb; }
01623         Mfea01HaveMulticastRouting6CB(const Mfea01HaveMulticastRouting6RF& cb)
01624           : cb(cb) { }
01625 
01626         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01627 
01628         void respond(const bool& arg_result) const {
01629             cb->dispatch(XrlCmdError::OKAY(),
01630                          &arg_result);
01631         }
01632     };
01633 
01634     struct Mfea01HaveMulticastRouting6Rsp :
01635       public Mfea01HaveMulticastRouting6CB {
01636         struct args_str {
01637             bool result;
01638         };
01639 
01640     private:
01641         args_str args;
01642 
01643     public:
01644         Mfea01HaveMulticastRouting6Rsp(const Mfea01HaveMulticastRouting6RF& cb)
01645           : Mfea01HaveMulticastRouting6CB(cb) { }
01646 
01647         void respond() const {
01648             Mfea01HaveMulticastRouting6CB::
01649             respond(args.result);
01650         }
01651 
01652         args_str* operator ->() {
01653             return &args;
01654         }
01655     };
01656 
01657     virtual void async_mfea_0_1_have_multicast_routing6
01658        (
01659     Mfea01HaveMulticastRouting6CB);
01660 #endif
01661 
01662     virtual XrlCmdError mfea_0_1_register_protocol6(
01663     // Input values,
01664     const string&   xrl_sender_name,
01665     const string&   if_name,
01666     const string&   vif_name,
01667     const uint32_t& ip_protocol) = 0;
01668 #ifdef XORP_ENABLE_ASYNC_SERVER
01669     typedef
01670     XorpCallback1<void, const XrlCmdError &>::RefPtr
01671     Mfea01RegisterProtocol6RF;
01672 
01673     class Mfea01RegisterProtocol6CB {
01674         Mfea01RegisterProtocol6RF cb;
01675 
01676     public:
01677         operator const Mfea01RegisterProtocol6RF& () const { return cb; }
01678         const Mfea01RegisterProtocol6RF& operator ->() const { return cb; }
01679         Mfea01RegisterProtocol6CB(const Mfea01RegisterProtocol6RF& cb)
01680           : cb(cb) { }
01681 
01682         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01683 
01684         void respond() const {
01685             cb->dispatch(XrlCmdError::OKAY());
01686         }
01687     };
01688 
01689     struct Mfea01RegisterProtocol6Rsp :
01690       public Mfea01RegisterProtocol6CB {
01691         Mfea01RegisterProtocol6Rsp(const Mfea01RegisterProtocol6RF& cb)
01692           : Mfea01RegisterProtocol6CB(cb) { }
01693 
01694     };
01695 
01696     virtual void async_mfea_0_1_register_protocol6
01697        (
01698     const string&   xrl_sender_name,
01699     const string&   if_name,
01700     const string&   vif_name,
01701     const uint32_t& ip_protocol,
01702     Mfea01RegisterProtocol6CB);
01703 #endif
01704 
01705     virtual XrlCmdError mfea_0_1_unregister_protocol6(
01706     // Input values,
01707     const string&   xrl_sender_name,
01708     const string&   if_name,
01709     const string&   vif_name) = 0;
01710 #ifdef XORP_ENABLE_ASYNC_SERVER
01711     typedef
01712     XorpCallback1<void, const XrlCmdError &>::RefPtr
01713     Mfea01UnregisterProtocol6RF;
01714 
01715     class Mfea01UnregisterProtocol6CB {
01716         Mfea01UnregisterProtocol6RF cb;
01717 
01718     public:
01719         operator const Mfea01UnregisterProtocol6RF& () const { return cb; }
01720         const Mfea01UnregisterProtocol6RF& operator ->() const { return cb; }
01721         Mfea01UnregisterProtocol6CB(const Mfea01UnregisterProtocol6RF& cb)
01722           : cb(cb) { }
01723 
01724         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01725 
01726         void respond() const {
01727             cb->dispatch(XrlCmdError::OKAY());
01728         }
01729     };
01730 
01731     struct Mfea01UnregisterProtocol6Rsp :
01732       public Mfea01UnregisterProtocol6CB {
01733         Mfea01UnregisterProtocol6Rsp(const Mfea01UnregisterProtocol6RF& cb)
01734           : Mfea01UnregisterProtocol6CB(cb) { }
01735 
01736     };
01737 
01738     virtual void async_mfea_0_1_unregister_protocol6
01739        (
01740     const string&   xrl_sender_name,
01741     const string&   if_name,
01742     const string&   vif_name,
01743     Mfea01UnregisterProtocol6CB);
01744 #endif
01745 
01746     virtual XrlCmdError mfea_0_1_add_mfc6(
01747     // Input values,
01748     const string&   xrl_sender_name,
01749     const IPv6& source_address,
01750     const IPv6& group_address,
01751     const uint32_t& iif_vif_index,
01752     const vector<uint8_t>&  oiflist,
01753     const vector<uint8_t>&  oiflist_disable_wrongvif,
01754     const uint32_t& max_vifs_oiflist,
01755     const IPv6& rp_address) = 0;
01756 #ifdef XORP_ENABLE_ASYNC_SERVER
01757     typedef
01758     XorpCallback1<void, const XrlCmdError &>::RefPtr
01759     Mfea01AddMfc6RF;
01760 
01761     class Mfea01AddMfc6CB {
01762         Mfea01AddMfc6RF cb;
01763 
01764     public:
01765         operator const Mfea01AddMfc6RF& () const { return cb; }
01766         const Mfea01AddMfc6RF& operator ->() const { return cb; }
01767         Mfea01AddMfc6CB(const Mfea01AddMfc6RF& cb)
01768           : cb(cb) { }
01769 
01770         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01771 
01772         void respond() const {
01773             cb->dispatch(XrlCmdError::OKAY());
01774         }
01775     };
01776 
01777     struct Mfea01AddMfc6Rsp :
01778       public Mfea01AddMfc6CB {
01779         Mfea01AddMfc6Rsp(const Mfea01AddMfc6RF& cb)
01780           : Mfea01AddMfc6CB(cb) { }
01781 
01782     };
01783 
01784     virtual void async_mfea_0_1_add_mfc6
01785        (
01786     const string&   xrl_sender_name,
01787     const IPv6& source_address,
01788     const IPv6& group_address,
01789     const uint32_t& iif_vif_index,
01790     const vector<uint8_t>&  oiflist,
01791     const vector<uint8_t>&  oiflist_disable_wrongvif,
01792     const uint32_t& max_vifs_oiflist,
01793     const IPv6& rp_address,
01794     Mfea01AddMfc6CB);
01795 #endif
01796 
01797     virtual XrlCmdError mfea_0_1_delete_mfc6(
01798     // Input values,
01799     const string&   xrl_sender_name,
01800     const IPv6& source_address,
01801     const IPv6& group_address) = 0;
01802 #ifdef XORP_ENABLE_ASYNC_SERVER
01803     typedef
01804     XorpCallback1<void, const XrlCmdError &>::RefPtr
01805     Mfea01DeleteMfc6RF;
01806 
01807     class Mfea01DeleteMfc6CB {
01808         Mfea01DeleteMfc6RF cb;
01809 
01810     public:
01811         operator const Mfea01DeleteMfc6RF& () const { return cb; }
01812         const Mfea01DeleteMfc6RF& operator ->() const { return cb; }
01813         Mfea01DeleteMfc6CB(const Mfea01DeleteMfc6RF& cb)
01814           : cb(cb) { }
01815 
01816         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01817 
01818         void respond() const {
01819             cb->dispatch(XrlCmdError::OKAY());
01820         }
01821     };
01822 
01823     struct Mfea01DeleteMfc6Rsp :
01824       public Mfea01DeleteMfc6CB {
01825         Mfea01DeleteMfc6Rsp(const Mfea01DeleteMfc6RF& cb)
01826           : Mfea01DeleteMfc6CB(cb) { }
01827 
01828     };
01829 
01830     virtual void async_mfea_0_1_delete_mfc6
01831        (
01832     const string&   xrl_sender_name,
01833     const IPv6& source_address,
01834     const IPv6& group_address,
01835     Mfea01DeleteMfc6CB);
01836 #endif
01837 
01838     virtual XrlCmdError mfea_0_1_add_dataflow_monitor6(
01839     // Input values,
01840     const string&   xrl_sender_name,
01841     const IPv6& source_address,
01842     const IPv6& group_address,
01843     const uint32_t& threshold_interval_sec,
01844     const uint32_t& threshold_interval_usec,
01845     const uint32_t& threshold_packets,
01846     const uint32_t& threshold_bytes,
01847     const bool& is_threshold_in_packets,
01848     const bool& is_threshold_in_bytes,
01849     const bool& is_geq_upcall,
01850     const bool& is_leq_upcall) = 0;
01851 #ifdef XORP_ENABLE_ASYNC_SERVER
01852     typedef
01853     XorpCallback1<void, const XrlCmdError &>::RefPtr
01854     Mfea01AddDataflowMonitor6RF;
01855 
01856     class Mfea01AddDataflowMonitor6CB {
01857         Mfea01AddDataflowMonitor6RF cb;
01858 
01859     public:
01860         operator const Mfea01AddDataflowMonitor6RF& () const { return cb; }
01861         const Mfea01AddDataflowMonitor6RF& operator ->() const { return cb; }
01862         Mfea01AddDataflowMonitor6CB(const Mfea01AddDataflowMonitor6RF& cb)
01863           : cb(cb) { }
01864 
01865         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01866 
01867         void respond() const {
01868             cb->dispatch(XrlCmdError::OKAY());
01869         }
01870     };
01871 
01872     struct Mfea01AddDataflowMonitor6Rsp :
01873       public Mfea01AddDataflowMonitor6CB {
01874         Mfea01AddDataflowMonitor6Rsp(const Mfea01AddDataflowMonitor6RF& cb)
01875           : Mfea01AddDataflowMonitor6CB(cb) { }
01876 
01877     };
01878 
01879     virtual void async_mfea_0_1_add_dataflow_monitor6
01880        (
01881     const string&   xrl_sender_name,
01882     const IPv6& source_address,
01883     const IPv6& group_address,
01884     const uint32_t& threshold_interval_sec,
01885     const uint32_t& threshold_interval_usec,
01886     const uint32_t& threshold_packets,
01887     const uint32_t& threshold_bytes,
01888     const bool& is_threshold_in_packets,
01889     const bool& is_threshold_in_bytes,
01890     const bool& is_geq_upcall,
01891     const bool& is_leq_upcall,
01892     Mfea01AddDataflowMonitor6CB);
01893 #endif
01894 
01895     virtual XrlCmdError mfea_0_1_delete_dataflow_monitor6(
01896     // Input values,
01897     const string&   xrl_sender_name,
01898     const IPv6& source_address,
01899     const IPv6& group_address,
01900     const uint32_t& threshold_interval_sec,
01901     const uint32_t& threshold_interval_usec,
01902     const uint32_t& threshold_packets,
01903     const uint32_t& threshold_bytes,
01904     const bool& is_threshold_in_packets,
01905     const bool& is_threshold_in_bytes,
01906     const bool& is_geq_upcall,
01907     const bool& is_leq_upcall) = 0;
01908 #ifdef XORP_ENABLE_ASYNC_SERVER
01909     typedef
01910     XorpCallback1<void, const XrlCmdError &>::RefPtr
01911     Mfea01DeleteDataflowMonitor6RF;
01912 
01913     class Mfea01DeleteDataflowMonitor6CB {
01914         Mfea01DeleteDataflowMonitor6RF cb;
01915 
01916     public:
01917         operator const Mfea01DeleteDataflowMonitor6RF& () const { return cb; }
01918         const Mfea01DeleteDataflowMonitor6RF& operator ->() const { return cb; }
01919         Mfea01DeleteDataflowMonitor6CB(const Mfea01DeleteDataflowMonitor6RF& cb)
01920           : cb(cb) { }
01921 
01922         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01923 
01924         void respond() const {
01925             cb->dispatch(XrlCmdError::OKAY());
01926         }
01927     };
01928 
01929     struct Mfea01DeleteDataflowMonitor6Rsp :
01930       public Mfea01DeleteDataflowMonitor6CB {
01931         Mfea01DeleteDataflowMonitor6Rsp(const Mfea01DeleteDataflowMonitor6RF& cb)
01932           : Mfea01DeleteDataflowMonitor6CB(cb) { }
01933 
01934     };
01935 
01936     virtual void async_mfea_0_1_delete_dataflow_monitor6
01937        (
01938     const string&   xrl_sender_name,
01939     const IPv6& source_address,
01940     const IPv6& group_address,
01941     const uint32_t& threshold_interval_sec,
01942     const uint32_t& threshold_interval_usec,
01943     const uint32_t& threshold_packets,
01944     const uint32_t& threshold_bytes,
01945     const bool& is_threshold_in_packets,
01946     const bool& is_threshold_in_bytes,
01947     const bool& is_geq_upcall,
01948     const bool& is_leq_upcall,
01949     Mfea01DeleteDataflowMonitor6CB);
01950 #endif
01951 
01952     virtual XrlCmdError mfea_0_1_delete_all_dataflow_monitor6(
01953     // Input values,
01954     const string&   xrl_sender_name,
01955     const IPv6& source_address,
01956     const IPv6& group_address) = 0;
01957 #ifdef XORP_ENABLE_ASYNC_SERVER
01958     typedef
01959     XorpCallback1<void, const XrlCmdError &>::RefPtr
01960     Mfea01DeleteAllDataflowMonitor6RF;
01961 
01962     class Mfea01DeleteAllDataflowMonitor6CB {
01963         Mfea01DeleteAllDataflowMonitor6RF cb;
01964 
01965     public:
01966         operator const Mfea01DeleteAllDataflowMonitor6RF& () const { return cb; }
01967         const Mfea01DeleteAllDataflowMonitor6RF& operator ->() const { return cb; }
01968         Mfea01DeleteAllDataflowMonitor6CB(const Mfea01DeleteAllDataflowMonitor6RF& cb)
01969           : cb(cb) { }
01970 
01971         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01972 
01973         void respond() const {
01974             cb->dispatch(XrlCmdError::OKAY());
01975         }
01976     };
01977 
01978     struct Mfea01DeleteAllDataflowMonitor6Rsp :
01979       public Mfea01DeleteAllDataflowMonitor6CB {
01980         Mfea01DeleteAllDataflowMonitor6Rsp(const Mfea01DeleteAllDataflowMonitor6RF& cb)
01981           : Mfea01DeleteAllDataflowMonitor6CB(cb) { }
01982 
01983     };
01984 
01985     virtual void async_mfea_0_1_delete_all_dataflow_monitor6
01986        (
01987     const string&   xrl_sender_name,
01988     const IPv6& source_address,
01989     const IPv6& group_address,
01990     Mfea01DeleteAllDataflowMonitor6CB);
01991 #endif
01992 
01993 private:
01994     XrlCmdRT handle_common_0_1_get_target_name(const XrlArgs& in, XrlCmdOT out);
01995 #ifdef XORP_ENABLE_ASYNC_SERVER
01996     void callback_common_0_1_get_target_name
01997        (const XrlCmdError &e,
01998     const string* arg_name,
01999         XrlRespCallback);
02000 #endif
02001 
02002     XrlCmdRT handle_common_0_1_get_version(const XrlArgs& in, XrlCmdOT out);
02003 #ifdef XORP_ENABLE_ASYNC_SERVER
02004     void callback_common_0_1_get_version
02005        (const XrlCmdError &e,
02006     const string* arg_version,
02007         XrlRespCallback);
02008 #endif
02009 
02010     XrlCmdRT handle_common_0_1_get_status(const XrlArgs& in, XrlCmdOT out);
02011 #ifdef XORP_ENABLE_ASYNC_SERVER
02012     void callback_common_0_1_get_status
02013        (const XrlCmdError &e,
02014     const uint32_t* arg_status,
02015     const string* arg_reason,
02016         XrlRespCallback);
02017 #endif
02018 
02019     XrlCmdRT handle_common_0_1_shutdown(const XrlArgs& in, XrlCmdOT out);
02020 #ifdef XORP_ENABLE_ASYNC_SERVER
02021     void callback_common_0_1_shutdown
02022        (const XrlCmdError &e,
02023         XrlRespCallback);
02024 #endif
02025 
02026     XrlCmdRT handle_common_0_1_startup(const XrlArgs& in, XrlCmdOT out);
02027 #ifdef XORP_ENABLE_ASYNC_SERVER
02028     void callback_common_0_1_startup
02029        (const XrlCmdError &e,
02030         XrlRespCallback);
02031 #endif
02032 
02033     XrlCmdRT handle_cli_processor_0_1_process_command(const XrlArgs& in, XrlCmdOT out);
02034 #ifdef XORP_ENABLE_ASYNC_SERVER
02035     void callback_cli_processor_0_1_process_command
02036        (const XrlCmdError &e,
02037     const string* arg_ret_processor_name,
02038     const string* arg_ret_cli_term_name,
02039     const uint32_t* arg_ret_cli_session_id,
02040     const string* arg_ret_command_output,
02041         XrlRespCallback);
02042 #endif
02043 
02044     XrlCmdRT handle_ifmgr_replicator_0_1_register_ifmgr_mirror(const XrlArgs& in, XrlCmdOT out);
02045 #ifdef XORP_ENABLE_ASYNC_SERVER
02046     void callback_ifmgr_replicator_0_1_register_ifmgr_mirror
02047        (const XrlCmdError &e,
02048         XrlRespCallback);
02049 #endif
02050 
02051     XrlCmdRT handle_ifmgr_replicator_0_1_unregister_ifmgr_mirror(const XrlArgs& in, XrlCmdOT out);
02052 #ifdef XORP_ENABLE_ASYNC_SERVER
02053     void callback_ifmgr_replicator_0_1_unregister_ifmgr_mirror
02054        (const XrlCmdError &e,
02055         XrlRespCallback);
02056 #endif
02057 
02058     XrlCmdRT handle_finder_event_observer_0_1_xrl_target_birth(const XrlArgs& in, XrlCmdOT out);
02059 #ifdef XORP_ENABLE_ASYNC_SERVER
02060     void callback_finder_event_observer_0_1_xrl_target_birth
02061        (const XrlCmdError &e,
02062         XrlRespCallback);
02063 #endif
02064 
02065     XrlCmdRT handle_finder_event_observer_0_1_xrl_target_death(const XrlArgs& in, XrlCmdOT out);
02066 #ifdef XORP_ENABLE_ASYNC_SERVER
02067     void callback_finder_event_observer_0_1_xrl_target_death
02068        (const XrlCmdError &e,
02069         XrlRespCallback);
02070 #endif
02071 
02072     XrlCmdRT handle_mfea_0_1_have_multicast_routing4(const XrlArgs& in, XrlCmdOT out);
02073 #ifdef XORP_ENABLE_ASYNC_SERVER
02074     void callback_mfea_0_1_have_multicast_routing4
02075        (const XrlCmdError &e,
02076     const bool* arg_result,
02077         XrlRespCallback);
02078 #endif
02079 
02080     XrlCmdRT handle_mfea_0_1_register_protocol4(const XrlArgs& in, XrlCmdOT out);
02081 #ifdef XORP_ENABLE_ASYNC_SERVER
02082     void callback_mfea_0_1_register_protocol4
02083        (const XrlCmdError &e,
02084         XrlRespCallback);
02085 #endif
02086 
02087     XrlCmdRT handle_mfea_0_1_unregister_protocol4(const XrlArgs& in, XrlCmdOT out);
02088 #ifdef XORP_ENABLE_ASYNC_SERVER
02089     void callback_mfea_0_1_unregister_protocol4
02090        (const XrlCmdError &e,
02091         XrlRespCallback);
02092 #endif
02093 
02094     XrlCmdRT handle_mfea_0_1_add_mfc4(const XrlArgs& in, XrlCmdOT out);
02095 #ifdef XORP_ENABLE_ASYNC_SERVER
02096     void callback_mfea_0_1_add_mfc4
02097        (const XrlCmdError &e,
02098         XrlRespCallback);
02099 #endif
02100 
02101     XrlCmdRT handle_mfea_0_1_delete_mfc4(const XrlArgs& in, XrlCmdOT out);
02102 #ifdef XORP_ENABLE_ASYNC_SERVER
02103     void callback_mfea_0_1_delete_mfc4
02104        (const XrlCmdError &e,
02105         XrlRespCallback);
02106 #endif
02107 
02108     XrlCmdRT handle_mfea_0_1_add_dataflow_monitor4(const XrlArgs& in, XrlCmdOT out);
02109 #ifdef XORP_ENABLE_ASYNC_SERVER
02110     void callback_mfea_0_1_add_dataflow_monitor4
02111        (const XrlCmdError &e,
02112         XrlRespCallback);
02113 #endif
02114 
02115     XrlCmdRT handle_mfea_0_1_delete_dataflow_monitor4(const XrlArgs& in, XrlCmdOT out);
02116 #ifdef XORP_ENABLE_ASYNC_SERVER
02117     void callback_mfea_0_1_delete_dataflow_monitor4
02118        (const XrlCmdError &e,
02119         XrlRespCallback);
02120 #endif
02121 
02122     XrlCmdRT handle_mfea_0_1_delete_all_dataflow_monitor4(const XrlArgs& in, XrlCmdOT out);
02123 #ifdef XORP_ENABLE_ASYNC_SERVER
02124     void callback_mfea_0_1_delete_all_dataflow_monitor4
02125        (const XrlCmdError &e,
02126         XrlRespCallback);
02127 #endif
02128 
02129     XrlCmdRT handle_mfea_0_1_enable_vif(const XrlArgs& in, XrlCmdOT out);
02130 #ifdef XORP_ENABLE_ASYNC_SERVER
02131     void callback_mfea_0_1_enable_vif
02132        (const XrlCmdError &e,
02133         XrlRespCallback);
02134 #endif
02135 
02136     XrlCmdRT handle_mfea_0_1_start_vif(const XrlArgs& in, XrlCmdOT out);
02137 #ifdef XORP_ENABLE_ASYNC_SERVER
02138     void callback_mfea_0_1_start_vif
02139        (const XrlCmdError &e,
02140         XrlRespCallback);
02141 #endif
02142 
02143     XrlCmdRT handle_mfea_0_1_stop_vif(const XrlArgs& in, XrlCmdOT out);
02144 #ifdef XORP_ENABLE_ASYNC_SERVER
02145     void callback_mfea_0_1_stop_vif
02146        (const XrlCmdError &e,
02147         XrlRespCallback);
02148 #endif
02149 
02150     XrlCmdRT handle_mfea_0_1_enable_all_vifs(const XrlArgs& in, XrlCmdOT out);
02151 #ifdef XORP_ENABLE_ASYNC_SERVER
02152     void callback_mfea_0_1_enable_all_vifs
02153        (const XrlCmdError &e,
02154         XrlRespCallback);
02155 #endif
02156 
02157     XrlCmdRT handle_mfea_0_1_start_all_vifs(const XrlArgs& in, XrlCmdOT out);
02158 #ifdef XORP_ENABLE_ASYNC_SERVER
02159     void callback_mfea_0_1_start_all_vifs
02160        (const XrlCmdError &e,
02161         XrlRespCallback);
02162 #endif
02163 
02164     XrlCmdRT handle_mfea_0_1_stop_all_vifs(const XrlArgs& in, XrlCmdOT out);
02165 #ifdef XORP_ENABLE_ASYNC_SERVER
02166     void callback_mfea_0_1_stop_all_vifs
02167        (const XrlCmdError &e,
02168         XrlRespCallback);
02169 #endif
02170 
02171     XrlCmdRT handle_mfea_0_1_enable_mfea(const XrlArgs& in, XrlCmdOT out);
02172 #ifdef XORP_ENABLE_ASYNC_SERVER
02173     void callback_mfea_0_1_enable_mfea
02174        (const XrlCmdError &e,
02175         XrlRespCallback);
02176 #endif
02177 
02178     XrlCmdRT handle_mfea_0_1_start_mfea(const XrlArgs& in, XrlCmdOT out);
02179 #ifdef XORP_ENABLE_ASYNC_SERVER
02180     void callback_mfea_0_1_start_mfea
02181        (const XrlCmdError &e,
02182         XrlRespCallback);
02183 #endif
02184 
02185     XrlCmdRT handle_mfea_0_1_stop_mfea(const XrlArgs& in, XrlCmdOT out);
02186 #ifdef XORP_ENABLE_ASYNC_SERVER
02187     void callback_mfea_0_1_stop_mfea
02188        (const XrlCmdError &e,
02189         XrlRespCallback);
02190 #endif
02191 
02192     XrlCmdRT handle_mfea_0_1_enable_cli(const XrlArgs& in, XrlCmdOT out);
02193 #ifdef XORP_ENABLE_ASYNC_SERVER
02194     void callback_mfea_0_1_enable_cli
02195        (const XrlCmdError &e,
02196         XrlRespCallback);
02197 #endif
02198 
02199     XrlCmdRT handle_mfea_0_1_start_cli(const XrlArgs& in, XrlCmdOT out);
02200 #ifdef XORP_ENABLE_ASYNC_SERVER
02201     void callback_mfea_0_1_start_cli
02202        (const XrlCmdError &e,
02203         XrlRespCallback);
02204 #endif
02205 
02206     XrlCmdRT handle_mfea_0_1_stop_cli(const XrlArgs& in, XrlCmdOT out);
02207 #ifdef XORP_ENABLE_ASYNC_SERVER
02208     void callback_mfea_0_1_stop_cli
02209        (const XrlCmdError &e,
02210         XrlRespCallback);
02211 #endif
02212 
02213     XrlCmdRT handle_mfea_0_1_log_trace_all(const XrlArgs& in, XrlCmdOT out);
02214 #ifdef XORP_ENABLE_ASYNC_SERVER
02215     void callback_mfea_0_1_log_trace_all
02216        (const XrlCmdError &e,
02217         XrlRespCallback);
02218 #endif
02219 
02220     XrlCmdRT handle_mfea_0_1_have_multicast_routing6(const XrlArgs& in, XrlCmdOT out);
02221 #ifdef XORP_ENABLE_ASYNC_SERVER
02222     void callback_mfea_0_1_have_multicast_routing6
02223        (const XrlCmdError &e,
02224     const bool* arg_result,
02225         XrlRespCallback);
02226 #endif
02227 
02228     XrlCmdRT handle_mfea_0_1_register_protocol6(const XrlArgs& in, XrlCmdOT out);
02229 #ifdef XORP_ENABLE_ASYNC_SERVER
02230     void callback_mfea_0_1_register_protocol6
02231        (const XrlCmdError &e,
02232         XrlRespCallback);
02233 #endif
02234 
02235     XrlCmdRT handle_mfea_0_1_unregister_protocol6(const XrlArgs& in, XrlCmdOT out);
02236 #ifdef XORP_ENABLE_ASYNC_SERVER
02237     void callback_mfea_0_1_unregister_protocol6
02238        (const XrlCmdError &e,
02239         XrlRespCallback);
02240 #endif
02241 
02242     XrlCmdRT handle_mfea_0_1_add_mfc6(const XrlArgs& in, XrlCmdOT out);
02243 #ifdef XORP_ENABLE_ASYNC_SERVER
02244     void callback_mfea_0_1_add_mfc6
02245        (const XrlCmdError &e,
02246         XrlRespCallback);
02247 #endif
02248 
02249     XrlCmdRT handle_mfea_0_1_delete_mfc6(const XrlArgs& in, XrlCmdOT out);
02250 #ifdef XORP_ENABLE_ASYNC_SERVER
02251     void callback_mfea_0_1_delete_mfc6
02252        (const XrlCmdError &e,
02253         XrlRespCallback);
02254 #endif
02255 
02256     XrlCmdRT handle_mfea_0_1_add_dataflow_monitor6(const XrlArgs& in, XrlCmdOT out);
02257 #ifdef XORP_ENABLE_ASYNC_SERVER
02258     void callback_mfea_0_1_add_dataflow_monitor6
02259        (const XrlCmdError &e,
02260         XrlRespCallback);
02261 #endif
02262 
02263     XrlCmdRT handle_mfea_0_1_delete_dataflow_monitor6(const XrlArgs& in, XrlCmdOT out);
02264 #ifdef XORP_ENABLE_ASYNC_SERVER
02265     void callback_mfea_0_1_delete_dataflow_monitor6
02266        (const XrlCmdError &e,
02267         XrlRespCallback);
02268 #endif
02269 
02270     XrlCmdRT handle_mfea_0_1_delete_all_dataflow_monitor6(const XrlArgs& in, XrlCmdOT out);
02271 #ifdef XORP_ENABLE_ASYNC_SERVER
02272     void callback_mfea_0_1_delete_all_dataflow_monitor6
02273        (const XrlCmdError &e,
02274         XrlRespCallback);
02275 #endif
02276 
02277     void add_handlers();
02278     void remove_handlers();
02279 
02280     struct handler_table {
02281         const char *name;
02282         XrlCmdRT (XrlMfeaTargetBase::*method)(const XrlArgs&, XrlCmdOT);
02283     };
02284 
02285     static const struct handler_table handlers[];
02286     static const size_t num_handlers;
02287 };
02288 
02289 #endif // __XRL_TARGETS_MFEA_BASE_HH__
 All Classes Namespaces Functions Variables Typedefs Enumerations