extras/vom/vom/prefix.hpp

   1 /*
   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:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   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.
  14  */
  15
  16 #ifndef __VOM_PREFIX_H__
  17 #define __VOM_PREFIX_H__
  18
  19 #include "vom/enum_base.hpp"
  20 #include <boost/asio/ip/address.hpp>
  21
  22 namespace VOM {
  23 /**
  24  * Types belonging to Routing
  25  */
  26
  27 /**
  28  * A next-hop protocol describes the protocol of a peer to which packets
  29  * are sent after matching a route.
  30  */
  31 class nh_proto_t : public enum_base<nh_proto_t>
  32 {
  33 public:
  34   const static nh_proto_t IPV4;
  35   const static nh_proto_t IPV6;
  36   const static nh_proto_t MPLS;
  37   const static nh_proto_t ETHERNET;
  38
  39   static const nh_proto_t& from_address(const boost::asio::ip::address& addr);
  40
  41 private:
  42   /**
  43    * Private constructor taking the value and the string name
  44    */
  45   nh_proto_t(int v, const std::string& s);
  46 };
  47
  48 /**
  49  * An L3 protocol can be used to construct a prefix that is used
  50  * to match packets are part of a route.
  51  */
  52 class l3_proto_t : public enum_base<l3_proto_t>
  53 {
  54 public:
  55   const static l3_proto_t IPV4;
  56   const static l3_proto_t IPV6;
  57   const static l3_proto_t MPLS;
  58
  59   bool is_ipv4();
  60   bool is_ipv6();
  61
  62   static const l3_proto_t& from_address(const boost::asio::ip::address& addr);
  63
  64   const nh_proto_t& to_nh_proto() const;
  65
  66 private:
  67   /**
  68    * Private constructor taking the value and the string name
  69    */
  70   l3_proto_t(int v, const std::string& s);
  71 };
  72
  73 /**
  74  * Ostream output for l3_proto_t
  75  */
  76 std::ostream& operator<<(std::ostream& os, const l3_proto_t& l3p);
  77
  78 namespace route {
  79 /**
  80  * type def the table-id
  81  */
  82 typedef uint32_t table_id_t;
  83
  84 /**
  85  * The table-id for the default table
  86  */
  87 const static table_id_t DEFAULT_TABLE = 0;
  88
  89 /**
  90  * A prefix defintion. Address + length
  91  */
  92 class prefix_t
  93 {
  94 public:
  95   /**
  96    * Default Constructor - creates ::/0
  97    */
  98   prefix_t();
  99   /**
 100    * Constructor with address and length
 101    */
 102   prefix_t(const boost::asio::ip::address& addr, uint8_t len);
 103   /**
 104    * Constructor with just the address, this creates a
 105    * host prefix
 106    */
 107   prefix_t(const boost::asio::ip::address& addr);
 108
 109   /**
 110    * Constructor with string and length
 111    */
 112   prefix_t(const std::string& s, uint8_t len);
 113
 114   /**
 115    * Copy Constructor
 116    */
 117   prefix_t(const prefix_t&);
 118
 119   /**
 120    * Constructor with VPP API prefix representation
 121    */
 122   prefix_t(uint8_t is_ip6, uint8_t* addr, uint8_t len);
 123   /**
 124    * Destructor
 125    */
 126   ~prefix_t();
 127
 128   /**
 129    * Get the address
 130    */
 131   const boost::asio::ip::address& address() const;
 132
 133   /**
 134    * Get the network mask width
 135    */
 136   uint8_t mask_width() const;
 137
 138   /**
 139    * Assignement
 140    */
 141   prefix_t& operator=(const prefix_t&);
 142
 143   /**
 144    * Less than operator
 145    */
 146   bool operator<(const prefix_t& o) const;
 147
 148   /**
 149    * equals operator
 150    */
 151   bool operator==(const prefix_t& o) const;
 152
 153   /**
 154    * not equal opartor
 155    */
 156   bool operator!=(const prefix_t& o) const;
 157
 158   /**
 159    * convert to string format for debug purposes
 160    */
 161   std::string to_string() const;
 162
 163   /**
 164    * The all Zeros prefix
 165    */
 166   const static prefix_t ZERO;
 167
 168   /**
 169    * The all Zeros v6 prefix
 170    */
 171   const static prefix_t ZEROv6;
 172
 173   /**
 174   * Convert the prefix into VPP API parameters
 175   */
 176   void to_vpp(uint8_t* is_ip6, uint8_t* addr, uint8_t* len) const;
 177
 178   /**
 179    * Return a address representation of the mask, e.g. 255.255.0.0
 180    */
 181   boost::asio::ip::address mask() const;
 182
 183   /**
 184    * get the lowest address in the prefix
 185    */
 186   prefix_t low() const;
 187
 188   /**
 189    * Get the highest address in the prefix
 190    */
 191   prefix_t high() const;
 192
 193   /**
 194    * Get the L3 protocol
 195    */
 196   l3_proto_t l3_proto() const;
 197
 198 private:
 199   /**
 200    * The address
 201    */
 202   boost::asio::ip::address m_addr;
 203
 204   /**
 205    * The prefix length
 206    */
 207   uint8_t m_len;
 208 };
 209
 210 /**
 211 * A prefix defintion. Address + length
 212 */
 213 class mprefix_t
 214 {
 215 public:
 216   /**
 217    * Default Constructor - creates ::/0
 218    */
 219   mprefix_t();
 220   /**
 221    * Constructor for (S,G)
 222    */
 223   mprefix_t(const boost::asio::ip::address& saddr,
 224             const boost::asio::ip::address& gaddr);
 225   /*
 226    * Constructor for (*,G)
 227    */
 228   mprefix_t(const boost::asio::ip::address& gaddr);
 229
 230   /*
 231    * Constructor for (*,G/n)
 232    */
 233   mprefix_t(const boost::asio::ip::address& gaddr, uint8_t len);
 234
 235   /**
 236 *Constructor for (S,G)
 237 */
 238   mprefix_t(const boost::asio::ip::address& saddr,
 239             const boost::asio::ip::address& gaddr,
 240             uint16_t len);
 241
 242   /**
 243    * Copy Constructor
 244    */
 245   mprefix_t(const mprefix_t&);
 246
 247   /**
 248    * Destructor
 249    */
 250   ~mprefix_t();
 251
 252   /**
 253    * Get the address
 254    */
 255   const boost::asio::ip::address& grp_address() const;
 256   const boost::asio::ip::address& src_address() const;
 257
 258   /**
 259    * Get the network mask width
 260    */
 261   uint8_t mask_width() const;
 262
 263   /**
 264    * Assignement
 265    */
 266   mprefix_t& operator=(const mprefix_t&);
 267
 268   /**
 269    * Less than operator
 270    */
 271   bool operator<(const mprefix_t& o) const;
 272
 273   /**
 274    * equals operator
 275    */
 276   bool operator==(const mprefix_t& o) const;
 277
 278   /**
 279    * not equal opartor
 280    */
 281   bool operator!=(const mprefix_t& o) const;
 282
 283   /**
 284    * convert to string format for debug purposes
 285    */
 286   std::string to_string() const;
 287
 288   /**
 289    * The all Zeros prefix
 290    */
 291   const static mprefix_t ZERO;
 292
 293   /**
 294    * The all Zeros v6 prefix
 295    */
 296   const static mprefix_t ZEROv6;
 297
 298   /**
 299    * Get the L3 protocol
 300    */
 301   l3_proto_t l3_proto() const;
 302
 303   void to_vpp(uint8_t* is_ip6,
 304               uint8_t* saddr,
 305               uint8_t* gaddr,
 306               uint16_t* len) const;
 307
 308 private:
 309   /**
 310    * The address
 311    */
 312   boost::asio::ip::address m_gaddr;
 313   boost::asio::ip::address m_saddr;
 314
 315   /**
 316    * The prefix length
 317    */
 318   uint8_t m_len;
 319 };
 320
 321 }; // namespace route
 322
 323 boost::asio::ip::address_v4 operator|(const boost::asio::ip::address_v4& addr1,
 324                                       const boost::asio::ip::address_v4& addr2);
 325
 326 boost::asio::ip::address_v4 operator&(const boost::asio::ip::address_v4& addr1,
 327                                       const boost::asio::ip::address_v4& addr2);
 328
 329 boost::asio::ip::address_v4 operator~(const boost::asio::ip::address_v4& addr1);
 330
 331 boost::asio::ip::address_v6 operator|(const boost::asio::ip::address_v6& addr1,
 332                                       const boost::asio::ip::address_v6& addr2);
 333
 334 boost::asio::ip::address_v6 operator&(const boost::asio::ip::address_v6& addr1,
 335                                       const boost::asio::ip::address_v6& addr2);
 336
 337 boost::asio::ip::address_v6 operator~(const boost::asio::ip::address_v6& addr1);
 338
 339 boost::asio::ip::address operator|(const boost::asio::ip::address& addr1,
 340                                    const boost::asio::ip::address& addr2);
 341
 342 boost::asio::ip::address operator&(const boost::asio::ip::address& addr1,
 343                                    const boost::asio::ip::address& addr2);
 344
 345 boost::asio::ip::address operator~(const boost::asio::ip::address& addr1);
 346
 347 /**
 348  * Ostream printer for prefix_t
 349  */
 350 std::ostream& operator<<(std::ostream& os, const route::prefix_t& pfx);
 351
 352 /**
 353  * Convert a boost address into a VPP bytes string
 354  */
 355 void to_bytes(const boost::asio::ip::address& addr,
 356               uint8_t* is_ip6,
 357               uint8_t* array);
 358 void to_bytes(const boost::asio::ip::address_v4& addr, uint8_t* array);
 359 void to_bytes(const boost::asio::ip::address_v6& addr, uint8_t* array);
 360
 361 /**
 362  * Get the prefix mask length of a host route from the boost address
 363  */
 364 uint32_t mask_width(const boost::asio::ip::address& addr);
 365
 366 /**
 367  * Convert a VPP byte stinrg into a boost addresss
 368  */
 369 boost::asio::ip::address from_bytes(uint8_t is_ip6, const uint8_t* array);
 370 };
 371
 372 /*
 373  * fd.io coding-style-patch-verification: ON
 374  *
 375  * Local Variables:
 376  * eval: (c-set-style "mozilla")
 377  * End:
 378  */
 379
 380 #endif