xorp

ospfv2_base.hh

00001 /*
00002  * obj/i686-pc-linux-gnu/xrl/targets/ospfv2_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_OSPFV2_BASE_HH__
00016 #define __XRL_TARGETS_OSPFV2_BASE_HH__
00017 
00018 #undef XORP_LIBRARY_NAME
00019 #define XORP_LIBRARY_NAME "XrlOspfv2Target"
00020 
00021 #include "libxorp/xlog.h"
00022 #include "libxipc/xrl_cmd_map.hh"
00023 
00024 class XrlOspfv2TargetBase {
00025 protected:
00026     XrlCmdMap* _cmds;
00027 
00028 public:
00036     XrlOspfv2TargetBase(XrlCmdMap* cmds = 0);
00037 
00043     virtual ~XrlOspfv2TargetBase();
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 "ospfv2/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 
00358     virtual XrlCmdError raw_packet4_client_0_1_recv(
00359     // Input values,
00360     const string&   if_name,
00361     const string&   vif_name,
00362     const IPv4& src_address,
00363     const IPv4& dst_address,
00364     const uint32_t& ip_protocol,
00365     const int32_t&  ip_ttl,
00366     const int32_t&  ip_tos,
00367     const bool& ip_router_alert,
00368     const bool& ip_internet_control,
00369     const vector<uint8_t>&  payload) = 0;
00370 #ifdef XORP_ENABLE_ASYNC_SERVER
00371     typedef
00372     XorpCallback1<void, const XrlCmdError &>::RefPtr
00373     RawPacket4Client01RecvRF;
00374 
00375     class RawPacket4Client01RecvCB {
00376         RawPacket4Client01RecvRF cb;
00377 
00378     public:
00379         operator const RawPacket4Client01RecvRF& () const { return cb; }
00380         const RawPacket4Client01RecvRF& operator ->() const { return cb; }
00381         RawPacket4Client01RecvCB(const RawPacket4Client01RecvRF& cb)
00382           : cb(cb) { }
00383 
00384         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00385 
00386         void respond() const {
00387             cb->dispatch(XrlCmdError::OKAY());
00388         }
00389     };
00390 
00391     struct RawPacket4Client01RecvRsp :
00392       public RawPacket4Client01RecvCB {
00393         RawPacket4Client01RecvRsp(const RawPacket4Client01RecvRF& cb)
00394           : RawPacket4Client01RecvCB(cb) { }
00395 
00396     };
00397 
00398     virtual void async_raw_packet4_client_0_1_recv
00399        (
00400     const string&   if_name,
00401     const string&   vif_name,
00402     const IPv4& src_address,
00403     const IPv4& dst_address,
00404     const uint32_t& ip_protocol,
00405     const int32_t&  ip_ttl,
00406     const int32_t&  ip_tos,
00407     const bool& ip_router_alert,
00408     const bool& ip_internet_control,
00409     const vector<uint8_t>&  payload,
00410     RawPacket4Client01RecvCB);
00411 #endif
00412 
00422     virtual XrlCmdError policy_backend_0_1_configure(
00423     // Input values,
00424     const uint32_t& filter,
00425     const string&   conf) = 0;
00426 #ifdef XORP_ENABLE_ASYNC_SERVER
00427     typedef
00428     XorpCallback1<void, const XrlCmdError &>::RefPtr
00429     PolicyBackend01ConfigureRF;
00430 
00431     class PolicyBackend01ConfigureCB {
00432         PolicyBackend01ConfigureRF cb;
00433 
00434     public:
00435         operator const PolicyBackend01ConfigureRF& () const { return cb; }
00436         const PolicyBackend01ConfigureRF& operator ->() const { return cb; }
00437         PolicyBackend01ConfigureCB(const PolicyBackend01ConfigureRF& cb)
00438           : cb(cb) { }
00439 
00440         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00441 
00442         void respond() const {
00443             cb->dispatch(XrlCmdError::OKAY());
00444         }
00445     };
00446 
00447     struct PolicyBackend01ConfigureRsp :
00448       public PolicyBackend01ConfigureCB {
00449         PolicyBackend01ConfigureRsp(const PolicyBackend01ConfigureRF& cb)
00450           : PolicyBackend01ConfigureCB(cb) { }
00451 
00452     };
00453 
00454     virtual void async_policy_backend_0_1_configure
00455        (
00456     const uint32_t& filter,
00457     const string&   conf,
00458     PolicyBackend01ConfigureCB);
00459 #endif
00460 
00468     virtual XrlCmdError policy_backend_0_1_reset(
00469     // Input values,
00470     const uint32_t& filter) = 0;
00471 #ifdef XORP_ENABLE_ASYNC_SERVER
00472     typedef
00473     XorpCallback1<void, const XrlCmdError &>::RefPtr
00474     PolicyBackend01ResetRF;
00475 
00476     class PolicyBackend01ResetCB {
00477         PolicyBackend01ResetRF cb;
00478 
00479     public:
00480         operator const PolicyBackend01ResetRF& () const { return cb; }
00481         const PolicyBackend01ResetRF& operator ->() const { return cb; }
00482         PolicyBackend01ResetCB(const PolicyBackend01ResetRF& cb)
00483           : cb(cb) { }
00484 
00485         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00486 
00487         void respond() const {
00488             cb->dispatch(XrlCmdError::OKAY());
00489         }
00490     };
00491 
00492     struct PolicyBackend01ResetRsp :
00493       public PolicyBackend01ResetCB {
00494         PolicyBackend01ResetRsp(const PolicyBackend01ResetRF& cb)
00495           : PolicyBackend01ResetCB(cb) { }
00496 
00497     };
00498 
00499     virtual void async_policy_backend_0_1_reset
00500        (
00501     const uint32_t& filter,
00502     PolicyBackend01ResetCB);
00503 #endif
00504 
00510     virtual XrlCmdError policy_backend_0_1_push_routes() = 0;
00511 #ifdef XORP_ENABLE_ASYNC_SERVER
00512     typedef
00513     XorpCallback1<void, const XrlCmdError &>::RefPtr
00514     PolicyBackend01PushRoutesRF;
00515 
00516     class PolicyBackend01PushRoutesCB {
00517         PolicyBackend01PushRoutesRF cb;
00518 
00519     public:
00520         operator const PolicyBackend01PushRoutesRF& () const { return cb; }
00521         const PolicyBackend01PushRoutesRF& operator ->() const { return cb; }
00522         PolicyBackend01PushRoutesCB(const PolicyBackend01PushRoutesRF& cb)
00523           : cb(cb) { }
00524 
00525         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00526 
00527         void respond() const {
00528             cb->dispatch(XrlCmdError::OKAY());
00529         }
00530     };
00531 
00532     struct PolicyBackend01PushRoutesRsp :
00533       public PolicyBackend01PushRoutesCB {
00534         PolicyBackend01PushRoutesRsp(const PolicyBackend01PushRoutesRF& cb)
00535           : PolicyBackend01PushRoutesCB(cb) { }
00536 
00537     };
00538 
00539     virtual void async_policy_backend_0_1_push_routes
00540        (
00541     PolicyBackend01PushRoutesCB);
00542 #endif
00543 
00561     virtual XrlCmdError policy_redist4_0_1_add_route4(
00562     // Input values,
00563     const IPv4Net&  network,
00564     const bool& unicast,
00565     const bool& multicast,
00566     const IPv4& nexthop,
00567     const uint32_t& metric,
00568     const XrlAtomList&  policytags) = 0;
00569 #ifdef XORP_ENABLE_ASYNC_SERVER
00570     typedef
00571     XorpCallback1<void, const XrlCmdError &>::RefPtr
00572     PolicyRedist401AddRoute4RF;
00573 
00574     class PolicyRedist401AddRoute4CB {
00575         PolicyRedist401AddRoute4RF cb;
00576 
00577     public:
00578         operator const PolicyRedist401AddRoute4RF& () const { return cb; }
00579         const PolicyRedist401AddRoute4RF& operator ->() const { return cb; }
00580         PolicyRedist401AddRoute4CB(const PolicyRedist401AddRoute4RF& cb)
00581           : cb(cb) { }
00582 
00583         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00584 
00585         void respond() const {
00586             cb->dispatch(XrlCmdError::OKAY());
00587         }
00588     };
00589 
00590     struct PolicyRedist401AddRoute4Rsp :
00591       public PolicyRedist401AddRoute4CB {
00592         PolicyRedist401AddRoute4Rsp(const PolicyRedist401AddRoute4RF& cb)
00593           : PolicyRedist401AddRoute4CB(cb) { }
00594 
00595     };
00596 
00597     virtual void async_policy_redist4_0_1_add_route4
00598        (
00599     const IPv4Net&  network,
00600     const bool& unicast,
00601     const bool& multicast,
00602     const IPv4& nexthop,
00603     const uint32_t& metric,
00604     const XrlAtomList&  policytags,
00605     PolicyRedist401AddRoute4CB);
00606 #endif
00607 
00619     virtual XrlCmdError policy_redist4_0_1_delete_route4(
00620     // Input values,
00621     const IPv4Net&  network,
00622     const bool& unicast,
00623     const bool& multicast) = 0;
00624 #ifdef XORP_ENABLE_ASYNC_SERVER
00625     typedef
00626     XorpCallback1<void, const XrlCmdError &>::RefPtr
00627     PolicyRedist401DeleteRoute4RF;
00628 
00629     class PolicyRedist401DeleteRoute4CB {
00630         PolicyRedist401DeleteRoute4RF cb;
00631 
00632     public:
00633         operator const PolicyRedist401DeleteRoute4RF& () const { return cb; }
00634         const PolicyRedist401DeleteRoute4RF& operator ->() const { return cb; }
00635         PolicyRedist401DeleteRoute4CB(const PolicyRedist401DeleteRoute4RF& cb)
00636           : cb(cb) { }
00637 
00638         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00639 
00640         void respond() const {
00641             cb->dispatch(XrlCmdError::OKAY());
00642         }
00643     };
00644 
00645     struct PolicyRedist401DeleteRoute4Rsp :
00646       public PolicyRedist401DeleteRoute4CB {
00647         PolicyRedist401DeleteRoute4Rsp(const PolicyRedist401DeleteRoute4RF& cb)
00648           : PolicyRedist401DeleteRoute4CB(cb) { }
00649 
00650     };
00651 
00652     virtual void async_policy_redist4_0_1_delete_route4
00653        (
00654     const IPv4Net&  network,
00655     const bool& unicast,
00656     const bool& multicast,
00657     PolicyRedist401DeleteRoute4CB);
00658 #endif
00659 
00665     virtual XrlCmdError ospfv2_0_1_set_router_id(
00666     // Input values,
00667     const IPv4& id) = 0;
00668 #ifdef XORP_ENABLE_ASYNC_SERVER
00669     typedef
00670     XorpCallback1<void, const XrlCmdError &>::RefPtr
00671     Ospfv201SetRouterIdRF;
00672 
00673     class Ospfv201SetRouterIdCB {
00674         Ospfv201SetRouterIdRF cb;
00675 
00676     public:
00677         operator const Ospfv201SetRouterIdRF& () const { return cb; }
00678         const Ospfv201SetRouterIdRF& operator ->() const { return cb; }
00679         Ospfv201SetRouterIdCB(const Ospfv201SetRouterIdRF& cb)
00680           : cb(cb) { }
00681 
00682         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00683 
00684         void respond() const {
00685             cb->dispatch(XrlCmdError::OKAY());
00686         }
00687     };
00688 
00689     struct Ospfv201SetRouterIdRsp :
00690       public Ospfv201SetRouterIdCB {
00691         Ospfv201SetRouterIdRsp(const Ospfv201SetRouterIdRF& cb)
00692           : Ospfv201SetRouterIdCB(cb) { }
00693 
00694     };
00695 
00696     virtual void async_ospfv2_0_1_set_router_id
00697        (
00698     const IPv4& id,
00699     Ospfv201SetRouterIdCB);
00700 #endif
00701 
00707     virtual XrlCmdError ospfv2_0_1_set_rfc1583_compatibility(
00708     // Input values,
00709     const bool& compatibility) = 0;
00710 #ifdef XORP_ENABLE_ASYNC_SERVER
00711     typedef
00712     XorpCallback1<void, const XrlCmdError &>::RefPtr
00713     Ospfv201SetRfc1583CompatibilityRF;
00714 
00715     class Ospfv201SetRfc1583CompatibilityCB {
00716         Ospfv201SetRfc1583CompatibilityRF cb;
00717 
00718     public:
00719         operator const Ospfv201SetRfc1583CompatibilityRF& () const { return cb; }
00720         const Ospfv201SetRfc1583CompatibilityRF& operator ->() const { return cb; }
00721         Ospfv201SetRfc1583CompatibilityCB(const Ospfv201SetRfc1583CompatibilityRF& cb)
00722           : cb(cb) { }
00723 
00724         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00725 
00726         void respond() const {
00727             cb->dispatch(XrlCmdError::OKAY());
00728         }
00729     };
00730 
00731     struct Ospfv201SetRfc1583CompatibilityRsp :
00732       public Ospfv201SetRfc1583CompatibilityCB {
00733         Ospfv201SetRfc1583CompatibilityRsp(const Ospfv201SetRfc1583CompatibilityRF& cb)
00734           : Ospfv201SetRfc1583CompatibilityCB(cb) { }
00735 
00736     };
00737 
00738     virtual void async_ospfv2_0_1_set_rfc1583_compatibility
00739        (
00740     const bool& compatibility,
00741     Ospfv201SetRfc1583CompatibilityCB);
00742 #endif
00743 
00749     virtual XrlCmdError ospfv2_0_1_set_ip_router_alert(
00750     // Input values,
00751     const bool& ip_router_alert) = 0;
00752 #ifdef XORP_ENABLE_ASYNC_SERVER
00753     typedef
00754     XorpCallback1<void, const XrlCmdError &>::RefPtr
00755     Ospfv201SetIpRouterAlertRF;
00756 
00757     class Ospfv201SetIpRouterAlertCB {
00758         Ospfv201SetIpRouterAlertRF cb;
00759 
00760     public:
00761         operator const Ospfv201SetIpRouterAlertRF& () const { return cb; }
00762         const Ospfv201SetIpRouterAlertRF& operator ->() const { return cb; }
00763         Ospfv201SetIpRouterAlertCB(const Ospfv201SetIpRouterAlertRF& cb)
00764           : cb(cb) { }
00765 
00766         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00767 
00768         void respond() const {
00769             cb->dispatch(XrlCmdError::OKAY());
00770         }
00771     };
00772 
00773     struct Ospfv201SetIpRouterAlertRsp :
00774       public Ospfv201SetIpRouterAlertCB {
00775         Ospfv201SetIpRouterAlertRsp(const Ospfv201SetIpRouterAlertRF& cb)
00776           : Ospfv201SetIpRouterAlertCB(cb) { }
00777 
00778     };
00779 
00780     virtual void async_ospfv2_0_1_set_ip_router_alert
00781        (
00782     const bool& ip_router_alert,
00783     Ospfv201SetIpRouterAlertCB);
00784 #endif
00785 
00795     virtual XrlCmdError ospfv2_0_1_create_area_router(
00796     // Input values,
00797     const IPv4& area,
00798     const string&   type) = 0;
00799 #ifdef XORP_ENABLE_ASYNC_SERVER
00800     typedef
00801     XorpCallback1<void, const XrlCmdError &>::RefPtr
00802     Ospfv201CreateAreaRouterRF;
00803 
00804     class Ospfv201CreateAreaRouterCB {
00805         Ospfv201CreateAreaRouterRF cb;
00806 
00807     public:
00808         operator const Ospfv201CreateAreaRouterRF& () const { return cb; }
00809         const Ospfv201CreateAreaRouterRF& operator ->() const { return cb; }
00810         Ospfv201CreateAreaRouterCB(const Ospfv201CreateAreaRouterRF& cb)
00811           : cb(cb) { }
00812 
00813         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00814 
00815         void respond() const {
00816             cb->dispatch(XrlCmdError::OKAY());
00817         }
00818     };
00819 
00820     struct Ospfv201CreateAreaRouterRsp :
00821       public Ospfv201CreateAreaRouterCB {
00822         Ospfv201CreateAreaRouterRsp(const Ospfv201CreateAreaRouterRF& cb)
00823           : Ospfv201CreateAreaRouterCB(cb) { }
00824 
00825     };
00826 
00827     virtual void async_ospfv2_0_1_create_area_router
00828        (
00829     const IPv4& area,
00830     const string&   type,
00831     Ospfv201CreateAreaRouterCB);
00832 #endif
00833 
00843     virtual XrlCmdError ospfv2_0_1_change_area_router_type(
00844     // Input values,
00845     const IPv4& area,
00846     const string&   type) = 0;
00847 #ifdef XORP_ENABLE_ASYNC_SERVER
00848     typedef
00849     XorpCallback1<void, const XrlCmdError &>::RefPtr
00850     Ospfv201ChangeAreaRouterTypeRF;
00851 
00852     class Ospfv201ChangeAreaRouterTypeCB {
00853         Ospfv201ChangeAreaRouterTypeRF cb;
00854 
00855     public:
00856         operator const Ospfv201ChangeAreaRouterTypeRF& () const { return cb; }
00857         const Ospfv201ChangeAreaRouterTypeRF& operator ->() const { return cb; }
00858         Ospfv201ChangeAreaRouterTypeCB(const Ospfv201ChangeAreaRouterTypeRF& cb)
00859           : cb(cb) { }
00860 
00861         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00862 
00863         void respond() const {
00864             cb->dispatch(XrlCmdError::OKAY());
00865         }
00866     };
00867 
00868     struct Ospfv201ChangeAreaRouterTypeRsp :
00869       public Ospfv201ChangeAreaRouterTypeCB {
00870         Ospfv201ChangeAreaRouterTypeRsp(const Ospfv201ChangeAreaRouterTypeRF& cb)
00871           : Ospfv201ChangeAreaRouterTypeCB(cb) { }
00872 
00873     };
00874 
00875     virtual void async_ospfv2_0_1_change_area_router_type
00876        (
00877     const IPv4& area,
00878     const string&   type,
00879     Ospfv201ChangeAreaRouterTypeCB);
00880 #endif
00881 
00889     virtual XrlCmdError ospfv2_0_1_destroy_area_router(
00890     // Input values,
00891     const IPv4& area) = 0;
00892 #ifdef XORP_ENABLE_ASYNC_SERVER
00893     typedef
00894     XorpCallback1<void, const XrlCmdError &>::RefPtr
00895     Ospfv201DestroyAreaRouterRF;
00896 
00897     class Ospfv201DestroyAreaRouterCB {
00898         Ospfv201DestroyAreaRouterRF cb;
00899 
00900     public:
00901         operator const Ospfv201DestroyAreaRouterRF& () const { return cb; }
00902         const Ospfv201DestroyAreaRouterRF& operator ->() const { return cb; }
00903         Ospfv201DestroyAreaRouterCB(const Ospfv201DestroyAreaRouterRF& cb)
00904           : cb(cb) { }
00905 
00906         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00907 
00908         void respond() const {
00909             cb->dispatch(XrlCmdError::OKAY());
00910         }
00911     };
00912 
00913     struct Ospfv201DestroyAreaRouterRsp :
00914       public Ospfv201DestroyAreaRouterCB {
00915         Ospfv201DestroyAreaRouterRsp(const Ospfv201DestroyAreaRouterRF& cb)
00916           : Ospfv201DestroyAreaRouterCB(cb) { }
00917 
00918     };
00919 
00920     virtual void async_ospfv2_0_1_destroy_area_router
00921        (
00922     const IPv4& area,
00923     Ospfv201DestroyAreaRouterCB);
00924 #endif
00925 
00939     virtual XrlCmdError ospfv2_0_1_create_peer(
00940     // Input values,
00941     const string&   ifname,
00942     const string&   vifname,
00943     const IPv4& addr,
00944     const string&   type,
00945     const IPv4& area) = 0;
00946 #ifdef XORP_ENABLE_ASYNC_SERVER
00947     typedef
00948     XorpCallback1<void, const XrlCmdError &>::RefPtr
00949     Ospfv201CreatePeerRF;
00950 
00951     class Ospfv201CreatePeerCB {
00952         Ospfv201CreatePeerRF cb;
00953 
00954     public:
00955         operator const Ospfv201CreatePeerRF& () const { return cb; }
00956         const Ospfv201CreatePeerRF& operator ->() const { return cb; }
00957         Ospfv201CreatePeerCB(const Ospfv201CreatePeerRF& cb)
00958           : cb(cb) { }
00959 
00960         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00961 
00962         void respond() const {
00963             cb->dispatch(XrlCmdError::OKAY());
00964         }
00965     };
00966 
00967     struct Ospfv201CreatePeerRsp :
00968       public Ospfv201CreatePeerCB {
00969         Ospfv201CreatePeerRsp(const Ospfv201CreatePeerRF& cb)
00970           : Ospfv201CreatePeerCB(cb) { }
00971 
00972     };
00973 
00974     virtual void async_ospfv2_0_1_create_peer
00975        (
00976     const string&   ifname,
00977     const string&   vifname,
00978     const IPv4& addr,
00979     const string&   type,
00980     const IPv4& area,
00981     Ospfv201CreatePeerCB);
00982 #endif
00983 
00989     virtual XrlCmdError ospfv2_0_1_delete_peer(
00990     // Input values,
00991     const string&   ifname,
00992     const string&   vifname) = 0;
00993 #ifdef XORP_ENABLE_ASYNC_SERVER
00994     typedef
00995     XorpCallback1<void, const XrlCmdError &>::RefPtr
00996     Ospfv201DeletePeerRF;
00997 
00998     class Ospfv201DeletePeerCB {
00999         Ospfv201DeletePeerRF cb;
01000 
01001     public:
01002         operator const Ospfv201DeletePeerRF& () const { return cb; }
01003         const Ospfv201DeletePeerRF& operator ->() const { return cb; }
01004         Ospfv201DeletePeerCB(const Ospfv201DeletePeerRF& cb)
01005           : cb(cb) { }
01006 
01007         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01008 
01009         void respond() const {
01010             cb->dispatch(XrlCmdError::OKAY());
01011         }
01012     };
01013 
01014     struct Ospfv201DeletePeerRsp :
01015       public Ospfv201DeletePeerCB {
01016         Ospfv201DeletePeerRsp(const Ospfv201DeletePeerRF& cb)
01017           : Ospfv201DeletePeerCB(cb) { }
01018 
01019     };
01020 
01021     virtual void async_ospfv2_0_1_delete_peer
01022        (
01023     const string&   ifname,
01024     const string&   vifname,
01025     Ospfv201DeletePeerCB);
01026 #endif
01027 
01033     virtual XrlCmdError ospfv2_0_1_set_peer_state(
01034     // Input values,
01035     const string&   ifname,
01036     const string&   vifname,
01037     const bool& enable) = 0;
01038 #ifdef XORP_ENABLE_ASYNC_SERVER
01039     typedef
01040     XorpCallback1<void, const XrlCmdError &>::RefPtr
01041     Ospfv201SetPeerStateRF;
01042 
01043     class Ospfv201SetPeerStateCB {
01044         Ospfv201SetPeerStateRF cb;
01045 
01046     public:
01047         operator const Ospfv201SetPeerStateRF& () const { return cb; }
01048         const Ospfv201SetPeerStateRF& operator ->() const { return cb; }
01049         Ospfv201SetPeerStateCB(const Ospfv201SetPeerStateRF& cb)
01050           : cb(cb) { }
01051 
01052         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01053 
01054         void respond() const {
01055             cb->dispatch(XrlCmdError::OKAY());
01056         }
01057     };
01058 
01059     struct Ospfv201SetPeerStateRsp :
01060       public Ospfv201SetPeerStateCB {
01061         Ospfv201SetPeerStateRsp(const Ospfv201SetPeerStateRF& cb)
01062           : Ospfv201SetPeerStateCB(cb) { }
01063 
01064     };
01065 
01066     virtual void async_ospfv2_0_1_set_peer_state
01067        (
01068     const string&   ifname,
01069     const string&   vifname,
01070     const bool& enable,
01071     Ospfv201SetPeerStateCB);
01072 #endif
01073 
01079     virtual XrlCmdError ospfv2_0_1_add_neighbour(
01080     // Input values,
01081     const string&   ifname,
01082     const string&   vifname,
01083     const IPv4& area,
01084     const IPv4& neighbour_address,
01085     const IPv4& neighbour_id) = 0;
01086 #ifdef XORP_ENABLE_ASYNC_SERVER
01087     typedef
01088     XorpCallback1<void, const XrlCmdError &>::RefPtr
01089     Ospfv201AddNeighbourRF;
01090 
01091     class Ospfv201AddNeighbourCB {
01092         Ospfv201AddNeighbourRF cb;
01093 
01094     public:
01095         operator const Ospfv201AddNeighbourRF& () const { return cb; }
01096         const Ospfv201AddNeighbourRF& operator ->() const { return cb; }
01097         Ospfv201AddNeighbourCB(const Ospfv201AddNeighbourRF& cb)
01098           : cb(cb) { }
01099 
01100         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01101 
01102         void respond() const {
01103             cb->dispatch(XrlCmdError::OKAY());
01104         }
01105     };
01106 
01107     struct Ospfv201AddNeighbourRsp :
01108       public Ospfv201AddNeighbourCB {
01109         Ospfv201AddNeighbourRsp(const Ospfv201AddNeighbourRF& cb)
01110           : Ospfv201AddNeighbourCB(cb) { }
01111 
01112     };
01113 
01114     virtual void async_ospfv2_0_1_add_neighbour
01115        (
01116     const string&   ifname,
01117     const string&   vifname,
01118     const IPv4& area,
01119     const IPv4& neighbour_address,
01120     const IPv4& neighbour_id,
01121     Ospfv201AddNeighbourCB);
01122 #endif
01123 
01129     virtual XrlCmdError ospfv2_0_1_remove_neighbour(
01130     // Input values,
01131     const string&   ifname,
01132     const string&   vifname,
01133     const IPv4& area,
01134     const IPv4& neighbour_address,
01135     const IPv4& neighbour_id) = 0;
01136 #ifdef XORP_ENABLE_ASYNC_SERVER
01137     typedef
01138     XorpCallback1<void, const XrlCmdError &>::RefPtr
01139     Ospfv201RemoveNeighbourRF;
01140 
01141     class Ospfv201RemoveNeighbourCB {
01142         Ospfv201RemoveNeighbourRF cb;
01143 
01144     public:
01145         operator const Ospfv201RemoveNeighbourRF& () const { return cb; }
01146         const Ospfv201RemoveNeighbourRF& operator ->() const { return cb; }
01147         Ospfv201RemoveNeighbourCB(const Ospfv201RemoveNeighbourRF& cb)
01148           : cb(cb) { }
01149 
01150         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01151 
01152         void respond() const {
01153             cb->dispatch(XrlCmdError::OKAY());
01154         }
01155     };
01156 
01157     struct Ospfv201RemoveNeighbourRsp :
01158       public Ospfv201RemoveNeighbourCB {
01159         Ospfv201RemoveNeighbourRsp(const Ospfv201RemoveNeighbourRF& cb)
01160           : Ospfv201RemoveNeighbourCB(cb) { }
01161 
01162     };
01163 
01164     virtual void async_ospfv2_0_1_remove_neighbour
01165        (
01166     const string&   ifname,
01167     const string&   vifname,
01168     const IPv4& area,
01169     const IPv4& neighbour_address,
01170     const IPv4& neighbour_id,
01171     Ospfv201RemoveNeighbourCB);
01172 #endif
01173 
01185     virtual XrlCmdError ospfv2_0_1_create_virtual_link(
01186     // Input values,
01187     const IPv4& neighbour_id,
01188     const IPv4& area) = 0;
01189 #ifdef XORP_ENABLE_ASYNC_SERVER
01190     typedef
01191     XorpCallback1<void, const XrlCmdError &>::RefPtr
01192     Ospfv201CreateVirtualLinkRF;
01193 
01194     class Ospfv201CreateVirtualLinkCB {
01195         Ospfv201CreateVirtualLinkRF cb;
01196 
01197     public:
01198         operator const Ospfv201CreateVirtualLinkRF& () const { return cb; }
01199         const Ospfv201CreateVirtualLinkRF& operator ->() const { return cb; }
01200         Ospfv201CreateVirtualLinkCB(const Ospfv201CreateVirtualLinkRF& cb)
01201           : cb(cb) { }
01202 
01203         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01204 
01205         void respond() const {
01206             cb->dispatch(XrlCmdError::OKAY());
01207         }
01208     };
01209 
01210     struct Ospfv201CreateVirtualLinkRsp :
01211       public Ospfv201CreateVirtualLinkCB {
01212         Ospfv201CreateVirtualLinkRsp(const Ospfv201CreateVirtualLinkRF& cb)
01213           : Ospfv201CreateVirtualLinkCB(cb) { }
01214 
01215     };
01216 
01217     virtual void async_ospfv2_0_1_create_virtual_link
01218        (
01219     const IPv4& neighbour_id,
01220     const IPv4& area,
01221     Ospfv201CreateVirtualLinkCB);
01222 #endif
01223 
01231     virtual XrlCmdError ospfv2_0_1_delete_virtual_link(
01232     // Input values,
01233     const IPv4& neighbour_id) = 0;
01234 #ifdef XORP_ENABLE_ASYNC_SERVER
01235     typedef
01236     XorpCallback1<void, const XrlCmdError &>::RefPtr
01237     Ospfv201DeleteVirtualLinkRF;
01238 
01239     class Ospfv201DeleteVirtualLinkCB {
01240         Ospfv201DeleteVirtualLinkRF cb;
01241 
01242     public:
01243         operator const Ospfv201DeleteVirtualLinkRF& () const { return cb; }
01244         const Ospfv201DeleteVirtualLinkRF& operator ->() const { return cb; }
01245         Ospfv201DeleteVirtualLinkCB(const Ospfv201DeleteVirtualLinkRF& cb)
01246           : cb(cb) { }
01247 
01248         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01249 
01250         void respond() const {
01251             cb->dispatch(XrlCmdError::OKAY());
01252         }
01253     };
01254 
01255     struct Ospfv201DeleteVirtualLinkRsp :
01256       public Ospfv201DeleteVirtualLinkCB {
01257         Ospfv201DeleteVirtualLinkRsp(const Ospfv201DeleteVirtualLinkRF& cb)
01258           : Ospfv201DeleteVirtualLinkCB(cb) { }
01259 
01260     };
01261 
01262     virtual void async_ospfv2_0_1_delete_virtual_link
01263        (
01264     const IPv4& neighbour_id,
01265     Ospfv201DeleteVirtualLinkCB);
01266 #endif
01267 
01277     virtual XrlCmdError ospfv2_0_1_transit_area_virtual_link(
01278     // Input values,
01279     const IPv4& neighbour_id,
01280     const IPv4& transit_area) = 0;
01281 #ifdef XORP_ENABLE_ASYNC_SERVER
01282     typedef
01283     XorpCallback1<void, const XrlCmdError &>::RefPtr
01284     Ospfv201TransitAreaVirtualLinkRF;
01285 
01286     class Ospfv201TransitAreaVirtualLinkCB {
01287         Ospfv201TransitAreaVirtualLinkRF cb;
01288 
01289     public:
01290         operator const Ospfv201TransitAreaVirtualLinkRF& () const { return cb; }
01291         const Ospfv201TransitAreaVirtualLinkRF& operator ->() const { return cb; }
01292         Ospfv201TransitAreaVirtualLinkCB(const Ospfv201TransitAreaVirtualLinkRF& cb)
01293           : cb(cb) { }
01294 
01295         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01296 
01297         void respond() const {
01298             cb->dispatch(XrlCmdError::OKAY());
01299         }
01300     };
01301 
01302     struct Ospfv201TransitAreaVirtualLinkRsp :
01303       public Ospfv201TransitAreaVirtualLinkCB {
01304         Ospfv201TransitAreaVirtualLinkRsp(const Ospfv201TransitAreaVirtualLinkRF& cb)
01305           : Ospfv201TransitAreaVirtualLinkCB(cb) { }
01306 
01307     };
01308 
01309     virtual void async_ospfv2_0_1_transit_area_virtual_link
01310        (
01311     const IPv4& neighbour_id,
01312     const IPv4& transit_area,
01313     Ospfv201TransitAreaVirtualLinkCB);
01314 #endif
01315 
01321     virtual XrlCmdError ospfv2_0_1_set_interface_cost(
01322     // Input values,
01323     const string&   ifname,
01324     const string&   vifname,
01325     const IPv4& area,
01326     const uint32_t& cost) = 0;
01327 #ifdef XORP_ENABLE_ASYNC_SERVER
01328     typedef
01329     XorpCallback1<void, const XrlCmdError &>::RefPtr
01330     Ospfv201SetInterfaceCostRF;
01331 
01332     class Ospfv201SetInterfaceCostCB {
01333         Ospfv201SetInterfaceCostRF cb;
01334 
01335     public:
01336         operator const Ospfv201SetInterfaceCostRF& () const { return cb; }
01337         const Ospfv201SetInterfaceCostRF& operator ->() const { return cb; }
01338         Ospfv201SetInterfaceCostCB(const Ospfv201SetInterfaceCostRF& cb)
01339           : cb(cb) { }
01340 
01341         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01342 
01343         void respond() const {
01344             cb->dispatch(XrlCmdError::OKAY());
01345         }
01346     };
01347 
01348     struct Ospfv201SetInterfaceCostRsp :
01349       public Ospfv201SetInterfaceCostCB {
01350         Ospfv201SetInterfaceCostRsp(const Ospfv201SetInterfaceCostRF& cb)
01351           : Ospfv201SetInterfaceCostCB(cb) { }
01352 
01353     };
01354 
01355     virtual void async_ospfv2_0_1_set_interface_cost
01356        (
01357     const string&   ifname,
01358     const string&   vifname,
01359     const IPv4& area,
01360     const uint32_t& cost,
01361     Ospfv201SetInterfaceCostCB);
01362 #endif
01363 
01375     virtual XrlCmdError ospfv2_0_1_set_retransmit_interval(
01376     // Input values,
01377     const string&   ifname,
01378     const string&   vifname,
01379     const IPv4& area,
01380     const uint32_t& interval) = 0;
01381 #ifdef XORP_ENABLE_ASYNC_SERVER
01382     typedef
01383     XorpCallback1<void, const XrlCmdError &>::RefPtr
01384     Ospfv201SetRetransmitIntervalRF;
01385 
01386     class Ospfv201SetRetransmitIntervalCB {
01387         Ospfv201SetRetransmitIntervalRF cb;
01388 
01389     public:
01390         operator const Ospfv201SetRetransmitIntervalRF& () const { return cb; }
01391         const Ospfv201SetRetransmitIntervalRF& operator ->() const { return cb; }
01392         Ospfv201SetRetransmitIntervalCB(const Ospfv201SetRetransmitIntervalRF& cb)
01393           : cb(cb) { }
01394 
01395         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01396 
01397         void respond() const {
01398             cb->dispatch(XrlCmdError::OKAY());
01399         }
01400     };
01401 
01402     struct Ospfv201SetRetransmitIntervalRsp :
01403       public Ospfv201SetRetransmitIntervalCB {
01404         Ospfv201SetRetransmitIntervalRsp(const Ospfv201SetRetransmitIntervalRF& cb)
01405           : Ospfv201SetRetransmitIntervalCB(cb) { }
01406 
01407     };
01408 
01409     virtual void async_ospfv2_0_1_set_retransmit_interval
01410        (
01411     const string&   ifname,
01412     const string&   vifname,
01413     const IPv4& area,
01414     const uint32_t& interval,
01415     Ospfv201SetRetransmitIntervalCB);
01416 #endif
01417 
01427     virtual XrlCmdError ospfv2_0_1_set_inftransdelay(
01428     // Input values,
01429     const string&   ifname,
01430     const string&   vifname,
01431     const IPv4& area,
01432     const uint32_t& delay) = 0;
01433 #ifdef XORP_ENABLE_ASYNC_SERVER
01434     typedef
01435     XorpCallback1<void, const XrlCmdError &>::RefPtr
01436     Ospfv201SetInftransdelayRF;
01437 
01438     class Ospfv201SetInftransdelayCB {
01439         Ospfv201SetInftransdelayRF cb;
01440 
01441     public:
01442         operator const Ospfv201SetInftransdelayRF& () const { return cb; }
01443         const Ospfv201SetInftransdelayRF& operator ->() const { return cb; }
01444         Ospfv201SetInftransdelayCB(const Ospfv201SetInftransdelayRF& cb)
01445           : cb(cb) { }
01446 
01447         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01448 
01449         void respond() const {
01450             cb->dispatch(XrlCmdError::OKAY());
01451         }
01452     };
01453 
01454     struct Ospfv201SetInftransdelayRsp :
01455       public Ospfv201SetInftransdelayCB {
01456         Ospfv201SetInftransdelayRsp(const Ospfv201SetInftransdelayRF& cb)
01457           : Ospfv201SetInftransdelayCB(cb) { }
01458 
01459     };
01460 
01461     virtual void async_ospfv2_0_1_set_inftransdelay
01462        (
01463     const string&   ifname,
01464     const string&   vifname,
01465     const IPv4& area,
01466     const uint32_t& delay,
01467     Ospfv201SetInftransdelayCB);
01468 #endif
01469 
01475     virtual XrlCmdError ospfv2_0_1_set_router_priority(
01476     // Input values,
01477     const string&   ifname,
01478     const string&   vifname,
01479     const IPv4& area,
01480     const uint32_t& priority) = 0;
01481 #ifdef XORP_ENABLE_ASYNC_SERVER
01482     typedef
01483     XorpCallback1<void, const XrlCmdError &>::RefPtr
01484     Ospfv201SetRouterPriorityRF;
01485 
01486     class Ospfv201SetRouterPriorityCB {
01487         Ospfv201SetRouterPriorityRF cb;
01488 
01489     public:
01490         operator const Ospfv201SetRouterPriorityRF& () const { return cb; }
01491         const Ospfv201SetRouterPriorityRF& operator ->() const { return cb; }
01492         Ospfv201SetRouterPriorityCB(const Ospfv201SetRouterPriorityRF& cb)
01493           : cb(cb) { }
01494 
01495         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01496 
01497         void respond() const {
01498             cb->dispatch(XrlCmdError::OKAY());
01499         }
01500     };
01501 
01502     struct Ospfv201SetRouterPriorityRsp :
01503       public Ospfv201SetRouterPriorityCB {
01504         Ospfv201SetRouterPriorityRsp(const Ospfv201SetRouterPriorityRF& cb)
01505           : Ospfv201SetRouterPriorityCB(cb) { }
01506 
01507     };
01508 
01509     virtual void async_ospfv2_0_1_set_router_priority
01510        (
01511     const string&   ifname,
01512     const string&   vifname,
01513     const IPv4& area,
01514     const uint32_t& priority,
01515     Ospfv201SetRouterPriorityCB);
01516 #endif
01517 
01523     virtual XrlCmdError ospfv2_0_1_set_hello_interval(
01524     // Input values,
01525     const string&   ifname,
01526     const string&   vifname,
01527     const IPv4& area,
01528     const uint32_t& interval) = 0;
01529 #ifdef XORP_ENABLE_ASYNC_SERVER
01530     typedef
01531     XorpCallback1<void, const XrlCmdError &>::RefPtr
01532     Ospfv201SetHelloIntervalRF;
01533 
01534     class Ospfv201SetHelloIntervalCB {
01535         Ospfv201SetHelloIntervalRF cb;
01536 
01537     public:
01538         operator const Ospfv201SetHelloIntervalRF& () const { return cb; }
01539         const Ospfv201SetHelloIntervalRF& operator ->() const { return cb; }
01540         Ospfv201SetHelloIntervalCB(const Ospfv201SetHelloIntervalRF& cb)
01541           : cb(cb) { }
01542 
01543         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01544 
01545         void respond() const {
01546             cb->dispatch(XrlCmdError::OKAY());
01547         }
01548     };
01549 
01550     struct Ospfv201SetHelloIntervalRsp :
01551       public Ospfv201SetHelloIntervalCB {
01552         Ospfv201SetHelloIntervalRsp(const Ospfv201SetHelloIntervalRF& cb)
01553           : Ospfv201SetHelloIntervalCB(cb) { }
01554 
01555     };
01556 
01557     virtual void async_ospfv2_0_1_set_hello_interval
01558        (
01559     const string&   ifname,
01560     const string&   vifname,
01561     const IPv4& area,
01562     const uint32_t& interval,
01563     Ospfv201SetHelloIntervalCB);
01564 #endif
01565 
01571     virtual XrlCmdError ospfv2_0_1_set_router_dead_interval(
01572     // Input values,
01573     const string&   ifname,
01574     const string&   vifname,
01575     const IPv4& area,
01576     const uint32_t& interval) = 0;
01577 #ifdef XORP_ENABLE_ASYNC_SERVER
01578     typedef
01579     XorpCallback1<void, const XrlCmdError &>::RefPtr
01580     Ospfv201SetRouterDeadIntervalRF;
01581 
01582     class Ospfv201SetRouterDeadIntervalCB {
01583         Ospfv201SetRouterDeadIntervalRF cb;
01584 
01585     public:
01586         operator const Ospfv201SetRouterDeadIntervalRF& () const { return cb; }
01587         const Ospfv201SetRouterDeadIntervalRF& operator ->() const { return cb; }
01588         Ospfv201SetRouterDeadIntervalCB(const Ospfv201SetRouterDeadIntervalRF& cb)
01589           : cb(cb) { }
01590 
01591         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01592 
01593         void respond() const {
01594             cb->dispatch(XrlCmdError::OKAY());
01595         }
01596     };
01597 
01598     struct Ospfv201SetRouterDeadIntervalRsp :
01599       public Ospfv201SetRouterDeadIntervalCB {
01600         Ospfv201SetRouterDeadIntervalRsp(const Ospfv201SetRouterDeadIntervalRF& cb)
01601           : Ospfv201SetRouterDeadIntervalCB(cb) { }
01602 
01603     };
01604 
01605     virtual void async_ospfv2_0_1_set_router_dead_interval
01606        (
01607     const string&   ifname,
01608     const string&   vifname,
01609     const IPv4& area,
01610     const uint32_t& interval,
01611     Ospfv201SetRouterDeadIntervalCB);
01612 #endif
01613 
01627     virtual XrlCmdError ospfv2_0_1_set_simple_authentication_key(
01628     // Input values,
01629     const string&   ifname,
01630     const string&   vifname,
01631     const IPv4& area,
01632     const string&   password) = 0;
01633 #ifdef XORP_ENABLE_ASYNC_SERVER
01634     typedef
01635     XorpCallback1<void, const XrlCmdError &>::RefPtr
01636     Ospfv201SetSimpleAuthenticationKeyRF;
01637 
01638     class Ospfv201SetSimpleAuthenticationKeyCB {
01639         Ospfv201SetSimpleAuthenticationKeyRF cb;
01640 
01641     public:
01642         operator const Ospfv201SetSimpleAuthenticationKeyRF& () const { return cb; }
01643         const Ospfv201SetSimpleAuthenticationKeyRF& operator ->() const { return cb; }
01644         Ospfv201SetSimpleAuthenticationKeyCB(const Ospfv201SetSimpleAuthenticationKeyRF& cb)
01645           : cb(cb) { }
01646 
01647         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01648 
01649         void respond() const {
01650             cb->dispatch(XrlCmdError::OKAY());
01651         }
01652     };
01653 
01654     struct Ospfv201SetSimpleAuthenticationKeyRsp :
01655       public Ospfv201SetSimpleAuthenticationKeyCB {
01656         Ospfv201SetSimpleAuthenticationKeyRsp(const Ospfv201SetSimpleAuthenticationKeyRF& cb)
01657           : Ospfv201SetSimpleAuthenticationKeyCB(cb) { }
01658 
01659     };
01660 
01661     virtual void async_ospfv2_0_1_set_simple_authentication_key
01662        (
01663     const string&   ifname,
01664     const string&   vifname,
01665     const IPv4& area,
01666     const string&   password,
01667     Ospfv201SetSimpleAuthenticationKeyCB);
01668 #endif
01669 
01681     virtual XrlCmdError ospfv2_0_1_delete_simple_authentication_key(
01682     // Input values,
01683     const string&   ifname,
01684     const string&   vifname,
01685     const IPv4& area) = 0;
01686 #ifdef XORP_ENABLE_ASYNC_SERVER
01687     typedef
01688     XorpCallback1<void, const XrlCmdError &>::RefPtr
01689     Ospfv201DeleteSimpleAuthenticationKeyRF;
01690 
01691     class Ospfv201DeleteSimpleAuthenticationKeyCB {
01692         Ospfv201DeleteSimpleAuthenticationKeyRF cb;
01693 
01694     public:
01695         operator const Ospfv201DeleteSimpleAuthenticationKeyRF& () const { return cb; }
01696         const Ospfv201DeleteSimpleAuthenticationKeyRF& operator ->() const { return cb; }
01697         Ospfv201DeleteSimpleAuthenticationKeyCB(const Ospfv201DeleteSimpleAuthenticationKeyRF& cb)
01698           : cb(cb) { }
01699 
01700         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01701 
01702         void respond() const {
01703             cb->dispatch(XrlCmdError::OKAY());
01704         }
01705     };
01706 
01707     struct Ospfv201DeleteSimpleAuthenticationKeyRsp :
01708       public Ospfv201DeleteSimpleAuthenticationKeyCB {
01709         Ospfv201DeleteSimpleAuthenticationKeyRsp(const Ospfv201DeleteSimpleAuthenticationKeyRF& cb)
01710           : Ospfv201DeleteSimpleAuthenticationKeyCB(cb) { }
01711 
01712     };
01713 
01714     virtual void async_ospfv2_0_1_delete_simple_authentication_key
01715        (
01716     const string&   ifname,
01717     const string&   vifname,
01718     const IPv4& area,
01719     Ospfv201DeleteSimpleAuthenticationKeyCB);
01720 #endif
01721 
01745     virtual XrlCmdError ospfv2_0_1_set_md5_authentication_key(
01746     // Input values,
01747     const string&   ifname,
01748     const string&   vifname,
01749     const IPv4& area,
01750     const uint32_t& key_id,
01751     const string&   password,
01752     const string&   start_time,
01753     const string&   end_time,
01754     const uint32_t& max_time_drift) = 0;
01755 #ifdef XORP_ENABLE_ASYNC_SERVER
01756     typedef
01757     XorpCallback1<void, const XrlCmdError &>::RefPtr
01758     Ospfv201SetMd5AuthenticationKeyRF;
01759 
01760     class Ospfv201SetMd5AuthenticationKeyCB {
01761         Ospfv201SetMd5AuthenticationKeyRF cb;
01762 
01763     public:
01764         operator const Ospfv201SetMd5AuthenticationKeyRF& () const { return cb; }
01765         const Ospfv201SetMd5AuthenticationKeyRF& operator ->() const { return cb; }
01766         Ospfv201SetMd5AuthenticationKeyCB(const Ospfv201SetMd5AuthenticationKeyRF& cb)
01767           : cb(cb) { }
01768 
01769         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01770 
01771         void respond() const {
01772             cb->dispatch(XrlCmdError::OKAY());
01773         }
01774     };
01775 
01776     struct Ospfv201SetMd5AuthenticationKeyRsp :
01777       public Ospfv201SetMd5AuthenticationKeyCB {
01778         Ospfv201SetMd5AuthenticationKeyRsp(const Ospfv201SetMd5AuthenticationKeyRF& cb)
01779           : Ospfv201SetMd5AuthenticationKeyCB(cb) { }
01780 
01781     };
01782 
01783     virtual void async_ospfv2_0_1_set_md5_authentication_key
01784        (
01785     const string&   ifname,
01786     const string&   vifname,
01787     const IPv4& area,
01788     const uint32_t& key_id,
01789     const string&   password,
01790     const string&   start_time,
01791     const string&   end_time,
01792     const uint32_t& max_time_drift,
01793     Ospfv201SetMd5AuthenticationKeyCB);
01794 #endif
01795 
01809     virtual XrlCmdError ospfv2_0_1_delete_md5_authentication_key(
01810     // Input values,
01811     const string&   ifname,
01812     const string&   vifname,
01813     const IPv4& area,
01814     const uint32_t& key_id) = 0;
01815 #ifdef XORP_ENABLE_ASYNC_SERVER
01816     typedef
01817     XorpCallback1<void, const XrlCmdError &>::RefPtr
01818     Ospfv201DeleteMd5AuthenticationKeyRF;
01819 
01820     class Ospfv201DeleteMd5AuthenticationKeyCB {
01821         Ospfv201DeleteMd5AuthenticationKeyRF cb;
01822 
01823     public:
01824         operator const Ospfv201DeleteMd5AuthenticationKeyRF& () const { return cb; }
01825         const Ospfv201DeleteMd5AuthenticationKeyRF& operator ->() const { return cb; }
01826         Ospfv201DeleteMd5AuthenticationKeyCB(const Ospfv201DeleteMd5AuthenticationKeyRF& 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 Ospfv201DeleteMd5AuthenticationKeyRsp :
01837       public Ospfv201DeleteMd5AuthenticationKeyCB {
01838         Ospfv201DeleteMd5AuthenticationKeyRsp(const Ospfv201DeleteMd5AuthenticationKeyRF& cb)
01839           : Ospfv201DeleteMd5AuthenticationKeyCB(cb) { }
01840 
01841     };
01842 
01843     virtual void async_ospfv2_0_1_delete_md5_authentication_key
01844        (
01845     const string&   ifname,
01846     const string&   vifname,
01847     const IPv4& area,
01848     const uint32_t& key_id,
01849     Ospfv201DeleteMd5AuthenticationKeyCB);
01850 #endif
01851 
01857     virtual XrlCmdError ospfv2_0_1_set_passive(
01858     // Input values,
01859     const string&   ifname,
01860     const string&   vifname,
01861     const IPv4& area,
01862     const bool& passive,
01863     const bool& host) = 0;
01864 #ifdef XORP_ENABLE_ASYNC_SERVER
01865     typedef
01866     XorpCallback1<void, const XrlCmdError &>::RefPtr
01867     Ospfv201SetPassiveRF;
01868 
01869     class Ospfv201SetPassiveCB {
01870         Ospfv201SetPassiveRF cb;
01871 
01872     public:
01873         operator const Ospfv201SetPassiveRF& () const { return cb; }
01874         const Ospfv201SetPassiveRF& operator ->() const { return cb; }
01875         Ospfv201SetPassiveCB(const Ospfv201SetPassiveRF& cb)
01876           : cb(cb) { }
01877 
01878         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01879 
01880         void respond() const {
01881             cb->dispatch(XrlCmdError::OKAY());
01882         }
01883     };
01884 
01885     struct Ospfv201SetPassiveRsp :
01886       public Ospfv201SetPassiveCB {
01887         Ospfv201SetPassiveRsp(const Ospfv201SetPassiveRF& cb)
01888           : Ospfv201SetPassiveCB(cb) { }
01889 
01890     };
01891 
01892     virtual void async_ospfv2_0_1_set_passive
01893        (
01894     const string&   ifname,
01895     const string&   vifname,
01896     const IPv4& area,
01897     const bool& passive,
01898     const bool& host,
01899     Ospfv201SetPassiveCB);
01900 #endif
01901 
01908     virtual XrlCmdError ospfv2_0_1_originate_default_route(
01909     // Input values,
01910     const IPv4& area,
01911     const bool& enable) = 0;
01912 #ifdef XORP_ENABLE_ASYNC_SERVER
01913     typedef
01914     XorpCallback1<void, const XrlCmdError &>::RefPtr
01915     Ospfv201OriginateDefaultRouteRF;
01916 
01917     class Ospfv201OriginateDefaultRouteCB {
01918         Ospfv201OriginateDefaultRouteRF cb;
01919 
01920     public:
01921         operator const Ospfv201OriginateDefaultRouteRF& () const { return cb; }
01922         const Ospfv201OriginateDefaultRouteRF& operator ->() const { return cb; }
01923         Ospfv201OriginateDefaultRouteCB(const Ospfv201OriginateDefaultRouteRF& cb)
01924           : cb(cb) { }
01925 
01926         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01927 
01928         void respond() const {
01929             cb->dispatch(XrlCmdError::OKAY());
01930         }
01931     };
01932 
01933     struct Ospfv201OriginateDefaultRouteRsp :
01934       public Ospfv201OriginateDefaultRouteCB {
01935         Ospfv201OriginateDefaultRouteRsp(const Ospfv201OriginateDefaultRouteRF& cb)
01936           : Ospfv201OriginateDefaultRouteCB(cb) { }
01937 
01938     };
01939 
01940     virtual void async_ospfv2_0_1_originate_default_route
01941        (
01942     const IPv4& area,
01943     const bool& enable,
01944     Ospfv201OriginateDefaultRouteCB);
01945 #endif
01946 
01953     virtual XrlCmdError ospfv2_0_1_stub_default_cost(
01954     // Input values,
01955     const IPv4& area,
01956     const uint32_t& cost) = 0;
01957 #ifdef XORP_ENABLE_ASYNC_SERVER
01958     typedef
01959     XorpCallback1<void, const XrlCmdError &>::RefPtr
01960     Ospfv201StubDefaultCostRF;
01961 
01962     class Ospfv201StubDefaultCostCB {
01963         Ospfv201StubDefaultCostRF cb;
01964 
01965     public:
01966         operator const Ospfv201StubDefaultCostRF& () const { return cb; }
01967         const Ospfv201StubDefaultCostRF& operator ->() const { return cb; }
01968         Ospfv201StubDefaultCostCB(const Ospfv201StubDefaultCostRF& 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 Ospfv201StubDefaultCostRsp :
01979       public Ospfv201StubDefaultCostCB {
01980         Ospfv201StubDefaultCostRsp(const Ospfv201StubDefaultCostRF& cb)
01981           : Ospfv201StubDefaultCostCB(cb) { }
01982 
01983     };
01984 
01985     virtual void async_ospfv2_0_1_stub_default_cost
01986        (
01987     const IPv4& area,
01988     const uint32_t& cost,
01989     Ospfv201StubDefaultCostCB);
01990 #endif
01991 
01997     virtual XrlCmdError ospfv2_0_1_summaries(
01998     // Input values,
01999     const IPv4& area,
02000     const bool& enable) = 0;
02001 #ifdef XORP_ENABLE_ASYNC_SERVER
02002     typedef
02003     XorpCallback1<void, const XrlCmdError &>::RefPtr
02004     Ospfv201SummariesRF;
02005 
02006     class Ospfv201SummariesCB {
02007         Ospfv201SummariesRF cb;
02008 
02009     public:
02010         operator const Ospfv201SummariesRF& () const { return cb; }
02011         const Ospfv201SummariesRF& operator ->() const { return cb; }
02012         Ospfv201SummariesCB(const Ospfv201SummariesRF& cb)
02013           : cb(cb) { }
02014 
02015         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02016 
02017         void respond() const {
02018             cb->dispatch(XrlCmdError::OKAY());
02019         }
02020     };
02021 
02022     struct Ospfv201SummariesRsp :
02023       public Ospfv201SummariesCB {
02024         Ospfv201SummariesRsp(const Ospfv201SummariesRF& cb)
02025           : Ospfv201SummariesCB(cb) { }
02026 
02027     };
02028 
02029     virtual void async_ospfv2_0_1_summaries
02030        (
02031     const IPv4& area,
02032     const bool& enable,
02033     Ospfv201SummariesCB);
02034 #endif
02035 
02041     virtual XrlCmdError ospfv2_0_1_area_range_add(
02042     // Input values,
02043     const IPv4& area,
02044     const IPv4Net&  net,
02045     const bool& advertise) = 0;
02046 #ifdef XORP_ENABLE_ASYNC_SERVER
02047     typedef
02048     XorpCallback1<void, const XrlCmdError &>::RefPtr
02049     Ospfv201AreaRangeAddRF;
02050 
02051     class Ospfv201AreaRangeAddCB {
02052         Ospfv201AreaRangeAddRF cb;
02053 
02054     public:
02055         operator const Ospfv201AreaRangeAddRF& () const { return cb; }
02056         const Ospfv201AreaRangeAddRF& operator ->() const { return cb; }
02057         Ospfv201AreaRangeAddCB(const Ospfv201AreaRangeAddRF& cb)
02058           : cb(cb) { }
02059 
02060         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02061 
02062         void respond() const {
02063             cb->dispatch(XrlCmdError::OKAY());
02064         }
02065     };
02066 
02067     struct Ospfv201AreaRangeAddRsp :
02068       public Ospfv201AreaRangeAddCB {
02069         Ospfv201AreaRangeAddRsp(const Ospfv201AreaRangeAddRF& cb)
02070           : Ospfv201AreaRangeAddCB(cb) { }
02071 
02072     };
02073 
02074     virtual void async_ospfv2_0_1_area_range_add
02075        (
02076     const IPv4& area,
02077     const IPv4Net&  net,
02078     const bool& advertise,
02079     Ospfv201AreaRangeAddCB);
02080 #endif
02081 
02087     virtual XrlCmdError ospfv2_0_1_area_range_delete(
02088     // Input values,
02089     const IPv4& area,
02090     const IPv4Net&  net) = 0;
02091 #ifdef XORP_ENABLE_ASYNC_SERVER
02092     typedef
02093     XorpCallback1<void, const XrlCmdError &>::RefPtr
02094     Ospfv201AreaRangeDeleteRF;
02095 
02096     class Ospfv201AreaRangeDeleteCB {
02097         Ospfv201AreaRangeDeleteRF cb;
02098 
02099     public:
02100         operator const Ospfv201AreaRangeDeleteRF& () const { return cb; }
02101         const Ospfv201AreaRangeDeleteRF& operator ->() const { return cb; }
02102         Ospfv201AreaRangeDeleteCB(const Ospfv201AreaRangeDeleteRF& cb)
02103           : cb(cb) { }
02104 
02105         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02106 
02107         void respond() const {
02108             cb->dispatch(XrlCmdError::OKAY());
02109         }
02110     };
02111 
02112     struct Ospfv201AreaRangeDeleteRsp :
02113       public Ospfv201AreaRangeDeleteCB {
02114         Ospfv201AreaRangeDeleteRsp(const Ospfv201AreaRangeDeleteRF& cb)
02115           : Ospfv201AreaRangeDeleteCB(cb) { }
02116 
02117     };
02118 
02119     virtual void async_ospfv2_0_1_area_range_delete
02120        (
02121     const IPv4& area,
02122     const IPv4Net&  net,
02123     Ospfv201AreaRangeDeleteCB);
02124 #endif
02125 
02131     virtual XrlCmdError ospfv2_0_1_area_range_change_state(
02132     // Input values,
02133     const IPv4& area,
02134     const IPv4Net&  net,
02135     const bool& advertise) = 0;
02136 #ifdef XORP_ENABLE_ASYNC_SERVER
02137     typedef
02138     XorpCallback1<void, const XrlCmdError &>::RefPtr
02139     Ospfv201AreaRangeChangeStateRF;
02140 
02141     class Ospfv201AreaRangeChangeStateCB {
02142         Ospfv201AreaRangeChangeStateRF cb;
02143 
02144     public:
02145         operator const Ospfv201AreaRangeChangeStateRF& () const { return cb; }
02146         const Ospfv201AreaRangeChangeStateRF& operator ->() const { return cb; }
02147         Ospfv201AreaRangeChangeStateCB(const Ospfv201AreaRangeChangeStateRF& cb)
02148           : cb(cb) { }
02149 
02150         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02151 
02152         void respond() const {
02153             cb->dispatch(XrlCmdError::OKAY());
02154         }
02155     };
02156 
02157     struct Ospfv201AreaRangeChangeStateRsp :
02158       public Ospfv201AreaRangeChangeStateCB {
02159         Ospfv201AreaRangeChangeStateRsp(const Ospfv201AreaRangeChangeStateRF& cb)
02160           : Ospfv201AreaRangeChangeStateCB(cb) { }
02161 
02162     };
02163 
02164     virtual void async_ospfv2_0_1_area_range_change_state
02165        (
02166     const IPv4& area,
02167     const IPv4Net&  net,
02168     const bool& advertise,
02169     Ospfv201AreaRangeChangeStateCB);
02170 #endif
02171 
02181     virtual XrlCmdError ospfv2_0_1_trace(
02182     // Input values,
02183     const string&   tvar,
02184     const bool& enable) = 0;
02185 #ifdef XORP_ENABLE_ASYNC_SERVER
02186     typedef
02187     XorpCallback1<void, const XrlCmdError &>::RefPtr
02188     Ospfv201TraceRF;
02189 
02190     class Ospfv201TraceCB {
02191         Ospfv201TraceRF cb;
02192 
02193     public:
02194         operator const Ospfv201TraceRF& () const { return cb; }
02195         const Ospfv201TraceRF& operator ->() const { return cb; }
02196         Ospfv201TraceCB(const Ospfv201TraceRF& cb)
02197           : cb(cb) { }
02198 
02199         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02200 
02201         void respond() const {
02202             cb->dispatch(XrlCmdError::OKAY());
02203         }
02204     };
02205 
02206     struct Ospfv201TraceRsp :
02207       public Ospfv201TraceCB {
02208         Ospfv201TraceRsp(const Ospfv201TraceRF& cb)
02209           : Ospfv201TraceCB(cb) { }
02210 
02211     };
02212 
02213     virtual void async_ospfv2_0_1_trace
02214        (
02215     const string&   tvar,
02216     const bool& enable,
02217     Ospfv201TraceCB);
02218 #endif
02219 
02240     virtual XrlCmdError ospfv2_0_1_get_lsa(
02241     // Input values,
02242     const IPv4& area,
02243     const uint32_t& index,
02244     // Output values,
02245     bool&   valid,
02246     bool&   toohigh,
02247     bool&   self,
02248     vector<uint8_t>&    lsa) = 0;
02249 #ifdef XORP_ENABLE_ASYNC_SERVER
02250     typedef
02251     XorpCallback5<void, const XrlCmdError &,
02252     const bool*,
02253     const bool*,
02254     const bool*,
02255     const vector<uint8_t>*>::RefPtr
02256     Ospfv201GetLsaRF;
02257 
02258     class Ospfv201GetLsaCB {
02259         Ospfv201GetLsaRF cb;
02260 
02261     public:
02262         operator const Ospfv201GetLsaRF& () const { return cb; }
02263         const Ospfv201GetLsaRF& operator ->() const { return cb; }
02264         Ospfv201GetLsaCB(const Ospfv201GetLsaRF& cb)
02265           : cb(cb) { }
02266 
02267         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL); }
02268 
02269         void respond(const bool& arg_valid,
02270                      const bool& arg_toohigh,
02271                      const bool& arg_self,
02272                      const vector<uint8_t>& arg_lsa) const {
02273             cb->dispatch(XrlCmdError::OKAY(),
02274                          &arg_valid,
02275                          &arg_toohigh,
02276                          &arg_self,
02277                          &arg_lsa);
02278         }
02279     };
02280 
02281     struct Ospfv201GetLsaRsp :
02282       public Ospfv201GetLsaCB {
02283         struct args_str {
02284             bool valid;
02285             bool toohigh;
02286             bool self;
02287             vector<uint8_t> lsa;
02288         };
02289 
02290     private:
02291         args_str args;
02292 
02293     public:
02294         Ospfv201GetLsaRsp(const Ospfv201GetLsaRF& cb)
02295           : Ospfv201GetLsaCB(cb) { }
02296 
02297         void respond() const {
02298             Ospfv201GetLsaCB::
02299             respond(args.valid,
02300                         args.toohigh,
02301                         args.self,
02302                         args.lsa);
02303         }
02304 
02305         args_str* operator ->() {
02306             return &args;
02307         }
02308     };
02309 
02310     virtual void async_ospfv2_0_1_get_lsa
02311        (
02312     const IPv4& area,
02313     const uint32_t& index,
02314     Ospfv201GetLsaCB);
02315 #endif
02316 
02323     virtual XrlCmdError ospfv2_0_1_get_area_list(
02324     // Output values,
02325     XrlAtomList&    areas) = 0;
02326 #ifdef XORP_ENABLE_ASYNC_SERVER
02327     typedef
02328     XorpCallback2<void, const XrlCmdError &,
02329     const XrlAtomList*>::RefPtr
02330     Ospfv201GetAreaListRF;
02331 
02332     class Ospfv201GetAreaListCB {
02333         Ospfv201GetAreaListRF cb;
02334 
02335     public:
02336         operator const Ospfv201GetAreaListRF& () const { return cb; }
02337         const Ospfv201GetAreaListRF& operator ->() const { return cb; }
02338         Ospfv201GetAreaListCB(const Ospfv201GetAreaListRF& cb)
02339           : cb(cb) { }
02340 
02341         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02342 
02343         void respond(const XrlAtomList& arg_areas) const {
02344             cb->dispatch(XrlCmdError::OKAY(),
02345                          &arg_areas);
02346         }
02347     };
02348 
02349     struct Ospfv201GetAreaListRsp :
02350       public Ospfv201GetAreaListCB {
02351         struct args_str {
02352             XrlAtomList areas;
02353         };
02354 
02355     private:
02356         args_str args;
02357 
02358     public:
02359         Ospfv201GetAreaListRsp(const Ospfv201GetAreaListRF& cb)
02360           : Ospfv201GetAreaListCB(cb) { }
02361 
02362         void respond() const {
02363             Ospfv201GetAreaListCB::
02364             respond(args.areas);
02365         }
02366 
02367         args_str* operator ->() {
02368             return &args;
02369         }
02370     };
02371 
02372     virtual void async_ospfv2_0_1_get_area_list
02373        (
02374     Ospfv201GetAreaListCB);
02375 #endif
02376 
02384     virtual XrlCmdError ospfv2_0_1_get_neighbour_list(
02385     // Output values,
02386     XrlAtomList&    areas) = 0;
02387 #ifdef XORP_ENABLE_ASYNC_SERVER
02388     typedef
02389     XorpCallback2<void, const XrlCmdError &,
02390     const XrlAtomList*>::RefPtr
02391     Ospfv201GetNeighbourListRF;
02392 
02393     class Ospfv201GetNeighbourListCB {
02394         Ospfv201GetNeighbourListRF cb;
02395 
02396     public:
02397         operator const Ospfv201GetNeighbourListRF& () const { return cb; }
02398         const Ospfv201GetNeighbourListRF& operator ->() const { return cb; }
02399         Ospfv201GetNeighbourListCB(const Ospfv201GetNeighbourListRF& cb)
02400           : cb(cb) { }
02401 
02402         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02403 
02404         void respond(const XrlAtomList& arg_areas) const {
02405             cb->dispatch(XrlCmdError::OKAY(),
02406                          &arg_areas);
02407         }
02408     };
02409 
02410     struct Ospfv201GetNeighbourListRsp :
02411       public Ospfv201GetNeighbourListCB {
02412         struct args_str {
02413             XrlAtomList areas;
02414         };
02415 
02416     private:
02417         args_str args;
02418 
02419     public:
02420         Ospfv201GetNeighbourListRsp(const Ospfv201GetNeighbourListRF& cb)
02421           : Ospfv201GetNeighbourListCB(cb) { }
02422 
02423         void respond() const {
02424             Ospfv201GetNeighbourListCB::
02425             respond(args.areas);
02426         }
02427 
02428         args_str* operator ->() {
02429             return &args;
02430         }
02431     };
02432 
02433     virtual void async_ospfv2_0_1_get_neighbour_list
02434        (
02435     Ospfv201GetNeighbourListCB);
02436 #endif
02437 
02469     virtual XrlCmdError ospfv2_0_1_get_neighbour_info(
02470     // Input values,
02471     const uint32_t& nid,
02472     // Output values,
02473     string& address,
02474     string& interface,
02475     string& state,
02476     IPv4&   rid,
02477     uint32_t&   priority,
02478     uint32_t&   deadtime,
02479     IPv4&   area,
02480     uint32_t&   opt,
02481     IPv4&   dr,
02482     IPv4&   bdr,
02483     uint32_t&   up,
02484     uint32_t&   adjacent) = 0;
02485 #ifdef XORP_ENABLE_ASYNC_SERVER
02486     typedef
02487     XorpCallback13<void, const XrlCmdError &,
02488     const string*,
02489     const string*,
02490     const string*,
02491     const IPv4*,
02492     const uint32_t*,
02493     const uint32_t*,
02494     const IPv4*,
02495     const uint32_t*,
02496     const IPv4*,
02497     const IPv4*,
02498     const uint32_t*,
02499     const uint32_t*>::RefPtr
02500     Ospfv201GetNeighbourInfoRF;
02501 
02502     class Ospfv201GetNeighbourInfoCB {
02503         Ospfv201GetNeighbourInfoRF cb;
02504 
02505     public:
02506         operator const Ospfv201GetNeighbourInfoRF& () const { return cb; }
02507         const Ospfv201GetNeighbourInfoRF& operator ->() const { return cb; }
02508         Ospfv201GetNeighbourInfoCB(const Ospfv201GetNeighbourInfoRF& cb)
02509           : cb(cb) { }
02510 
02511         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); }
02512 
02513         void respond(const string& arg_address,
02514                      const string& arg_interface,
02515                      const string& arg_state,
02516                      const IPv4& arg_rid,
02517                      const uint32_t& arg_priority,
02518                      const uint32_t& arg_deadtime,
02519                      const IPv4& arg_area,
02520                      const uint32_t& arg_opt,
02521                      const IPv4& arg_dr,
02522                      const IPv4& arg_bdr,
02523                      const uint32_t& arg_up,
02524                      const uint32_t& arg_adjacent) const {
02525             cb->dispatch(XrlCmdError::OKAY(),
02526                          &arg_address,
02527                          &arg_interface,
02528                          &arg_state,
02529                          &arg_rid,
02530                          &arg_priority,
02531                          &arg_deadtime,
02532                          &arg_area,
02533                          &arg_opt,
02534                          &arg_dr,
02535                          &arg_bdr,
02536                          &arg_up,
02537                          &arg_adjacent);
02538         }
02539     };
02540 
02541     struct Ospfv201GetNeighbourInfoRsp :
02542       public Ospfv201GetNeighbourInfoCB {
02543         struct args_str {
02544             string address;
02545             string interface;
02546             string state;
02547             IPv4 rid;
02548             uint32_t priority;
02549             uint32_t deadtime;
02550             IPv4 area;
02551             uint32_t opt;
02552             IPv4 dr;
02553             IPv4 bdr;
02554             uint32_t up;
02555             uint32_t adjacent;
02556         };
02557 
02558     private:
02559         args_str args;
02560 
02561     public:
02562         Ospfv201GetNeighbourInfoRsp(const Ospfv201GetNeighbourInfoRF& cb)
02563           : Ospfv201GetNeighbourInfoCB(cb) { }
02564 
02565         void respond() const {
02566             Ospfv201GetNeighbourInfoCB::
02567             respond(args.address,
02568                         args.interface,
02569                         args.state,
02570                         args.rid,
02571                         args.priority,
02572                         args.deadtime,
02573                         args.area,
02574                         args.opt,
02575                         args.dr,
02576                         args.bdr,
02577                         args.up,
02578                         args.adjacent);
02579         }
02580 
02581         args_str* operator ->() {
02582             return &args;
02583         }
02584     };
02585 
02586     virtual void async_ospfv2_0_1_get_neighbour_info
02587        (
02588     const uint32_t& nid,
02589     Ospfv201GetNeighbourInfoCB);
02590 #endif
02591 
02597     virtual XrlCmdError ospfv2_0_1_clear_database() = 0;
02598 #ifdef XORP_ENABLE_ASYNC_SERVER
02599     typedef
02600     XorpCallback1<void, const XrlCmdError &>::RefPtr
02601     Ospfv201ClearDatabaseRF;
02602 
02603     class Ospfv201ClearDatabaseCB {
02604         Ospfv201ClearDatabaseRF cb;
02605 
02606     public:
02607         operator const Ospfv201ClearDatabaseRF& () const { return cb; }
02608         const Ospfv201ClearDatabaseRF& operator ->() const { return cb; }
02609         Ospfv201ClearDatabaseCB(const Ospfv201ClearDatabaseRF& cb)
02610           : cb(cb) { }
02611 
02612         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02613 
02614         void respond() const {
02615             cb->dispatch(XrlCmdError::OKAY());
02616         }
02617     };
02618 
02619     struct Ospfv201ClearDatabaseRsp :
02620       public Ospfv201ClearDatabaseCB {
02621         Ospfv201ClearDatabaseRsp(const Ospfv201ClearDatabaseRF& cb)
02622           : Ospfv201ClearDatabaseCB(cb) { }
02623 
02624     };
02625 
02626     virtual void async_ospfv2_0_1_clear_database
02627        (
02628     Ospfv201ClearDatabaseCB);
02629 #endif
02630 
02631 private:
02632     XrlCmdRT handle_common_0_1_get_target_name(const XrlArgs& in, XrlCmdOT out);
02633 #ifdef XORP_ENABLE_ASYNC_SERVER
02634     void callback_common_0_1_get_target_name
02635        (const XrlCmdError &e,
02636     const string* arg_name,
02637         XrlRespCallback);
02638 #endif
02639 
02640     XrlCmdRT handle_common_0_1_get_version(const XrlArgs& in, XrlCmdOT out);
02641 #ifdef XORP_ENABLE_ASYNC_SERVER
02642     void callback_common_0_1_get_version
02643        (const XrlCmdError &e,
02644     const string* arg_version,
02645         XrlRespCallback);
02646 #endif
02647 
02648     XrlCmdRT handle_common_0_1_get_status(const XrlArgs& in, XrlCmdOT out);
02649 #ifdef XORP_ENABLE_ASYNC_SERVER
02650     void callback_common_0_1_get_status
02651        (const XrlCmdError &e,
02652     const uint32_t* arg_status,
02653     const string* arg_reason,
02654         XrlRespCallback);
02655 #endif
02656 
02657     XrlCmdRT handle_common_0_1_shutdown(const XrlArgs& in, XrlCmdOT out);
02658 #ifdef XORP_ENABLE_ASYNC_SERVER
02659     void callback_common_0_1_shutdown
02660        (const XrlCmdError &e,
02661         XrlRespCallback);
02662 #endif
02663 
02664     XrlCmdRT handle_common_0_1_startup(const XrlArgs& in, XrlCmdOT out);
02665 #ifdef XORP_ENABLE_ASYNC_SERVER
02666     void callback_common_0_1_startup
02667        (const XrlCmdError &e,
02668         XrlRespCallback);
02669 #endif
02670 
02671     XrlCmdRT handle_raw_packet4_client_0_1_recv(const XrlArgs& in, XrlCmdOT out);
02672 #ifdef XORP_ENABLE_ASYNC_SERVER
02673     void callback_raw_packet4_client_0_1_recv
02674        (const XrlCmdError &e,
02675         XrlRespCallback);
02676 #endif
02677 
02678     XrlCmdRT handle_policy_backend_0_1_configure(const XrlArgs& in, XrlCmdOT out);
02679 #ifdef XORP_ENABLE_ASYNC_SERVER
02680     void callback_policy_backend_0_1_configure
02681        (const XrlCmdError &e,
02682         XrlRespCallback);
02683 #endif
02684 
02685     XrlCmdRT handle_policy_backend_0_1_reset(const XrlArgs& in, XrlCmdOT out);
02686 #ifdef XORP_ENABLE_ASYNC_SERVER
02687     void callback_policy_backend_0_1_reset
02688        (const XrlCmdError &e,
02689         XrlRespCallback);
02690 #endif
02691 
02692     XrlCmdRT handle_policy_backend_0_1_push_routes(const XrlArgs& in, XrlCmdOT out);
02693 #ifdef XORP_ENABLE_ASYNC_SERVER
02694     void callback_policy_backend_0_1_push_routes
02695        (const XrlCmdError &e,
02696         XrlRespCallback);
02697 #endif
02698 
02699     XrlCmdRT handle_policy_redist4_0_1_add_route4(const XrlArgs& in, XrlCmdOT out);
02700 #ifdef XORP_ENABLE_ASYNC_SERVER
02701     void callback_policy_redist4_0_1_add_route4
02702        (const XrlCmdError &e,
02703         XrlRespCallback);
02704 #endif
02705 
02706     XrlCmdRT handle_policy_redist4_0_1_delete_route4(const XrlArgs& in, XrlCmdOT out);
02707 #ifdef XORP_ENABLE_ASYNC_SERVER
02708     void callback_policy_redist4_0_1_delete_route4
02709        (const XrlCmdError &e,
02710         XrlRespCallback);
02711 #endif
02712 
02713     XrlCmdRT handle_ospfv2_0_1_set_router_id(const XrlArgs& in, XrlCmdOT out);
02714 #ifdef XORP_ENABLE_ASYNC_SERVER
02715     void callback_ospfv2_0_1_set_router_id
02716        (const XrlCmdError &e,
02717         XrlRespCallback);
02718 #endif
02719 
02720     XrlCmdRT handle_ospfv2_0_1_set_rfc1583_compatibility(const XrlArgs& in, XrlCmdOT out);
02721 #ifdef XORP_ENABLE_ASYNC_SERVER
02722     void callback_ospfv2_0_1_set_rfc1583_compatibility
02723        (const XrlCmdError &e,
02724         XrlRespCallback);
02725 #endif
02726 
02727     XrlCmdRT handle_ospfv2_0_1_set_ip_router_alert(const XrlArgs& in, XrlCmdOT out);
02728 #ifdef XORP_ENABLE_ASYNC_SERVER
02729     void callback_ospfv2_0_1_set_ip_router_alert
02730        (const XrlCmdError &e,
02731         XrlRespCallback);
02732 #endif
02733 
02734     XrlCmdRT handle_ospfv2_0_1_create_area_router(const XrlArgs& in, XrlCmdOT out);
02735 #ifdef XORP_ENABLE_ASYNC_SERVER
02736     void callback_ospfv2_0_1_create_area_router
02737        (const XrlCmdError &e,
02738         XrlRespCallback);
02739 #endif
02740 
02741     XrlCmdRT handle_ospfv2_0_1_change_area_router_type(const XrlArgs& in, XrlCmdOT out);
02742 #ifdef XORP_ENABLE_ASYNC_SERVER
02743     void callback_ospfv2_0_1_change_area_router_type
02744        (const XrlCmdError &e,
02745         XrlRespCallback);
02746 #endif
02747 
02748     XrlCmdRT handle_ospfv2_0_1_destroy_area_router(const XrlArgs& in, XrlCmdOT out);
02749 #ifdef XORP_ENABLE_ASYNC_SERVER
02750     void callback_ospfv2_0_1_destroy_area_router
02751        (const XrlCmdError &e,
02752         XrlRespCallback);
02753 #endif
02754 
02755     XrlCmdRT handle_ospfv2_0_1_create_peer(const XrlArgs& in, XrlCmdOT out);
02756 #ifdef XORP_ENABLE_ASYNC_SERVER
02757     void callback_ospfv2_0_1_create_peer
02758        (const XrlCmdError &e,
02759         XrlRespCallback);
02760 #endif
02761 
02762     XrlCmdRT handle_ospfv2_0_1_delete_peer(const XrlArgs& in, XrlCmdOT out);
02763 #ifdef XORP_ENABLE_ASYNC_SERVER
02764     void callback_ospfv2_0_1_delete_peer
02765        (const XrlCmdError &e,
02766         XrlRespCallback);
02767 #endif
02768 
02769     XrlCmdRT handle_ospfv2_0_1_set_peer_state(const XrlArgs& in, XrlCmdOT out);
02770 #ifdef XORP_ENABLE_ASYNC_SERVER
02771     void callback_ospfv2_0_1_set_peer_state
02772        (const XrlCmdError &e,
02773         XrlRespCallback);
02774 #endif
02775 
02776     XrlCmdRT handle_ospfv2_0_1_add_neighbour(const XrlArgs& in, XrlCmdOT out);
02777 #ifdef XORP_ENABLE_ASYNC_SERVER
02778     void callback_ospfv2_0_1_add_neighbour
02779        (const XrlCmdError &e,
02780         XrlRespCallback);
02781 #endif
02782 
02783     XrlCmdRT handle_ospfv2_0_1_remove_neighbour(const XrlArgs& in, XrlCmdOT out);
02784 #ifdef XORP_ENABLE_ASYNC_SERVER
02785     void callback_ospfv2_0_1_remove_neighbour
02786        (const XrlCmdError &e,
02787         XrlRespCallback);
02788 #endif
02789 
02790     XrlCmdRT handle_ospfv2_0_1_create_virtual_link(const XrlArgs& in, XrlCmdOT out);
02791 #ifdef XORP_ENABLE_ASYNC_SERVER
02792     void callback_ospfv2_0_1_create_virtual_link
02793        (const XrlCmdError &e,
02794         XrlRespCallback);
02795 #endif
02796 
02797     XrlCmdRT handle_ospfv2_0_1_delete_virtual_link(const XrlArgs& in, XrlCmdOT out);
02798 #ifdef XORP_ENABLE_ASYNC_SERVER
02799     void callback_ospfv2_0_1_delete_virtual_link
02800        (const XrlCmdError &e,
02801         XrlRespCallback);
02802 #endif
02803 
02804     XrlCmdRT handle_ospfv2_0_1_transit_area_virtual_link(const XrlArgs& in, XrlCmdOT out);
02805 #ifdef XORP_ENABLE_ASYNC_SERVER
02806     void callback_ospfv2_0_1_transit_area_virtual_link
02807        (const XrlCmdError &e,
02808         XrlRespCallback);
02809 #endif
02810 
02811     XrlCmdRT handle_ospfv2_0_1_set_interface_cost(const XrlArgs& in, XrlCmdOT out);
02812 #ifdef XORP_ENABLE_ASYNC_SERVER
02813     void callback_ospfv2_0_1_set_interface_cost
02814        (const XrlCmdError &e,
02815         XrlRespCallback);
02816 #endif
02817 
02818     XrlCmdRT handle_ospfv2_0_1_set_retransmit_interval(const XrlArgs& in, XrlCmdOT out);
02819 #ifdef XORP_ENABLE_ASYNC_SERVER
02820     void callback_ospfv2_0_1_set_retransmit_interval
02821        (const XrlCmdError &e,
02822         XrlRespCallback);
02823 #endif
02824 
02825     XrlCmdRT handle_ospfv2_0_1_set_inftransdelay(const XrlArgs& in, XrlCmdOT out);
02826 #ifdef XORP_ENABLE_ASYNC_SERVER
02827     void callback_ospfv2_0_1_set_inftransdelay
02828        (const XrlCmdError &e,
02829         XrlRespCallback);
02830 #endif
02831 
02832     XrlCmdRT handle_ospfv2_0_1_set_router_priority(const XrlArgs& in, XrlCmdOT out);
02833 #ifdef XORP_ENABLE_ASYNC_SERVER
02834     void callback_ospfv2_0_1_set_router_priority
02835        (const XrlCmdError &e,
02836         XrlRespCallback);
02837 #endif
02838 
02839     XrlCmdRT handle_ospfv2_0_1_set_hello_interval(const XrlArgs& in, XrlCmdOT out);
02840 #ifdef XORP_ENABLE_ASYNC_SERVER
02841     void callback_ospfv2_0_1_set_hello_interval
02842        (const XrlCmdError &e,
02843         XrlRespCallback);
02844 #endif
02845 
02846     XrlCmdRT handle_ospfv2_0_1_set_router_dead_interval(const XrlArgs& in, XrlCmdOT out);
02847 #ifdef XORP_ENABLE_ASYNC_SERVER
02848     void callback_ospfv2_0_1_set_router_dead_interval
02849        (const XrlCmdError &e,
02850         XrlRespCallback);
02851 #endif
02852 
02853     XrlCmdRT handle_ospfv2_0_1_set_simple_authentication_key(const XrlArgs& in, XrlCmdOT out);
02854 #ifdef XORP_ENABLE_ASYNC_SERVER
02855     void callback_ospfv2_0_1_set_simple_authentication_key
02856        (const XrlCmdError &e,
02857         XrlRespCallback);
02858 #endif
02859 
02860     XrlCmdRT handle_ospfv2_0_1_delete_simple_authentication_key(const XrlArgs& in, XrlCmdOT out);
02861 #ifdef XORP_ENABLE_ASYNC_SERVER
02862     void callback_ospfv2_0_1_delete_simple_authentication_key
02863        (const XrlCmdError &e,
02864         XrlRespCallback);
02865 #endif
02866 
02867     XrlCmdRT handle_ospfv2_0_1_set_md5_authentication_key(const XrlArgs& in, XrlCmdOT out);
02868 #ifdef XORP_ENABLE_ASYNC_SERVER
02869     void callback_ospfv2_0_1_set_md5_authentication_key
02870        (const XrlCmdError &e,
02871         XrlRespCallback);
02872 #endif
02873 
02874     XrlCmdRT handle_ospfv2_0_1_delete_md5_authentication_key(const XrlArgs& in, XrlCmdOT out);
02875 #ifdef XORP_ENABLE_ASYNC_SERVER
02876     void callback_ospfv2_0_1_delete_md5_authentication_key
02877        (const XrlCmdError &e,
02878         XrlRespCallback);
02879 #endif
02880 
02881     XrlCmdRT handle_ospfv2_0_1_set_passive(const XrlArgs& in, XrlCmdOT out);
02882 #ifdef XORP_ENABLE_ASYNC_SERVER
02883     void callback_ospfv2_0_1_set_passive
02884        (const XrlCmdError &e,
02885         XrlRespCallback);
02886 #endif
02887 
02888     XrlCmdRT handle_ospfv2_0_1_originate_default_route(const XrlArgs& in, XrlCmdOT out);
02889 #ifdef XORP_ENABLE_ASYNC_SERVER
02890     void callback_ospfv2_0_1_originate_default_route
02891        (const XrlCmdError &e,
02892         XrlRespCallback);
02893 #endif
02894 
02895     XrlCmdRT handle_ospfv2_0_1_stub_default_cost(const XrlArgs& in, XrlCmdOT out);
02896 #ifdef XORP_ENABLE_ASYNC_SERVER
02897     void callback_ospfv2_0_1_stub_default_cost
02898        (const XrlCmdError &e,
02899         XrlRespCallback);
02900 #endif
02901 
02902     XrlCmdRT handle_ospfv2_0_1_summaries(const XrlArgs& in, XrlCmdOT out);
02903 #ifdef XORP_ENABLE_ASYNC_SERVER
02904     void callback_ospfv2_0_1_summaries
02905        (const XrlCmdError &e,
02906         XrlRespCallback);
02907 #endif
02908 
02909     XrlCmdRT handle_ospfv2_0_1_area_range_add(const XrlArgs& in, XrlCmdOT out);
02910 #ifdef XORP_ENABLE_ASYNC_SERVER
02911     void callback_ospfv2_0_1_area_range_add
02912        (const XrlCmdError &e,
02913         XrlRespCallback);
02914 #endif
02915 
02916     XrlCmdRT handle_ospfv2_0_1_area_range_delete(const XrlArgs& in, XrlCmdOT out);
02917 #ifdef XORP_ENABLE_ASYNC_SERVER
02918     void callback_ospfv2_0_1_area_range_delete
02919        (const XrlCmdError &e,
02920         XrlRespCallback);
02921 #endif
02922 
02923     XrlCmdRT handle_ospfv2_0_1_area_range_change_state(const XrlArgs& in, XrlCmdOT out);
02924 #ifdef XORP_ENABLE_ASYNC_SERVER
02925     void callback_ospfv2_0_1_area_range_change_state
02926        (const XrlCmdError &e,
02927         XrlRespCallback);
02928 #endif
02929 
02930     XrlCmdRT handle_ospfv2_0_1_trace(const XrlArgs& in, XrlCmdOT out);
02931 #ifdef XORP_ENABLE_ASYNC_SERVER
02932     void callback_ospfv2_0_1_trace
02933        (const XrlCmdError &e,
02934         XrlRespCallback);
02935 #endif
02936 
02937     XrlCmdRT handle_ospfv2_0_1_get_lsa(const XrlArgs& in, XrlCmdOT out);
02938 #ifdef XORP_ENABLE_ASYNC_SERVER
02939     void callback_ospfv2_0_1_get_lsa
02940        (const XrlCmdError &e,
02941     const bool* arg_valid,
02942     const bool* arg_toohigh,
02943     const bool* arg_self,
02944     const vector<uint8_t>* arg_lsa,
02945         XrlRespCallback);
02946 #endif
02947 
02948     XrlCmdRT handle_ospfv2_0_1_get_area_list(const XrlArgs& in, XrlCmdOT out);
02949 #ifdef XORP_ENABLE_ASYNC_SERVER
02950     void callback_ospfv2_0_1_get_area_list
02951        (const XrlCmdError &e,
02952     const XrlAtomList* arg_areas,
02953         XrlRespCallback);
02954 #endif
02955 
02956     XrlCmdRT handle_ospfv2_0_1_get_neighbour_list(const XrlArgs& in, XrlCmdOT out);
02957 #ifdef XORP_ENABLE_ASYNC_SERVER
02958     void callback_ospfv2_0_1_get_neighbour_list
02959        (const XrlCmdError &e,
02960     const XrlAtomList* arg_areas,
02961         XrlRespCallback);
02962 #endif
02963 
02964     XrlCmdRT handle_ospfv2_0_1_get_neighbour_info(const XrlArgs& in, XrlCmdOT out);
02965 #ifdef XORP_ENABLE_ASYNC_SERVER
02966     void callback_ospfv2_0_1_get_neighbour_info
02967        (const XrlCmdError &e,
02968     const string* arg_address,
02969     const string* arg_interface,
02970     const string* arg_state,
02971     const IPv4* arg_rid,
02972     const uint32_t* arg_priority,
02973     const uint32_t* arg_deadtime,
02974     const IPv4* arg_area,
02975     const uint32_t* arg_opt,
02976     const IPv4* arg_dr,
02977     const IPv4* arg_bdr,
02978     const uint32_t* arg_up,
02979     const uint32_t* arg_adjacent,
02980         XrlRespCallback);
02981 #endif
02982 
02983     XrlCmdRT handle_ospfv2_0_1_clear_database(const XrlArgs& in, XrlCmdOT out);
02984 #ifdef XORP_ENABLE_ASYNC_SERVER
02985     void callback_ospfv2_0_1_clear_database
02986        (const XrlCmdError &e,
02987         XrlRespCallback);
02988 #endif
02989 
02990     void add_handlers();
02991     void remove_handlers();
02992 
02993     struct handler_table {
02994         const char *name;
02995         XrlCmdRT (XrlOspfv2TargetBase::*method)(const XrlArgs&, XrlCmdOT);
02996     };
02997 
02998     static const struct handler_table handlers[];
02999     static const size_t num_handlers;
03000 };
03001 
03002 #endif // __XRL_TARGETS_OSPFV2_BASE_HH__
 All Classes Namespaces Functions Variables Typedefs Enumerations