nfd-autoreg.cpp
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2014-2023, 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 "core/network.hpp"
27 #include "core/version.hpp"
28 
29 #include <ndn-cxx/face.hpp>
30 #include <ndn-cxx/mgmt/nfd/controller.hpp>
31 #include <ndn-cxx/mgmt/nfd/face-monitor.hpp>
32 #include <ndn-cxx/mgmt/nfd/status-dataset.hpp>
33 #include <ndn-cxx/net/face-uri.hpp>
34 #include <ndn-cxx/security/key-chain.hpp>
35 
36 #include <boost/asio/signal_set.hpp>
37 #include <boost/exception/diagnostic_information.hpp>
38 #include <boost/program_options/options_description.hpp>
39 #include <boost/program_options/parsers.hpp>
40 #include <boost/program_options/variables_map.hpp>
41 
42 #include <iostream>
43 
45 
46 using ndn::FaceUri;
47 using ndn::Name;
48 
49 class AutoregServer : boost::noncopyable
50 {
51 public:
52  static void
53  onRegisterCommandSuccess(uint64_t faceId, const Name& prefix)
54  {
55  std::cerr << "SUCCESS: register " << prefix << " on face " << faceId << std::endl;
56  }
57 
58  static void
59  onRegisterCommandFailure(uint64_t faceId, const Name& prefix,
60  const ndn::nfd::ControlResponse& response)
61  {
62  std::cerr << "FAILED: register " << prefix << " on face " << faceId
63  << " (code: " << response.getCode() << ", reason: " << response.getText() << ")"
64  << std::endl;
65  }
66 
70  static bool
71  hasAllowedSchema(const FaceUri& uri)
72  {
73  const std::string& scheme = uri.getScheme();
74  return scheme == "udp4" || scheme == "tcp4" ||
75  scheme == "udp6" || scheme == "tcp6";
76  }
77 
81  bool
82  isBlacklisted(const boost::asio::ip::address& address) const
83  {
84  return std::any_of(m_blackList.begin(), m_blackList.end(),
85  [&] (const auto& net) { return net.doesContain(address); });
86  }
87 
91  bool
92  isWhitelisted(const boost::asio::ip::address& address) const
93  {
94  return std::any_of(m_whiteList.begin(), m_whiteList.end(),
95  [&] (const auto& net) { return net.doesContain(address); });
96  }
97 
98  void
99  registerPrefixesForFace(uint64_t faceId, const std::vector<Name>& prefixes)
100  {
101  for (const Name& prefix : prefixes) {
102  m_controller.start<ndn::nfd::RibRegisterCommand>(
103  ndn::nfd::ControlParameters()
104  .setName(prefix)
105  .setFaceId(faceId)
106  .setOrigin(ndn::nfd::ROUTE_ORIGIN_AUTOREG)
107  .setCost(m_cost)
108  .setExpirationPeriod(ndn::time::milliseconds::max()),
109  [=] (auto&&...) { onRegisterCommandSuccess(faceId, prefix); },
110  [=] (const auto& response) { onRegisterCommandFailure(faceId, prefix, response); });
111  }
112  }
113 
114  void
115  registerPrefixesIfNeeded(uint64_t faceId, const FaceUri& uri, ndn::nfd::FacePersistency facePersistency)
116  {
117  if (hasAllowedSchema(uri)) {
118  boost::system::error_code ec;
119  auto address = boost::asio::ip::make_address(uri.getHost(), ec);
120 
121  if (!address.is_multicast()) {
122  // register all-face prefixes
123  registerPrefixesForFace(faceId, m_allFacesPrefixes);
124 
125  // register autoreg prefixes if new face is on-demand and not blacklisted and whitelisted
126  if (facePersistency == ndn::nfd::FACE_PERSISTENCY_ON_DEMAND &&
127  !isBlacklisted(address) && isWhitelisted(address)) {
128  registerPrefixesForFace(faceId, m_autoregPrefixes);
129  }
130  }
131  }
132  }
133 
134  void
135  onNotification(const ndn::nfd::FaceEventNotification& notification)
136  {
137  if (notification.getKind() == ndn::nfd::FACE_EVENT_CREATED &&
138  notification.getFaceScope() != ndn::nfd::FACE_SCOPE_LOCAL) {
139  std::cerr << "PROCESSING: " << notification << std::endl;
140 
141  registerPrefixesIfNeeded(notification.getFaceId(), FaceUri(notification.getRemoteUri()),
142  notification.getFacePersistency());
143  }
144  else {
145  std::cerr << "IGNORED: " << notification << std::endl;
146  }
147  }
148 
149  void
150  startProcessing()
151  {
152  std::cerr << "AUTOREG prefixes: " << std::endl;
153  for (const Name& prefix : m_autoregPrefixes) {
154  std::cout << " " << prefix << std::endl;
155  }
156  std::cerr << "ALL-FACES-AUTOREG prefixes: " << std::endl;
157  for (const Name& prefix : m_allFacesPrefixes) {
158  std::cout << " " << prefix << std::endl;
159  }
160 
161  if (!m_blackList.empty()) {
162  std::cerr << "Blacklisted networks: " << std::endl;
163  for (const Network& network : m_blackList) {
164  std::cout << " " << network << std::endl;
165  }
166  }
167 
168  std::cerr << "Whitelisted networks: " << std::endl;
169  for (const Network& network : m_whiteList) {
170  std::cout << " " << network << std::endl;
171  }
172 
173  m_faceMonitor.onNotification.connect([this] (const auto& notif) { onNotification(notif); });
174  m_faceMonitor.start();
175 
176  boost::asio::signal_set signalSet(m_face.getIoContext(), SIGINT, SIGTERM);
177  signalSet.async_wait([this] (auto&&...) { m_face.shutdown(); });
178 
179  m_face.processEvents();
180  }
181 
182  void
183  startFetchingFaceStatusDataset()
184  {
185  m_controller.fetch<ndn::nfd::FaceDataset>(
186  [this] (const auto& faces) {
187  for (const auto& faceStatus : faces) {
188  registerPrefixesIfNeeded(faceStatus.getFaceId(), FaceUri(faceStatus.getRemoteUri()),
189  faceStatus.getFacePersistency());
190  }
191  },
192  [] (auto&&...) {});
193  }
194 
195  int
196  main(int argc, char* argv[])
197  {
198  namespace po = boost::program_options;
199 
200  po::options_description optionsDesc("Options");
201  optionsDesc.add_options()
202  ("help,h", "print this message and exit")
203  ("version,V", "show version information and exit")
204  ("prefix,i", po::value<std::vector<Name>>(&m_autoregPrefixes)->composing(),
205  "prefix that should be automatically registered when a new non-local face is created")
206  ("all-faces-prefix,a", po::value<std::vector<Name>>(&m_allFacesPrefixes)->composing(),
207  "prefix that should be automatically registered for all TCP and UDP non-local faces "
208  "(blacklists and whitelists do not apply to this prefix)")
209  ("cost,c", po::value<uint64_t>(&m_cost)->default_value(m_cost),
210  "FIB cost that should be assigned to autoreg nexthops")
211  ("whitelist,w", po::value<std::vector<Network>>(&m_whiteList)->composing(),
212  "Whitelisted network, e.g., 192.168.2.0/24 or ::1/128")
213  ("blacklist,b", po::value<std::vector<Network>>(&m_blackList)->composing(),
214  "Blacklisted network, e.g., 192.168.2.32/30 or ::1/128")
215  ;
216 
217  auto usage = [&] (std::ostream& os) {
218  os << "Usage: " << argv[0] << " [--prefix=</autoreg/prefix>]... [options]\n"
219  << "\n"
220  << optionsDesc;
221  };
222 
223  po::variables_map options;
224  try {
225  po::store(po::parse_command_line(argc, argv, optionsDesc), options);
226  po::notify(options);
227  }
228  catch (const std::exception& e) {
229  std::cerr << "ERROR: " << e.what() << std::endl << std::endl;
230  usage(std::cerr);
231  return 2;
232  }
233 
234  if (options.count("help") > 0) {
235  usage(std::cout);
236  return 0;
237  }
238 
239  if (options.count("version") > 0) {
240  std::cout << NFD_VERSION_BUILD_STRING << std::endl;
241  return 0;
242  }
243 
244  if (m_autoregPrefixes.empty() && m_allFacesPrefixes.empty()) {
245  std::cerr << "ERROR: at least one --prefix or --all-faces-prefix must be specified"
246  << std::endl << std::endl;
247  usage(std::cerr);
248  return 2;
249  }
250 
251  if (m_whiteList.empty()) {
252  // Allow everything
253  m_whiteList.push_back(Network::getMaxRangeV4());
254  m_whiteList.push_back(Network::getMaxRangeV6());
255  }
256 
257  try {
258  startFetchingFaceStatusDataset();
259  startProcessing();
260  }
261  catch (const std::exception& e) {
262  std::cerr << "ERROR: " << boost::diagnostic_information(e);
263  return 1;
264  }
265 
266  return 0;
267  }
268 
269 private:
270  ndn::Face m_face;
271  ndn::KeyChain m_keyChain;
272  ndn::nfd::Controller m_controller{m_face, m_keyChain};
273  ndn::nfd::FaceMonitor m_faceMonitor{m_face};
274  std::vector<Name> m_autoregPrefixes;
275  std::vector<Name> m_allFacesPrefixes;
276  uint64_t m_cost = 255;
277  std::vector<Network> m_whiteList;
278  std::vector<Network> m_blackList;
279 };
280 
281 } // namespace nfd::tools::autoreg
282 
283 int
284 main(int argc, char* argv[])
285 {
286  nfd::tools::autoreg::AutoregServer server;
287  return server.main(argc, argv);
288 }
static const Network & getMaxRangeV6()
Definition: network.cpp:56
static const Network & getMaxRangeV4()
Definition: network.cpp:48
static void usage(std::ostream &os, const po::options_description &opts, const char *programName)
Definition: main.cpp:51
int main(int argc, char *argv[])
const char NFD_VERSION_BUILD_STRING[]
NFD version string, including git commit information if NFD is build from a specific git commit.