diff -r 000000000000 -r 2b3e5ec03512 servlib/routing/TcaRouter.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/servlib/routing/TcaRouter.h Thu Apr 21 14:57:45 2011 +0100 @@ -0,0 +1,160 @@ +/* + * Copyright 2005-2006 University of Waterloo + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#ifndef _TCA_ROUTER_H_ +#define _TCA_ROUTER_H_ + +#include "naming/EndpointID.h" +#include "TableBasedRouter.h" + +#define SERVLIB 1 +//#include "TcaTypes.h" +#include "TcaEndpointID.h" +#include "TcaControlBundle.h" + + +namespace dtn { + + +/** + * This is the implementation of the TCA bundle routing algorithm. + * + * A TCARouter is a specialized TableBasedRouter where the route + * table is manipulated in response to certain control bundles + * (for example, a "register" bundle, or a "change-of-address" bundle). + * Specialized routing logic is then applied in order to route late-bound + * bundles addressed to a mobile node, to the mobile's current location + * in the network. + * + * The main interface point is the overridden handle_bundle_received + * function which tests for the special TCA bundles (control bundles and + * late-bound data bundles). + * + */ + +class TcaRouter : public TableBasedRouter { + +public: + + enum Role { TCA_MOBILE, TCA_ROUTER, TCA_GATEWAY }; + + // Internal bundle-forwarding rule. + // This mostly has to do with how to treat the default route + // (UDR = "Use Default Route"). + enum ForwardingRule { + FWD_NEVER, // do not forward, ever + FWD_UDR_EXCLUSIVELY, // forward (only) to the default route + FWD_UDR_NEVER, // fwd to matching, except default route + FWD_UDR_IFNECESSARY, // fwd to matching, using default route iff + // no other matches + FWD_UDR_ALWAYS // forward to matching, including default route + }; + + TcaRouter(Role role); + +protected: + + Role role_; + + TcaEndpointID admin_app_; // eid of local admin application + + std::string get_role_str() const; + + // BundleEventHandler functions to handle events important to TCA. + virtual void handle_bundle_received(BundleReceivedEvent* event); + virtual void handle_bundle_transmitted(BundleTransmittedEvent* event); + virtual void handle_contact_up(ContactUpEvent* event); + virtual void handle_contact_down(ContactDownEvent* event); + virtual void handle_link_available(LinkAvailableEvent* event); + virtual void handle_link_unavailable(LinkUnavailableEvent* event); + virtual void handle_shutdown_request(ShutdownRequest* event); + + // fwd function to broadcast a bundle to everybody in the route table + virtual int fwd_to_all(Bundle* bundle); + + virtual int fwd_to_matching(Bundle* bundle, const LinkRef& next_hop); + virtual int fwd_to_matching(Bundle* bundle) { + LinkRef link("TcaRouter::fwd_to_matching: null"); + return fwd_to_matching(bundle, link); + } + + // fwd function with special forwarding rules for default route + // used for forwarding unbound tca bundles and some tca control bundles + virtual int fwd_to_matching_r(Bundle* bundle, const LinkRef& next_hop, + ForwardingRule fwd_rule); + + bool on_coa_transmitted(Bundle* b, const TcaControlBundle& cb); + bool on_ask_transmitted(Bundle* b, const TcaControlBundle& cb); + bool on_adv_transmitted(Bundle* b, const TcaControlBundle& cb); + + // special control bundle handlers + bool handle_register(Bundle* b); + bool handle_coa(Bundle* b); + + // handle bundle sent to anonymous address + bool handle_anonymous_bundle(Bundle* b); + + bool handle_ask(Bundle* b, const TcaControlBundle& cb); + + // handle control bundles addressed to bundlelayer + bool handle_bl_control_bundle(Bundle* b); + + bool handle_bl_ask(Bundle* b, const TcaControlBundle& cb); + bool handle_get_routes(Bundle* b, const TcaControlBundle& cb); + bool handle_add_route(Bundle* b, const TcaControlBundle& cb); + bool handle_del_route(Bundle* b, const TcaControlBundle& cb); + + // handle regular late-bound tca data bundle + bool handle_tca_unbound_bundle(Bundle* bundle); + + bool on_route_unbound_bundle(Bundle* bundle); + bool on_gate_unbound_bundle(Bundle* bundle); + + // did the bundle originate at this node? + bool is_local_source(Bundle* b); + + ForwardingRule get_forwarding_rule(Bundle* b); + + // create a link entry for the given address + LinkRef create_link(const std::string& link_addr); + + // create a route entry for the given endpoint pattern, specified link + RouteEntry* create_route(const std::string& pattern, const LinkRef& p_link); + + // create a route *and link* if necessary, for the given endpoint pattern, + // given link address + bool create_route(const std::string& pattern, + const std::string& link_addr); + + // Ultra-simplified helper function to inject a new bundle into + // the works, using defaults for most fields. + // Specify empty src for bundlelayer + bool post_bundle(const EndpointID& src, const EndpointID& dest, + const std::string& payload); + + // Ultra-simplified helper function to post a wrapped bundle to the + // admin app. This is in lieu of a WrappedBundle class. + bool push_wrapped_bundle(const std::string& code, + const EndpointID& src, + const EndpointID& dest, + const std::string& bsp); + +}; + +} // namespace dtn + +#endif /* _TCA_ROUTER_H_ */