2 * Copyright (c) 2017 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
16 #ifndef __VOM_ROUTE_H__
17 #define __VOM_ROUTE_H__
19 #include "vom/interface.hpp"
20 #include "vom/prefix.hpp"
21 #include "vom/route_domain.hpp"
22 #include "vom/singular_db.hpp"
26 * Types belonging to Routing
30 * A path for IP or MPLS routes
38 class special_t : public enum_base<special_t>
42 * A standard path type. this includes path types
43 * that use the next-hop and interface
45 const static special_t STANDARD;
48 * A local/for-us/recieve
50 const static special_t LOCAL;
55 const static special_t DROP;
58 * a path will return ICMP unreachables
60 const static special_t UNREACH;
63 * a path will return ICMP prohibit
65 const static special_t PROHIBIT;
69 * Private constructor taking the value and the string name
71 special_t(int v, const std::string& s);
77 class flags_t : public enum_base<flags_t>
83 const static flags_t NONE;
86 * A path that resolves via a DVR next-hop
88 const static flags_t DVR;
92 * Private constructor taking the value and the string name
94 flags_t(int v, const std::string& s);
98 * constructor for special paths
100 path(special_t special, const nh_proto_t& proto = nh_proto_t::IPV4);
103 * Constructor for standard non-recursive paths
105 path(const boost::asio::ip::address& nh,
106 const interface& interface,
108 uint8_t preference = 0);
111 * Constructor for standard recursive paths
113 path(const route_domain& rd,
114 const boost::asio::ip::address& nh,
116 uint8_t preference = 0);
119 * Constructor for DVR paths or attached paths.
121 path(const interface& interface,
122 const nh_proto_t& proto,
123 const flags_t& flags = flags_t::NONE,
125 uint8_t preference = 0);
138 * comparison operator
140 bool operator==(const path& p) const;
143 * Less than operator for set insertion
145 bool operator<(const path& p) const;
148 * convert to string format for debug purposes
150 std::string to_string() const;
155 special_t type() const;
156 nh_proto_t nh_proto() const;
157 flags_t flags() const;
158 const boost::asio::ip::address& nh() const;
159 std::shared_ptr<route_domain> rd() const;
160 std::shared_ptr<interface> itf() const;
161 uint8_t weight() const;
162 uint8_t preference() const;
166 * The special path tpye
171 * The next-hop protocol
173 nh_proto_t m_nh_proto;
183 boost::asio::ip::address m_nh;
186 * For recursive routes, this is the table in which the
187 * the next-hop exists.
189 std::shared_ptr<route_domain> m_rd;
192 * The next-hop interface [if present].
194 std::shared_ptr<interface> m_interface;
204 uint8_t m_preference;
207 class itf_flags_t : public enum_base<itf_flags_t>
210 const static itf_flags_t NONE;
212 * Path is accepting multicast traffic
214 const static itf_flags_t ACCEPT;
217 * A local/for-us/recieve
219 const static itf_flags_t FORWARD;
223 * Private constructor taking the value and the string name
225 itf_flags_t(int v, const std::string& s);
229 * A path-list is a set of paths
231 typedef std::set<path> path_list_t;
234 * A mpath-list is a set of paths and interface flags
236 typedef std::set<std::pair<path, itf_flags_t>> mpath_list_t;
239 * ostream output for iterator
241 std::ostream& operator<<(std::ostream& os, const path_list_t& path_list);
242 std::ostream& operator<<(std::ostream& os, const mpath_list_t& path_list);
247 class ip_route : public object_base
251 * The key for a route
253 typedef std::pair<route::table_id_t, prefix_t> key_t;
256 * Construct a route in the default table
258 ip_route(const prefix_t& prefix);
261 * Construct a route with a path
263 ip_route(const prefix_t& prefix, const path& p);
268 ip_route(const ip_route& r);
271 * Construct a route in the given route domain
273 ip_route(const route_domain& rd, const prefix_t& prefix);
276 * Construct a route in the given route domain with a path
278 ip_route(const route_domain& rd, const prefix_t& prefix, const path& p);
286 * Get the route's key
288 const key_t key() const;
291 * Comparison operator
293 bool operator==(const ip_route& i) const;
296 * Return the matching 'singular instance'
298 std::shared_ptr<ip_route> singular() const;
303 void add(const path& path);
308 void remove(const path& path);
311 * Find the instnace of the route domain in the OM
313 static std::shared_ptr<ip_route> find(const ip_route& temp);
316 * Dump all route-doamin into the stream provided
318 static void dump(std::ostream& os);
321 * replay the object to create it in hardware
326 * Convert to string for debugging
328 std::string to_string() const;
331 * Return the matching 'singular instance'
333 static std::shared_ptr<ip_route> find(const key_t& k);
337 * Class definition for listeners to OM events
339 class event_handler : public OM::listener, public inspect::command_handler
343 virtual ~event_handler() = default;
346 * Handle a populate event
348 void handle_populate(const client_db::key_t& key);
351 * Handle a replay event
353 void handle_replay();
356 * Show the object in the Singular DB
358 void show(std::ostream& os);
361 * Get the sortable Id of the listener
363 dependency_t order() const;
367 * event_handler to register with OM
369 static event_handler m_evh;
372 * Find or add the instnace of the route domain in the OM
374 static std::shared_ptr<ip_route> find_or_add(const ip_route& temp);
377 * It's the OM class that updates the objects in HW
379 friend class VOM::OM;
382 * It's the singular_db class that calls replay()
384 friend class singular_db<key_t, ip_route>;
387 * Commit the acculmulated changes into VPP. i.e. to a 'HW" write.
389 void update(const ip_route& obj);
392 * Sweep/reap the object if still stale
397 * HW configuration for the result of creating the route
399 HW::item<handle_t> m_hw;
402 * The route domain the route is in.
404 std::shared_ptr<route_domain> m_rd;
407 * The prefix to match
417 * A map of all routes
419 static singular_db<key_t, ip_route> m_db;
423 * A IP multicast route
425 class ip_mroute : public object_base
429 * The key for a route
431 typedef std::pair<route::table_id_t, mprefix_t> key_t;
434 * Construct a route in the default table
436 ip_mroute(const mprefix_t& mprefix);
441 ip_mroute(const ip_mroute& r);
444 * Construct a route in the given route domain
446 ip_mroute(const route_domain& rd, const mprefix_t& mprefix);
454 * Get the route's key
456 const key_t key() const;
459 * Comparison operator
461 bool operator==(const ip_mroute& i) const;
464 * Return the matching 'singular instance'
466 std::shared_ptr<ip_mroute> singular() const;
469 * Find the instnace of the route domain in the OM
471 static std::shared_ptr<ip_mroute> find(const ip_mroute& temp);
474 * Dump all route-doamin into the stream provided
476 static void dump(std::ostream& os);
479 * replay the object to create it in hardware
484 * Convert to string for debugging
486 std::string to_string() const;
489 * Return the matching 'singular instance'
491 static std::shared_ptr<ip_mroute> find(const key_t& k);
493 void add(const path& path, const itf_flags_t& flag);
497 * Class definition for listeners to OM events
499 class event_handler : public OM::listener, public inspect::command_handler
503 virtual ~event_handler() = default;
506 * Handle a populate event
508 void handle_populate(const client_db::key_t& key);
511 * Handle a replay event
513 void handle_replay();
516 * Show the object in the Singular DB
518 void show(std::ostream& os);
521 * Get the sortable Id of the listener
523 dependency_t order() const;
527 * event_handler to register with OM
529 static event_handler m_evh;
532 * Find or add the instnace of the route domain in the OM
534 static std::shared_ptr<ip_mroute> find_or_add(const ip_mroute& temp);
537 * It's the OM class that updates the objects in HW
539 friend class VOM::OM;
542 * It's the singular_db class that calls replay()
544 friend class singular_db<key_t, ip_mroute>;
547 * Commit the acculmulated changes into VPP. i.e. to a 'HW" write.
549 void update(const ip_mroute& obj);
552 * Sweep/reap the object if still stale
557 * HW configuration for the result of creating the route
562 * The route domain the route is in.
564 std::shared_ptr<route_domain> m_rd;
567 * The mprefix to match
574 mpath_list_t m_paths;
577 * A map of all routes
579 static singular_db<key_t, ip_mroute> m_db;
582 std::ostream& operator<<(std::ostream& os, const ip_route::key_t& key);
583 std::ostream& operator<<(std::ostream& os, const ip_mroute::key_t& key);
584 }; // namespace route
588 * fd.io coding-style-patch-verification: ON
591 * eval: (c-set-style "mozilla")