xorp

olsr4_base.hh

00001 /*
00002  * obj/i686-pc-linux-gnu/xrl/targets/olsr4_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_OLSR4_BASE_HH__
00016 #define __XRL_TARGETS_OLSR4_BASE_HH__
00017 
00018 #undef XORP_LIBRARY_NAME
00019 #define XORP_LIBRARY_NAME "XrlOlsr4Target"
00020 
00021 #include "libxorp/xlog.h"
00022 #include "libxipc/xrl_cmd_map.hh"
00023 
00024 class XrlOlsr4TargetBase {
00025 protected:
00026     XrlCmdMap* _cmds;
00027 
00028 public:
00036     XrlOlsr4TargetBase(XrlCmdMap* cmds = 0);
00037 
00043     virtual ~XrlOlsr4TargetBase();
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 "olsr4/0.0"; }
00066 
00067 protected:
00068 
00074     virtual XrlCmdError common_0_1_get_target_name(
00075     // Output values,
00076     string& name) = 0;
00077 #ifdef XORP_ENABLE_ASYNC_SERVER
00078     typedef
00079     XorpCallback2<void, const XrlCmdError &,
00080     const string*>::RefPtr
00081     Common01GetTargetNameRF;
00082 
00083     class Common01GetTargetNameCB {
00084         Common01GetTargetNameRF cb;
00085 
00086     public:
00087         operator const Common01GetTargetNameRF& () const { return cb; }
00088         const Common01GetTargetNameRF& operator ->() const { return cb; }
00089         Common01GetTargetNameCB(const Common01GetTargetNameRF& cb)
00090           : cb(cb) { }
00091 
00092         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00093 
00094         void respond(const string& arg_name) const {
00095             cb->dispatch(XrlCmdError::OKAY(),
00096                          &arg_name);
00097         }
00098     };
00099 
00100     struct Common01GetTargetNameRsp :
00101       public Common01GetTargetNameCB {
00102         struct args_str {
00103             string name;
00104         };
00105 
00106     private:
00107         args_str args;
00108 
00109     public:
00110         Common01GetTargetNameRsp(const Common01GetTargetNameRF& cb)
00111           : Common01GetTargetNameCB(cb) { }
00112 
00113         void respond() const {
00114             Common01GetTargetNameCB::
00115             respond(args.name);
00116         }
00117 
00118         args_str* operator ->() {
00119             return &args;
00120         }
00121     };
00122 
00123     virtual void async_common_0_1_get_target_name
00124        (
00125     Common01GetTargetNameCB);
00126 #endif
00127 
00133     virtual XrlCmdError common_0_1_get_version(
00134     // Output values,
00135     string& version) = 0;
00136 #ifdef XORP_ENABLE_ASYNC_SERVER
00137     typedef
00138     XorpCallback2<void, const XrlCmdError &,
00139     const string*>::RefPtr
00140     Common01GetVersionRF;
00141 
00142     class Common01GetVersionCB {
00143         Common01GetVersionRF cb;
00144 
00145     public:
00146         operator const Common01GetVersionRF& () const { return cb; }
00147         const Common01GetVersionRF& operator ->() const { return cb; }
00148         Common01GetVersionCB(const Common01GetVersionRF& cb)
00149           : cb(cb) { }
00150 
00151         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00152 
00153         void respond(const string& arg_version) const {
00154             cb->dispatch(XrlCmdError::OKAY(),
00155                          &arg_version);
00156         }
00157     };
00158 
00159     struct Common01GetVersionRsp :
00160       public Common01GetVersionCB {
00161         struct args_str {
00162             string version;
00163         };
00164 
00165     private:
00166         args_str args;
00167 
00168     public:
00169         Common01GetVersionRsp(const Common01GetVersionRF& cb)
00170           : Common01GetVersionCB(cb) { }
00171 
00172         void respond() const {
00173             Common01GetVersionCB::
00174             respond(args.version);
00175         }
00176 
00177         args_str* operator ->() {
00178             return &args;
00179         }
00180     };
00181 
00182     virtual void async_common_0_1_get_version
00183        (
00184     Common01GetVersionCB);
00185 #endif
00186 
00192     virtual XrlCmdError common_0_1_get_status(
00193     // Output values,
00194     uint32_t&   status,
00195     string& reason) = 0;
00196 #ifdef XORP_ENABLE_ASYNC_SERVER
00197     typedef
00198     XorpCallback3<void, const XrlCmdError &,
00199     const uint32_t*,
00200     const string*>::RefPtr
00201     Common01GetStatusRF;
00202 
00203     class Common01GetStatusCB {
00204         Common01GetStatusRF cb;
00205 
00206     public:
00207         operator const Common01GetStatusRF& () const { return cb; }
00208         const Common01GetStatusRF& operator ->() const { return cb; }
00209         Common01GetStatusCB(const Common01GetStatusRF& cb)
00210           : cb(cb) { }
00211 
00212         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL); }
00213 
00214         void respond(const uint32_t& arg_status,
00215                      const string& arg_reason) const {
00216             cb->dispatch(XrlCmdError::OKAY(),
00217                          &arg_status,
00218                          &arg_reason);
00219         }
00220     };
00221 
00222     struct Common01GetStatusRsp :
00223       public Common01GetStatusCB {
00224         struct args_str {
00225             uint32_t status;
00226             string reason;
00227         };
00228 
00229     private:
00230         args_str args;
00231 
00232     public:
00233         Common01GetStatusRsp(const Common01GetStatusRF& cb)
00234           : Common01GetStatusCB(cb) { }
00235 
00236         void respond() const {
00237             Common01GetStatusCB::
00238             respond(args.status,
00239                         args.reason);
00240         }
00241 
00242         args_str* operator ->() {
00243             return &args;
00244         }
00245     };
00246 
00247     virtual void async_common_0_1_get_status
00248        (
00249     Common01GetStatusCB);
00250 #endif
00251 
00257     virtual XrlCmdError common_0_1_shutdown() = 0;
00258 #ifdef XORP_ENABLE_ASYNC_SERVER
00259     typedef
00260     XorpCallback1<void, const XrlCmdError &>::RefPtr
00261     Common01ShutdownRF;
00262 
00263     class Common01ShutdownCB {
00264         Common01ShutdownRF cb;
00265 
00266     public:
00267         operator const Common01ShutdownRF& () const { return cb; }
00268         const Common01ShutdownRF& operator ->() const { return cb; }
00269         Common01ShutdownCB(const Common01ShutdownRF& cb)
00270           : cb(cb) { }
00271 
00272         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00273 
00274         void respond() const {
00275             cb->dispatch(XrlCmdError::OKAY());
00276         }
00277     };
00278 
00279     struct Common01ShutdownRsp :
00280       public Common01ShutdownCB {
00281         Common01ShutdownRsp(const Common01ShutdownRF& cb)
00282           : Common01ShutdownCB(cb) { }
00283 
00284     };
00285 
00286     virtual void async_common_0_1_shutdown
00287        (
00288     Common01ShutdownCB);
00289 #endif
00290 
00296     virtual XrlCmdError common_0_1_startup() = 0;
00297 #ifdef XORP_ENABLE_ASYNC_SERVER
00298     typedef
00299     XorpCallback1<void, const XrlCmdError &>::RefPtr
00300     Common01StartupRF;
00301 
00302     class Common01StartupCB {
00303         Common01StartupRF cb;
00304 
00305     public:
00306         operator const Common01StartupRF& () const { return cb; }
00307         const Common01StartupRF& operator ->() const { return cb; }
00308         Common01StartupCB(const Common01StartupRF& cb)
00309           : cb(cb) { }
00310 
00311         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00312 
00313         void respond() const {
00314             cb->dispatch(XrlCmdError::OKAY());
00315         }
00316     };
00317 
00318     struct Common01StartupRsp :
00319       public Common01StartupCB {
00320         Common01StartupRsp(const Common01StartupRF& cb)
00321           : Common01StartupCB(cb) { }
00322 
00323     };
00324 
00325     virtual void async_common_0_1_startup
00326        (
00327     Common01StartupCB);
00328 #endif
00329 
00339     virtual XrlCmdError finder_event_observer_0_1_xrl_target_birth(
00340     // Input values,
00341     const string&   target_class,
00342     const string&   target_instance) = 0;
00343 #ifdef XORP_ENABLE_ASYNC_SERVER
00344     typedef
00345     XorpCallback1<void, const XrlCmdError &>::RefPtr
00346     FinderEventObserver01XrlTargetBirthRF;
00347 
00348     class FinderEventObserver01XrlTargetBirthCB {
00349         FinderEventObserver01XrlTargetBirthRF cb;
00350 
00351     public:
00352         operator const FinderEventObserver01XrlTargetBirthRF& () const { return cb; }
00353         const FinderEventObserver01XrlTargetBirthRF& operator ->() const { return cb; }
00354         FinderEventObserver01XrlTargetBirthCB(const FinderEventObserver01XrlTargetBirthRF& cb)
00355           : cb(cb) { }
00356 
00357         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00358 
00359         void respond() const {
00360             cb->dispatch(XrlCmdError::OKAY());
00361         }
00362     };
00363 
00364     struct FinderEventObserver01XrlTargetBirthRsp :
00365       public FinderEventObserver01XrlTargetBirthCB {
00366         FinderEventObserver01XrlTargetBirthRsp(const FinderEventObserver01XrlTargetBirthRF& cb)
00367           : FinderEventObserver01XrlTargetBirthCB(cb) { }
00368 
00369     };
00370 
00371     virtual void async_finder_event_observer_0_1_xrl_target_birth
00372        (
00373     const string&   target_class,
00374     const string&   target_instance,
00375     FinderEventObserver01XrlTargetBirthCB);
00376 #endif
00377 
00387     virtual XrlCmdError finder_event_observer_0_1_xrl_target_death(
00388     // Input values,
00389     const string&   target_class,
00390     const string&   target_instance) = 0;
00391 #ifdef XORP_ENABLE_ASYNC_SERVER
00392     typedef
00393     XorpCallback1<void, const XrlCmdError &>::RefPtr
00394     FinderEventObserver01XrlTargetDeathRF;
00395 
00396     class FinderEventObserver01XrlTargetDeathCB {
00397         FinderEventObserver01XrlTargetDeathRF cb;
00398 
00399     public:
00400         operator const FinderEventObserver01XrlTargetDeathRF& () const { return cb; }
00401         const FinderEventObserver01XrlTargetDeathRF& operator ->() const { return cb; }
00402         FinderEventObserver01XrlTargetDeathCB(const FinderEventObserver01XrlTargetDeathRF& cb)
00403           : cb(cb) { }
00404 
00405         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00406 
00407         void respond() const {
00408             cb->dispatch(XrlCmdError::OKAY());
00409         }
00410     };
00411 
00412     struct FinderEventObserver01XrlTargetDeathRsp :
00413       public FinderEventObserver01XrlTargetDeathCB {
00414         FinderEventObserver01XrlTargetDeathRsp(const FinderEventObserver01XrlTargetDeathRF& cb)
00415           : FinderEventObserver01XrlTargetDeathCB(cb) { }
00416 
00417     };
00418 
00419     virtual void async_finder_event_observer_0_1_xrl_target_death
00420        (
00421     const string&   target_class,
00422     const string&   target_instance,
00423     FinderEventObserver01XrlTargetDeathCB);
00424 #endif
00425 
00447     virtual XrlCmdError socket4_user_0_1_recv_event(
00448     // Input values,
00449     const string&   sockid,
00450     const string&   if_name,
00451     const string&   vif_name,
00452     const IPv4& src_host,
00453     const uint32_t& src_port,
00454     const vector<uint8_t>&  data) = 0;
00455 #ifdef XORP_ENABLE_ASYNC_SERVER
00456     typedef
00457     XorpCallback1<void, const XrlCmdError &>::RefPtr
00458     Socket4User01RecvEventRF;
00459 
00460     class Socket4User01RecvEventCB {
00461         Socket4User01RecvEventRF cb;
00462 
00463     public:
00464         operator const Socket4User01RecvEventRF& () const { return cb; }
00465         const Socket4User01RecvEventRF& operator ->() const { return cb; }
00466         Socket4User01RecvEventCB(const Socket4User01RecvEventRF& cb)
00467           : cb(cb) { }
00468 
00469         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00470 
00471         void respond() const {
00472             cb->dispatch(XrlCmdError::OKAY());
00473         }
00474     };
00475 
00476     struct Socket4User01RecvEventRsp :
00477       public Socket4User01RecvEventCB {
00478         Socket4User01RecvEventRsp(const Socket4User01RecvEventRF& cb)
00479           : Socket4User01RecvEventCB(cb) { }
00480 
00481     };
00482 
00483     virtual void async_socket4_user_0_1_recv_event
00484        (
00485     const string&   sockid,
00486     const string&   if_name,
00487     const string&   vif_name,
00488     const IPv4& src_host,
00489     const uint32_t& src_port,
00490     const vector<uint8_t>&  data,
00491     Socket4User01RecvEventCB);
00492 #endif
00493 
00514     virtual XrlCmdError socket4_user_0_1_inbound_connect_event(
00515     // Input values,
00516     const string&   sockid,
00517     const IPv4& src_host,
00518     const uint32_t& src_port,
00519     const string&   new_sockid,
00520     // Output values,
00521     bool&   accept) = 0;
00522 #ifdef XORP_ENABLE_ASYNC_SERVER
00523     typedef
00524     XorpCallback2<void, const XrlCmdError &,
00525     const bool*>::RefPtr
00526     Socket4User01InboundConnectEventRF;
00527 
00528     class Socket4User01InboundConnectEventCB {
00529         Socket4User01InboundConnectEventRF cb;
00530 
00531     public:
00532         operator const Socket4User01InboundConnectEventRF& () const { return cb; }
00533         const Socket4User01InboundConnectEventRF& operator ->() const { return cb; }
00534         Socket4User01InboundConnectEventCB(const Socket4User01InboundConnectEventRF& cb)
00535           : cb(cb) { }
00536 
00537         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
00538 
00539         void respond(const bool& arg_accept) const {
00540             cb->dispatch(XrlCmdError::OKAY(),
00541                          &arg_accept);
00542         }
00543     };
00544 
00545     struct Socket4User01InboundConnectEventRsp :
00546       public Socket4User01InboundConnectEventCB {
00547         struct args_str {
00548             bool accept;
00549         };
00550 
00551     private:
00552         args_str args;
00553 
00554     public:
00555         Socket4User01InboundConnectEventRsp(const Socket4User01InboundConnectEventRF& cb)
00556           : Socket4User01InboundConnectEventCB(cb) { }
00557 
00558         void respond() const {
00559             Socket4User01InboundConnectEventCB::
00560             respond(args.accept);
00561         }
00562 
00563         args_str* operator ->() {
00564             return &args;
00565         }
00566     };
00567 
00568     virtual void async_socket4_user_0_1_inbound_connect_event
00569        (
00570     const string&   sockid,
00571     const IPv4& src_host,
00572     const uint32_t& src_port,
00573     const string&   new_sockid,
00574     Socket4User01InboundConnectEventCB);
00575 #endif
00576 
00588     virtual XrlCmdError socket4_user_0_1_outgoing_connect_event(
00589     // Input values,
00590     const string&   sockid) = 0;
00591 #ifdef XORP_ENABLE_ASYNC_SERVER
00592     typedef
00593     XorpCallback1<void, const XrlCmdError &>::RefPtr
00594     Socket4User01OutgoingConnectEventRF;
00595 
00596     class Socket4User01OutgoingConnectEventCB {
00597         Socket4User01OutgoingConnectEventRF cb;
00598 
00599     public:
00600         operator const Socket4User01OutgoingConnectEventRF& () const { return cb; }
00601         const Socket4User01OutgoingConnectEventRF& operator ->() const { return cb; }
00602         Socket4User01OutgoingConnectEventCB(const Socket4User01OutgoingConnectEventRF& cb)
00603           : cb(cb) { }
00604 
00605         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00606 
00607         void respond() const {
00608             cb->dispatch(XrlCmdError::OKAY());
00609         }
00610     };
00611 
00612     struct Socket4User01OutgoingConnectEventRsp :
00613       public Socket4User01OutgoingConnectEventCB {
00614         Socket4User01OutgoingConnectEventRsp(const Socket4User01OutgoingConnectEventRF& cb)
00615           : Socket4User01OutgoingConnectEventCB(cb) { }
00616 
00617     };
00618 
00619     virtual void async_socket4_user_0_1_outgoing_connect_event
00620        (
00621     const string&   sockid,
00622     Socket4User01OutgoingConnectEventCB);
00623 #endif
00624 
00637     virtual XrlCmdError socket4_user_0_1_error_event(
00638     // Input values,
00639     const string&   sockid,
00640     const string&   error,
00641     const bool& fatal) = 0;
00642 #ifdef XORP_ENABLE_ASYNC_SERVER
00643     typedef
00644     XorpCallback1<void, const XrlCmdError &>::RefPtr
00645     Socket4User01ErrorEventRF;
00646 
00647     class Socket4User01ErrorEventCB {
00648         Socket4User01ErrorEventRF cb;
00649 
00650     public:
00651         operator const Socket4User01ErrorEventRF& () const { return cb; }
00652         const Socket4User01ErrorEventRF& operator ->() const { return cb; }
00653         Socket4User01ErrorEventCB(const Socket4User01ErrorEventRF& cb)
00654           : cb(cb) { }
00655 
00656         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00657 
00658         void respond() const {
00659             cb->dispatch(XrlCmdError::OKAY());
00660         }
00661     };
00662 
00663     struct Socket4User01ErrorEventRsp :
00664       public Socket4User01ErrorEventCB {
00665         Socket4User01ErrorEventRsp(const Socket4User01ErrorEventRF& cb)
00666           : Socket4User01ErrorEventCB(cb) { }
00667 
00668     };
00669 
00670     virtual void async_socket4_user_0_1_error_event
00671        (
00672     const string&   sockid,
00673     const string&   error,
00674     const bool& fatal,
00675     Socket4User01ErrorEventCB);
00676 #endif
00677 
00688     virtual XrlCmdError socket4_user_0_1_disconnect_event(
00689     // Input values,
00690     const string&   sockid) = 0;
00691 #ifdef XORP_ENABLE_ASYNC_SERVER
00692     typedef
00693     XorpCallback1<void, const XrlCmdError &>::RefPtr
00694     Socket4User01DisconnectEventRF;
00695 
00696     class Socket4User01DisconnectEventCB {
00697         Socket4User01DisconnectEventRF cb;
00698 
00699     public:
00700         operator const Socket4User01DisconnectEventRF& () const { return cb; }
00701         const Socket4User01DisconnectEventRF& operator ->() const { return cb; }
00702         Socket4User01DisconnectEventCB(const Socket4User01DisconnectEventRF& cb)
00703           : cb(cb) { }
00704 
00705         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00706 
00707         void respond() const {
00708             cb->dispatch(XrlCmdError::OKAY());
00709         }
00710     };
00711 
00712     struct Socket4User01DisconnectEventRsp :
00713       public Socket4User01DisconnectEventCB {
00714         Socket4User01DisconnectEventRsp(const Socket4User01DisconnectEventRF& cb)
00715           : Socket4User01DisconnectEventCB(cb) { }
00716 
00717     };
00718 
00719     virtual void async_socket4_user_0_1_disconnect_event
00720        (
00721     const string&   sockid,
00722     Socket4User01DisconnectEventCB);
00723 #endif
00724 
00734     virtual XrlCmdError policy_backend_0_1_configure(
00735     // Input values,
00736     const uint32_t& filter,
00737     const string&   conf) = 0;
00738 #ifdef XORP_ENABLE_ASYNC_SERVER
00739     typedef
00740     XorpCallback1<void, const XrlCmdError &>::RefPtr
00741     PolicyBackend01ConfigureRF;
00742 
00743     class PolicyBackend01ConfigureCB {
00744         PolicyBackend01ConfigureRF cb;
00745 
00746     public:
00747         operator const PolicyBackend01ConfigureRF& () const { return cb; }
00748         const PolicyBackend01ConfigureRF& operator ->() const { return cb; }
00749         PolicyBackend01ConfigureCB(const PolicyBackend01ConfigureRF& cb)
00750           : cb(cb) { }
00751 
00752         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00753 
00754         void respond() const {
00755             cb->dispatch(XrlCmdError::OKAY());
00756         }
00757     };
00758 
00759     struct PolicyBackend01ConfigureRsp :
00760       public PolicyBackend01ConfigureCB {
00761         PolicyBackend01ConfigureRsp(const PolicyBackend01ConfigureRF& cb)
00762           : PolicyBackend01ConfigureCB(cb) { }
00763 
00764     };
00765 
00766     virtual void async_policy_backend_0_1_configure
00767        (
00768     const uint32_t& filter,
00769     const string&   conf,
00770     PolicyBackend01ConfigureCB);
00771 #endif
00772 
00780     virtual XrlCmdError policy_backend_0_1_reset(
00781     // Input values,
00782     const uint32_t& filter) = 0;
00783 #ifdef XORP_ENABLE_ASYNC_SERVER
00784     typedef
00785     XorpCallback1<void, const XrlCmdError &>::RefPtr
00786     PolicyBackend01ResetRF;
00787 
00788     class PolicyBackend01ResetCB {
00789         PolicyBackend01ResetRF cb;
00790 
00791     public:
00792         operator const PolicyBackend01ResetRF& () const { return cb; }
00793         const PolicyBackend01ResetRF& operator ->() const { return cb; }
00794         PolicyBackend01ResetCB(const PolicyBackend01ResetRF& cb)
00795           : cb(cb) { }
00796 
00797         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00798 
00799         void respond() const {
00800             cb->dispatch(XrlCmdError::OKAY());
00801         }
00802     };
00803 
00804     struct PolicyBackend01ResetRsp :
00805       public PolicyBackend01ResetCB {
00806         PolicyBackend01ResetRsp(const PolicyBackend01ResetRF& cb)
00807           : PolicyBackend01ResetCB(cb) { }
00808 
00809     };
00810 
00811     virtual void async_policy_backend_0_1_reset
00812        (
00813     const uint32_t& filter,
00814     PolicyBackend01ResetCB);
00815 #endif
00816 
00822     virtual XrlCmdError policy_backend_0_1_push_routes() = 0;
00823 #ifdef XORP_ENABLE_ASYNC_SERVER
00824     typedef
00825     XorpCallback1<void, const XrlCmdError &>::RefPtr
00826     PolicyBackend01PushRoutesRF;
00827 
00828     class PolicyBackend01PushRoutesCB {
00829         PolicyBackend01PushRoutesRF cb;
00830 
00831     public:
00832         operator const PolicyBackend01PushRoutesRF& () const { return cb; }
00833         const PolicyBackend01PushRoutesRF& operator ->() const { return cb; }
00834         PolicyBackend01PushRoutesCB(const PolicyBackend01PushRoutesRF& cb)
00835           : cb(cb) { }
00836 
00837         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00838 
00839         void respond() const {
00840             cb->dispatch(XrlCmdError::OKAY());
00841         }
00842     };
00843 
00844     struct PolicyBackend01PushRoutesRsp :
00845       public PolicyBackend01PushRoutesCB {
00846         PolicyBackend01PushRoutesRsp(const PolicyBackend01PushRoutesRF& cb)
00847           : PolicyBackend01PushRoutesCB(cb) { }
00848 
00849     };
00850 
00851     virtual void async_policy_backend_0_1_push_routes
00852        (
00853     PolicyBackend01PushRoutesCB);
00854 #endif
00855 
00873     virtual XrlCmdError policy_redist4_0_1_add_route4(
00874     // Input values,
00875     const IPv4Net&  network,
00876     const bool& unicast,
00877     const bool& multicast,
00878     const IPv4& nexthop,
00879     const uint32_t& metric,
00880     const XrlAtomList&  policytags) = 0;
00881 #ifdef XORP_ENABLE_ASYNC_SERVER
00882     typedef
00883     XorpCallback1<void, const XrlCmdError &>::RefPtr
00884     PolicyRedist401AddRoute4RF;
00885 
00886     class PolicyRedist401AddRoute4CB {
00887         PolicyRedist401AddRoute4RF cb;
00888 
00889     public:
00890         operator const PolicyRedist401AddRoute4RF& () const { return cb; }
00891         const PolicyRedist401AddRoute4RF& operator ->() const { return cb; }
00892         PolicyRedist401AddRoute4CB(const PolicyRedist401AddRoute4RF& cb)
00893           : cb(cb) { }
00894 
00895         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00896 
00897         void respond() const {
00898             cb->dispatch(XrlCmdError::OKAY());
00899         }
00900     };
00901 
00902     struct PolicyRedist401AddRoute4Rsp :
00903       public PolicyRedist401AddRoute4CB {
00904         PolicyRedist401AddRoute4Rsp(const PolicyRedist401AddRoute4RF& cb)
00905           : PolicyRedist401AddRoute4CB(cb) { }
00906 
00907     };
00908 
00909     virtual void async_policy_redist4_0_1_add_route4
00910        (
00911     const IPv4Net&  network,
00912     const bool& unicast,
00913     const bool& multicast,
00914     const IPv4& nexthop,
00915     const uint32_t& metric,
00916     const XrlAtomList&  policytags,
00917     PolicyRedist401AddRoute4CB);
00918 #endif
00919 
00931     virtual XrlCmdError policy_redist4_0_1_delete_route4(
00932     // Input values,
00933     const IPv4Net&  network,
00934     const bool& unicast,
00935     const bool& multicast) = 0;
00936 #ifdef XORP_ENABLE_ASYNC_SERVER
00937     typedef
00938     XorpCallback1<void, const XrlCmdError &>::RefPtr
00939     PolicyRedist401DeleteRoute4RF;
00940 
00941     class PolicyRedist401DeleteRoute4CB {
00942         PolicyRedist401DeleteRoute4RF cb;
00943 
00944     public:
00945         operator const PolicyRedist401DeleteRoute4RF& () const { return cb; }
00946         const PolicyRedist401DeleteRoute4RF& operator ->() const { return cb; }
00947         PolicyRedist401DeleteRoute4CB(const PolicyRedist401DeleteRoute4RF& cb)
00948           : cb(cb) { }
00949 
00950         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00951 
00952         void respond() const {
00953             cb->dispatch(XrlCmdError::OKAY());
00954         }
00955     };
00956 
00957     struct PolicyRedist401DeleteRoute4Rsp :
00958       public PolicyRedist401DeleteRoute4CB {
00959         PolicyRedist401DeleteRoute4Rsp(const PolicyRedist401DeleteRoute4RF& cb)
00960           : PolicyRedist401DeleteRoute4CB(cb) { }
00961 
00962     };
00963 
00964     virtual void async_policy_redist4_0_1_delete_route4
00965        (
00966     const IPv4Net&  network,
00967     const bool& unicast,
00968     const bool& multicast,
00969     PolicyRedist401DeleteRoute4CB);
00970 #endif
00971 
00979     virtual XrlCmdError profile_0_1_enable(
00980     // Input values,
00981     const string&   pname) = 0;
00982 #ifdef XORP_ENABLE_ASYNC_SERVER
00983     typedef
00984     XorpCallback1<void, const XrlCmdError &>::RefPtr
00985     Profile01EnableRF;
00986 
00987     class Profile01EnableCB {
00988         Profile01EnableRF cb;
00989 
00990     public:
00991         operator const Profile01EnableRF& () const { return cb; }
00992         const Profile01EnableRF& operator ->() const { return cb; }
00993         Profile01EnableCB(const Profile01EnableRF& cb)
00994           : cb(cb) { }
00995 
00996         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
00997 
00998         void respond() const {
00999             cb->dispatch(XrlCmdError::OKAY());
01000         }
01001     };
01002 
01003     struct Profile01EnableRsp :
01004       public Profile01EnableCB {
01005         Profile01EnableRsp(const Profile01EnableRF& cb)
01006           : Profile01EnableCB(cb) { }
01007 
01008     };
01009 
01010     virtual void async_profile_0_1_enable
01011        (
01012     const string&   pname,
01013     Profile01EnableCB);
01014 #endif
01015 
01023     virtual XrlCmdError profile_0_1_disable(
01024     // Input values,
01025     const string&   pname) = 0;
01026 #ifdef XORP_ENABLE_ASYNC_SERVER
01027     typedef
01028     XorpCallback1<void, const XrlCmdError &>::RefPtr
01029     Profile01DisableRF;
01030 
01031     class Profile01DisableCB {
01032         Profile01DisableRF cb;
01033 
01034     public:
01035         operator const Profile01DisableRF& () const { return cb; }
01036         const Profile01DisableRF& operator ->() const { return cb; }
01037         Profile01DisableCB(const Profile01DisableRF& cb)
01038           : cb(cb) { }
01039 
01040         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01041 
01042         void respond() const {
01043             cb->dispatch(XrlCmdError::OKAY());
01044         }
01045     };
01046 
01047     struct Profile01DisableRsp :
01048       public Profile01DisableCB {
01049         Profile01DisableRsp(const Profile01DisableRF& cb)
01050           : Profile01DisableCB(cb) { }
01051 
01052     };
01053 
01054     virtual void async_profile_0_1_disable
01055        (
01056     const string&   pname,
01057     Profile01DisableCB);
01058 #endif
01059 
01069     virtual XrlCmdError profile_0_1_get_entries(
01070     // Input values,
01071     const string&   pname,
01072     const string&   instance_name) = 0;
01073 #ifdef XORP_ENABLE_ASYNC_SERVER
01074     typedef
01075     XorpCallback1<void, const XrlCmdError &>::RefPtr
01076     Profile01GetEntriesRF;
01077 
01078     class Profile01GetEntriesCB {
01079         Profile01GetEntriesRF cb;
01080 
01081     public:
01082         operator const Profile01GetEntriesRF& () const { return cb; }
01083         const Profile01GetEntriesRF& operator ->() const { return cb; }
01084         Profile01GetEntriesCB(const Profile01GetEntriesRF& cb)
01085           : cb(cb) { }
01086 
01087         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01088 
01089         void respond() const {
01090             cb->dispatch(XrlCmdError::OKAY());
01091         }
01092     };
01093 
01094     struct Profile01GetEntriesRsp :
01095       public Profile01GetEntriesCB {
01096         Profile01GetEntriesRsp(const Profile01GetEntriesRF& cb)
01097           : Profile01GetEntriesCB(cb) { }
01098 
01099     };
01100 
01101     virtual void async_profile_0_1_get_entries
01102        (
01103     const string&   pname,
01104     const string&   instance_name,
01105     Profile01GetEntriesCB);
01106 #endif
01107 
01115     virtual XrlCmdError profile_0_1_clear(
01116     // Input values,
01117     const string&   pname) = 0;
01118 #ifdef XORP_ENABLE_ASYNC_SERVER
01119     typedef
01120     XorpCallback1<void, const XrlCmdError &>::RefPtr
01121     Profile01ClearRF;
01122 
01123     class Profile01ClearCB {
01124         Profile01ClearRF cb;
01125 
01126     public:
01127         operator const Profile01ClearRF& () const { return cb; }
01128         const Profile01ClearRF& operator ->() const { return cb; }
01129         Profile01ClearCB(const Profile01ClearRF& cb)
01130           : cb(cb) { }
01131 
01132         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01133 
01134         void respond() const {
01135             cb->dispatch(XrlCmdError::OKAY());
01136         }
01137     };
01138 
01139     struct Profile01ClearRsp :
01140       public Profile01ClearCB {
01141         Profile01ClearRsp(const Profile01ClearRF& cb)
01142           : Profile01ClearCB(cb) { }
01143 
01144     };
01145 
01146     virtual void async_profile_0_1_clear
01147        (
01148     const string&   pname,
01149     Profile01ClearCB);
01150 #endif
01151 
01157     virtual XrlCmdError profile_0_1_list(
01158     // Output values,
01159     string& info) = 0;
01160 #ifdef XORP_ENABLE_ASYNC_SERVER
01161     typedef
01162     XorpCallback2<void, const XrlCmdError &,
01163     const string*>::RefPtr
01164     Profile01ListRF;
01165 
01166     class Profile01ListCB {
01167         Profile01ListRF cb;
01168 
01169     public:
01170         operator const Profile01ListRF& () const { return cb; }
01171         const Profile01ListRF& operator ->() const { return cb; }
01172         Profile01ListCB(const Profile01ListRF& cb)
01173           : cb(cb) { }
01174 
01175         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01176 
01177         void respond(const string& arg_info) const {
01178             cb->dispatch(XrlCmdError::OKAY(),
01179                          &arg_info);
01180         }
01181     };
01182 
01183     struct Profile01ListRsp :
01184       public Profile01ListCB {
01185         struct args_str {
01186             string info;
01187         };
01188 
01189     private:
01190         args_str args;
01191 
01192     public:
01193         Profile01ListRsp(const Profile01ListRF& cb)
01194           : Profile01ListCB(cb) { }
01195 
01196         void respond() const {
01197             Profile01ListCB::
01198             respond(args.info);
01199         }
01200 
01201         args_str* operator ->() {
01202             return &args;
01203         }
01204     };
01205 
01206     virtual void async_profile_0_1_list
01207        (
01208     Profile01ListCB);
01209 #endif
01210 
01220     virtual XrlCmdError olsr4_0_1_trace(
01221     // Input values,
01222     const string&   tvar,
01223     const bool& enable) = 0;
01224 #ifdef XORP_ENABLE_ASYNC_SERVER
01225     typedef
01226     XorpCallback1<void, const XrlCmdError &>::RefPtr
01227     Olsr401TraceRF;
01228 
01229     class Olsr401TraceCB {
01230         Olsr401TraceRF cb;
01231 
01232     public:
01233         operator const Olsr401TraceRF& () const { return cb; }
01234         const Olsr401TraceRF& operator ->() const { return cb; }
01235         Olsr401TraceCB(const Olsr401TraceRF& cb)
01236           : cb(cb) { }
01237 
01238         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01239 
01240         void respond() const {
01241             cb->dispatch(XrlCmdError::OKAY());
01242         }
01243     };
01244 
01245     struct Olsr401TraceRsp :
01246       public Olsr401TraceCB {
01247         Olsr401TraceRsp(const Olsr401TraceRF& cb)
01248           : Olsr401TraceCB(cb) { }
01249 
01250     };
01251 
01252     virtual void async_olsr4_0_1_trace
01253        (
01254     const string&   tvar,
01255     const bool& enable,
01256     Olsr401TraceCB);
01257 #endif
01258 
01264     virtual XrlCmdError olsr4_0_1_clear_database() = 0;
01265 #ifdef XORP_ENABLE_ASYNC_SERVER
01266     typedef
01267     XorpCallback1<void, const XrlCmdError &>::RefPtr
01268     Olsr401ClearDatabaseRF;
01269 
01270     class Olsr401ClearDatabaseCB {
01271         Olsr401ClearDatabaseRF cb;
01272 
01273     public:
01274         operator const Olsr401ClearDatabaseRF& () const { return cb; }
01275         const Olsr401ClearDatabaseRF& operator ->() const { return cb; }
01276         Olsr401ClearDatabaseCB(const Olsr401ClearDatabaseRF& cb)
01277           : cb(cb) { }
01278 
01279         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01280 
01281         void respond() const {
01282             cb->dispatch(XrlCmdError::OKAY());
01283         }
01284     };
01285 
01286     struct Olsr401ClearDatabaseRsp :
01287       public Olsr401ClearDatabaseCB {
01288         Olsr401ClearDatabaseRsp(const Olsr401ClearDatabaseRF& cb)
01289           : Olsr401ClearDatabaseCB(cb) { }
01290 
01291     };
01292 
01293     virtual void async_olsr4_0_1_clear_database
01294        (
01295     Olsr401ClearDatabaseCB);
01296 #endif
01297 
01305     virtual XrlCmdError olsr4_0_1_set_willingness(
01306     // Input values,
01307     const uint32_t& willingness) = 0;
01308 #ifdef XORP_ENABLE_ASYNC_SERVER
01309     typedef
01310     XorpCallback1<void, const XrlCmdError &>::RefPtr
01311     Olsr401SetWillingnessRF;
01312 
01313     class Olsr401SetWillingnessCB {
01314         Olsr401SetWillingnessRF cb;
01315 
01316     public:
01317         operator const Olsr401SetWillingnessRF& () const { return cb; }
01318         const Olsr401SetWillingnessRF& operator ->() const { return cb; }
01319         Olsr401SetWillingnessCB(const Olsr401SetWillingnessRF& cb)
01320           : cb(cb) { }
01321 
01322         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01323 
01324         void respond() const {
01325             cb->dispatch(XrlCmdError::OKAY());
01326         }
01327     };
01328 
01329     struct Olsr401SetWillingnessRsp :
01330       public Olsr401SetWillingnessCB {
01331         Olsr401SetWillingnessRsp(const Olsr401SetWillingnessRF& cb)
01332           : Olsr401SetWillingnessCB(cb) { }
01333 
01334     };
01335 
01336     virtual void async_olsr4_0_1_set_willingness
01337        (
01338     const uint32_t& willingness,
01339     Olsr401SetWillingnessCB);
01340 #endif
01341 
01347     virtual XrlCmdError olsr4_0_1_get_willingness(
01348     // Output values,
01349     uint32_t&   willingness) = 0;
01350 #ifdef XORP_ENABLE_ASYNC_SERVER
01351     typedef
01352     XorpCallback2<void, const XrlCmdError &,
01353     const uint32_t*>::RefPtr
01354     Olsr401GetWillingnessRF;
01355 
01356     class Olsr401GetWillingnessCB {
01357         Olsr401GetWillingnessRF cb;
01358 
01359     public:
01360         operator const Olsr401GetWillingnessRF& () const { return cb; }
01361         const Olsr401GetWillingnessRF& operator ->() const { return cb; }
01362         Olsr401GetWillingnessCB(const Olsr401GetWillingnessRF& cb)
01363           : cb(cb) { }
01364 
01365         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01366 
01367         void respond(const uint32_t& arg_willingness) const {
01368             cb->dispatch(XrlCmdError::OKAY(),
01369                          &arg_willingness);
01370         }
01371     };
01372 
01373     struct Olsr401GetWillingnessRsp :
01374       public Olsr401GetWillingnessCB {
01375         struct args_str {
01376             uint32_t willingness;
01377         };
01378 
01379     private:
01380         args_str args;
01381 
01382     public:
01383         Olsr401GetWillingnessRsp(const Olsr401GetWillingnessRF& cb)
01384           : Olsr401GetWillingnessCB(cb) { }
01385 
01386         void respond() const {
01387             Olsr401GetWillingnessCB::
01388             respond(args.willingness);
01389         }
01390 
01391         args_str* operator ->() {
01392             return &args;
01393         }
01394     };
01395 
01396     virtual void async_olsr4_0_1_get_willingness
01397        (
01398     Olsr401GetWillingnessCB);
01399 #endif
01400 
01408     virtual XrlCmdError olsr4_0_1_set_mpr_coverage(
01409     // Input values,
01410     const uint32_t& coverage) = 0;
01411 #ifdef XORP_ENABLE_ASYNC_SERVER
01412     typedef
01413     XorpCallback1<void, const XrlCmdError &>::RefPtr
01414     Olsr401SetMprCoverageRF;
01415 
01416     class Olsr401SetMprCoverageCB {
01417         Olsr401SetMprCoverageRF cb;
01418 
01419     public:
01420         operator const Olsr401SetMprCoverageRF& () const { return cb; }
01421         const Olsr401SetMprCoverageRF& operator ->() const { return cb; }
01422         Olsr401SetMprCoverageCB(const Olsr401SetMprCoverageRF& cb)
01423           : cb(cb) { }
01424 
01425         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01426 
01427         void respond() const {
01428             cb->dispatch(XrlCmdError::OKAY());
01429         }
01430     };
01431 
01432     struct Olsr401SetMprCoverageRsp :
01433       public Olsr401SetMprCoverageCB {
01434         Olsr401SetMprCoverageRsp(const Olsr401SetMprCoverageRF& cb)
01435           : Olsr401SetMprCoverageCB(cb) { }
01436 
01437     };
01438 
01439     virtual void async_olsr4_0_1_set_mpr_coverage
01440        (
01441     const uint32_t& coverage,
01442     Olsr401SetMprCoverageCB);
01443 #endif
01444 
01450     virtual XrlCmdError olsr4_0_1_get_mpr_coverage(
01451     // Output values,
01452     uint32_t&   coverage) = 0;
01453 #ifdef XORP_ENABLE_ASYNC_SERVER
01454     typedef
01455     XorpCallback2<void, const XrlCmdError &,
01456     const uint32_t*>::RefPtr
01457     Olsr401GetMprCoverageRF;
01458 
01459     class Olsr401GetMprCoverageCB {
01460         Olsr401GetMprCoverageRF cb;
01461 
01462     public:
01463         operator const Olsr401GetMprCoverageRF& () const { return cb; }
01464         const Olsr401GetMprCoverageRF& operator ->() const { return cb; }
01465         Olsr401GetMprCoverageCB(const Olsr401GetMprCoverageRF& cb)
01466           : cb(cb) { }
01467 
01468         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01469 
01470         void respond(const uint32_t& arg_coverage) const {
01471             cb->dispatch(XrlCmdError::OKAY(),
01472                          &arg_coverage);
01473         }
01474     };
01475 
01476     struct Olsr401GetMprCoverageRsp :
01477       public Olsr401GetMprCoverageCB {
01478         struct args_str {
01479             uint32_t coverage;
01480         };
01481 
01482     private:
01483         args_str args;
01484 
01485     public:
01486         Olsr401GetMprCoverageRsp(const Olsr401GetMprCoverageRF& cb)
01487           : Olsr401GetMprCoverageCB(cb) { }
01488 
01489         void respond() const {
01490             Olsr401GetMprCoverageCB::
01491             respond(args.coverage);
01492         }
01493 
01494         args_str* operator ->() {
01495             return &args;
01496         }
01497     };
01498 
01499     virtual void async_olsr4_0_1_get_mpr_coverage
01500        (
01501     Olsr401GetMprCoverageCB);
01502 #endif
01503 
01509     virtual XrlCmdError olsr4_0_1_set_tc_redundancy(
01510     // Input values,
01511     const string&   redundancy) = 0;
01512 #ifdef XORP_ENABLE_ASYNC_SERVER
01513     typedef
01514     XorpCallback1<void, const XrlCmdError &>::RefPtr
01515     Olsr401SetTcRedundancyRF;
01516 
01517     class Olsr401SetTcRedundancyCB {
01518         Olsr401SetTcRedundancyRF cb;
01519 
01520     public:
01521         operator const Olsr401SetTcRedundancyRF& () const { return cb; }
01522         const Olsr401SetTcRedundancyRF& operator ->() const { return cb; }
01523         Olsr401SetTcRedundancyCB(const Olsr401SetTcRedundancyRF& cb)
01524           : cb(cb) { }
01525 
01526         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01527 
01528         void respond() const {
01529             cb->dispatch(XrlCmdError::OKAY());
01530         }
01531     };
01532 
01533     struct Olsr401SetTcRedundancyRsp :
01534       public Olsr401SetTcRedundancyCB {
01535         Olsr401SetTcRedundancyRsp(const Olsr401SetTcRedundancyRF& cb)
01536           : Olsr401SetTcRedundancyCB(cb) { }
01537 
01538     };
01539 
01540     virtual void async_olsr4_0_1_set_tc_redundancy
01541        (
01542     const string&   redundancy,
01543     Olsr401SetTcRedundancyCB);
01544 #endif
01545 
01551     virtual XrlCmdError olsr4_0_1_get_tc_redundancy(
01552     // Output values,
01553     string& redundancy) = 0;
01554 #ifdef XORP_ENABLE_ASYNC_SERVER
01555     typedef
01556     XorpCallback2<void, const XrlCmdError &,
01557     const string*>::RefPtr
01558     Olsr401GetTcRedundancyRF;
01559 
01560     class Olsr401GetTcRedundancyCB {
01561         Olsr401GetTcRedundancyRF cb;
01562 
01563     public:
01564         operator const Olsr401GetTcRedundancyRF& () const { return cb; }
01565         const Olsr401GetTcRedundancyRF& operator ->() const { return cb; }
01566         Olsr401GetTcRedundancyCB(const Olsr401GetTcRedundancyRF& cb)
01567           : cb(cb) { }
01568 
01569         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01570 
01571         void respond(const string& arg_redundancy) const {
01572             cb->dispatch(XrlCmdError::OKAY(),
01573                          &arg_redundancy);
01574         }
01575     };
01576 
01577     struct Olsr401GetTcRedundancyRsp :
01578       public Olsr401GetTcRedundancyCB {
01579         struct args_str {
01580             string redundancy;
01581         };
01582 
01583     private:
01584         args_str args;
01585 
01586     public:
01587         Olsr401GetTcRedundancyRsp(const Olsr401GetTcRedundancyRF& cb)
01588           : Olsr401GetTcRedundancyCB(cb) { }
01589 
01590         void respond() const {
01591             Olsr401GetTcRedundancyCB::
01592             respond(args.redundancy);
01593         }
01594 
01595         args_str* operator ->() {
01596             return &args;
01597         }
01598     };
01599 
01600     virtual void async_olsr4_0_1_get_tc_redundancy
01601        (
01602     Olsr401GetTcRedundancyCB);
01603 #endif
01604 
01612     virtual XrlCmdError olsr4_0_1_set_tc_fisheye(
01613     // Input values,
01614     const bool& enabled) = 0;
01615 #ifdef XORP_ENABLE_ASYNC_SERVER
01616     typedef
01617     XorpCallback1<void, const XrlCmdError &>::RefPtr
01618     Olsr401SetTcFisheyeRF;
01619 
01620     class Olsr401SetTcFisheyeCB {
01621         Olsr401SetTcFisheyeRF cb;
01622 
01623     public:
01624         operator const Olsr401SetTcFisheyeRF& () const { return cb; }
01625         const Olsr401SetTcFisheyeRF& operator ->() const { return cb; }
01626         Olsr401SetTcFisheyeCB(const Olsr401SetTcFisheyeRF& cb)
01627           : cb(cb) { }
01628 
01629         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01630 
01631         void respond() const {
01632             cb->dispatch(XrlCmdError::OKAY());
01633         }
01634     };
01635 
01636     struct Olsr401SetTcFisheyeRsp :
01637       public Olsr401SetTcFisheyeCB {
01638         Olsr401SetTcFisheyeRsp(const Olsr401SetTcFisheyeRF& cb)
01639           : Olsr401SetTcFisheyeCB(cb) { }
01640 
01641     };
01642 
01643     virtual void async_olsr4_0_1_set_tc_fisheye
01644        (
01645     const bool& enabled,
01646     Olsr401SetTcFisheyeCB);
01647 #endif
01648 
01654     virtual XrlCmdError olsr4_0_1_get_tc_fisheye(
01655     // Output values,
01656     bool&   enabled) = 0;
01657 #ifdef XORP_ENABLE_ASYNC_SERVER
01658     typedef
01659     XorpCallback2<void, const XrlCmdError &,
01660     const bool*>::RefPtr
01661     Olsr401GetTcFisheyeRF;
01662 
01663     class Olsr401GetTcFisheyeCB {
01664         Olsr401GetTcFisheyeRF cb;
01665 
01666     public:
01667         operator const Olsr401GetTcFisheyeRF& () const { return cb; }
01668         const Olsr401GetTcFisheyeRF& operator ->() const { return cb; }
01669         Olsr401GetTcFisheyeCB(const Olsr401GetTcFisheyeRF& cb)
01670           : cb(cb) { }
01671 
01672         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01673 
01674         void respond(const bool& arg_enabled) const {
01675             cb->dispatch(XrlCmdError::OKAY(),
01676                          &arg_enabled);
01677         }
01678     };
01679 
01680     struct Olsr401GetTcFisheyeRsp :
01681       public Olsr401GetTcFisheyeCB {
01682         struct args_str {
01683             bool enabled;
01684         };
01685 
01686     private:
01687         args_str args;
01688 
01689     public:
01690         Olsr401GetTcFisheyeRsp(const Olsr401GetTcFisheyeRF& cb)
01691           : Olsr401GetTcFisheyeCB(cb) { }
01692 
01693         void respond() const {
01694             Olsr401GetTcFisheyeCB::
01695             respond(args.enabled);
01696         }
01697 
01698         args_str* operator ->() {
01699             return &args;
01700         }
01701     };
01702 
01703     virtual void async_olsr4_0_1_get_tc_fisheye
01704        (
01705     Olsr401GetTcFisheyeCB);
01706 #endif
01707 
01713     virtual XrlCmdError olsr4_0_1_set_hna_base_cost(
01714     // Input values,
01715     const uint32_t& metric) = 0;
01716 #ifdef XORP_ENABLE_ASYNC_SERVER
01717     typedef
01718     XorpCallback1<void, const XrlCmdError &>::RefPtr
01719     Olsr401SetHnaBaseCostRF;
01720 
01721     class Olsr401SetHnaBaseCostCB {
01722         Olsr401SetHnaBaseCostRF cb;
01723 
01724     public:
01725         operator const Olsr401SetHnaBaseCostRF& () const { return cb; }
01726         const Olsr401SetHnaBaseCostRF& operator ->() const { return cb; }
01727         Olsr401SetHnaBaseCostCB(const Olsr401SetHnaBaseCostRF& cb)
01728           : cb(cb) { }
01729 
01730         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01731 
01732         void respond() const {
01733             cb->dispatch(XrlCmdError::OKAY());
01734         }
01735     };
01736 
01737     struct Olsr401SetHnaBaseCostRsp :
01738       public Olsr401SetHnaBaseCostCB {
01739         Olsr401SetHnaBaseCostRsp(const Olsr401SetHnaBaseCostRF& cb)
01740           : Olsr401SetHnaBaseCostCB(cb) { }
01741 
01742     };
01743 
01744     virtual void async_olsr4_0_1_set_hna_base_cost
01745        (
01746     const uint32_t& metric,
01747     Olsr401SetHnaBaseCostCB);
01748 #endif
01749 
01755     virtual XrlCmdError olsr4_0_1_get_hna_base_cost(
01756     // Output values,
01757     uint32_t&   metric) = 0;
01758 #ifdef XORP_ENABLE_ASYNC_SERVER
01759     typedef
01760     XorpCallback2<void, const XrlCmdError &,
01761     const uint32_t*>::RefPtr
01762     Olsr401GetHnaBaseCostRF;
01763 
01764     class Olsr401GetHnaBaseCostCB {
01765         Olsr401GetHnaBaseCostRF cb;
01766 
01767     public:
01768         operator const Olsr401GetHnaBaseCostRF& () const { return cb; }
01769         const Olsr401GetHnaBaseCostRF& operator ->() const { return cb; }
01770         Olsr401GetHnaBaseCostCB(const Olsr401GetHnaBaseCostRF& cb)
01771           : cb(cb) { }
01772 
01773         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01774 
01775         void respond(const uint32_t& arg_metric) const {
01776             cb->dispatch(XrlCmdError::OKAY(),
01777                          &arg_metric);
01778         }
01779     };
01780 
01781     struct Olsr401GetHnaBaseCostRsp :
01782       public Olsr401GetHnaBaseCostCB {
01783         struct args_str {
01784             uint32_t metric;
01785         };
01786 
01787     private:
01788         args_str args;
01789 
01790     public:
01791         Olsr401GetHnaBaseCostRsp(const Olsr401GetHnaBaseCostRF& cb)
01792           : Olsr401GetHnaBaseCostCB(cb) { }
01793 
01794         void respond() const {
01795             Olsr401GetHnaBaseCostCB::
01796             respond(args.metric);
01797         }
01798 
01799         args_str* operator ->() {
01800             return &args;
01801         }
01802     };
01803 
01804     virtual void async_olsr4_0_1_get_hna_base_cost
01805        (
01806     Olsr401GetHnaBaseCostCB);
01807 #endif
01808 
01816     virtual XrlCmdError olsr4_0_1_set_hello_interval(
01817     // Input values,
01818     const uint32_t& interval) = 0;
01819 #ifdef XORP_ENABLE_ASYNC_SERVER
01820     typedef
01821     XorpCallback1<void, const XrlCmdError &>::RefPtr
01822     Olsr401SetHelloIntervalRF;
01823 
01824     class Olsr401SetHelloIntervalCB {
01825         Olsr401SetHelloIntervalRF cb;
01826 
01827     public:
01828         operator const Olsr401SetHelloIntervalRF& () const { return cb; }
01829         const Olsr401SetHelloIntervalRF& operator ->() const { return cb; }
01830         Olsr401SetHelloIntervalCB(const Olsr401SetHelloIntervalRF& cb)
01831           : cb(cb) { }
01832 
01833         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01834 
01835         void respond() const {
01836             cb->dispatch(XrlCmdError::OKAY());
01837         }
01838     };
01839 
01840     struct Olsr401SetHelloIntervalRsp :
01841       public Olsr401SetHelloIntervalCB {
01842         Olsr401SetHelloIntervalRsp(const Olsr401SetHelloIntervalRF& cb)
01843           : Olsr401SetHelloIntervalCB(cb) { }
01844 
01845     };
01846 
01847     virtual void async_olsr4_0_1_set_hello_interval
01848        (
01849     const uint32_t& interval,
01850     Olsr401SetHelloIntervalCB);
01851 #endif
01852 
01858     virtual XrlCmdError olsr4_0_1_get_hello_interval(
01859     // Output values,
01860     uint32_t&   interval) = 0;
01861 #ifdef XORP_ENABLE_ASYNC_SERVER
01862     typedef
01863     XorpCallback2<void, const XrlCmdError &,
01864     const uint32_t*>::RefPtr
01865     Olsr401GetHelloIntervalRF;
01866 
01867     class Olsr401GetHelloIntervalCB {
01868         Olsr401GetHelloIntervalRF cb;
01869 
01870     public:
01871         operator const Olsr401GetHelloIntervalRF& () const { return cb; }
01872         const Olsr401GetHelloIntervalRF& operator ->() const { return cb; }
01873         Olsr401GetHelloIntervalCB(const Olsr401GetHelloIntervalRF& cb)
01874           : cb(cb) { }
01875 
01876         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01877 
01878         void respond(const uint32_t& arg_interval) const {
01879             cb->dispatch(XrlCmdError::OKAY(),
01880                          &arg_interval);
01881         }
01882     };
01883 
01884     struct Olsr401GetHelloIntervalRsp :
01885       public Olsr401GetHelloIntervalCB {
01886         struct args_str {
01887             uint32_t interval;
01888         };
01889 
01890     private:
01891         args_str args;
01892 
01893     public:
01894         Olsr401GetHelloIntervalRsp(const Olsr401GetHelloIntervalRF& cb)
01895           : Olsr401GetHelloIntervalCB(cb) { }
01896 
01897         void respond() const {
01898             Olsr401GetHelloIntervalCB::
01899             respond(args.interval);
01900         }
01901 
01902         args_str* operator ->() {
01903             return &args;
01904         }
01905     };
01906 
01907     virtual void async_olsr4_0_1_get_hello_interval
01908        (
01909     Olsr401GetHelloIntervalCB);
01910 #endif
01911 
01919     virtual XrlCmdError olsr4_0_1_set_refresh_interval(
01920     // Input values,
01921     const uint32_t& interval) = 0;
01922 #ifdef XORP_ENABLE_ASYNC_SERVER
01923     typedef
01924     XorpCallback1<void, const XrlCmdError &>::RefPtr
01925     Olsr401SetRefreshIntervalRF;
01926 
01927     class Olsr401SetRefreshIntervalCB {
01928         Olsr401SetRefreshIntervalRF cb;
01929 
01930     public:
01931         operator const Olsr401SetRefreshIntervalRF& () const { return cb; }
01932         const Olsr401SetRefreshIntervalRF& operator ->() const { return cb; }
01933         Olsr401SetRefreshIntervalCB(const Olsr401SetRefreshIntervalRF& cb)
01934           : cb(cb) { }
01935 
01936         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
01937 
01938         void respond() const {
01939             cb->dispatch(XrlCmdError::OKAY());
01940         }
01941     };
01942 
01943     struct Olsr401SetRefreshIntervalRsp :
01944       public Olsr401SetRefreshIntervalCB {
01945         Olsr401SetRefreshIntervalRsp(const Olsr401SetRefreshIntervalRF& cb)
01946           : Olsr401SetRefreshIntervalCB(cb) { }
01947 
01948     };
01949 
01950     virtual void async_olsr4_0_1_set_refresh_interval
01951        (
01952     const uint32_t& interval,
01953     Olsr401SetRefreshIntervalCB);
01954 #endif
01955 
01961     virtual XrlCmdError olsr4_0_1_get_refresh_interval(
01962     // Output values,
01963     uint32_t&   interval) = 0;
01964 #ifdef XORP_ENABLE_ASYNC_SERVER
01965     typedef
01966     XorpCallback2<void, const XrlCmdError &,
01967     const uint32_t*>::RefPtr
01968     Olsr401GetRefreshIntervalRF;
01969 
01970     class Olsr401GetRefreshIntervalCB {
01971         Olsr401GetRefreshIntervalRF cb;
01972 
01973     public:
01974         operator const Olsr401GetRefreshIntervalRF& () const { return cb; }
01975         const Olsr401GetRefreshIntervalRF& operator ->() const { return cb; }
01976         Olsr401GetRefreshIntervalCB(const Olsr401GetRefreshIntervalRF& cb)
01977           : cb(cb) { }
01978 
01979         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
01980 
01981         void respond(const uint32_t& arg_interval) const {
01982             cb->dispatch(XrlCmdError::OKAY(),
01983                          &arg_interval);
01984         }
01985     };
01986 
01987     struct Olsr401GetRefreshIntervalRsp :
01988       public Olsr401GetRefreshIntervalCB {
01989         struct args_str {
01990             uint32_t interval;
01991         };
01992 
01993     private:
01994         args_str args;
01995 
01996     public:
01997         Olsr401GetRefreshIntervalRsp(const Olsr401GetRefreshIntervalRF& cb)
01998           : Olsr401GetRefreshIntervalCB(cb) { }
01999 
02000         void respond() const {
02001             Olsr401GetRefreshIntervalCB::
02002             respond(args.interval);
02003         }
02004 
02005         args_str* operator ->() {
02006             return &args;
02007         }
02008     };
02009 
02010     virtual void async_olsr4_0_1_get_refresh_interval
02011        (
02012     Olsr401GetRefreshIntervalCB);
02013 #endif
02014 
02022     virtual XrlCmdError olsr4_0_1_set_tc_interval(
02023     // Input values,
02024     const uint32_t& interval) = 0;
02025 #ifdef XORP_ENABLE_ASYNC_SERVER
02026     typedef
02027     XorpCallback1<void, const XrlCmdError &>::RefPtr
02028     Olsr401SetTcIntervalRF;
02029 
02030     class Olsr401SetTcIntervalCB {
02031         Olsr401SetTcIntervalRF cb;
02032 
02033     public:
02034         operator const Olsr401SetTcIntervalRF& () const { return cb; }
02035         const Olsr401SetTcIntervalRF& operator ->() const { return cb; }
02036         Olsr401SetTcIntervalCB(const Olsr401SetTcIntervalRF& cb)
02037           : cb(cb) { }
02038 
02039         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02040 
02041         void respond() const {
02042             cb->dispatch(XrlCmdError::OKAY());
02043         }
02044     };
02045 
02046     struct Olsr401SetTcIntervalRsp :
02047       public Olsr401SetTcIntervalCB {
02048         Olsr401SetTcIntervalRsp(const Olsr401SetTcIntervalRF& cb)
02049           : Olsr401SetTcIntervalCB(cb) { }
02050 
02051     };
02052 
02053     virtual void async_olsr4_0_1_set_tc_interval
02054        (
02055     const uint32_t& interval,
02056     Olsr401SetTcIntervalCB);
02057 #endif
02058 
02064     virtual XrlCmdError olsr4_0_1_get_tc_interval(
02065     // Output values,
02066     uint32_t&   interval) = 0;
02067 #ifdef XORP_ENABLE_ASYNC_SERVER
02068     typedef
02069     XorpCallback2<void, const XrlCmdError &,
02070     const uint32_t*>::RefPtr
02071     Olsr401GetTcIntervalRF;
02072 
02073     class Olsr401GetTcIntervalCB {
02074         Olsr401GetTcIntervalRF cb;
02075 
02076     public:
02077         operator const Olsr401GetTcIntervalRF& () const { return cb; }
02078         const Olsr401GetTcIntervalRF& operator ->() const { return cb; }
02079         Olsr401GetTcIntervalCB(const Olsr401GetTcIntervalRF& cb)
02080           : cb(cb) { }
02081 
02082         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02083 
02084         void respond(const uint32_t& arg_interval) const {
02085             cb->dispatch(XrlCmdError::OKAY(),
02086                          &arg_interval);
02087         }
02088     };
02089 
02090     struct Olsr401GetTcIntervalRsp :
02091       public Olsr401GetTcIntervalCB {
02092         struct args_str {
02093             uint32_t interval;
02094         };
02095 
02096     private:
02097         args_str args;
02098 
02099     public:
02100         Olsr401GetTcIntervalRsp(const Olsr401GetTcIntervalRF& cb)
02101           : Olsr401GetTcIntervalCB(cb) { }
02102 
02103         void respond() const {
02104             Olsr401GetTcIntervalCB::
02105             respond(args.interval);
02106         }
02107 
02108         args_str* operator ->() {
02109             return &args;
02110         }
02111     };
02112 
02113     virtual void async_olsr4_0_1_get_tc_interval
02114        (
02115     Olsr401GetTcIntervalCB);
02116 #endif
02117 
02125     virtual XrlCmdError olsr4_0_1_set_mid_interval(
02126     // Input values,
02127     const uint32_t& interval) = 0;
02128 #ifdef XORP_ENABLE_ASYNC_SERVER
02129     typedef
02130     XorpCallback1<void, const XrlCmdError &>::RefPtr
02131     Olsr401SetMidIntervalRF;
02132 
02133     class Olsr401SetMidIntervalCB {
02134         Olsr401SetMidIntervalRF cb;
02135 
02136     public:
02137         operator const Olsr401SetMidIntervalRF& () const { return cb; }
02138         const Olsr401SetMidIntervalRF& operator ->() const { return cb; }
02139         Olsr401SetMidIntervalCB(const Olsr401SetMidIntervalRF& cb)
02140           : cb(cb) { }
02141 
02142         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02143 
02144         void respond() const {
02145             cb->dispatch(XrlCmdError::OKAY());
02146         }
02147     };
02148 
02149     struct Olsr401SetMidIntervalRsp :
02150       public Olsr401SetMidIntervalCB {
02151         Olsr401SetMidIntervalRsp(const Olsr401SetMidIntervalRF& cb)
02152           : Olsr401SetMidIntervalCB(cb) { }
02153 
02154     };
02155 
02156     virtual void async_olsr4_0_1_set_mid_interval
02157        (
02158     const uint32_t& interval,
02159     Olsr401SetMidIntervalCB);
02160 #endif
02161 
02167     virtual XrlCmdError olsr4_0_1_get_mid_interval(
02168     // Output values,
02169     uint32_t&   interval) = 0;
02170 #ifdef XORP_ENABLE_ASYNC_SERVER
02171     typedef
02172     XorpCallback2<void, const XrlCmdError &,
02173     const uint32_t*>::RefPtr
02174     Olsr401GetMidIntervalRF;
02175 
02176     class Olsr401GetMidIntervalCB {
02177         Olsr401GetMidIntervalRF cb;
02178 
02179     public:
02180         operator const Olsr401GetMidIntervalRF& () const { return cb; }
02181         const Olsr401GetMidIntervalRF& operator ->() const { return cb; }
02182         Olsr401GetMidIntervalCB(const Olsr401GetMidIntervalRF& cb)
02183           : cb(cb) { }
02184 
02185         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02186 
02187         void respond(const uint32_t& arg_interval) const {
02188             cb->dispatch(XrlCmdError::OKAY(),
02189                          &arg_interval);
02190         }
02191     };
02192 
02193     struct Olsr401GetMidIntervalRsp :
02194       public Olsr401GetMidIntervalCB {
02195         struct args_str {
02196             uint32_t interval;
02197         };
02198 
02199     private:
02200         args_str args;
02201 
02202     public:
02203         Olsr401GetMidIntervalRsp(const Olsr401GetMidIntervalRF& cb)
02204           : Olsr401GetMidIntervalCB(cb) { }
02205 
02206         void respond() const {
02207             Olsr401GetMidIntervalCB::
02208             respond(args.interval);
02209         }
02210 
02211         args_str* operator ->() {
02212             return &args;
02213         }
02214     };
02215 
02216     virtual void async_olsr4_0_1_get_mid_interval
02217        (
02218     Olsr401GetMidIntervalCB);
02219 #endif
02220 
02228     virtual XrlCmdError olsr4_0_1_set_hna_interval(
02229     // Input values,
02230     const uint32_t& interval) = 0;
02231 #ifdef XORP_ENABLE_ASYNC_SERVER
02232     typedef
02233     XorpCallback1<void, const XrlCmdError &>::RefPtr
02234     Olsr401SetHnaIntervalRF;
02235 
02236     class Olsr401SetHnaIntervalCB {
02237         Olsr401SetHnaIntervalRF cb;
02238 
02239     public:
02240         operator const Olsr401SetHnaIntervalRF& () const { return cb; }
02241         const Olsr401SetHnaIntervalRF& operator ->() const { return cb; }
02242         Olsr401SetHnaIntervalCB(const Olsr401SetHnaIntervalRF& cb)
02243           : cb(cb) { }
02244 
02245         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02246 
02247         void respond() const {
02248             cb->dispatch(XrlCmdError::OKAY());
02249         }
02250     };
02251 
02252     struct Olsr401SetHnaIntervalRsp :
02253       public Olsr401SetHnaIntervalCB {
02254         Olsr401SetHnaIntervalRsp(const Olsr401SetHnaIntervalRF& cb)
02255           : Olsr401SetHnaIntervalCB(cb) { }
02256 
02257     };
02258 
02259     virtual void async_olsr4_0_1_set_hna_interval
02260        (
02261     const uint32_t& interval,
02262     Olsr401SetHnaIntervalCB);
02263 #endif
02264 
02270     virtual XrlCmdError olsr4_0_1_get_hna_interval(
02271     // Output values,
02272     uint32_t&   interval) = 0;
02273 #ifdef XORP_ENABLE_ASYNC_SERVER
02274     typedef
02275     XorpCallback2<void, const XrlCmdError &,
02276     const uint32_t*>::RefPtr
02277     Olsr401GetHnaIntervalRF;
02278 
02279     class Olsr401GetHnaIntervalCB {
02280         Olsr401GetHnaIntervalRF cb;
02281 
02282     public:
02283         operator const Olsr401GetHnaIntervalRF& () const { return cb; }
02284         const Olsr401GetHnaIntervalRF& operator ->() const { return cb; }
02285         Olsr401GetHnaIntervalCB(const Olsr401GetHnaIntervalRF& cb)
02286           : cb(cb) { }
02287 
02288         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02289 
02290         void respond(const uint32_t& arg_interval) const {
02291             cb->dispatch(XrlCmdError::OKAY(),
02292                          &arg_interval);
02293         }
02294     };
02295 
02296     struct Olsr401GetHnaIntervalRsp :
02297       public Olsr401GetHnaIntervalCB {
02298         struct args_str {
02299             uint32_t interval;
02300         };
02301 
02302     private:
02303         args_str args;
02304 
02305     public:
02306         Olsr401GetHnaIntervalRsp(const Olsr401GetHnaIntervalRF& cb)
02307           : Olsr401GetHnaIntervalCB(cb) { }
02308 
02309         void respond() const {
02310             Olsr401GetHnaIntervalCB::
02311             respond(args.interval);
02312         }
02313 
02314         args_str* operator ->() {
02315             return &args;
02316         }
02317     };
02318 
02319     virtual void async_olsr4_0_1_get_hna_interval
02320        (
02321     Olsr401GetHnaIntervalCB);
02322 #endif
02323 
02331     virtual XrlCmdError olsr4_0_1_set_dup_hold_time(
02332     // Input values,
02333     const uint32_t& dup_hold_time) = 0;
02334 #ifdef XORP_ENABLE_ASYNC_SERVER
02335     typedef
02336     XorpCallback1<void, const XrlCmdError &>::RefPtr
02337     Olsr401SetDupHoldTimeRF;
02338 
02339     class Olsr401SetDupHoldTimeCB {
02340         Olsr401SetDupHoldTimeRF cb;
02341 
02342     public:
02343         operator const Olsr401SetDupHoldTimeRF& () const { return cb; }
02344         const Olsr401SetDupHoldTimeRF& operator ->() const { return cb; }
02345         Olsr401SetDupHoldTimeCB(const Olsr401SetDupHoldTimeRF& cb)
02346           : cb(cb) { }
02347 
02348         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02349 
02350         void respond() const {
02351             cb->dispatch(XrlCmdError::OKAY());
02352         }
02353     };
02354 
02355     struct Olsr401SetDupHoldTimeRsp :
02356       public Olsr401SetDupHoldTimeCB {
02357         Olsr401SetDupHoldTimeRsp(const Olsr401SetDupHoldTimeRF& cb)
02358           : Olsr401SetDupHoldTimeCB(cb) { }
02359 
02360     };
02361 
02362     virtual void async_olsr4_0_1_set_dup_hold_time
02363        (
02364     const uint32_t& dup_hold_time,
02365     Olsr401SetDupHoldTimeCB);
02366 #endif
02367 
02373     virtual XrlCmdError olsr4_0_1_get_dup_hold_time(
02374     // Output values,
02375     uint32_t&   dup_hold_time) = 0;
02376 #ifdef XORP_ENABLE_ASYNC_SERVER
02377     typedef
02378     XorpCallback2<void, const XrlCmdError &,
02379     const uint32_t*>::RefPtr
02380     Olsr401GetDupHoldTimeRF;
02381 
02382     class Olsr401GetDupHoldTimeCB {
02383         Olsr401GetDupHoldTimeRF cb;
02384 
02385     public:
02386         operator const Olsr401GetDupHoldTimeRF& () const { return cb; }
02387         const Olsr401GetDupHoldTimeRF& operator ->() const { return cb; }
02388         Olsr401GetDupHoldTimeCB(const Olsr401GetDupHoldTimeRF& cb)
02389           : cb(cb) { }
02390 
02391         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02392 
02393         void respond(const uint32_t& arg_dup_hold_time) const {
02394             cb->dispatch(XrlCmdError::OKAY(),
02395                          &arg_dup_hold_time);
02396         }
02397     };
02398 
02399     struct Olsr401GetDupHoldTimeRsp :
02400       public Olsr401GetDupHoldTimeCB {
02401         struct args_str {
02402             uint32_t dup_hold_time;
02403         };
02404 
02405     private:
02406         args_str args;
02407 
02408     public:
02409         Olsr401GetDupHoldTimeRsp(const Olsr401GetDupHoldTimeRF& cb)
02410           : Olsr401GetDupHoldTimeCB(cb) { }
02411 
02412         void respond() const {
02413             Olsr401GetDupHoldTimeCB::
02414             respond(args.dup_hold_time);
02415         }
02416 
02417         args_str* operator ->() {
02418             return &args;
02419         }
02420     };
02421 
02422     virtual void async_olsr4_0_1_get_dup_hold_time
02423        (
02424     Olsr401GetDupHoldTimeCB);
02425 #endif
02426 
02434     virtual XrlCmdError olsr4_0_1_set_main_address(
02435     // Input values,
02436     const IPv4& addr) = 0;
02437 #ifdef XORP_ENABLE_ASYNC_SERVER
02438     typedef
02439     XorpCallback1<void, const XrlCmdError &>::RefPtr
02440     Olsr401SetMainAddressRF;
02441 
02442     class Olsr401SetMainAddressCB {
02443         Olsr401SetMainAddressRF cb;
02444 
02445     public:
02446         operator const Olsr401SetMainAddressRF& () const { return cb; }
02447         const Olsr401SetMainAddressRF& operator ->() const { return cb; }
02448         Olsr401SetMainAddressCB(const Olsr401SetMainAddressRF& cb)
02449           : cb(cb) { }
02450 
02451         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02452 
02453         void respond() const {
02454             cb->dispatch(XrlCmdError::OKAY());
02455         }
02456     };
02457 
02458     struct Olsr401SetMainAddressRsp :
02459       public Olsr401SetMainAddressCB {
02460         Olsr401SetMainAddressRsp(const Olsr401SetMainAddressRF& cb)
02461           : Olsr401SetMainAddressCB(cb) { }
02462 
02463     };
02464 
02465     virtual void async_olsr4_0_1_set_main_address
02466        (
02467     const IPv4& addr,
02468     Olsr401SetMainAddressCB);
02469 #endif
02470 
02476     virtual XrlCmdError olsr4_0_1_get_main_address(
02477     // Output values,
02478     IPv4&   addr) = 0;
02479 #ifdef XORP_ENABLE_ASYNC_SERVER
02480     typedef
02481     XorpCallback2<void, const XrlCmdError &,
02482     const IPv4*>::RefPtr
02483     Olsr401GetMainAddressRF;
02484 
02485     class Olsr401GetMainAddressCB {
02486         Olsr401GetMainAddressRF cb;
02487 
02488     public:
02489         operator const Olsr401GetMainAddressRF& () const { return cb; }
02490         const Olsr401GetMainAddressRF& operator ->() const { return cb; }
02491         Olsr401GetMainAddressCB(const Olsr401GetMainAddressRF& cb)
02492           : cb(cb) { }
02493 
02494         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02495 
02496         void respond(const IPv4& arg_addr) const {
02497             cb->dispatch(XrlCmdError::OKAY(),
02498                          &arg_addr);
02499         }
02500     };
02501 
02502     struct Olsr401GetMainAddressRsp :
02503       public Olsr401GetMainAddressCB {
02504         struct args_str {
02505             IPv4 addr;
02506         };
02507 
02508     private:
02509         args_str args;
02510 
02511     public:
02512         Olsr401GetMainAddressRsp(const Olsr401GetMainAddressRF& cb)
02513           : Olsr401GetMainAddressCB(cb) { }
02514 
02515         void respond() const {
02516             Olsr401GetMainAddressCB::
02517             respond(args.addr);
02518         }
02519 
02520         args_str* operator ->() {
02521             return &args;
02522         }
02523     };
02524 
02525     virtual void async_olsr4_0_1_get_main_address
02526        (
02527     Olsr401GetMainAddressCB);
02528 #endif
02529 
02555     virtual XrlCmdError olsr4_0_1_bind_address(
02556     // Input values,
02557     const string&   ifname,
02558     const string&   vifname,
02559     const IPv4& local_addr,
02560     const uint32_t& local_port,
02561     const IPv4& all_nodes_addr,
02562     const uint32_t& all_nodes_port) = 0;
02563 #ifdef XORP_ENABLE_ASYNC_SERVER
02564     typedef
02565     XorpCallback1<void, const XrlCmdError &>::RefPtr
02566     Olsr401BindAddressRF;
02567 
02568     class Olsr401BindAddressCB {
02569         Olsr401BindAddressRF cb;
02570 
02571     public:
02572         operator const Olsr401BindAddressRF& () const { return cb; }
02573         const Olsr401BindAddressRF& operator ->() const { return cb; }
02574         Olsr401BindAddressCB(const Olsr401BindAddressRF& cb)
02575           : cb(cb) { }
02576 
02577         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02578 
02579         void respond() const {
02580             cb->dispatch(XrlCmdError::OKAY());
02581         }
02582     };
02583 
02584     struct Olsr401BindAddressRsp :
02585       public Olsr401BindAddressCB {
02586         Olsr401BindAddressRsp(const Olsr401BindAddressRF& cb)
02587           : Olsr401BindAddressCB(cb) { }
02588 
02589     };
02590 
02591     virtual void async_olsr4_0_1_bind_address
02592        (
02593     const string&   ifname,
02594     const string&   vifname,
02595     const IPv4& local_addr,
02596     const uint32_t& local_port,
02597     const IPv4& all_nodes_addr,
02598     const uint32_t& all_nodes_port,
02599     Olsr401BindAddressCB);
02600 #endif
02601 
02611     virtual XrlCmdError olsr4_0_1_unbind_address(
02612     // Input values,
02613     const string&   ifname,
02614     const string&   vifname) = 0;
02615 #ifdef XORP_ENABLE_ASYNC_SERVER
02616     typedef
02617     XorpCallback1<void, const XrlCmdError &>::RefPtr
02618     Olsr401UnbindAddressRF;
02619 
02620     class Olsr401UnbindAddressCB {
02621         Olsr401UnbindAddressRF cb;
02622 
02623     public:
02624         operator const Olsr401UnbindAddressRF& () const { return cb; }
02625         const Olsr401UnbindAddressRF& operator ->() const { return cb; }
02626         Olsr401UnbindAddressCB(const Olsr401UnbindAddressRF& cb)
02627           : cb(cb) { }
02628 
02629         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02630 
02631         void respond() const {
02632             cb->dispatch(XrlCmdError::OKAY());
02633         }
02634     };
02635 
02636     struct Olsr401UnbindAddressRsp :
02637       public Olsr401UnbindAddressCB {
02638         Olsr401UnbindAddressRsp(const Olsr401UnbindAddressRF& cb)
02639           : Olsr401UnbindAddressCB(cb) { }
02640 
02641     };
02642 
02643     virtual void async_olsr4_0_1_unbind_address
02644        (
02645     const string&   ifname,
02646     const string&   vifname,
02647     Olsr401UnbindAddressCB);
02648 #endif
02649 
02662     virtual XrlCmdError olsr4_0_1_set_binding_enabled(
02663     // Input values,
02664     const string&   ifname,
02665     const string&   vifname,
02666     const bool& enabled) = 0;
02667 #ifdef XORP_ENABLE_ASYNC_SERVER
02668     typedef
02669     XorpCallback1<void, const XrlCmdError &>::RefPtr
02670     Olsr401SetBindingEnabledRF;
02671 
02672     class Olsr401SetBindingEnabledCB {
02673         Olsr401SetBindingEnabledRF cb;
02674 
02675     public:
02676         operator const Olsr401SetBindingEnabledRF& () const { return cb; }
02677         const Olsr401SetBindingEnabledRF& operator ->() const { return cb; }
02678         Olsr401SetBindingEnabledCB(const Olsr401SetBindingEnabledRF& cb)
02679           : cb(cb) { }
02680 
02681         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02682 
02683         void respond() const {
02684             cb->dispatch(XrlCmdError::OKAY());
02685         }
02686     };
02687 
02688     struct Olsr401SetBindingEnabledRsp :
02689       public Olsr401SetBindingEnabledCB {
02690         Olsr401SetBindingEnabledRsp(const Olsr401SetBindingEnabledRF& cb)
02691           : Olsr401SetBindingEnabledCB(cb) { }
02692 
02693     };
02694 
02695     virtual void async_olsr4_0_1_set_binding_enabled
02696        (
02697     const string&   ifname,
02698     const string&   vifname,
02699     const bool& enabled,
02700     Olsr401SetBindingEnabledCB);
02701 #endif
02702 
02715     virtual XrlCmdError olsr4_0_1_get_binding_enabled(
02716     // Input values,
02717     const string&   ifname,
02718     const string&   vifname,
02719     // Output values,
02720     bool&   enabled) = 0;
02721 #ifdef XORP_ENABLE_ASYNC_SERVER
02722     typedef
02723     XorpCallback2<void, const XrlCmdError &,
02724     const bool*>::RefPtr
02725     Olsr401GetBindingEnabledRF;
02726 
02727     class Olsr401GetBindingEnabledCB {
02728         Olsr401GetBindingEnabledRF cb;
02729 
02730     public:
02731         operator const Olsr401GetBindingEnabledRF& () const { return cb; }
02732         const Olsr401GetBindingEnabledRF& operator ->() const { return cb; }
02733         Olsr401GetBindingEnabledCB(const Olsr401GetBindingEnabledRF& cb)
02734           : cb(cb) { }
02735 
02736         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02737 
02738         void respond(const bool& arg_enabled) const {
02739             cb->dispatch(XrlCmdError::OKAY(),
02740                          &arg_enabled);
02741         }
02742     };
02743 
02744     struct Olsr401GetBindingEnabledRsp :
02745       public Olsr401GetBindingEnabledCB {
02746         struct args_str {
02747             bool enabled;
02748         };
02749 
02750     private:
02751         args_str args;
02752 
02753     public:
02754         Olsr401GetBindingEnabledRsp(const Olsr401GetBindingEnabledRF& cb)
02755           : Olsr401GetBindingEnabledCB(cb) { }
02756 
02757         void respond() const {
02758             Olsr401GetBindingEnabledCB::
02759             respond(args.enabled);
02760         }
02761 
02762         args_str* operator ->() {
02763             return &args;
02764         }
02765     };
02766 
02767     virtual void async_olsr4_0_1_get_binding_enabled
02768        (
02769     const string&   ifname,
02770     const string&   vifname,
02771     Olsr401GetBindingEnabledCB);
02772 #endif
02773 
02789     virtual XrlCmdError olsr4_0_1_change_local_addr_port(
02790     // Input values,
02791     const string&   ifname,
02792     const string&   vifname,
02793     const IPv4& local_addr,
02794     const uint32_t& local_port) = 0;
02795 #ifdef XORP_ENABLE_ASYNC_SERVER
02796     typedef
02797     XorpCallback1<void, const XrlCmdError &>::RefPtr
02798     Olsr401ChangeLocalAddrPortRF;
02799 
02800     class Olsr401ChangeLocalAddrPortCB {
02801         Olsr401ChangeLocalAddrPortRF cb;
02802 
02803     public:
02804         operator const Olsr401ChangeLocalAddrPortRF& () const { return cb; }
02805         const Olsr401ChangeLocalAddrPortRF& operator ->() const { return cb; }
02806         Olsr401ChangeLocalAddrPortCB(const Olsr401ChangeLocalAddrPortRF& cb)
02807           : cb(cb) { }
02808 
02809         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02810 
02811         void respond() const {
02812             cb->dispatch(XrlCmdError::OKAY());
02813         }
02814     };
02815 
02816     struct Olsr401ChangeLocalAddrPortRsp :
02817       public Olsr401ChangeLocalAddrPortCB {
02818         Olsr401ChangeLocalAddrPortRsp(const Olsr401ChangeLocalAddrPortRF& cb)
02819           : Olsr401ChangeLocalAddrPortCB(cb) { }
02820 
02821     };
02822 
02823     virtual void async_olsr4_0_1_change_local_addr_port
02824        (
02825     const string&   ifname,
02826     const string&   vifname,
02827     const IPv4& local_addr,
02828     const uint32_t& local_port,
02829     Olsr401ChangeLocalAddrPortCB);
02830 #endif
02831 
02847     virtual XrlCmdError olsr4_0_1_change_all_nodes_addr_port(
02848     // Input values,
02849     const string&   ifname,
02850     const string&   vifname,
02851     const IPv4& all_nodes_addr,
02852     const uint32_t& all_nodes_port) = 0;
02853 #ifdef XORP_ENABLE_ASYNC_SERVER
02854     typedef
02855     XorpCallback1<void, const XrlCmdError &>::RefPtr
02856     Olsr401ChangeAllNodesAddrPortRF;
02857 
02858     class Olsr401ChangeAllNodesAddrPortCB {
02859         Olsr401ChangeAllNodesAddrPortRF cb;
02860 
02861     public:
02862         operator const Olsr401ChangeAllNodesAddrPortRF& () const { return cb; }
02863         const Olsr401ChangeAllNodesAddrPortRF& operator ->() const { return cb; }
02864         Olsr401ChangeAllNodesAddrPortCB(const Olsr401ChangeAllNodesAddrPortRF& cb)
02865           : cb(cb) { }
02866 
02867         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
02868 
02869         void respond() const {
02870             cb->dispatch(XrlCmdError::OKAY());
02871         }
02872     };
02873 
02874     struct Olsr401ChangeAllNodesAddrPortRsp :
02875       public Olsr401ChangeAllNodesAddrPortCB {
02876         Olsr401ChangeAllNodesAddrPortRsp(const Olsr401ChangeAllNodesAddrPortRF& cb)
02877           : Olsr401ChangeAllNodesAddrPortCB(cb) { }
02878 
02879     };
02880 
02881     virtual void async_olsr4_0_1_change_all_nodes_addr_port
02882        (
02883     const string&   ifname,
02884     const string&   vifname,
02885     const IPv4& all_nodes_addr,
02886     const uint32_t& all_nodes_port,
02887     Olsr401ChangeAllNodesAddrPortCB);
02888 #endif
02889 
02897     virtual XrlCmdError olsr4_0_1_get_interface_list(
02898     // Output values,
02899     XrlAtomList&    interfaces) = 0;
02900 #ifdef XORP_ENABLE_ASYNC_SERVER
02901     typedef
02902     XorpCallback2<void, const XrlCmdError &,
02903     const XrlAtomList*>::RefPtr
02904     Olsr401GetInterfaceListRF;
02905 
02906     class Olsr401GetInterfaceListCB {
02907         Olsr401GetInterfaceListRF cb;
02908 
02909     public:
02910         operator const Olsr401GetInterfaceListRF& () const { return cb; }
02911         const Olsr401GetInterfaceListRF& operator ->() const { return cb; }
02912         Olsr401GetInterfaceListCB(const Olsr401GetInterfaceListRF& cb)
02913           : cb(cb) { }
02914 
02915         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
02916 
02917         void respond(const XrlAtomList& arg_interfaces) const {
02918             cb->dispatch(XrlCmdError::OKAY(),
02919                          &arg_interfaces);
02920         }
02921     };
02922 
02923     struct Olsr401GetInterfaceListRsp :
02924       public Olsr401GetInterfaceListCB {
02925         struct args_str {
02926             XrlAtomList interfaces;
02927         };
02928 
02929     private:
02930         args_str args;
02931 
02932     public:
02933         Olsr401GetInterfaceListRsp(const Olsr401GetInterfaceListRF& cb)
02934           : Olsr401GetInterfaceListCB(cb) { }
02935 
02936         void respond() const {
02937             Olsr401GetInterfaceListCB::
02938             respond(args.interfaces);
02939         }
02940 
02941         args_str* operator ->() {
02942             return &args;
02943         }
02944     };
02945 
02946     virtual void async_olsr4_0_1_get_interface_list
02947        (
02948     Olsr401GetInterfaceListCB);
02949 #endif
02950 
02970     virtual XrlCmdError olsr4_0_1_get_interface_info(
02971     // Input values,
02972     const uint32_t& faceid,
02973     // Output values,
02974     string& ifname,
02975     string& vifname,
02976     IPv4&   local_addr,
02977     uint32_t&   local_port,
02978     IPv4&   all_nodes_addr,
02979     uint32_t&   all_nodes_port) = 0;
02980 #ifdef XORP_ENABLE_ASYNC_SERVER
02981     typedef
02982     XorpCallback7<void, const XrlCmdError &,
02983     const string*,
02984     const string*,
02985     const IPv4*,
02986     const uint32_t*,
02987     const IPv4*,
02988     const uint32_t*>::RefPtr
02989     Olsr401GetInterfaceInfoRF;
02990 
02991     class Olsr401GetInterfaceInfoCB {
02992         Olsr401GetInterfaceInfoRF cb;
02993 
02994     public:
02995         operator const Olsr401GetInterfaceInfoRF& () const { return cb; }
02996         const Olsr401GetInterfaceInfoRF& operator ->() const { return cb; }
02997         Olsr401GetInterfaceInfoCB(const Olsr401GetInterfaceInfoRF& cb)
02998           : cb(cb) { }
02999 
03000         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL, NULL, NULL); }
03001 
03002         void respond(const string& arg_ifname,
03003                      const string& arg_vifname,
03004                      const IPv4& arg_local_addr,
03005                      const uint32_t& arg_local_port,
03006                      const IPv4& arg_all_nodes_addr,
03007                      const uint32_t& arg_all_nodes_port) const {
03008             cb->dispatch(XrlCmdError::OKAY(),
03009                          &arg_ifname,
03010                          &arg_vifname,
03011                          &arg_local_addr,
03012                          &arg_local_port,
03013                          &arg_all_nodes_addr,
03014                          &arg_all_nodes_port);
03015         }
03016     };
03017 
03018     struct Olsr401GetInterfaceInfoRsp :
03019       public Olsr401GetInterfaceInfoCB {
03020         struct args_str {
03021             string ifname;
03022             string vifname;
03023             IPv4 local_addr;
03024             uint32_t local_port;
03025             IPv4 all_nodes_addr;
03026             uint32_t all_nodes_port;
03027         };
03028 
03029     private:
03030         args_str args;
03031 
03032     public:
03033         Olsr401GetInterfaceInfoRsp(const Olsr401GetInterfaceInfoRF& cb)
03034           : Olsr401GetInterfaceInfoCB(cb) { }
03035 
03036         void respond() const {
03037             Olsr401GetInterfaceInfoCB::
03038             respond(args.ifname,
03039                         args.vifname,
03040                         args.local_addr,
03041                         args.local_port,
03042                         args.all_nodes_addr,
03043                         args.all_nodes_port);
03044         }
03045 
03046         args_str* operator ->() {
03047             return &args;
03048         }
03049     };
03050 
03051     virtual void async_olsr4_0_1_get_interface_info
03052        (
03053     const uint32_t& faceid,
03054     Olsr401GetInterfaceInfoCB);
03055 #endif
03056 
03068     virtual XrlCmdError olsr4_0_1_set_interface_cost(
03069     // Input values,
03070     const string&   ifname,
03071     const string&   vifname,
03072     const uint32_t& cost) = 0;
03073 #ifdef XORP_ENABLE_ASYNC_SERVER
03074     typedef
03075     XorpCallback1<void, const XrlCmdError &>::RefPtr
03076     Olsr401SetInterfaceCostRF;
03077 
03078     class Olsr401SetInterfaceCostCB {
03079         Olsr401SetInterfaceCostRF cb;
03080 
03081     public:
03082         operator const Olsr401SetInterfaceCostRF& () const { return cb; }
03083         const Olsr401SetInterfaceCostRF& operator ->() const { return cb; }
03084         Olsr401SetInterfaceCostCB(const Olsr401SetInterfaceCostRF& cb)
03085           : cb(cb) { }
03086 
03087         void fail(const XrlCmdError &e) const { cb->dispatch(e); }
03088 
03089         void respond() const {
03090             cb->dispatch(XrlCmdError::OKAY());
03091         }
03092     };
03093 
03094     struct Olsr401SetInterfaceCostRsp :
03095       public Olsr401SetInterfaceCostCB {
03096         Olsr401SetInterfaceCostRsp(const Olsr401SetInterfaceCostRF& cb)
03097           : Olsr401SetInterfaceCostCB(cb) { }
03098 
03099     };
03100 
03101     virtual void async_olsr4_0_1_set_interface_cost
03102        (
03103     const string&   ifname,
03104     const string&   vifname,
03105     const uint32_t& cost,
03106     Olsr401SetInterfaceCostCB);
03107 #endif
03108 
03134     virtual XrlCmdError olsr4_0_1_get_interface_stats(
03135     // Input values,
03136     const string&   ifname,
03137     const string&   vifname,
03138     // Output values,
03139     uint32_t&   bad_packets,
03140     uint32_t&   bad_messages,
03141     uint32_t&   messages_from_self,
03142     uint32_t&   unknown_messages,
03143     uint32_t&   duplicates,
03144     uint32_t&   forwarded) = 0;
03145 #ifdef XORP_ENABLE_ASYNC_SERVER
03146     typedef
03147     XorpCallback7<void, const XrlCmdError &,
03148     const uint32_t*,
03149     const uint32_t*,
03150     const uint32_t*,
03151     const uint32_t*,
03152     const uint32_t*,
03153     const uint32_t*>::RefPtr
03154     Olsr401GetInterfaceStatsRF;
03155 
03156     class Olsr401GetInterfaceStatsCB {
03157         Olsr401GetInterfaceStatsRF cb;
03158 
03159     public:
03160         operator const Olsr401GetInterfaceStatsRF& () const { return cb; }
03161         const Olsr401GetInterfaceStatsRF& operator ->() const { return cb; }
03162         Olsr401GetInterfaceStatsCB(const Olsr401GetInterfaceStatsRF& cb)
03163           : cb(cb) { }
03164 
03165         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL, NULL, NULL); }
03166 
03167         void respond(const uint32_t& arg_bad_packets,
03168                      const uint32_t& arg_bad_messages,
03169                      const uint32_t& arg_messages_from_self,
03170                      const uint32_t& arg_unknown_messages,
03171                      const uint32_t& arg_duplicates,
03172                      const uint32_t& arg_forwarded) const {
03173             cb->dispatch(XrlCmdError::OKAY(),
03174                          &arg_bad_packets,
03175                          &arg_bad_messages,
03176                          &arg_messages_from_self,
03177                          &arg_unknown_messages,
03178                          &arg_duplicates,
03179                          &arg_forwarded);
03180         }
03181     };
03182 
03183     struct Olsr401GetInterfaceStatsRsp :
03184       public Olsr401GetInterfaceStatsCB {
03185         struct args_str {
03186             uint32_t bad_packets;
03187             uint32_t bad_messages;
03188             uint32_t messages_from_self;
03189             uint32_t unknown_messages;
03190             uint32_t duplicates;
03191             uint32_t forwarded;
03192         };
03193 
03194     private:
03195         args_str args;
03196 
03197     public:
03198         Olsr401GetInterfaceStatsRsp(const Olsr401GetInterfaceStatsRF& cb)
03199           : Olsr401GetInterfaceStatsCB(cb) { }
03200 
03201         void respond() const {
03202             Olsr401GetInterfaceStatsCB::
03203             respond(args.bad_packets,
03204                         args.bad_messages,
03205                         args.messages_from_self,
03206                         args.unknown_messages,
03207                         args.duplicates,
03208                         args.forwarded);
03209         }
03210 
03211         args_str* operator ->() {
03212             return &args;
03213         }
03214     };
03215 
03216     virtual void async_olsr4_0_1_get_interface_stats
03217        (
03218     const string&   ifname,
03219     const string&   vifname,
03220     Olsr401GetInterfaceStatsCB);
03221 #endif
03222 
03229     virtual XrlCmdError olsr4_0_1_get_link_list(
03230     // Output values,
03231     XrlAtomList&    links) = 0;
03232 #ifdef XORP_ENABLE_ASYNC_SERVER
03233     typedef
03234     XorpCallback2<void, const XrlCmdError &,
03235     const XrlAtomList*>::RefPtr
03236     Olsr401GetLinkListRF;
03237 
03238     class Olsr401GetLinkListCB {
03239         Olsr401GetLinkListRF cb;
03240 
03241     public:
03242         operator const Olsr401GetLinkListRF& () const { return cb; }
03243         const Olsr401GetLinkListRF& operator ->() const { return cb; }
03244         Olsr401GetLinkListCB(const Olsr401GetLinkListRF& cb)
03245           : cb(cb) { }
03246 
03247         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
03248 
03249         void respond(const XrlAtomList& arg_links) const {
03250             cb->dispatch(XrlCmdError::OKAY(),
03251                          &arg_links);
03252         }
03253     };
03254 
03255     struct Olsr401GetLinkListRsp :
03256       public Olsr401GetLinkListCB {
03257         struct args_str {
03258             XrlAtomList links;
03259         };
03260 
03261     private:
03262         args_str args;
03263 
03264     public:
03265         Olsr401GetLinkListRsp(const Olsr401GetLinkListRF& cb)
03266           : Olsr401GetLinkListCB(cb) { }
03267 
03268         void respond() const {
03269             Olsr401GetLinkListCB::
03270             respond(args.links);
03271         }
03272 
03273         args_str* operator ->() {
03274             return &args;
03275         }
03276     };
03277 
03278     virtual void async_olsr4_0_1_get_link_list
03279        (
03280     Olsr401GetLinkListCB);
03281 #endif
03282 
03308     virtual XrlCmdError olsr4_0_1_get_link_info(
03309     // Input values,
03310     const uint32_t& linkid,
03311     // Output values,
03312     IPv4&   local_addr,
03313     IPv4&   remote_addr,
03314     IPv4&   main_addr,
03315     uint32_t&   link_type,
03316     uint32_t&   sym_time,
03317     uint32_t&   asym_time,
03318     uint32_t&   hold_time) = 0;
03319 #ifdef XORP_ENABLE_ASYNC_SERVER
03320     typedef
03321     XorpCallback8<void, const XrlCmdError &,
03322     const IPv4*,
03323     const IPv4*,
03324     const IPv4*,
03325     const uint32_t*,
03326     const uint32_t*,
03327     const uint32_t*,
03328     const uint32_t*>::RefPtr
03329     Olsr401GetLinkInfoRF;
03330 
03331     class Olsr401GetLinkInfoCB {
03332         Olsr401GetLinkInfoRF cb;
03333 
03334     public:
03335         operator const Olsr401GetLinkInfoRF& () const { return cb; }
03336         const Olsr401GetLinkInfoRF& operator ->() const { return cb; }
03337         Olsr401GetLinkInfoCB(const Olsr401GetLinkInfoRF& cb)
03338           : cb(cb) { }
03339 
03340         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL, NULL, NULL, NULL); }
03341 
03342         void respond(const IPv4& arg_local_addr,
03343                      const IPv4& arg_remote_addr,
03344                      const IPv4& arg_main_addr,
03345                      const uint32_t& arg_link_type,
03346                      const uint32_t& arg_sym_time,
03347                      const uint32_t& arg_asym_time,
03348                      const uint32_t& arg_hold_time) const {
03349             cb->dispatch(XrlCmdError::OKAY(),
03350                          &arg_local_addr,
03351                          &arg_remote_addr,
03352                          &arg_main_addr,
03353                          &arg_link_type,
03354                          &arg_sym_time,
03355                          &arg_asym_time,
03356                          &arg_hold_time);
03357         }
03358     };
03359 
03360     struct Olsr401GetLinkInfoRsp :
03361       public Olsr401GetLinkInfoCB {
03362         struct args_str {
03363             IPv4 local_addr;
03364             IPv4 remote_addr;
03365             IPv4 main_addr;
03366             uint32_t link_type;
03367             uint32_t sym_time;
03368             uint32_t asym_time;
03369             uint32_t hold_time;
03370         };
03371 
03372     private:
03373         args_str args;
03374 
03375     public:
03376         Olsr401GetLinkInfoRsp(const Olsr401GetLinkInfoRF& cb)
03377           : Olsr401GetLinkInfoCB(cb) { }
03378 
03379         void respond() const {
03380             Olsr401GetLinkInfoCB::
03381             respond(args.local_addr,
03382                         args.remote_addr,
03383                         args.main_addr,
03384                         args.link_type,
03385                         args.sym_time,
03386                         args.asym_time,
03387                         args.hold_time);
03388         }
03389 
03390         args_str* operator ->() {
03391             return &args;
03392         }
03393     };
03394 
03395     virtual void async_olsr4_0_1_get_link_info
03396        (
03397     const uint32_t& linkid,
03398     Olsr401GetLinkInfoCB);
03399 #endif
03400 
03408     virtual XrlCmdError olsr4_0_1_get_neighbor_list(
03409     // Output values,
03410     XrlAtomList&    neighbors) = 0;
03411 #ifdef XORP_ENABLE_ASYNC_SERVER
03412     typedef
03413     XorpCallback2<void, const XrlCmdError &,
03414     const XrlAtomList*>::RefPtr
03415     Olsr401GetNeighborListRF;
03416 
03417     class Olsr401GetNeighborListCB {
03418         Olsr401GetNeighborListRF cb;
03419 
03420     public:
03421         operator const Olsr401GetNeighborListRF& () const { return cb; }
03422         const Olsr401GetNeighborListRF& operator ->() const { return cb; }
03423         Olsr401GetNeighborListCB(const Olsr401GetNeighborListRF& cb)
03424           : cb(cb) { }
03425 
03426         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
03427 
03428         void respond(const XrlAtomList& arg_neighbors) const {
03429             cb->dispatch(XrlCmdError::OKAY(),
03430                          &arg_neighbors);
03431         }
03432     };
03433 
03434     struct Olsr401GetNeighborListRsp :
03435       public Olsr401GetNeighborListCB {
03436         struct args_str {
03437             XrlAtomList neighbors;
03438         };
03439 
03440     private:
03441         args_str args;
03442 
03443     public:
03444         Olsr401GetNeighborListRsp(const Olsr401GetNeighborListRF& cb)
03445           : Olsr401GetNeighborListCB(cb) { }
03446 
03447         void respond() const {
03448             Olsr401GetNeighborListCB::
03449             respond(args.neighbors);
03450         }
03451 
03452         args_str* operator ->() {
03453             return &args;
03454         }
03455     };
03456 
03457     virtual void async_olsr4_0_1_get_neighbor_list
03458        (
03459     Olsr401GetNeighborListCB);
03460 #endif
03461 
03491     virtual XrlCmdError olsr4_0_1_get_neighbor_info(
03492     // Input values,
03493     const uint32_t& nid,
03494     // Output values,
03495     IPv4&   main_addr,
03496     uint32_t&   willingness,
03497     uint32_t&   degree,
03498     uint32_t&   link_count,
03499     uint32_t&   twohop_link_count,
03500     bool&   is_advertised,
03501     bool&   is_sym,
03502     bool&   is_mpr,
03503     bool&   is_mpr_selector) = 0;
03504 #ifdef XORP_ENABLE_ASYNC_SERVER
03505     typedef
03506     XorpCallback10<void, const XrlCmdError &,
03507     const IPv4*,
03508     const uint32_t*,
03509     const uint32_t*,
03510     const uint32_t*,
03511     const uint32_t*,
03512     const bool*,
03513     const bool*,
03514     const bool*,
03515     const bool*>::RefPtr
03516     Olsr401GetNeighborInfoRF;
03517 
03518     class Olsr401GetNeighborInfoCB {
03519         Olsr401GetNeighborInfoRF cb;
03520 
03521     public:
03522         operator const Olsr401GetNeighborInfoRF& () const { return cb; }
03523         const Olsr401GetNeighborInfoRF& operator ->() const { return cb; }
03524         Olsr401GetNeighborInfoCB(const Olsr401GetNeighborInfoRF& cb)
03525           : cb(cb) { }
03526 
03527         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); }
03528 
03529         void respond(const IPv4& arg_main_addr,
03530                      const uint32_t& arg_willingness,
03531                      const uint32_t& arg_degree,
03532                      const uint32_t& arg_link_count,
03533                      const uint32_t& arg_twohop_link_count,
03534                      const bool& arg_is_advertised,
03535                      const bool& arg_is_sym,
03536                      const bool& arg_is_mpr,
03537                      const bool& arg_is_mpr_selector) const {
03538             cb->dispatch(XrlCmdError::OKAY(),
03539                          &arg_main_addr,
03540                          &arg_willingness,
03541                          &arg_degree,
03542                          &arg_link_count,
03543                          &arg_twohop_link_count,
03544                          &arg_is_advertised,
03545                          &arg_is_sym,
03546                          &arg_is_mpr,
03547                          &arg_is_mpr_selector);
03548         }
03549     };
03550 
03551     struct Olsr401GetNeighborInfoRsp :
03552       public Olsr401GetNeighborInfoCB {
03553         struct args_str {
03554             IPv4 main_addr;
03555             uint32_t willingness;
03556             uint32_t degree;
03557             uint32_t link_count;
03558             uint32_t twohop_link_count;
03559             bool is_advertised;
03560             bool is_sym;
03561             bool is_mpr;
03562             bool is_mpr_selector;
03563         };
03564 
03565     private:
03566         args_str args;
03567 
03568     public:
03569         Olsr401GetNeighborInfoRsp(const Olsr401GetNeighborInfoRF& cb)
03570           : Olsr401GetNeighborInfoCB(cb) { }
03571 
03572         void respond() const {
03573             Olsr401GetNeighborInfoCB::
03574             respond(args.main_addr,
03575                         args.willingness,
03576                         args.degree,
03577                         args.link_count,
03578                         args.twohop_link_count,
03579                         args.is_advertised,
03580                         args.is_sym,
03581                         args.is_mpr,
03582                         args.is_mpr_selector);
03583         }
03584 
03585         args_str* operator ->() {
03586             return &args;
03587         }
03588     };
03589 
03590     virtual void async_olsr4_0_1_get_neighbor_info
03591        (
03592     const uint32_t& nid,
03593     Olsr401GetNeighborInfoCB);
03594 #endif
03595 
03603     virtual XrlCmdError olsr4_0_1_get_twohop_link_list(
03604     // Output values,
03605     XrlAtomList&    twohop_links) = 0;
03606 #ifdef XORP_ENABLE_ASYNC_SERVER
03607     typedef
03608     XorpCallback2<void, const XrlCmdError &,
03609     const XrlAtomList*>::RefPtr
03610     Olsr401GetTwohopLinkListRF;
03611 
03612     class Olsr401GetTwohopLinkListCB {
03613         Olsr401GetTwohopLinkListRF cb;
03614 
03615     public:
03616         operator const Olsr401GetTwohopLinkListRF& () const { return cb; }
03617         const Olsr401GetTwohopLinkListRF& operator ->() const { return cb; }
03618         Olsr401GetTwohopLinkListCB(const Olsr401GetTwohopLinkListRF& cb)
03619           : cb(cb) { }
03620 
03621         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
03622 
03623         void respond(const XrlAtomList& arg_twohop_links) const {
03624             cb->dispatch(XrlCmdError::OKAY(),
03625                          &arg_twohop_links);
03626         }
03627     };
03628 
03629     struct Olsr401GetTwohopLinkListRsp :
03630       public Olsr401GetTwohopLinkListCB {
03631         struct args_str {
03632             XrlAtomList twohop_links;
03633         };
03634 
03635     private:
03636         args_str args;
03637 
03638     public:
03639         Olsr401GetTwohopLinkListRsp(const Olsr401GetTwohopLinkListRF& cb)
03640           : Olsr401GetTwohopLinkListCB(cb) { }
03641 
03642         void respond() const {
03643             Olsr401GetTwohopLinkListCB::
03644             respond(args.twohop_links);
03645         }
03646 
03647         args_str* operator ->() {
03648             return &args;
03649         }
03650     };
03651 
03652     virtual void async_olsr4_0_1_get_twohop_link_list
03653        (
03654     Olsr401GetTwohopLinkListCB);
03655 #endif
03656 
03675     virtual XrlCmdError olsr4_0_1_get_twohop_link_info(
03676     // Input values,
03677     const uint32_t& tlid,
03678     // Output values,
03679     uint32_t&   last_face_id,
03680     IPv4&   nexthop_addr,
03681     IPv4&   dest_addr,
03682     uint32_t&   hold_time) = 0;
03683 #ifdef XORP_ENABLE_ASYNC_SERVER
03684     typedef
03685     XorpCallback5<void, const XrlCmdError &,
03686     const uint32_t*,
03687     const IPv4*,
03688     const IPv4*,
03689     const uint32_t*>::RefPtr
03690     Olsr401GetTwohopLinkInfoRF;
03691 
03692     class Olsr401GetTwohopLinkInfoCB {
03693         Olsr401GetTwohopLinkInfoRF cb;
03694 
03695     public:
03696         operator const Olsr401GetTwohopLinkInfoRF& () const { return cb; }
03697         const Olsr401GetTwohopLinkInfoRF& operator ->() const { return cb; }
03698         Olsr401GetTwohopLinkInfoCB(const Olsr401GetTwohopLinkInfoRF& cb)
03699           : cb(cb) { }
03700 
03701         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL); }
03702 
03703         void respond(const uint32_t& arg_last_face_id,
03704                      const IPv4& arg_nexthop_addr,
03705                      const IPv4& arg_dest_addr,
03706                      const uint32_t& arg_hold_time) const {
03707             cb->dispatch(XrlCmdError::OKAY(),
03708                          &arg_last_face_id,
03709                          &arg_nexthop_addr,
03710                          &arg_dest_addr,
03711                          &arg_hold_time);
03712         }
03713     };
03714 
03715     struct Olsr401GetTwohopLinkInfoRsp :
03716       public Olsr401GetTwohopLinkInfoCB {
03717         struct args_str {
03718             uint32_t last_face_id;
03719             IPv4 nexthop_addr;
03720             IPv4 dest_addr;
03721             uint32_t hold_time;
03722         };
03723 
03724     private:
03725         args_str args;
03726 
03727     public:
03728         Olsr401GetTwohopLinkInfoRsp(const Olsr401GetTwohopLinkInfoRF& cb)
03729           : Olsr401GetTwohopLinkInfoCB(cb) { }
03730 
03731         void respond() const {
03732             Olsr401GetTwohopLinkInfoCB::
03733             respond(args.last_face_id,
03734                         args.nexthop_addr,
03735                         args.dest_addr,
03736                         args.hold_time);
03737         }
03738 
03739         args_str* operator ->() {
03740             return &args;
03741         }
03742     };
03743 
03744     virtual void async_olsr4_0_1_get_twohop_link_info
03745        (
03746     const uint32_t& tlid,
03747     Olsr401GetTwohopLinkInfoCB);
03748 #endif
03749 
03757     virtual XrlCmdError olsr4_0_1_get_twohop_neighbor_list(
03758     // Output values,
03759     XrlAtomList&    twohop_neighbors) = 0;
03760 #ifdef XORP_ENABLE_ASYNC_SERVER
03761     typedef
03762     XorpCallback2<void, const XrlCmdError &,
03763     const XrlAtomList*>::RefPtr
03764     Olsr401GetTwohopNeighborListRF;
03765 
03766     class Olsr401GetTwohopNeighborListCB {
03767         Olsr401GetTwohopNeighborListRF cb;
03768 
03769     public:
03770         operator const Olsr401GetTwohopNeighborListRF& () const { return cb; }
03771         const Olsr401GetTwohopNeighborListRF& operator ->() const { return cb; }
03772         Olsr401GetTwohopNeighborListCB(const Olsr401GetTwohopNeighborListRF& cb)
03773           : cb(cb) { }
03774 
03775         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
03776 
03777         void respond(const XrlAtomList& arg_twohop_neighbors) const {
03778             cb->dispatch(XrlCmdError::OKAY(),
03779                          &arg_twohop_neighbors);
03780         }
03781     };
03782 
03783     struct Olsr401GetTwohopNeighborListRsp :
03784       public Olsr401GetTwohopNeighborListCB {
03785         struct args_str {
03786             XrlAtomList twohop_neighbors;
03787         };
03788 
03789     private:
03790         args_str args;
03791 
03792     public:
03793         Olsr401GetTwohopNeighborListRsp(const Olsr401GetTwohopNeighborListRF& cb)
03794           : Olsr401GetTwohopNeighborListCB(cb) { }
03795 
03796         void respond() const {
03797             Olsr401GetTwohopNeighborListCB::
03798             respond(args.twohop_neighbors);
03799         }
03800 
03801         args_str* operator ->() {
03802             return &args;
03803         }
03804     };
03805 
03806     virtual void async_olsr4_0_1_get_twohop_neighbor_list
03807        (
03808     Olsr401GetTwohopNeighborListCB);
03809 #endif
03810 
03832     virtual XrlCmdError olsr4_0_1_get_twohop_neighbor_info(
03833     // Input values,
03834     const uint32_t& tnid,
03835     // Output values,
03836     IPv4&   main_addr,
03837     bool&   is_strict,
03838     uint32_t&   link_count,
03839     uint32_t&   reachability,
03840     uint32_t&   coverage) = 0;
03841 #ifdef XORP_ENABLE_ASYNC_SERVER
03842     typedef
03843     XorpCallback6<void, const XrlCmdError &,
03844     const IPv4*,
03845     const bool*,
03846     const uint32_t*,
03847     const uint32_t*,
03848     const uint32_t*>::RefPtr
03849     Olsr401GetTwohopNeighborInfoRF;
03850 
03851     class Olsr401GetTwohopNeighborInfoCB {
03852         Olsr401GetTwohopNeighborInfoRF cb;
03853 
03854     public:
03855         operator const Olsr401GetTwohopNeighborInfoRF& () const { return cb; }
03856         const Olsr401GetTwohopNeighborInfoRF& operator ->() const { return cb; }
03857         Olsr401GetTwohopNeighborInfoCB(const Olsr401GetTwohopNeighborInfoRF& cb)
03858           : cb(cb) { }
03859 
03860         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL, NULL); }
03861 
03862         void respond(const IPv4& arg_main_addr,
03863                      const bool& arg_is_strict,
03864                      const uint32_t& arg_link_count,
03865                      const uint32_t& arg_reachability,
03866                      const uint32_t& arg_coverage) const {
03867             cb->dispatch(XrlCmdError::OKAY(),
03868                          &arg_main_addr,
03869                          &arg_is_strict,
03870                          &arg_link_count,
03871                          &arg_reachability,
03872                          &arg_coverage);
03873         }
03874     };
03875 
03876     struct Olsr401GetTwohopNeighborInfoRsp :
03877       public Olsr401GetTwohopNeighborInfoCB {
03878         struct args_str {
03879             IPv4 main_addr;
03880             bool is_strict;
03881             uint32_t link_count;
03882             uint32_t reachability;
03883             uint32_t coverage;
03884         };
03885 
03886     private:
03887         args_str args;
03888 
03889     public:
03890         Olsr401GetTwohopNeighborInfoRsp(const Olsr401GetTwohopNeighborInfoRF& cb)
03891           : Olsr401GetTwohopNeighborInfoCB(cb) { }
03892 
03893         void respond() const {
03894             Olsr401GetTwohopNeighborInfoCB::
03895             respond(args.main_addr,
03896                         args.is_strict,
03897                         args.link_count,
03898                         args.reachability,
03899                         args.coverage);
03900         }
03901 
03902         args_str* operator ->() {
03903             return &args;
03904         }
03905     };
03906 
03907     virtual void async_olsr4_0_1_get_twohop_neighbor_info
03908        (
03909     const uint32_t& tnid,
03910     Olsr401GetTwohopNeighborInfoCB);
03911 #endif
03912 
03920     virtual XrlCmdError olsr4_0_1_get_mid_entry_list(
03921     // Output values,
03922     XrlAtomList&    mid_entries) = 0;
03923 #ifdef XORP_ENABLE_ASYNC_SERVER
03924     typedef
03925     XorpCallback2<void, const XrlCmdError &,
03926     const XrlAtomList*>::RefPtr
03927     Olsr401GetMidEntryListRF;
03928 
03929     class Olsr401GetMidEntryListCB {
03930         Olsr401GetMidEntryListRF cb;
03931 
03932     public:
03933         operator const Olsr401GetMidEntryListRF& () const { return cb; }
03934         const Olsr401GetMidEntryListRF& operator ->() const { return cb; }
03935         Olsr401GetMidEntryListCB(const Olsr401GetMidEntryListRF& cb)
03936           : cb(cb) { }
03937 
03938         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
03939 
03940         void respond(const XrlAtomList& arg_mid_entries) const {
03941             cb->dispatch(XrlCmdError::OKAY(),
03942                          &arg_mid_entries);
03943         }
03944     };
03945 
03946     struct Olsr401GetMidEntryListRsp :
03947       public Olsr401GetMidEntryListCB {
03948         struct args_str {
03949             XrlAtomList mid_entries;
03950         };
03951 
03952     private:
03953         args_str args;
03954 
03955     public:
03956         Olsr401GetMidEntryListRsp(const Olsr401GetMidEntryListRF& cb)
03957           : Olsr401GetMidEntryListCB(cb) { }
03958 
03959         void respond() const {
03960             Olsr401GetMidEntryListCB::
03961             respond(args.mid_entries);
03962         }
03963 
03964         args_str* operator ->() {
03965             return &args;
03966         }
03967     };
03968 
03969     virtual void async_olsr4_0_1_get_mid_entry_list
03970        (
03971     Olsr401GetMidEntryListCB);
03972 #endif
03973 
03990     virtual XrlCmdError olsr4_0_1_get_mid_entry(
03991     // Input values,
03992     const uint32_t& midid,
03993     // Output values,
03994     IPv4&   main_addr,
03995     IPv4&   iface_addr,
03996     uint32_t&   distance,
03997     uint32_t&   hold_time) = 0;
03998 #ifdef XORP_ENABLE_ASYNC_SERVER
03999     typedef
04000     XorpCallback5<void, const XrlCmdError &,
04001     const IPv4*,
04002     const IPv4*,
04003     const uint32_t*,
04004     const uint32_t*>::RefPtr
04005     Olsr401GetMidEntryRF;
04006 
04007     class Olsr401GetMidEntryCB {
04008         Olsr401GetMidEntryRF cb;
04009 
04010     public:
04011         operator const Olsr401GetMidEntryRF& () const { return cb; }
04012         const Olsr401GetMidEntryRF& operator ->() const { return cb; }
04013         Olsr401GetMidEntryCB(const Olsr401GetMidEntryRF& cb)
04014           : cb(cb) { }
04015 
04016         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL); }
04017 
04018         void respond(const IPv4& arg_main_addr,
04019                      const IPv4& arg_iface_addr,
04020                      const uint32_t& arg_distance,
04021                      const uint32_t& arg_hold_time) const {
04022             cb->dispatch(XrlCmdError::OKAY(),
04023                          &arg_main_addr,
04024                          &arg_iface_addr,
04025                          &arg_distance,
04026                          &arg_hold_time);
04027         }
04028     };
04029 
04030     struct Olsr401GetMidEntryRsp :
04031       public Olsr401GetMidEntryCB {
04032         struct args_str {
04033             IPv4 main_addr;
04034             IPv4 iface_addr;
04035             uint32_t distance;
04036             uint32_t hold_time;
04037         };
04038 
04039     private:
04040         args_str args;
04041 
04042     public:
04043         Olsr401GetMidEntryRsp(const Olsr401GetMidEntryRF& cb)
04044           : Olsr401GetMidEntryCB(cb) { }
04045 
04046         void respond() const {
04047             Olsr401GetMidEntryCB::
04048             respond(args.main_addr,
04049                         args.iface_addr,
04050                         args.distance,
04051                         args.hold_time);
04052         }
04053 
04054         args_str* operator ->() {
04055             return &args;
04056         }
04057     };
04058 
04059     virtual void async_olsr4_0_1_get_mid_entry
04060        (
04061     const uint32_t& midid,
04062     Olsr401GetMidEntryCB);
04063 #endif
04064 
04072     virtual XrlCmdError olsr4_0_1_get_tc_entry_list(
04073     // Output values,
04074     XrlAtomList&    tc_entries) = 0;
04075 #ifdef XORP_ENABLE_ASYNC_SERVER
04076     typedef
04077     XorpCallback2<void, const XrlCmdError &,
04078     const XrlAtomList*>::RefPtr
04079     Olsr401GetTcEntryListRF;
04080 
04081     class Olsr401GetTcEntryListCB {
04082         Olsr401GetTcEntryListRF cb;
04083 
04084     public:
04085         operator const Olsr401GetTcEntryListRF& () const { return cb; }
04086         const Olsr401GetTcEntryListRF& operator ->() const { return cb; }
04087         Olsr401GetTcEntryListCB(const Olsr401GetTcEntryListRF& cb)
04088           : cb(cb) { }
04089 
04090         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
04091 
04092         void respond(const XrlAtomList& arg_tc_entries) const {
04093             cb->dispatch(XrlCmdError::OKAY(),
04094                          &arg_tc_entries);
04095         }
04096     };
04097 
04098     struct Olsr401GetTcEntryListRsp :
04099       public Olsr401GetTcEntryListCB {
04100         struct args_str {
04101             XrlAtomList tc_entries;
04102         };
04103 
04104     private:
04105         args_str args;
04106 
04107     public:
04108         Olsr401GetTcEntryListRsp(const Olsr401GetTcEntryListRF& cb)
04109           : Olsr401GetTcEntryListCB(cb) { }
04110 
04111         void respond() const {
04112             Olsr401GetTcEntryListCB::
04113             respond(args.tc_entries);
04114         }
04115 
04116         args_str* operator ->() {
04117             return &args;
04118         }
04119     };
04120 
04121     virtual void async_olsr4_0_1_get_tc_entry_list
04122        (
04123     Olsr401GetTcEntryListCB);
04124 #endif
04125 
04144     virtual XrlCmdError olsr4_0_1_get_tc_entry(
04145     // Input values,
04146     const uint32_t& tcid,
04147     // Output values,
04148     IPv4&   destination,
04149     IPv4&   lasthop,
04150     uint32_t&   distance,
04151     uint32_t&   seqno,
04152     uint32_t&   hold_time) = 0;
04153 #ifdef XORP_ENABLE_ASYNC_SERVER
04154     typedef
04155     XorpCallback6<void, const XrlCmdError &,
04156     const IPv4*,
04157     const IPv4*,
04158     const uint32_t*,
04159     const uint32_t*,
04160     const uint32_t*>::RefPtr
04161     Olsr401GetTcEntryRF;
04162 
04163     class Olsr401GetTcEntryCB {
04164         Olsr401GetTcEntryRF cb;
04165 
04166     public:
04167         operator const Olsr401GetTcEntryRF& () const { return cb; }
04168         const Olsr401GetTcEntryRF& operator ->() const { return cb; }
04169         Olsr401GetTcEntryCB(const Olsr401GetTcEntryRF& cb)
04170           : cb(cb) { }
04171 
04172         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL, NULL); }
04173 
04174         void respond(const IPv4& arg_destination,
04175                      const IPv4& arg_lasthop,
04176                      const uint32_t& arg_distance,
04177                      const uint32_t& arg_seqno,
04178                      const uint32_t& arg_hold_time) const {
04179             cb->dispatch(XrlCmdError::OKAY(),
04180                          &arg_destination,
04181                          &arg_lasthop,
04182                          &arg_distance,
04183                          &arg_seqno,
04184                          &arg_hold_time);
04185         }
04186     };
04187 
04188     struct Olsr401GetTcEntryRsp :
04189       public Olsr401GetTcEntryCB {
04190         struct args_str {
04191             IPv4 destination;
04192             IPv4 lasthop;
04193             uint32_t distance;
04194             uint32_t seqno;
04195             uint32_t hold_time;
04196         };
04197 
04198     private:
04199         args_str args;
04200 
04201     public:
04202         Olsr401GetTcEntryRsp(const Olsr401GetTcEntryRF& cb)
04203           : Olsr401GetTcEntryCB(cb) { }
04204 
04205         void respond() const {
04206             Olsr401GetTcEntryCB::
04207             respond(args.destination,
04208                         args.lasthop,
04209                         args.distance,
04210                         args.seqno,
04211                         args.hold_time);
04212         }
04213 
04214         args_str* operator ->() {
04215             return &args;
04216         }
04217     };
04218 
04219     virtual void async_olsr4_0_1_get_tc_entry
04220        (
04221     const uint32_t& tcid,
04222     Olsr401GetTcEntryCB);
04223 #endif
04224 
04232     virtual XrlCmdError olsr4_0_1_get_hna_entry_list(
04233     // Output values,
04234     XrlAtomList&    hna_entries) = 0;
04235 #ifdef XORP_ENABLE_ASYNC_SERVER
04236     typedef
04237     XorpCallback2<void, const XrlCmdError &,
04238     const XrlAtomList*>::RefPtr
04239     Olsr401GetHnaEntryListRF;
04240 
04241     class Olsr401GetHnaEntryListCB {
04242         Olsr401GetHnaEntryListRF cb;
04243 
04244     public:
04245         operator const Olsr401GetHnaEntryListRF& () const { return cb; }
04246         const Olsr401GetHnaEntryListRF& operator ->() const { return cb; }
04247         Olsr401GetHnaEntryListCB(const Olsr401GetHnaEntryListRF& cb)
04248           : cb(cb) { }
04249 
04250         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL); }
04251 
04252         void respond(const XrlAtomList& arg_hna_entries) const {
04253             cb->dispatch(XrlCmdError::OKAY(),
04254                          &arg_hna_entries);
04255         }
04256     };
04257 
04258     struct Olsr401GetHnaEntryListRsp :
04259       public Olsr401GetHnaEntryListCB {
04260         struct args_str {
04261             XrlAtomList hna_entries;
04262         };
04263 
04264     private:
04265         args_str args;
04266 
04267     public:
04268         Olsr401GetHnaEntryListRsp(const Olsr401GetHnaEntryListRF& cb)
04269           : Olsr401GetHnaEntryListCB(cb) { }
04270 
04271         void respond() const {
04272             Olsr401GetHnaEntryListCB::
04273             respond(args.hna_entries);
04274         }
04275 
04276         args_str* operator ->() {
04277             return &args;
04278         }
04279     };
04280 
04281     virtual void async_olsr4_0_1_get_hna_entry_list
04282        (
04283     Olsr401GetHnaEntryListCB);
04284 #endif
04285 
04302     virtual XrlCmdError olsr4_0_1_get_hna_entry(
04303     // Input values,
04304     const uint32_t& hnaid,
04305     // Output values,
04306     IPv4Net&    destination,
04307     IPv4&   lasthop,
04308     uint32_t&   distance,
04309     uint32_t&   hold_time) = 0;
04310 #ifdef XORP_ENABLE_ASYNC_SERVER
04311     typedef
04312     XorpCallback5<void, const XrlCmdError &,
04313     const IPv4Net*,
04314     const IPv4*,
04315     const uint32_t*,
04316     const uint32_t*>::RefPtr
04317     Olsr401GetHnaEntryRF;
04318 
04319     class Olsr401GetHnaEntryCB {
04320         Olsr401GetHnaEntryRF cb;
04321 
04322     public:
04323         operator const Olsr401GetHnaEntryRF& () const { return cb; }
04324         const Olsr401GetHnaEntryRF& operator ->() const { return cb; }
04325         Olsr401GetHnaEntryCB(const Olsr401GetHnaEntryRF& cb)
04326           : cb(cb) { }
04327 
04328         void fail(const XrlCmdError &e) const { cb->dispatch(e, NULL, NULL, NULL, NULL); }
04329 
04330         void respond(const IPv4Net& arg_destination,
04331                      const IPv4& arg_lasthop,
04332                      const uint32_t& arg_distance,
04333                      const uint32_t& arg_hold_time) const {
04334             cb->dispatch(XrlCmdError::OKAY(),
04335                          &arg_destination,
04336                          &arg_lasthop,
04337                          &arg_distance,
04338                          &arg_hold_time);
04339         }
04340     };
04341 
04342     struct Olsr401GetHnaEntryRsp :
04343       public Olsr401GetHnaEntryCB {
04344         struct args_str {
04345             IPv4Net destination;
04346             IPv4 lasthop;
04347             uint32_t distance;
04348             uint32_t hold_time;
04349         };
04350 
04351     private:
04352         args_str args;
04353 
04354     public:
04355         Olsr401GetHnaEntryRsp(const Olsr401GetHnaEntryRF& cb)
04356           : Olsr401GetHnaEntryCB(cb) { }
04357 
04358         void respond() const {
04359             Olsr401GetHnaEntryCB::
04360             respond(args.destination,
04361                         args.lasthop,
04362                         args.distance,
04363                         args.hold_time);
04364         }
04365 
04366         args_str* operator ->() {
04367             return &args;
04368         }
04369     };
04370 
04371     virtual void async_olsr4_0_1_get_hna_entry
04372        (
04373     const uint32_t& hnaid,
04374     Olsr401GetHnaEntryCB);
04375 #endif
04376 
04377 private:
04378     XrlCmdRT handle_common_0_1_get_target_name(const XrlArgs& in, XrlCmdOT out);
04379 #ifdef XORP_ENABLE_ASYNC_SERVER
04380     void callback_common_0_1_get_target_name
04381        (const XrlCmdError &e,
04382     const string* arg_name,
04383         XrlRespCallback);
04384 #endif
04385 
04386     XrlCmdRT handle_common_0_1_get_version(const XrlArgs& in, XrlCmdOT out);
04387 #ifdef XORP_ENABLE_ASYNC_SERVER
04388     void callback_common_0_1_get_version
04389        (const XrlCmdError &e,
04390     const string* arg_version,
04391         XrlRespCallback);
04392 #endif
04393 
04394     XrlCmdRT handle_common_0_1_get_status(const XrlArgs& in, XrlCmdOT out);
04395 #ifdef XORP_ENABLE_ASYNC_SERVER
04396     void callback_common_0_1_get_status
04397        (const XrlCmdError &e,
04398     const uint32_t* arg_status,
04399     const string* arg_reason,
04400         XrlRespCallback);
04401 #endif
04402 
04403     XrlCmdRT handle_common_0_1_shutdown(const XrlArgs& in, XrlCmdOT out);
04404 #ifdef XORP_ENABLE_ASYNC_SERVER
04405     void callback_common_0_1_shutdown
04406        (const XrlCmdError &e,
04407         XrlRespCallback);
04408 #endif
04409 
04410     XrlCmdRT handle_common_0_1_startup(const XrlArgs& in, XrlCmdOT out);
04411 #ifdef XORP_ENABLE_ASYNC_SERVER
04412     void callback_common_0_1_startup
04413        (const XrlCmdError &e,
04414         XrlRespCallback);
04415 #endif
04416 
04417     XrlCmdRT handle_finder_event_observer_0_1_xrl_target_birth(const XrlArgs& in, XrlCmdOT out);
04418 #ifdef XORP_ENABLE_ASYNC_SERVER
04419     void callback_finder_event_observer_0_1_xrl_target_birth
04420        (const XrlCmdError &e,
04421         XrlRespCallback);
04422 #endif
04423 
04424     XrlCmdRT handle_finder_event_observer_0_1_xrl_target_death(const XrlArgs& in, XrlCmdOT out);
04425 #ifdef XORP_ENABLE_ASYNC_SERVER
04426     void callback_finder_event_observer_0_1_xrl_target_death
04427        (const XrlCmdError &e,
04428         XrlRespCallback);
04429 #endif
04430 
04431     XrlCmdRT handle_socket4_user_0_1_recv_event(const XrlArgs& in, XrlCmdOT out);
04432 #ifdef XORP_ENABLE_ASYNC_SERVER
04433     void callback_socket4_user_0_1_recv_event
04434        (const XrlCmdError &e,
04435         XrlRespCallback);
04436 #endif
04437 
04438     XrlCmdRT handle_socket4_user_0_1_inbound_connect_event(const XrlArgs& in, XrlCmdOT out);
04439 #ifdef XORP_ENABLE_ASYNC_SERVER
04440     void callback_socket4_user_0_1_inbound_connect_event
04441        (const XrlCmdError &e,
04442     const bool* arg_accept,
04443         XrlRespCallback);
04444 #endif
04445 
04446     XrlCmdRT handle_socket4_user_0_1_outgoing_connect_event(const XrlArgs& in, XrlCmdOT out);
04447 #ifdef XORP_ENABLE_ASYNC_SERVER
04448     void callback_socket4_user_0_1_outgoing_connect_event
04449        (const XrlCmdError &e,
04450         XrlRespCallback);
04451 #endif
04452 
04453     XrlCmdRT handle_socket4_user_0_1_error_event(const XrlArgs& in, XrlCmdOT out);
04454 #ifdef XORP_ENABLE_ASYNC_SERVER
04455     void callback_socket4_user_0_1_error_event
04456        (const XrlCmdError &e,
04457         XrlRespCallback);
04458 #endif
04459 
04460     XrlCmdRT handle_socket4_user_0_1_disconnect_event(const XrlArgs& in, XrlCmdOT out);
04461 #ifdef XORP_ENABLE_ASYNC_SERVER
04462     void callback_socket4_user_0_1_disconnect_event
04463        (const XrlCmdError &e,
04464         XrlRespCallback);
04465 #endif
04466 
04467     XrlCmdRT handle_policy_backend_0_1_configure(const XrlArgs& in, XrlCmdOT out);
04468 #ifdef XORP_ENABLE_ASYNC_SERVER
04469     void callback_policy_backend_0_1_configure
04470        (const XrlCmdError &e,
04471         XrlRespCallback);
04472 #endif
04473 
04474     XrlCmdRT handle_policy_backend_0_1_reset(const XrlArgs& in, XrlCmdOT out);
04475 #ifdef XORP_ENABLE_ASYNC_SERVER
04476     void callback_policy_backend_0_1_reset
04477        (const XrlCmdError &e,
04478         XrlRespCallback);
04479 #endif
04480 
04481     XrlCmdRT handle_policy_backend_0_1_push_routes(const XrlArgs& in, XrlCmdOT out);
04482 #ifdef XORP_ENABLE_ASYNC_SERVER
04483     void callback_policy_backend_0_1_push_routes
04484        (const XrlCmdError &e,
04485         XrlRespCallback);
04486 #endif
04487 
04488     XrlCmdRT handle_policy_redist4_0_1_add_route4(const XrlArgs& in, XrlCmdOT out);
04489 #ifdef XORP_ENABLE_ASYNC_SERVER
04490     void callback_policy_redist4_0_1_add_route4
04491        (const XrlCmdError &e,
04492         XrlRespCallback);
04493 #endif
04494 
04495     XrlCmdRT handle_policy_redist4_0_1_delete_route4(const XrlArgs& in, XrlCmdOT out);
04496 #ifdef XORP_ENABLE_ASYNC_SERVER
04497     void callback_policy_redist4_0_1_delete_route4
04498        (const XrlCmdError &e,
04499         XrlRespCallback);
04500 #endif
04501 
04502     XrlCmdRT handle_profile_0_1_enable(const XrlArgs& in, XrlCmdOT out);
04503 #ifdef XORP_ENABLE_ASYNC_SERVER
04504     void callback_profile_0_1_enable
04505        (const XrlCmdError &e,
04506         XrlRespCallback);
04507 #endif
04508 
04509     XrlCmdRT handle_profile_0_1_disable(const XrlArgs& in, XrlCmdOT out);
04510 #ifdef XORP_ENABLE_ASYNC_SERVER
04511     void callback_profile_0_1_disable
04512        (const XrlCmdError &e,
04513         XrlRespCallback);
04514 #endif
04515 
04516     XrlCmdRT handle_profile_0_1_get_entries(const XrlArgs& in, XrlCmdOT out);
04517 #ifdef XORP_ENABLE_ASYNC_SERVER
04518     void callback_profile_0_1_get_entries
04519        (const XrlCmdError &e,
04520         XrlRespCallback);
04521 #endif
04522 
04523     XrlCmdRT handle_profile_0_1_clear(const XrlArgs& in, XrlCmdOT out);
04524 #ifdef XORP_ENABLE_ASYNC_SERVER
04525     void callback_profile_0_1_clear
04526        (const XrlCmdError &e,
04527         XrlRespCallback);
04528 #endif
04529 
04530     XrlCmdRT handle_profile_0_1_list(const XrlArgs& in, XrlCmdOT out);
04531 #ifdef XORP_ENABLE_ASYNC_SERVER
04532     void callback_profile_0_1_list
04533        (const XrlCmdError &e,
04534     const string* arg_info,
04535         XrlRespCallback);
04536 #endif
04537 
04538     XrlCmdRT handle_olsr4_0_1_trace(const XrlArgs& in, XrlCmdOT out);
04539 #ifdef XORP_ENABLE_ASYNC_SERVER
04540     void callback_olsr4_0_1_trace
04541        (const XrlCmdError &e,
04542         XrlRespCallback);
04543 #endif
04544 
04545     XrlCmdRT handle_olsr4_0_1_clear_database(const XrlArgs& in, XrlCmdOT out);
04546 #ifdef XORP_ENABLE_ASYNC_SERVER
04547     void callback_olsr4_0_1_clear_database
04548        (const XrlCmdError &e,
04549         XrlRespCallback);
04550 #endif
04551 
04552     XrlCmdRT handle_olsr4_0_1_set_willingness(const XrlArgs& in, XrlCmdOT out);
04553 #ifdef XORP_ENABLE_ASYNC_SERVER
04554     void callback_olsr4_0_1_set_willingness
04555        (const XrlCmdError &e,
04556         XrlRespCallback);
04557 #endif
04558 
04559     XrlCmdRT handle_olsr4_0_1_get_willingness(const XrlArgs& in, XrlCmdOT out);
04560 #ifdef XORP_ENABLE_ASYNC_SERVER
04561     void callback_olsr4_0_1_get_willingness
04562        (const XrlCmdError &e,
04563     const uint32_t* arg_willingness,
04564         XrlRespCallback);
04565 #endif
04566 
04567     XrlCmdRT handle_olsr4_0_1_set_mpr_coverage(const XrlArgs& in, XrlCmdOT out);
04568 #ifdef XORP_ENABLE_ASYNC_SERVER
04569     void callback_olsr4_0_1_set_mpr_coverage
04570        (const XrlCmdError &e,
04571         XrlRespCallback);
04572 #endif
04573 
04574     XrlCmdRT handle_olsr4_0_1_get_mpr_coverage(const XrlArgs& in, XrlCmdOT out);
04575 #ifdef XORP_ENABLE_ASYNC_SERVER
04576     void callback_olsr4_0_1_get_mpr_coverage
04577        (const XrlCmdError &e,
04578     const uint32_t* arg_coverage,
04579         XrlRespCallback);
04580 #endif
04581 
04582     XrlCmdRT handle_olsr4_0_1_set_tc_redundancy(const XrlArgs& in, XrlCmdOT out);
04583 #ifdef XORP_ENABLE_ASYNC_SERVER
04584     void callback_olsr4_0_1_set_tc_redundancy
04585        (const XrlCmdError &e,
04586         XrlRespCallback);
04587 #endif
04588 
04589     XrlCmdRT handle_olsr4_0_1_get_tc_redundancy(const XrlArgs& in, XrlCmdOT out);
04590 #ifdef XORP_ENABLE_ASYNC_SERVER
04591     void callback_olsr4_0_1_get_tc_redundancy
04592        (const XrlCmdError &e,
04593     const string* arg_redundancy,
04594         XrlRespCallback);
04595 #endif
04596 
04597     XrlCmdRT handle_olsr4_0_1_set_tc_fisheye(const XrlArgs& in, XrlCmdOT out);
04598 #ifdef XORP_ENABLE_ASYNC_SERVER
04599     void callback_olsr4_0_1_set_tc_fisheye
04600        (const XrlCmdError &e,
04601         XrlRespCallback);
04602 #endif
04603 
04604     XrlCmdRT handle_olsr4_0_1_get_tc_fisheye(const XrlArgs& in, XrlCmdOT out);
04605 #ifdef XORP_ENABLE_ASYNC_SERVER
04606     void callback_olsr4_0_1_get_tc_fisheye
04607        (const XrlCmdError &e,
04608     const bool* arg_enabled,
04609         XrlRespCallback);
04610 #endif
04611 
04612     XrlCmdRT handle_olsr4_0_1_set_hna_base_cost(const XrlArgs& in, XrlCmdOT out);
04613 #ifdef XORP_ENABLE_ASYNC_SERVER
04614     void callback_olsr4_0_1_set_hna_base_cost
04615        (const XrlCmdError &e,
04616         XrlRespCallback);
04617 #endif
04618 
04619     XrlCmdRT handle_olsr4_0_1_get_hna_base_cost(const XrlArgs& in, XrlCmdOT out);
04620 #ifdef XORP_ENABLE_ASYNC_SERVER
04621     void callback_olsr4_0_1_get_hna_base_cost
04622        (const XrlCmdError &e,
04623     const uint32_t* arg_metric,
04624         XrlRespCallback);
04625 #endif
04626 
04627     XrlCmdRT handle_olsr4_0_1_set_hello_interval(const XrlArgs& in, XrlCmdOT out);
04628 #ifdef XORP_ENABLE_ASYNC_SERVER
04629     void callback_olsr4_0_1_set_hello_interval
04630        (const XrlCmdError &e,
04631         XrlRespCallback);
04632 #endif
04633 
04634     XrlCmdRT handle_olsr4_0_1_get_hello_interval(const XrlArgs& in, XrlCmdOT out);
04635 #ifdef XORP_ENABLE_ASYNC_SERVER
04636     void callback_olsr4_0_1_get_hello_interval
04637        (const XrlCmdError &e,
04638     const uint32_t* arg_interval,
04639         XrlRespCallback);
04640 #endif
04641 
04642     XrlCmdRT handle_olsr4_0_1_set_refresh_interval(const XrlArgs& in, XrlCmdOT out);
04643 #ifdef XORP_ENABLE_ASYNC_SERVER
04644     void callback_olsr4_0_1_set_refresh_interval
04645        (const XrlCmdError &e,
04646         XrlRespCallback);
04647 #endif
04648 
04649     XrlCmdRT handle_olsr4_0_1_get_refresh_interval(const XrlArgs& in, XrlCmdOT out);
04650 #ifdef XORP_ENABLE_ASYNC_SERVER
04651     void callback_olsr4_0_1_get_refresh_interval
04652        (const XrlCmdError &e,
04653     const uint32_t* arg_interval,
04654         XrlRespCallback);
04655 #endif
04656 
04657     XrlCmdRT handle_olsr4_0_1_set_tc_interval(const XrlArgs& in, XrlCmdOT out);
04658 #ifdef XORP_ENABLE_ASYNC_SERVER
04659     void callback_olsr4_0_1_set_tc_interval
04660        (const XrlCmdError &e,
04661         XrlRespCallback);
04662 #endif
04663 
04664     XrlCmdRT handle_olsr4_0_1_get_tc_interval(const XrlArgs& in, XrlCmdOT out);
04665 #ifdef XORP_ENABLE_ASYNC_SERVER
04666     void callback_olsr4_0_1_get_tc_interval
04667        (const XrlCmdError &e,
04668     const uint32_t* arg_interval,
04669         XrlRespCallback);
04670 #endif
04671 
04672     XrlCmdRT handle_olsr4_0_1_set_mid_interval(const XrlArgs& in, XrlCmdOT out);
04673 #ifdef XORP_ENABLE_ASYNC_SERVER
04674     void callback_olsr4_0_1_set_mid_interval
04675        (const XrlCmdError &e,
04676         XrlRespCallback);
04677 #endif
04678 
04679     XrlCmdRT handle_olsr4_0_1_get_mid_interval(const XrlArgs& in, XrlCmdOT out);
04680 #ifdef XORP_ENABLE_ASYNC_SERVER
04681     void callback_olsr4_0_1_get_mid_interval
04682        (const XrlCmdError &e,
04683     const uint32_t* arg_interval,
04684         XrlRespCallback);
04685 #endif
04686 
04687     XrlCmdRT handle_olsr4_0_1_set_hna_interval(const XrlArgs& in, XrlCmdOT out);
04688 #ifdef XORP_ENABLE_ASYNC_SERVER
04689     void callback_olsr4_0_1_set_hna_interval
04690        (const XrlCmdError &e,
04691         XrlRespCallback);
04692 #endif
04693 
04694     XrlCmdRT handle_olsr4_0_1_get_hna_interval(const XrlArgs& in, XrlCmdOT out);
04695 #ifdef XORP_ENABLE_ASYNC_SERVER
04696     void callback_olsr4_0_1_get_hna_interval
04697        (const XrlCmdError &e,
04698     const uint32_t* arg_interval,
04699         XrlRespCallback);
04700 #endif
04701 
04702     XrlCmdRT handle_olsr4_0_1_set_dup_hold_time(const XrlArgs& in, XrlCmdOT out);
04703 #ifdef XORP_ENABLE_ASYNC_SERVER
04704     void callback_olsr4_0_1_set_dup_hold_time
04705        (const XrlCmdError &e,
04706         XrlRespCallback);
04707 #endif
04708 
04709     XrlCmdRT handle_olsr4_0_1_get_dup_hold_time(const XrlArgs& in, XrlCmdOT out);
04710 #ifdef XORP_ENABLE_ASYNC_SERVER
04711     void callback_olsr4_0_1_get_dup_hold_time
04712        (const XrlCmdError &e,
04713     const uint32_t* arg_dup_hold_time,
04714         XrlRespCallback);
04715 #endif
04716 
04717     XrlCmdRT handle_olsr4_0_1_set_main_address(const XrlArgs& in, XrlCmdOT out);
04718 #ifdef XORP_ENABLE_ASYNC_SERVER
04719     void callback_olsr4_0_1_set_main_address
04720        (const XrlCmdError &e,
04721         XrlRespCallback);
04722 #endif
04723 
04724     XrlCmdRT handle_olsr4_0_1_get_main_address(const XrlArgs& in, XrlCmdOT out);
04725 #ifdef XORP_ENABLE_ASYNC_SERVER
04726     void callback_olsr4_0_1_get_main_address
04727        (const XrlCmdError &e,
04728     const IPv4* arg_addr,
04729         XrlRespCallback);
04730 #endif
04731 
04732     XrlCmdRT handle_olsr4_0_1_bind_address(const XrlArgs& in, XrlCmdOT out);
04733 #ifdef XORP_ENABLE_ASYNC_SERVER
04734     void callback_olsr4_0_1_bind_address
04735        (const XrlCmdError &e,
04736         XrlRespCallback);
04737 #endif
04738 
04739     XrlCmdRT handle_olsr4_0_1_unbind_address(const XrlArgs& in, XrlCmdOT out);
04740 #ifdef XORP_ENABLE_ASYNC_SERVER
04741     void callback_olsr4_0_1_unbind_address
04742        (const XrlCmdError &e,
04743         XrlRespCallback);
04744 #endif
04745 
04746     XrlCmdRT handle_olsr4_0_1_set_binding_enabled(const XrlArgs& in, XrlCmdOT out);
04747 #ifdef XORP_ENABLE_ASYNC_SERVER
04748     void callback_olsr4_0_1_set_binding_enabled
04749        (const XrlCmdError &e,
04750         XrlRespCallback);
04751 #endif
04752 
04753     XrlCmdRT handle_olsr4_0_1_get_binding_enabled(const XrlArgs& in, XrlCmdOT out);
04754 #ifdef XORP_ENABLE_ASYNC_SERVER
04755     void callback_olsr4_0_1_get_binding_enabled
04756        (const XrlCmdError &e,
04757     const bool* arg_enabled,
04758         XrlRespCallback);
04759 #endif
04760 
04761     XrlCmdRT handle_olsr4_0_1_change_local_addr_port(const XrlArgs& in, XrlCmdOT out);
04762 #ifdef XORP_ENABLE_ASYNC_SERVER
04763     void callback_olsr4_0_1_change_local_addr_port
04764        (const XrlCmdError &e,
04765         XrlRespCallback);
04766 #endif
04767 
04768     XrlCmdRT handle_olsr4_0_1_change_all_nodes_addr_port(const XrlArgs& in, XrlCmdOT out);
04769 #ifdef XORP_ENABLE_ASYNC_SERVER
04770     void callback_olsr4_0_1_change_all_nodes_addr_port
04771        (const XrlCmdError &e,
04772         XrlRespCallback);
04773 #endif
04774 
04775     XrlCmdRT handle_olsr4_0_1_get_interface_list(const XrlArgs& in, XrlCmdOT out);
04776 #ifdef XORP_ENABLE_ASYNC_SERVER
04777     void callback_olsr4_0_1_get_interface_list
04778        (const XrlCmdError &e,
04779     const XrlAtomList* arg_interfaces,
04780         XrlRespCallback);
04781 #endif
04782 
04783     XrlCmdRT handle_olsr4_0_1_get_interface_info(const XrlArgs& in, XrlCmdOT out);
04784 #ifdef XORP_ENABLE_ASYNC_SERVER
04785     void callback_olsr4_0_1_get_interface_info
04786        (const XrlCmdError &e,
04787     const string* arg_ifname,
04788     const string* arg_vifname,
04789     const IPv4* arg_local_addr,
04790     const uint32_t* arg_local_port,
04791     const IPv4* arg_all_nodes_addr,
04792     const uint32_t* arg_all_nodes_port,
04793         XrlRespCallback);
04794 #endif
04795 
04796     XrlCmdRT handle_olsr4_0_1_set_interface_cost(const XrlArgs& in, XrlCmdOT out);
04797 #ifdef XORP_ENABLE_ASYNC_SERVER
04798     void callback_olsr4_0_1_set_interface_cost
04799        (const XrlCmdError &e,
04800         XrlRespCallback);
04801 #endif
04802 
04803     XrlCmdRT handle_olsr4_0_1_get_interface_stats(const XrlArgs& in, XrlCmdOT out);
04804 #ifdef XORP_ENABLE_ASYNC_SERVER
04805     void callback_olsr4_0_1_get_interface_stats
04806        (const XrlCmdError &e,
04807     const uint32_t* arg_bad_packets,
04808     const uint32_t* arg_bad_messages,
04809     const uint32_t* arg_messages_from_self,
04810     const uint32_t* arg_unknown_messages,
04811     const uint32_t* arg_duplicates,
04812     const uint32_t* arg_forwarded,
04813         XrlRespCallback);
04814 #endif
04815 
04816     XrlCmdRT handle_olsr4_0_1_get_link_list(const XrlArgs& in, XrlCmdOT out);
04817 #ifdef XORP_ENABLE_ASYNC_SERVER
04818     void callback_olsr4_0_1_get_link_list
04819        (const XrlCmdError &e,
04820     const XrlAtomList* arg_links,
04821         XrlRespCallback);
04822 #endif
04823 
04824     XrlCmdRT handle_olsr4_0_1_get_link_info(const XrlArgs& in, XrlCmdOT out);
04825 #ifdef XORP_ENABLE_ASYNC_SERVER
04826     void callback_olsr4_0_1_get_link_info
04827        (const XrlCmdError &e,
04828     const IPv4* arg_local_addr,
04829     const IPv4* arg_remote_addr,
04830     const IPv4* arg_main_addr,
04831     const uint32_t* arg_link_type,
04832     const uint32_t* arg_sym_time,
04833     const uint32_t* arg_asym_time,
04834     const uint32_t* arg_hold_time,
04835         XrlRespCallback);
04836 #endif
04837 
04838     XrlCmdRT handle_olsr4_0_1_get_neighbor_list(const XrlArgs& in, XrlCmdOT out);
04839 #ifdef XORP_ENABLE_ASYNC_SERVER
04840     void callback_olsr4_0_1_get_neighbor_list
04841        (const XrlCmdError &e,
04842     const XrlAtomList* arg_neighbors,
04843         XrlRespCallback);
04844 #endif
04845 
04846     XrlCmdRT handle_olsr4_0_1_get_neighbor_info(const XrlArgs& in, XrlCmdOT out);
04847 #ifdef XORP_ENABLE_ASYNC_SERVER
04848     void callback_olsr4_0_1_get_neighbor_info
04849        (const XrlCmdError &e,
04850     const IPv4* arg_main_addr,
04851     const uint32_t* arg_willingness,
04852     const uint32_t* arg_degree,
04853     const uint32_t* arg_link_count,
04854     const uint32_t* arg_twohop_link_count,
04855     const bool* arg_is_advertised,
04856     const bool* arg_is_sym,
04857     const bool* arg_is_mpr,
04858     const bool* arg_is_mpr_selector,
04859         XrlRespCallback);
04860 #endif
04861 
04862     XrlCmdRT handle_olsr4_0_1_get_twohop_link_list(const XrlArgs& in, XrlCmdOT out);
04863 #ifdef XORP_ENABLE_ASYNC_SERVER
04864     void callback_olsr4_0_1_get_twohop_link_list
04865        (const XrlCmdError &e,
04866     const XrlAtomList* arg_twohop_links,
04867         XrlRespCallback);
04868 #endif
04869 
04870     XrlCmdRT handle_olsr4_0_1_get_twohop_link_info(const XrlArgs& in, XrlCmdOT out);
04871 #ifdef XORP_ENABLE_ASYNC_SERVER
04872     void callback_olsr4_0_1_get_twohop_link_info
04873        (const XrlCmdError &e,
04874     const uint32_t* arg_last_face_id,
04875     const IPv4* arg_nexthop_addr,
04876     const IPv4* arg_dest_addr,
04877     const uint32_t* arg_hold_time,
04878         XrlRespCallback);
04879 #endif
04880 
04881     XrlCmdRT handle_olsr4_0_1_get_twohop_neighbor_list(const XrlArgs& in, XrlCmdOT out);
04882 #ifdef XORP_ENABLE_ASYNC_SERVER
04883     void callback_olsr4_0_1_get_twohop_neighbor_list
04884        (const XrlCmdError &e,
04885     const XrlAtomList* arg_twohop_neighbors,
04886         XrlRespCallback);
04887 #endif
04888 
04889     XrlCmdRT handle_olsr4_0_1_get_twohop_neighbor_info(const XrlArgs& in, XrlCmdOT out);
04890 #ifdef XORP_ENABLE_ASYNC_SERVER
04891     void callback_olsr4_0_1_get_twohop_neighbor_info
04892        (const XrlCmdError &e,
04893     const IPv4* arg_main_addr,
04894     const bool* arg_is_strict,
04895     const uint32_t* arg_link_count,
04896     const uint32_t* arg_reachability,
04897     const uint32_t* arg_coverage,
04898         XrlRespCallback);
04899 #endif
04900 
04901     XrlCmdRT handle_olsr4_0_1_get_mid_entry_list(const XrlArgs& in, XrlCmdOT out);
04902 #ifdef XORP_ENABLE_ASYNC_SERVER
04903     void callback_olsr4_0_1_get_mid_entry_list
04904        (const XrlCmdError &e,
04905     const XrlAtomList* arg_mid_entries,
04906         XrlRespCallback);
04907 #endif
04908 
04909     XrlCmdRT handle_olsr4_0_1_get_mid_entry(const XrlArgs& in, XrlCmdOT out);
04910 #ifdef XORP_ENABLE_ASYNC_SERVER
04911     void callback_olsr4_0_1_get_mid_entry
04912        (const XrlCmdError &e,
04913     const IPv4* arg_main_addr,
04914     const IPv4* arg_iface_addr,
04915     const uint32_t* arg_distance,
04916     const uint32_t* arg_hold_time,
04917         XrlRespCallback);
04918 #endif
04919 
04920     XrlCmdRT handle_olsr4_0_1_get_tc_entry_list(const XrlArgs& in, XrlCmdOT out);
04921 #ifdef XORP_ENABLE_ASYNC_SERVER
04922     void callback_olsr4_0_1_get_tc_entry_list
04923        (const XrlCmdError &e,
04924     const XrlAtomList* arg_tc_entries,
04925         XrlRespCallback);
04926 #endif
04927 
04928     XrlCmdRT handle_olsr4_0_1_get_tc_entry(const XrlArgs& in, XrlCmdOT out);
04929 #ifdef XORP_ENABLE_ASYNC_SERVER
04930     void callback_olsr4_0_1_get_tc_entry
04931        (const XrlCmdError &e,
04932     const IPv4* arg_destination,
04933     const IPv4* arg_lasthop,
04934     const uint32_t* arg_distance,
04935     const uint32_t* arg_seqno,
04936     const uint32_t* arg_hold_time,
04937         XrlRespCallback);
04938 #endif
04939 
04940     XrlCmdRT handle_olsr4_0_1_get_hna_entry_list(const XrlArgs& in, XrlCmdOT out);
04941 #ifdef XORP_ENABLE_ASYNC_SERVER
04942     void callback_olsr4_0_1_get_hna_entry_list
04943        (const XrlCmdError &e,
04944     const XrlAtomList* arg_hna_entries,
04945         XrlRespCallback);
04946 #endif
04947 
04948     XrlCmdRT handle_olsr4_0_1_get_hna_entry(const XrlArgs& in, XrlCmdOT out);
04949 #ifdef XORP_ENABLE_ASYNC_SERVER
04950     void callback_olsr4_0_1_get_hna_entry
04951        (const XrlCmdError &e,
04952     const IPv4Net* arg_destination,
04953     const IPv4* arg_lasthop,
04954     const uint32_t* arg_distance,
04955     const uint32_t* arg_hold_time,
04956         XrlRespCallback);
04957 #endif
04958 
04959     void add_handlers();
04960     void remove_handlers();
04961 
04962     struct handler_table {
04963         const char *name;
04964         XrlCmdRT (XrlOlsr4TargetBase::*method)(const XrlArgs&, XrlCmdOT);
04965     };
04966 
04967     static const struct handler_table handlers[];
04968     static const size_t num_handlers;
04969 };
04970 
04971 #endif // __XRL_TARGETS_OLSR4_BASE_HH__
 All Classes Namespaces Functions Variables Typedefs Enumerations