extras/vom/vom/gbp_rule.cpp

   1 /*
   2  * Copyright (c) 2018 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 #include <sstream>
  17
  18 #include "vom/gbp_rule.hpp"
  19
  20 namespace VOM {
  21 gbp_rule::next_hop_t::next_hop_t(const boost::asio::ip::address& ip,
  22                                  const mac_address_t& mac,
  23                                  uint32_t bd_id,
  24                                  uint32_t rd_id)
  25   : m_ip(ip)
  26   , m_mac(mac)
  27   , m_bd_id(bd_id)
  28   , m_rd_id(rd_id)
  29 {
  30 }
  31
  32 std::string
  33 gbp_rule::next_hop_t::to_string() const
  34 {
  35   std::ostringstream s;
  36
  37   s << "["
  38     << "ip:" << m_ip << " mac:" << m_mac.to_string() << " bd:" << m_bd_id
  39     << " rd:" << m_rd_id << "]";
  40
  41   return (s.str());
  42 }
  43
  44 bool
  45 gbp_rule::next_hop_t::operator<(const gbp_rule::next_hop_t& nh) const
  46 {
  47   return (nh.m_ip < m_ip);
  48 }
  49
  50 bool
  51 gbp_rule::next_hop_t::operator==(const gbp_rule::next_hop_t& nh) const
  52 {
  53   return ((m_ip == nh.m_ip) && (m_mac == nh.m_mac) && (m_bd_id == nh.m_bd_id) &&
  54           (m_rd_id == nh.m_rd_id));
  55 }
  56
  57 const boost::asio::ip::address&
  58 gbp_rule::next_hop_t::getIp() const
  59 {
  60   return m_ip;
  61 }
  62
  63 const mac_address_t&
  64 gbp_rule::next_hop_t::getMac() const
  65 {
  66   return m_mac;
  67 }
  68
  69 const uint32_t
  70 gbp_rule::next_hop_t::getBdId() const
  71 {
  72   return m_bd_id;
  73 }
  74
  75 const uint32_t
  76 gbp_rule::next_hop_t::getRdId() const
  77 {
  78   return m_rd_id;
  79 }
  80
  81 const gbp_rule::hash_mode_t gbp_rule::hash_mode_t::SRC_IP(1, "src-ip");
  82 const gbp_rule::hash_mode_t gbp_rule::hash_mode_t::DST_IP(0, "dst-ip");
  83 const gbp_rule::hash_mode_t gbp_rule::hash_mode_t::SYMMETRIC(2, "symmetric");
  84
  85 gbp_rule::hash_mode_t::hash_mode_t(int v, const std::string s)
  86   : enum_base(v, s)
  87 {
  88 }
  89
  90 const gbp_rule::hash_mode_t&
  91 gbp_rule::hash_mode_t::from_int(vapi_enum_gbp_hash_mode i)
  92 {
  93   if (i == GBP_API_HASH_MODE_SYMMETRIC)
  94     return gbp_rule::hash_mode_t::SYMMETRIC;
  95   else if (i == GBP_API_HASH_MODE_SRC_IP)
  96     return gbp_rule::hash_mode_t::SRC_IP;
  97
  98   return gbp_rule::hash_mode_t::DST_IP;
  99 }
 100
 101 gbp_rule::next_hop_set_t::next_hop_set_t(const gbp_rule::hash_mode_t& hm,
 102                                          gbp_rule::next_hops_t& nhs)
 103   : m_hm(hm)
 104   , m_nhs(nhs)
 105 {
 106 }
 107
 108 gbp_rule::next_hop_set_t::next_hop_set_t(const hash_mode_t& hm)
 109   : m_hm(hm)
 110   , m_nhs()
 111 {
 112 }
 113
 114 std::string
 115 gbp_rule::next_hop_set_t::to_string() const
 116 {
 117   std::ostringstream s;
 118
 119   s << "hash-mode:" << m_hm.to_string() << " next-hops:[";
 120   auto it = m_nhs.cbegin();
 121   while (it != m_nhs.cend()) {
 122     s << " " << it->to_string();
 123     ++it;
 124   }
 125   s << " ] next-hop-size:" << m_nhs.size();
 126
 127   return (s.str());
 128 }
 129
 130 bool
 131 gbp_rule::next_hop_set_t::operator==(const next_hop_set_t& nhs) const
 132 {
 133   return ((m_hm == nhs.m_hm) && (m_nhs == nhs.m_nhs));
 134 }
 135
 136 const gbp_rule::hash_mode_t&
 137 gbp_rule::next_hop_set_t::hash_mode() const
 138 {
 139   return m_hm;
 140 }
 141
 142 const gbp_rule::next_hops_t&
 143 gbp_rule::next_hop_set_t::next_hops() const
 144 {
 145   return m_nhs;
 146 }
 147
 148 const gbp_rule::action_t gbp_rule::action_t::REDIRECT(2, "redirect");
 149 const gbp_rule::action_t gbp_rule::action_t::PERMIT(1, "permit");
 150 const gbp_rule::action_t gbp_rule::action_t::DENY(0, "deny");
 151
 152 gbp_rule::action_t::action_t(int v, const std::string s)
 153   : enum_base(v, s)
 154 {
 155 }
 156
 157 const gbp_rule::action_t&
 158 gbp_rule::action_t::from_int(vapi_enum_gbp_rule_action i)
 159 {
 160   if (i == GBP_API_RULE_REDIRECT)
 161     return gbp_rule::action_t::REDIRECT;
 162   else if (i == GBP_API_RULE_PERMIT)
 163     return gbp_rule::action_t::PERMIT;
 164
 165   return gbp_rule::action_t::DENY;
 166 }
 167
 168 gbp_rule::gbp_rule(uint32_t priority,
 169                    const gbp_rule::next_hop_set_t& nhs,
 170                    const gbp_rule::action_t& a)
 171   : m_priority(priority)
 172   , m_nhs(nhs)
 173   , m_action(a)
 174 {
 175 }
 176
 177 gbp_rule::gbp_rule(uint32_t priority, const gbp_rule::action_t& a)
 178   : m_priority(priority)
 179   , m_nhs()
 180   , m_action(a)
 181 {
 182 }
 183
 184 bool
 185 gbp_rule::operator<(const gbp_rule& other) const
 186 {
 187   return (other.m_priority < m_priority);
 188 }
 189
 190 bool
 191 gbp_rule::operator==(const gbp_rule& rule) const
 192 {
 193   return ((m_action == rule.m_action) && (m_nhs == rule.m_nhs) &&
 194           (m_priority == rule.m_priority));
 195 }
 196
 197 std::string
 198 gbp_rule::to_string() const
 199 {
 200   std::ostringstream s;
 201
 202   s << "gbp-rule:["
 203     << "priority:" << m_priority << " action:" << m_action.to_string()
 204     << " next-hop-set:[" << m_nhs.to_string() << "]]";
 205
 206   return (s.str());
 207 }
 208
 209 const gbp_rule::action_t&
 210 gbp_rule::action() const
 211 {
 212   return m_action;
 213 }
 214
 215 const gbp_rule::next_hop_set_t&
 216 gbp_rule::nhs() const
 217 {
 218   return m_nhs;
 219 }
 220 }; // namespace VOM
 221
 222 /*
 223  * fd.io coding-style-patch-verification: ON
 224  *
 225  * Local Variables:
 226  * eval: (c-set-style "mozilla")
 227  * End:
 228  */