extras/vom/vom/nat_binding_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/nat_binding_cmds.hpp"
  17
  18 namespace VOM {
  19 namespace nat_binding_cmds {
  20 bind_44_input_cmd::bind_44_input_cmd(HW::item<bool>& item,
  21                                      const handle_t& itf,
  22                                      const nat_binding::zone_t& zone)
  23   : rpc_cmd(item)
  24   , m_itf(itf)
  25   , m_zone(zone)
  26 {
  27 }
  28
  29 bool
  30 bind_44_input_cmd::operator==(const bind_44_input_cmd& other) const
  31 {
  32   return ((m_itf == other.m_itf) && (m_zone == other.m_zone));
  33 }
  34
  35 rc_t
  36 bind_44_input_cmd::issue(connection& con)
  37 {
  38   msg_t req(con.ctx(), std::ref(*this));
  39
  40   auto& payload = req.get_request().get_payload();
  41   payload.is_add = 1;
  42   payload.is_inside = (nat_binding::zone_t::INSIDE == m_zone ? 1 : 0);
  43   payload.sw_if_index = m_itf.value();
  44
  45   VAPI_CALL(req.execute());
  46
  47   m_hw_item.set(wait());
  48
  49   return rc_t::OK;
  50 }
  51
  52 std::string
  53 bind_44_input_cmd::to_string() const
  54 {
  55   std::ostringstream s;
  56   s << "nat-44-input-binding-create: " << m_hw_item.to_string()
  57     << " itf:" << m_itf << " " << m_zone.to_string();
  58
  59   return (s.str());
  60 }
  61
  62 unbind_44_input_cmd::unbind_44_input_cmd(HW::item<bool>& item,
  63                                          const handle_t& itf,
  64                                          const nat_binding::zone_t& zone)
  65   : rpc_cmd(item)
  66   , m_itf(itf)
  67   , m_zone(zone)
  68 {
  69 }
  70
  71 bool
  72 unbind_44_input_cmd::operator==(const unbind_44_input_cmd& other) const
  73 {
  74   return ((m_itf == other.m_itf) && (m_zone == other.m_zone));
  75 }
  76
  77 rc_t
  78 unbind_44_input_cmd::issue(connection& con)
  79 {
  80   msg_t req(con.ctx(), std::ref(*this));
  81
  82   auto& payload = req.get_request().get_payload();
  83   payload.is_add = 0;
  84   payload.is_inside = (nat_binding::zone_t::INSIDE == m_zone ? 1 : 0);
  85   payload.sw_if_index = m_itf.value();
  86
  87   VAPI_CALL(req.execute());
  88
  89   m_hw_item.set(wait());
  90
  91   return rc_t::OK;
  92 }
  93
  94 std::string
  95 unbind_44_input_cmd::to_string() const
  96 {
  97   std::ostringstream s;
  98   s << "nat-44-input-binding-create: " << m_hw_item.to_string()
  99     << " itf:" << m_itf << " " << m_zone.to_string();
 100
 101   return (s.str());
 102 }
 103
 104 bind_44_output_cmd::bind_44_output_cmd(HW::item<bool>& item,
 105                                        const handle_t& itf,
 106                                        const nat_binding::zone_t& zone)
 107   : rpc_cmd(item)
 108   , m_itf(itf)
 109   , m_zone(zone)
 110 {
 111 }
 112
 113 bool
 114 bind_44_output_cmd::operator==(const bind_44_output_cmd& other) const
 115 {
 116   return ((m_itf == other.m_itf) && (m_zone == other.m_zone));
 117 }
 118
 119 rc_t
 120 bind_44_output_cmd::issue(connection& con)
 121 {
 122   msg_t req(con.ctx(), std::ref(*this));
 123
 124   auto& payload = req.get_request().get_payload();
 125   payload.is_add = 1;
 126   payload.is_inside = (nat_binding::zone_t::INSIDE == m_zone ? 1 : 0);
 127   payload.sw_if_index = m_itf.value();
 128
 129   VAPI_CALL(req.execute());
 130
 131   m_hw_item.set(wait());
 132
 133   return rc_t::OK;
 134 }
 135
 136 std::string
 137 bind_44_output_cmd::to_string() const
 138 {
 139   std::ostringstream s;
 140   s << "nat-44-output-binding-create: " << m_hw_item.to_string()
 141     << " itf:" << m_itf << " " << m_zone.to_string();
 142
 143   return (s.str());
 144 }
 145
 146 unbind_44_output_cmd::unbind_44_output_cmd(HW::item<bool>& item,
 147                                            const handle_t& itf,
 148                                            const nat_binding::zone_t& zone)
 149   : rpc_cmd(item)
 150   , m_itf(itf)
 151   , m_zone(zone)
 152 {
 153 }
 154
 155 bool
 156 unbind_44_output_cmd::operator==(const unbind_44_output_cmd& other) const
 157 {
 158   return ((m_itf == other.m_itf) && (m_zone == other.m_zone));
 159 }
 160
 161 rc_t
 162 unbind_44_output_cmd::issue(connection& con)
 163 {
 164   msg_t req(con.ctx(), std::ref(*this));
 165
 166   auto& payload = req.get_request().get_payload();
 167   payload.is_add = 0;
 168   payload.is_inside = (nat_binding::zone_t::INSIDE == m_zone ? 1 : 0);
 169   payload.sw_if_index = m_itf.value();
 170
 171   VAPI_CALL(req.execute());
 172
 173   m_hw_item.set(wait());
 174
 175   return rc_t::OK;
 176 }
 177
 178 std::string
 179 unbind_44_output_cmd::to_string() const
 180 {
 181   std::ostringstream s;
 182   s << "nat-44-output-binding-create: " << m_hw_item.to_string()
 183     << " itf:" << m_itf << " " << m_zone.to_string();
 184
 185   return (s.str());
 186 }
 187
 188 dump_input_44_cmd::dump_input_44_cmd()
 189 {
 190 }
 191
 192 dump_input_44_cmd::dump_input_44_cmd(const dump_input_44_cmd& d)
 193 {
 194 }
 195
 196 bool
 197 dump_input_44_cmd::operator==(const dump_input_44_cmd& other) const
 198 {
 199   return (true);
 200 }
 201
 202 rc_t
 203 dump_input_44_cmd::issue(connection& con)
 204 {
 205   m_dump.reset(new msg_t(con.ctx(), std::ref(*this)));
 206
 207   VAPI_CALL(m_dump->execute());
 208
 209   wait();
 210
 211   return rc_t::OK;
 212 }
 213
 214 std::string
 215 dump_input_44_cmd::to_string() const
 216 {
 217   return ("nat-44-input-binding-dump");
 218 }
 219
 220 dump_output_44_cmd::dump_output_44_cmd()
 221 {
 222 }
 223
 224 dump_output_44_cmd::dump_output_44_cmd(const dump_output_44_cmd& d)
 225 {
 226 }
 227
 228 bool
 229 dump_output_44_cmd::operator==(const dump_output_44_cmd& other) const
 230 {
 231   return (true);
 232 }
 233
 234 rc_t
 235 dump_output_44_cmd::issue(connection& con)
 236 {
 237   m_dump.reset(new msg_t(con.ctx(), std::ref(*this)));
 238
 239   VAPI_CALL(m_dump->execute());
 240
 241   wait();
 242
 243   return rc_t::OK;
 244 }
 245
 246 std::string
 247 dump_output_44_cmd::to_string() const
 248 {
 249   return ("nat-44-output-binding-dump");
 250 }
 251
 252 bind_66_input_cmd::bind_66_input_cmd(HW::item<bool>& item,
 253                                      const handle_t& itf,
 254                                      const nat_binding::zone_t& zone)
 255   : rpc_cmd(item)
 256   , m_itf(itf)
 257   , m_zone(zone)
 258 {
 259 }
 260
 261 bool
 262 bind_66_input_cmd::operator==(const bind_66_input_cmd& other) const
 263 {
 264   return ((m_itf == other.m_itf) && (m_zone == other.m_zone));
 265 }
 266
 267 rc_t
 268 bind_66_input_cmd::issue(connection& con)
 269 {
 270   msg_t req(con.ctx(), std::ref(*this));
 271
 272   auto& payload = req.get_request().get_payload();
 273   payload.is_add = 1;
 274   payload.is_inside = (nat_binding::zone_t::INSIDE == m_zone ? 1 : 0);
 275   payload.sw_if_index = m_itf.value();
 276
 277   VAPI_CALL(req.execute());
 278
 279   m_hw_item.set(wait());
 280
 281   return rc_t::OK;
 282 }
 283
 284 std::string
 285 bind_66_input_cmd::to_string() const
 286 {
 287   std::ostringstream s;
 288   s << "nat-66-input-binding-create: " << m_hw_item.to_string()
 289     << " itf:" << m_itf << " " << m_zone.to_string();
 290
 291   return (s.str());
 292 }
 293
 294 unbind_66_input_cmd::unbind_66_input_cmd(HW::item<bool>& item,
 295                                          const handle_t& itf,
 296                                          const nat_binding::zone_t& zone)
 297   : rpc_cmd(item)
 298   , m_itf(itf)
 299   , m_zone(zone)
 300 {
 301 }
 302
 303 bool
 304 unbind_66_input_cmd::operator==(const unbind_66_input_cmd& other) const
 305 {
 306   return ((m_itf == other.m_itf) && (m_zone == other.m_zone));
 307 }
 308
 309 rc_t
 310 unbind_66_input_cmd::issue(connection& con)
 311 {
 312   msg_t req(con.ctx(), std::ref(*this));
 313
 314   auto& payload = req.get_request().get_payload();
 315   payload.is_add = 0;
 316   payload.is_inside = (nat_binding::zone_t::INSIDE == m_zone ? 1 : 0);
 317   payload.sw_if_index = m_itf.value();
 318
 319   VAPI_CALL(req.execute());
 320
 321   m_hw_item.set(wait());
 322
 323   return rc_t::OK;
 324 }
 325
 326 std::string
 327 unbind_66_input_cmd::to_string() const
 328 {
 329   std::ostringstream s;
 330   s << "nat-66-input-binding-create: " << m_hw_item.to_string()
 331     << " itf:" << m_itf << " " << m_zone.to_string();
 332
 333   return (s.str());
 334 }
 335
 336 dump_input_66_cmd::dump_input_66_cmd()
 337 {
 338 }
 339
 340 dump_input_66_cmd::dump_input_66_cmd(const dump_input_66_cmd& d)
 341 {
 342 }
 343
 344 bool
 345 dump_input_66_cmd::operator==(const dump_input_66_cmd& other) const
 346 {
 347   return (true);
 348 }
 349
 350 rc_t
 351 dump_input_66_cmd::issue(connection& con)
 352 {
 353   m_dump.reset(new msg_t(con.ctx(), std::ref(*this)));
 354
 355   VAPI_CALL(m_dump->execute());
 356
 357   wait();
 358
 359   return rc_t::OK;
 360 }
 361
 362 std::string
 363 dump_input_66_cmd::to_string() const
 364 {
 365   return ("nat-66-input-binding-dump");
 366 }
 367
 368 }; // namespace nat_binding_cmds
 369 }; // namespace VOM
 370
 371 /*
 372  * fd.io coding-style-patch-verification: ON
 373  *
 374  * Local Variables:
 375  * eval: (c-set-style "mozilla")
 376  * End:
 377  */