extras/vom/vom/dhcp_client.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/dhcp_client.hpp"
  17 #include "vom/dhcp_client_cmds.hpp"
  18 #include "vom/route_api_types.hpp"
  19 #include "vom/singular_db_funcs.hpp"
  20
  21 namespace VOM {
  22 const dhcp_client::state_t dhcp_client::state_t::DISCOVER(0, "discover");
  23 const dhcp_client::state_t dhcp_client::state_t::REQUEST(1, "request");
  24 const dhcp_client::state_t dhcp_client::state_t::BOUND(2, "bound");
  25
  26 dhcp_client::state_t::state_t(int v, const std::string& s)
  27   : enum_base<dhcp_client::state_t>(v, s)
  28 {
  29 }
  30
  31 const dhcp_client::state_t&
  32 dhcp_client::state_t::from_vpp(int n)
  33 {
  34   if (REQUEST == n)
  35     return (REQUEST);
  36   if (BOUND == n)
  37     return (BOUND);
  38
  39   return (DISCOVER);
  40 }
  41
  42 singular_db<interface::key_t, dhcp_client> dhcp_client::m_db;
  43 std::weak_ptr<dhcp_client_cmds::events_cmd> dhcp_client::m_s_event_cmd;
  44 dhcp_client::dhcp_client_listener dhcp_client::m_listener;
  45
  46 dhcp_client::event_handler dhcp_client::m_evh;
  47
  48 dhcp_client::dhcp_client(const interface& itf,
  49                          const std::string& hostname,
  50                          bool set_broadcast_flag,
  51                          const ip_dscp_t& dscp,
  52                          event_listener* ev)
  53   : m_itf(itf.singular())
  54   , m_hostname(hostname)
  55   , m_client_id(l2_address_t::ZERO)
  56   , m_set_broadcast_flag(set_broadcast_flag)
  57   , m_dscp(dscp)
  58   , m_binding(0)
  59   , m_evl(ev)
  60   , m_event_cmd(get_event_cmd())
  61 {
  62 }
  63
  64 dhcp_client::dhcp_client(const interface& itf,
  65                          const std::string& hostname,
  66                          const l2_address_t& client_id,
  67                          bool set_broadcast_flag,
  68                          const ip_dscp_t& dscp,
  69                          event_listener* ev)
  70   : m_itf(itf.singular())
  71   , m_hostname(hostname)
  72   , m_client_id(client_id)
  73   , m_set_broadcast_flag(set_broadcast_flag)
  74   , m_dscp(dscp)
  75   , m_binding(0)
  76   , m_evl(ev)
  77   , m_event_cmd(get_event_cmd())
  78 {
  79 }
  80
  81 dhcp_client::dhcp_client(const dhcp_client& o)
  82   : m_itf(o.m_itf)
  83   , m_hostname(o.m_hostname)
  84   , m_client_id(o.m_client_id)
  85   , m_set_broadcast_flag(o.m_set_broadcast_flag)
  86   , m_dscp(o.m_dscp)
  87   , m_binding(0)
  88   , m_evl(o.m_evl)
  89   , m_event_cmd(o.m_event_cmd)
  90 {
  91 }
  92
  93 dhcp_client::~dhcp_client()
  94 {
  95   sweep();
  96
  97   // not in the DB anymore.
  98   m_db.release(m_itf->key(), this);
  99 }
 100
 101 bool
 102 dhcp_client::operator==(const dhcp_client& l) const
 103 {
 104   return ((key() == l.key()) && (m_hostname == l.m_hostname) &&
 105           (m_client_id == l.m_client_id && m_dscp == l.m_dscp));
 106 }
 107
 108 const dhcp_client::key_t&
 109 dhcp_client::key() const
 110 {
 111   return (m_itf->key());
 112 }
 113
 114 void
 115 dhcp_client::sweep()
 116 {
 117   if (m_binding) {
 118     HW::enqueue(
 119       new dhcp_client_cmds::unbind_cmd(m_binding, m_itf->handle(), m_hostname));
 120   }
 121   HW::write();
 122 }
 123
 124 void
 125 dhcp_client::dump(std::ostream& os)
 126 {
 127   db_dump(m_db, os);
 128 }
 129
 130 void
 131 dhcp_client::replay()
 132 {
 133   if (m_binding) {
 134     HW::enqueue(new dhcp_client_cmds::bind_cmd(
 135       m_binding, m_itf->handle(), m_hostname, m_client_id, false, m_dscp));
 136   }
 137 }
 138
 139 std::string
 140 dhcp_client::to_string() const
 141 {
 142   std::ostringstream s;
 143   s << "DHCP-client: " << m_itf->to_string() << " hostname:" << m_hostname
 144     << " client_id:[" << m_client_id << "] "
 145     << "dscp:" << m_dscp.to_string() << " " << m_binding.to_string();
 146   if (m_lease)
 147     s << " " << m_lease->to_string();
 148   else
 149     s << " no-lease";
 150
 151   return (s.str());
 152 }
 153
 154 void
 155 dhcp_client::update(const dhcp_client& desired)
 156 {
 157   /*
 158    * the desired state is always that the interface should be created
 159    */
 160   if (!m_binding) {
 161     HW::enqueue(new dhcp_client_cmds::bind_cmd(
 162       m_binding, m_itf->handle(), m_hostname, m_client_id, false, m_dscp));
 163   }
 164
 165   if (desired.m_lease)
 166     m_lease = desired.m_lease;
 167   if (m_evl != desired.m_evl) {
 168     m_evl = desired.m_evl;
 169   }
 170 }
 171
 172 const std::shared_ptr<dhcp_client::lease_t>
 173 dhcp_client::lease() const
 174 {
 175   return (m_lease);
 176 }
 177
 178 void
 179 dhcp_client::lease(std::shared_ptr<dhcp_client::lease_t> lease)
 180 {
 181   m_lease = lease;
 182 }
 183
 184 std::shared_ptr<dhcp_client>
 185 dhcp_client::find_or_add(const dhcp_client& temp)
 186 {
 187   return (m_db.find_or_add(temp.m_itf->key(), temp));
 188 }
 189
 190 std::shared_ptr<dhcp_client>
 191 dhcp_client::find(const key_t& k)
 192 {
 193   return (m_db.find(k));
 194 }
 195
 196 std::shared_ptr<dhcp_client>
 197 dhcp_client::singular() const
 198 {
 199   return find_or_add(*this);
 200 }
 201
 202 dhcp_client::lease_t::lease_t()
 203   : state(state_t::DISCOVER)
 204   , mac(mac_address_t::ZERO)
 205 {
 206 }
 207
 208 dhcp_client::lease_t::lease_t(const state_t& state,
 209                               std::shared_ptr<interface> itf,
 210                               const boost::asio::ip::address& router_address,
 211                               const route::prefix_t& host_prefix,
 212                               const std::string& hostname,
 213                               const mac_address_t& mac)
 214   : state(state)
 215   , itf(itf)
 216   , router_address(router_address)
 217   , host_prefix(host_prefix)
 218   , hostname(hostname)
 219   , mac(mac)
 220 {
 221 }
 222
 223 std::string
 224 dhcp_client::lease_t::to_string() const
 225 {
 226   std::stringstream ss;
 227
 228   ss << "lease:[" << itf->to_string() << " state: " << state.to_string()
 229      << " host: " << host_prefix.to_string() << " router: " << router_address
 230      << " mac: " << mac.to_string() << "]";
 231
 232   return (ss.str());
 233 }
 234
 235 dhcp_client::event_listener::event_listener()
 236   : m_status(rc_t::NOOP)
 237 {
 238 }
 239
 240 HW::item<bool>&
 241 dhcp_client::event_listener::status()
 242 {
 243   return (m_status);
 244 }
 245
 246 dhcp_client::event_handler::event_handler()
 247 {
 248   OM::register_listener(this);
 249   inspect::register_handler({ "dhcp" }, "DHCP clients", this);
 250 }
 251
 252 void
 253 dhcp_client::event_handler::handle_replay()
 254 {
 255   m_db.replay();
 256 }
 257
 258 void
 259 dhcp_client::event_handler::handle_populate(const client_db::key_t& key)
 260 {
 261   std::shared_ptr<dhcp_client_cmds::dump_cmd> cmd =
 262     std::make_shared<dhcp_client_cmds::dump_cmd>();
 263
 264   HW::enqueue(cmd);
 265   HW::write();
 266
 267   for (auto& record : *cmd) {
 268     auto& payload = record.get_payload();
 269
 270     std::shared_ptr<interface> itf =
 271       interface::find(payload.client.sw_if_index);
 272
 273     if (!itf) {
 274       VOM_LOG(log_level_t::ERROR) << "dhcp-client dump:"
 275                                   << " itf:" << payload.client.sw_if_index;
 276       continue;
 277     }
 278
 279     const dhcp_client::state_t& s =
 280       dhcp_client::state_t::from_vpp(payload.lease.state);
 281     route::prefix_t pfx(payload.lease.is_ipv6, payload.lease.host_address,
 282                         payload.lease.mask_width);
 283     std::string hostname =
 284       reinterpret_cast<const char*>(payload.lease.hostname);
 285     l2_address_t l2(payload.client.id + 1);
 286     dhcp_client dc(*itf, hostname, l2, payload.client.set_broadcast_flag,
 287                    from_api(payload.client.dscp));
 288     dc.lease(std::make_shared<dhcp_client::lease_t>(
 289       s, itf, from_bytes(0, payload.lease.router_address), pfx, hostname,
 290       mac_address_t(payload.lease.host_mac)));
 291     OM::commit(key, dc);
 292   }
 293 }
 294
 295 dependency_t
 296 dhcp_client::event_handler::order() const
 297 {
 298   return (dependency_t::BINDING);
 299 }
 300
 301 void
 302 dhcp_client::event_handler::show(std::ostream& os)
 303 {
 304   db_dump(m_db, os);
 305 }
 306
 307 std::shared_ptr<dhcp_client_cmds::events_cmd>
 308 dhcp_client::get_event_cmd()
 309 {
 310   if (m_s_event_cmd.expired()) {
 311     std::shared_ptr<dhcp_client_cmds::events_cmd> c =
 312       std::make_shared<dhcp_client_cmds::events_cmd>(m_listener);
 313
 314     m_s_event_cmd = c;
 315
 316     HW::enqueue(c);
 317     HW::write();
 318
 319     return c;
 320   }
 321
 322   return (m_s_event_cmd.lock());
 323 }
 324
 325 void
 326 dhcp_client::handle_dhcp_event(std::shared_ptr<lease_t> lease)
 327 {
 328   m_lease = lease;
 329   if (m_evl)
 330     m_evl->handle_dhcp_event(m_lease);
 331 }
 332
 333 void
 334 dhcp_client::dhcp_client_listener::handle_dhcp_event(std::shared_ptr<lease_t> e)
 335 {
 336   /*
 337    * Find the client the event references
 338    */
 339   std::shared_ptr<dhcp_client> client = find(e->itf->key());
 340
 341   if (client) {
 342     client->handle_dhcp_event(e);
 343   }
 344 }
 345
 346 }; // namespace VOM
 347
 348 /*
 349  * fd.io coding-style-patch-verification: ON
 350  *
 351  * Local Variables:
 352  * eval: (c-set-style "mozilla")
 353  * End:
 354  */