--- /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_ */