extras/vom/vom/gbp_contract_cmds.cpp

   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 #include "vom/gbp_contract_cmds.hpp"
  17 #include "vom/api_types.hpp"
  18
  19 namespace VOM {
  20 namespace gbp_contract_cmds {
  21
  22 create_cmd::create_cmd(HW::item<uint32_t>& item,
  23                        sclass_t sclass,
  24                        sclass_t dclass,
  25                        const handle_t& acl,
  26                        const gbp_contract::gbp_rules_t& gbp_rules,
  27                        const gbp_contract::ethertype_set_t& allowed_ethertypes)
  28   : rpc_cmd(item)
  29   , m_sclass(sclass)
  30   , m_dclass(dclass)
  31   , m_acl(acl)
  32   , m_gbp_rules(gbp_rules)
  33   , m_allowed_ethertypes(allowed_ethertypes)
  34 {
  35 }
  36
  37 bool
  38 create_cmd::operator==(const create_cmd& other) const
  39 {
  40   return ((m_acl == other.m_acl) && (m_sclass == other.m_sclass) &&
  41           (m_dclass == other.m_dclass) && (m_gbp_rules == other.m_gbp_rules) &&
  42           (m_allowed_ethertypes == other.m_allowed_ethertypes));
  43 }
  44
  45 #define ARRAY_LEN(x) (sizeof(x) / sizeof(x[0]))
  46
  47 rc_t
  48 create_cmd::issue(connection& con)
  49 {
  50   size_t n_rules = m_gbp_rules.size();
  51   uint32_t ii = 0;
  52
  53   msg_t req(con.ctx(), n_rules, std::ref(*this));
  54
  55   auto& payload = req.get_request().get_payload();
  56   payload.is_add = 1;
  57   payload.contract.acl_index = m_acl.value();
  58   payload.contract.sclass = m_sclass;
  59   payload.contract.dclass = m_dclass;
  60   payload.contract.n_rules = n_rules;
  61   payload.contract.n_ether_types = m_allowed_ethertypes.size();
  62
  63   for (auto tt : m_allowed_ethertypes) {
  64     payload.contract.allowed_ethertypes[ii] = tt.value();
  65     ii++;
  66     if (ii == ARRAY_LEN(payload.contract.allowed_ethertypes))
  67       break;
  68   }
  69
  70   ii = 0;
  71   for (auto rule : m_gbp_rules) {
  72     if (rule.action() == gbp_rule::action_t::REDIRECT)
  73       payload.contract.rules[ii].action = GBP_API_RULE_REDIRECT;
  74     else if (rule.action() == gbp_rule::action_t::PERMIT)
  75       payload.contract.rules[ii].action = GBP_API_RULE_PERMIT;
  76     else
  77       payload.contract.rules[ii].action = GBP_API_RULE_DENY;
  78
  79     if (rule.nhs().hash_mode() == gbp_rule::hash_mode_t::SYMMETRIC)
  80       payload.contract.rules[ii].nh_set.hash_mode = GBP_API_HASH_MODE_SYMMETRIC;
  81     else if (rule.nhs().hash_mode() == gbp_rule::hash_mode_t::SRC_IP)
  82       payload.contract.rules[ii].nh_set.hash_mode = GBP_API_HASH_MODE_SRC_IP;
  83     else
  84       payload.contract.rules[ii].nh_set.hash_mode = GBP_API_HASH_MODE_DST_IP;
  85
  86     const gbp_rule::next_hops_t& next_hops = rule.nhs().next_hops();
  87     uint8_t jj = 0, nh_size = (next_hops.size() > 8) ? 8 : next_hops.size();
  88
  89     payload.contract.rules[ii].nh_set.n_nhs = nh_size;
  90     for (auto nh : next_hops) {
  91       to_api(nh.getIp(), payload.contract.rules[ii].nh_set.nhs[jj].ip);
  92       to_api(nh.getMac(), payload.contract.rules[ii].nh_set.nhs[jj].mac);
  93       payload.contract.rules[ii].nh_set.nhs[jj].bd_id = nh.getBdId();
  94       payload.contract.rules[ii].nh_set.nhs[jj].rd_id = nh.getRdId();
  95       jj++;
  96     }
  97     ++ii;
  98   }
  99
 100   VAPI_CALL(req.execute());
 101
 102   return (wait());
 103 }
 104
 105 std::string
 106 create_cmd::to_string() const
 107 {
 108   std::ostringstream s;
 109   s << "gbp-contract-create: " << m_hw_item.to_string()
 110     << " sclass:" << m_sclass << " dclass:" << m_dclass << " acl:" << m_acl;
 111   s << "[ethertype:";
 112   for (auto e : m_allowed_ethertypes)
 113     s << " " << e;
 114   s << "]";
 115
 116   return (s.str());
 117 }
 118
 119 delete_cmd::delete_cmd(HW::item<uint32_t>& item,
 120                        sclass_t sclass,
 121                        sclass_t dclass)
 122   : rpc_cmd(item)
 123   , m_sclass(sclass)
 124   , m_dclass(dclass)
 125 {
 126 }
 127
 128 bool
 129 delete_cmd::operator==(const delete_cmd& other) const
 130 {
 131   return ((m_sclass == other.m_sclass) && (m_dclass == other.m_dclass));
 132 }
 133
 134 rc_t
 135 delete_cmd::issue(connection& con)
 136 {
 137   msg_t req(con.ctx(), 0, std::ref(*this));
 138
 139   auto& payload = req.get_request().get_payload();
 140   payload.is_add = 0;
 141   payload.contract.acl_index = ~0;
 142   payload.contract.sclass = m_sclass;
 143   payload.contract.dclass = m_dclass;
 144
 145   VAPI_CALL(req.execute());
 146
 147   return (wait());
 148 }
 149
 150 std::string
 151 delete_cmd::to_string() const
 152 {
 153   std::ostringstream s;
 154   s << "gbp-contract-delete: " << m_hw_item.to_string()
 155     << " sclass:" << m_sclass << " dclass:" << m_dclass;
 156
 157   return (s.str());
 158 }
 159
 160 bool
 161 dump_cmd::operator==(const dump_cmd& other) const
 162 {
 163   return (true);
 164 }
 165
 166 rc_t
 167 dump_cmd::issue(connection& con)
 168 {
 169   m_dump.reset(new msg_t(con.ctx(), std::ref(*this)));
 170
 171   VAPI_CALL(m_dump->execute());
 172
 173   wait();
 174
 175   return rc_t::OK;
 176 }
 177
 178 std::string
 179 dump_cmd::to_string() const
 180 {
 181   return ("gbp-contract-dump");
 182 }
 183
 184 }; // namespace gbp_contract_cmds
 185 }; // namespace VOM
 186
 187 /*
 188  * fd.io coding-style-patch-verification: ON
 189  *
 190  * Local Variables:
 191  * eval: (c-set-style "mozilla")
 192  * End:
 193  */