ethernet-factory.cpp
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2014-2024, Regents of the University of California,
4  * Arizona Board of Regents,
5  * Colorado State University,
6  * University Pierre & Marie Curie, Sorbonne University,
7  * Washington University in St. Louis,
8  * Beijing Institute of Technology,
9  * The University of Memphis.
10  *
11  * This file is part of NFD (Named Data Networking Forwarding Daemon).
12  * See AUTHORS.md for complete list of NFD authors and contributors.
13  *
14  * NFD is free software: you can redistribute it and/or modify it under the terms
15  * of the GNU General Public License as published by the Free Software Foundation,
16  * either version 3 of the License, or (at your option) any later version.
17  *
18  * NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
19  * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
20  * PURPOSE. See the GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License along with
23  * NFD, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
24  */
25 
26 #include "ethernet-factory.hpp"
27 #include "generic-link-service.hpp"
29 
30 #include <boost/range/adaptors.hpp>
31 #include <boost/range/algorithm/copy.hpp>
32 
33 namespace nfd::face {
34 
35 NFD_LOG_INIT(EthernetFactory);
37 
38 const std::string&
40 {
41  static std::string id("ether");
42  return id;
43 }
44 
46  : ProtocolFactory(params)
47 {
48  m_netifAddConn = netmon->onInterfaceAdded.connect([this] (const auto& netif) {
49  applyUnicastConfigToNetif(netif);
50  applyMcastConfigToNetif(*netif);
51  });
52 }
53 
54 void
55 EthernetFactory::doProcessConfig(OptionalConfigSection configSection,
57 {
58  // ether
59  // {
60  // listen yes
61  // idle_timeout 600
62  // mcast yes
63  // mcast_group 01:00:5E:00:17:AA
64  // mcast_ad_hoc no
65  // whitelist
66  // {
67  // *
68  // }
69  // blacklist
70  // {
71  // }
72  // }
73 
74  UnicastConfig unicastConfig;
75  MulticastConfig mcastConfig;
76 
77  if (configSection) {
78  // listen and mcast default to 'yes' but only if face_system.ether section is present
79  unicastConfig.isEnabled = unicastConfig.wantListen = mcastConfig.isEnabled = true;
80 
81  for (const auto& pair : *configSection) {
82  const std::string& key = pair.first;
83  const ConfigSection& value = pair.second;
84 
85  if (key == "listen") {
86  unicastConfig.wantListen = ConfigFile::parseYesNo(pair, "face_system.ether");
87  }
88  else if (key == "idle_timeout") {
89  unicastConfig.idleTimeout = time::seconds(ConfigFile::parseNumber<uint32_t>(pair, "face_system.ether"));
90  }
91  else if (key == "mcast") {
92  mcastConfig.isEnabled = ConfigFile::parseYesNo(pair, "face_system.ether");
93  }
94  else if (key == "mcast_group") {
95  const std::string& valueStr = value.get_value<std::string>();
96  mcastConfig.group = ethernet::Address::fromString(valueStr);
97  if (mcastConfig.group.isNull()) {
98  NDN_THROW(ConfigFile::Error("face_system.ether.mcast_group: '" +
99  valueStr + "' cannot be parsed as an Ethernet address"));
100  }
101  else if (!mcastConfig.group.isMulticast()) {
102  NDN_THROW(ConfigFile::Error("face_system.ether.mcast_group: '" +
103  valueStr + "' is not a multicast address"));
104  }
105  }
106  else if (key == "mcast_ad_hoc") {
107  bool wantAdHoc = ConfigFile::parseYesNo(pair, "face_system.ether");
108  mcastConfig.linkType = wantAdHoc ? ndn::nfd::LINK_TYPE_AD_HOC : ndn::nfd::LINK_TYPE_MULTI_ACCESS;
109  }
110  else if (key == "whitelist") {
111  mcastConfig.netifPredicate.parseWhitelist(value);
112  }
113  else if (key == "blacklist") {
114  mcastConfig.netifPredicate.parseBlacklist(value);
115  }
116  else {
117  NDN_THROW(ConfigFile::Error("Unrecognized option face_system.ether." + key));
118  }
119  }
120  }
121 
122  if (context.isDryRun) {
123  return;
124  }
125 
126  if (unicastConfig.isEnabled) {
127  if (m_unicastConfig.wantListen && !unicastConfig.wantListen && !m_channels.empty()) {
128  NFD_LOG_WARN("Cannot stop listening on Ethernet channels");
129  }
130  if (m_unicastConfig.idleTimeout != unicastConfig.idleTimeout && !m_channels.empty()) {
131  NFD_LOG_WARN("Idle timeout setting applies to new Ethernet channels only");
132  }
133  }
134  else if (m_unicastConfig.isEnabled && !m_channels.empty()) {
135  NFD_LOG_WARN("Cannot disable Ethernet channels after initialization");
136  }
137 
138  if (m_mcastConfig.isEnabled != mcastConfig.isEnabled) {
139  if (mcastConfig.isEnabled) {
140  NFD_LOG_INFO("enabling multicast on " << mcastConfig.group);
141  }
142  else {
143  NFD_LOG_INFO("disabling multicast");
144  }
145  }
146  else if (mcastConfig.isEnabled) {
147  if (m_mcastConfig.linkType != mcastConfig.linkType && !m_mcastFaces.empty()) {
148  NFD_LOG_WARN("Cannot change ad hoc setting on existing faces");
149  }
150  if (m_mcastConfig.group != mcastConfig.group) {
151  NFD_LOG_INFO("changing multicast group from " << m_mcastConfig.group <<
152  " to " << mcastConfig.group);
153  }
154  if (m_mcastConfig.netifPredicate != mcastConfig.netifPredicate) {
155  NFD_LOG_INFO("changing whitelist/blacklist");
156  }
157  }
158 
159  // Even if there are no configuration changes, we still need to re-apply
160  // the configuration because netifs may have changed.
161  m_unicastConfig = std::move(unicastConfig);
162  m_mcastConfig = std::move(mcastConfig);
163  applyConfig(context);
164 }
165 
166 void
167 EthernetFactory::doCreateFace(const CreateFaceRequest& req,
168  const FaceCreatedCallback& onCreated,
169  const FaceCreationFailedCallback& onFailure)
170 {
171  if (!req.localUri || req.localUri->getScheme() != "dev") {
172  NFD_LOG_TRACE("createFace: dev:// LocalUri required");
173  onFailure(406, "Creation of unicast Ethernet faces requires a LocalUri with dev:// scheme");
174  return;
175  }
176 
177  if (req.params.persistency == ndn::nfd::FACE_PERSISTENCY_ON_DEMAND) {
178  NFD_LOG_TRACE("createFace: unsupported FacePersistency");
179  onFailure(406, "Outgoing Ethernet faces do not support on-demand persistency");
180  return;
181  }
182 
183  ethernet::Address remoteEndpoint(ethernet::Address::fromString(req.remoteUri.getHost()));
184  std::string localEndpoint(req.localUri->getHost());
185 
186  if (remoteEndpoint.isMulticast()) {
187  NFD_LOG_TRACE("createFace: unsupported multicast endpoint");
188  onFailure(406, "Cannot create multicast Ethernet faces");
189  return;
190  }
191 
192  if (req.params.wantLocalFields) {
193  // Ethernet faces are never local
194  NFD_LOG_TRACE("createFace: cannot create non-local face with local fields enabled");
195  onFailure(406, "Local fields can only be enabled on faces with local scope");
196  return;
197  }
198 
199  if (req.params.mtu && *req.params.mtu < MIN_MTU) {
200  // The specified MTU must be greater than the minimum possible
201  NFD_LOG_TRACE("createFace: override MTU cannot be less than " << MIN_MTU);
202  onFailure(406, "Override MTU cannot be less than " + std::to_string(MIN_MTU));
203  return;
204  }
205 
206  for (const auto& i : m_channels) {
207  if (i.first == localEndpoint) {
208  i.second->connect(remoteEndpoint, req.params, onCreated, onFailure);
209  return;
210  }
211  }
212 
213  NFD_LOG_TRACE("No channels available to connect to " << remoteEndpoint);
214  onFailure(504, "No channels available to connect");
215 }
216 
217 shared_ptr<EthernetChannel>
218 EthernetFactory::createChannel(const shared_ptr<const ndn::net::NetworkInterface>& localEndpoint,
219  time::nanoseconds idleTimeout)
220 {
221  auto it = m_channels.find(localEndpoint->getName());
222  if (it != m_channels.end())
223  return it->second;
224 
225  auto channel = std::make_shared<EthernetChannel>(localEndpoint, idleTimeout);
226  m_channels[localEndpoint->getName()] = channel;
227  return channel;
228 }
229 
230 std::vector<shared_ptr<const Channel>>
231 EthernetFactory::doGetChannels() const
232 {
233  return getChannelsFromMap(m_channels);
234 }
235 
236 shared_ptr<Face>
237 EthernetFactory::createMulticastFace(const ndn::net::NetworkInterface& netif,
238  const ethernet::Address& address)
239 {
240  BOOST_ASSERT(address.isMulticast());
241 
242  std::pair key(netif.getName(), address);
243  auto found = m_mcastFaces.find(key);
244  if (found != m_mcastFaces.end()) {
245  return found->second;
246  }
247 
249  opts.allowFragmentation = true;
250  opts.allowReassembly = true;
251 
252  auto linkService = make_unique<GenericLinkService>(opts);
253  auto transport = make_unique<MulticastEthernetTransport>(netif, address, m_mcastConfig.linkType);
254  auto face = make_shared<Face>(std::move(linkService), std::move(transport));
255 
256  m_mcastFaces[key] = face;
257  connectFaceClosedSignal(*face, [this, key] { m_mcastFaces.erase(key); });
258 
259  auto channelIt = m_channels.find(netif.getName());
260  if (channelIt != m_channels.end()) {
261  face->setChannel(channelIt->second);
262  }
263 
264  return face;
265 }
266 
267 shared_ptr<EthernetChannel>
268 EthernetFactory::applyUnicastConfigToNetif(const shared_ptr<const ndn::net::NetworkInterface>& netif)
269 {
270  if (!m_unicastConfig.isEnabled) {
271  return nullptr;
272  }
273 
274  if (!netif->isUp()) {
275  NFD_LOG_DEBUG("Not creating channel on " << netif->getName() << ": netif is down");
276  return nullptr;
277  }
278 
279  if (netif->getType() != ndn::net::InterfaceType::ETHERNET) {
280  NFD_LOG_DEBUG("Not creating channel on " << netif->getName() << ": incompatible netif type");
281  return nullptr;
282  }
283 
284  if (netif->getEthernetAddress().isNull()) {
285  NFD_LOG_DEBUG("Not creating channel on " << netif->getName() << ": invalid Ethernet address");
286  return nullptr;
287  }
288 
289  auto channel = this->createChannel(netif, m_unicastConfig.idleTimeout);
290  if (m_unicastConfig.wantListen && !channel->isListening()) {
291  try {
292  channel->listen(this->addFace, nullptr);
293  }
294  catch (const EthernetChannel::Error& e) {
295  NFD_LOG_WARN("Cannot listen on " << netif->getName() << ": " << e.what());
296  }
297  }
298  return channel;
299 }
300 
301 shared_ptr<Face>
302 EthernetFactory::applyMcastConfigToNetif(const ndn::net::NetworkInterface& netif)
303 {
304  if (!m_mcastConfig.isEnabled) {
305  return nullptr;
306  }
307 
308  if (!netif.isUp()) {
309  NFD_LOG_DEBUG("Not creating multicast face on " << netif.getName() << ": netif is down");
310  return nullptr;
311  }
312 
313  if (netif.getType() != ndn::net::InterfaceType::ETHERNET) {
314  NFD_LOG_DEBUG("Not creating multicast face on " << netif.getName() << ": incompatible netif type");
315  return nullptr;
316  }
317 
318  if (netif.getEthernetAddress().isNull()) {
319  NFD_LOG_DEBUG("Not creating multicast face on " << netif.getName() << ": invalid Ethernet address");
320  return nullptr;
321  }
322 
323  if (!netif.canMulticast()) {
324  NFD_LOG_DEBUG("Not creating multicast face on " << netif.getName() << ": netif cannot multicast");
325  return nullptr;
326  }
327 
328  if (!m_mcastConfig.netifPredicate(netif)) {
329  NFD_LOG_DEBUG("Not creating multicast face on " << netif.getName() << ": rejected by whitelist/blacklist");
330  return nullptr;
331  }
332 
333  NFD_LOG_DEBUG("Creating multicast face on " << netif.getName());
334  shared_ptr<Face> face;
335  try {
336  face = createMulticastFace(netif, m_mcastConfig.group);
337  }
338  catch (const std::runtime_error& e) {
339  NFD_LOG_WARN("Cannot create multicast face on " << netif.getName() << ": " << e.what());
340  return nullptr; // not a fatal error
341  }
342 
343  if (face->getId() == INVALID_FACEID) {
344  // new face: register with forwarding
345  this->addFace(face);
346  }
347 
348  return face;
349 }
350 
351 void
352 EthernetFactory::applyConfig(const FaceSystem::ConfigContext&)
353 {
354  if (m_unicastConfig.isEnabled) {
355  providedSchemes.insert("ether");
356  }
357  else {
358  providedSchemes.erase("ether");
359  }
360 
361  // collect old multicast faces
362  std::set<shared_ptr<Face>> oldFaces;
363  boost::copy(m_mcastFaces | boost::adaptors::map_values, std::inserter(oldFaces, oldFaces.end()));
364 
365  // create channels and multicast faces if requested by config
366  for (const auto& netif : netmon->listNetworkInterfaces()) {
367  applyUnicastConfigToNetif(netif);
368 
369  auto face = applyMcastConfigToNetif(*netif);
370  if (face != nullptr) {
371  // don't destroy face
372  oldFaces.erase(face);
373  }
374  }
375 
376  // destroy old multicast faces that are not needed in new configuration
377  for (const auto& face : oldFaces) {
378  face->close();
379  }
380 }
381 
382 } // namespace nfd::face
static bool parseYesNo(const ConfigSection &node, const std::string &key, const std::string &sectionName)
Parse a config option that can be either "yes" or "no".
Definition: config-file.cpp:60
Protocol factory for Ethernet.
EthernetFactory(const CtorParams &params)
static const std::string & getId() noexcept
shared_ptr< Face > createMulticastFace(const ndn::net::NetworkInterface &localEndpoint, const ethernet::Address &group)
Create a face to communicate on the given Ethernet multicast group.
shared_ptr< EthernetChannel > createChannel(const shared_ptr< const ndn::net::NetworkInterface > &localEndpoint, time::nanoseconds idleTimeout)
Create Ethernet-based channel on the specified network interface.
Context for processing a config section in ProtocolFactory.
Provides support for an underlying protocol.
static std::vector< shared_ptr< const Channel > > getChannelsFromMap(const ChannelMap &channelMap)
std::set< std::string > providedSchemes
FaceUri schemes provided by this protocol factory.
FaceCreatedCallback addFace
callback when a new face is created
shared_ptr< ndn::net::NetworkMonitor > netmon
NetworkMonitor for listing available network interfaces and monitoring their changes.
#define NFD_LOG_INFO
Definition: logger.hpp:39
#define NFD_LOG_INIT(name)
Definition: logger.hpp:31
#define NFD_LOG_WARN
Definition: logger.hpp:40
#define NFD_LOG_DEBUG
Definition: logger.hpp:38
#define NFD_LOG_TRACE
Definition: logger.hpp:37
std::function< void(uint32_t status, const std::string &reason)> FaceCreationFailedCallback
Prototype for the callback that is invoked when a face fails to be created.
Definition: channel.hpp:94
constexpr FaceId INVALID_FACEID
Indicates an invalid FaceId.
Definition: face-common.hpp:51
constexpr ssize_t MIN_MTU
Minimum MTU that may be set.
Definition: face-common.hpp:66
std::function< void(const shared_ptr< Face > &)> FaceCreatedCallback
Prototype for the callback that is invoked when a face is created (in response to an incoming connect...
Definition: channel.hpp:90
void connectFaceClosedSignal(Face &face, std::function< void()> f)
Invokes a callback when a face is closed.
Definition: channel.cpp:46
boost::optional< const ConfigSection & > OptionalConfigSection
An optional configuration file section.
Definition: config-file.hpp:46
boost::property_tree::ptree ConfigSection
A configuration file section.
Definition: config-file.hpp:41
#define NFD_REGISTER_PROTOCOL_FACTORY(PF)
Registers a protocol factory.
Parameters to ProtocolFactory constructor.