NS-3 based Named Data Networking (NDN) simulator
ndnSIM 2.3: NDN, CCN, CCNx, content centric networks
API Documentation
network-monitor-impl-osx.cpp
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2013-2017 Regents of the University of California.
4  *
5  * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
6  *
7  * ndn-cxx library is free software: you can redistribute it and/or modify it under the
8  * terms of the GNU Lesser General Public License as published by the Free Software
9  * Foundation, either version 3 of the License, or (at your option) any later version.
10  *
11  * ndn-cxx library is distributed in the hope that it will be useful, but WITHOUT ANY
12  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
13  * PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
14  *
15  * You should have received copies of the GNU General Public License and GNU Lesser
16  * General Public License along with ndn-cxx, e.g., in COPYING.md file. If not, see
17  * <http://www.gnu.org/licenses/>.
18  *
19  * See AUTHORS.md for complete list of ndn-cxx authors and contributors.
20  *
21  *
22  * Parts of this implementation is based on daemondo command of MacPorts
23  * (https://www.macports.org/):
24  *
25  * Copyright (c) 2005-2007 James Berry <jberry@macports.org>
26  * All rights reserved.
27  *
28  * Redistribution and use in source and binary forms, with or without
29  * modification, are permitted provided that the following conditions
30  * are met:
31  * 1. Redistributions of source code must retain the above copyright
32  * notice, this list of conditions and the following disclaimer.
33  * 2. Redistributions in binary form must reproduce the above copyright
34  * notice, this list of conditions and the following disclaimer in the
35  * documentation and/or other materials provided with the distribution.
36  * 3. Neither the name of The MacPorts Project nor the names of its contributors
37  * may be used to endorse or promote products derived from this software
38  * without specific prior written permission.
39  *
40  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
41  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
44  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
45  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
46  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
47  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
48  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
50  * POSSIBILITY OF SUCH DAMAGE.
51  */
52 
54 
55 #include "../network-address.hpp"
56 #include "../../name.hpp"
57 #include "../../util/logger.hpp"
58 
59 #include <ifaddrs.h> // for getifaddrs()
60 #include <net/if.h> // for if_nametoindex()
61 #include <net/if_dl.h> // for struct sockaddr_dl
62 #include <net/if_types.h> // for IFT_* constants
63 #include <netinet/in.h> // for struct sockaddr_in{,6}
64 
65 #include <boost/asio/io_service.hpp>
66 #include <boost/asio/ip/address.hpp>
67 #include <boost/asio/ip/udp.hpp>
68 
69 namespace ndn {
70 namespace net {
71 
72 using util::CFReleaser;
73 
74 NDN_LOG_INIT(ndn.NetworkMonitor);
75 
76 class IfAddrs : noncopyable
77 {
78 public:
80  {
81  if (::getifaddrs(&m_ifaList) < 0) {
82  BOOST_THROW_EXCEPTION(NetworkMonitorImplOsx::Error(std::string("getifaddrs() failed: ") +
83  strerror(errno)));
84  }
85  }
86 
88  {
89  if (m_ifaList != nullptr) {
90  ::freeifaddrs(m_ifaList);
91  }
92  }
93 
94  ifaddrs*
95  get() const noexcept
96  {
97  return m_ifaList;
98  }
99 
100 private:
101  ifaddrs* m_ifaList = nullptr;
102 };
103 
105  : m_scheduler(io)
106  , m_cfLoopEvent(m_scheduler)
107  , m_context{0, this, nullptr, nullptr, nullptr}
108  , m_scStore(SCDynamicStoreCreate(nullptr, CFSTR("net.named-data.ndn-cxx.NetworkMonitor"),
109  &NetworkMonitorImplOsx::onConfigChanged, &m_context))
110  , m_loopSource(SCDynamicStoreCreateRunLoopSource(nullptr, m_scStore.get(), 0))
111  , m_ioctlSocket(io, boost::asio::ip::udp::v4())
112 {
113  scheduleCfLoop();
114 
115  // Notifications from Darwin Notify Center:
116  //
117  // com.apple.system.config.network_change
118  //
119  CFNotificationCenterAddObserver(CFNotificationCenterGetDarwinNotifyCenter(),
120  static_cast<void*>(this),
121  &NetworkMonitorImplOsx::afterNotificationCenterEvent,
122  CFSTR("com.apple.system.config.network_change"),
123  nullptr, // object to observe
124  CFNotificationSuspensionBehaviorDeliverImmediately);
125 
126  CFRunLoopAddSource(CFRunLoopGetCurrent(), m_loopSource.get(), kCFRunLoopDefaultMode);
127 
128  // Notifications from SystemConfiguration:
129  //
130  // State:/Network/Interface/.*/Link
131  // State:/Network/Interface/.*/IPv4
132  // State:/Network/Interface/.*/IPv6
133  // State:/Network/Interface/.*/AirPort (not used)
134  //
135  // https://developer.apple.com/library/content/documentation/Networking/Conceptual/SystemConfigFrameworks/SC_UnderstandSchema/SC_UnderstandSchema.html
136  //
137  auto patterns = CFArrayCreateMutable(nullptr, 0, &kCFTypeArrayCallBacks);
138  CFArrayAppendValue(patterns, CFSTR("State:/Network/Interface/.*/Link"));
139  CFArrayAppendValue(patterns, CFSTR("State:/Network/Interface/.*/IPv4"));
140  CFArrayAppendValue(patterns, CFSTR("State:/Network/Interface/.*/IPv6"));
141 
142  if (!SCDynamicStoreSetNotificationKeys(m_scStore.get(), nullptr, patterns)) {
143  BOOST_THROW_EXCEPTION(Error("SCDynamicStoreSetNotificationKeys failed"));
144  }
145 
146  io.post([this] { enumerateInterfaces(); });
147 }
148 
150 {
151  CFRunLoopRemoveSource(CFRunLoopGetCurrent(), m_loopSource.get(), kCFRunLoopDefaultMode);
152 
153  CFNotificationCenterRemoveEveryObserver(CFNotificationCenterGetDarwinNotifyCenter(),
154  static_cast<void*>(this));
155 }
156 
157 shared_ptr<const NetworkInterface>
158 NetworkMonitorImplOsx::getNetworkInterface(const std::string& ifname) const
159 {
160  auto it = m_interfaces.find(ifname);
161  return it == m_interfaces.end() ? nullptr : it->second;
162 }
163 
164 std::vector<shared_ptr<const NetworkInterface>>
166 {
167  std::vector<shared_ptr<const NetworkInterface>> v;
168  v.reserve(m_interfaces.size());
169 
170  for (const auto& e : m_interfaces) {
171  v.push_back(e.second);
172  }
173  return v;
174 }
175 
176 void
177 NetworkMonitorImplOsx::afterNotificationCenterEvent(CFNotificationCenterRef center,
178  void* observer,
179  CFStringRef name,
180  const void* object,
181  CFDictionaryRef userInfo)
182 {
183  static_cast<NetworkMonitorImplOsx*>(observer)->emitSignal(onNetworkStateChanged);
184 }
185 
186 void
187 NetworkMonitorImplOsx::scheduleCfLoop()
188 {
189  // poll each second for new events
190  m_cfLoopEvent = m_scheduler.scheduleEvent(time::seconds(1), [this] {
191  // this should dispatch ready events and exit
192  CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0, true);
193  scheduleCfLoop();
194  });
195 }
196 
197 void
198 NetworkMonitorImplOsx::enumerateInterfaces()
199 {
200  IfAddrs ifaList;
201  for (const auto& ifName : getInterfaceNames()) {
202  addNewInterface(ifName, ifaList);
203  }
205 }
206 
207 static std::string
208 convertToStdString(CFStringRef cfStr)
209 {
210  const char* cStr = CFStringGetCStringPtr(cfStr, kCFStringEncodingASCII);
211  if (cStr != nullptr) {
212  // fast path
213  return cStr;
214  }
215 
216  // reserve space for the string + null terminator
217  std::string str(CFStringGetLength(cfStr) + 1, '\0');
218  if (!CFStringGetCString(cfStr, &str.front(), str.size(), kCFStringEncodingASCII)) {
219  BOOST_THROW_EXCEPTION(NetworkMonitorImplOsx::Error("CFString conversion failed"));
220  }
221 
222  // drop the null terminator, std::string doesn't need it
223  str.pop_back();
224  return str;
225 }
226 
227 std::set<std::string>
228 NetworkMonitorImplOsx::getInterfaceNames() const
229 {
230  CFReleaser<CFDictionaryRef> dict =
231  (CFDictionaryRef)SCDynamicStoreCopyValue(m_scStore.get(), CFSTR("State:/Network/Interface"));
232  if (dict.get() == nullptr) {
233  return {};
234  }
235 
236  CFArrayRef interfaces = (CFArrayRef)CFDictionaryGetValue(dict.get(), CFSTR("Interfaces"));
237  if (interfaces == nullptr) {
238  return {};
239  }
240 
241  std::set<std::string> ifNames;
242  size_t count = CFArrayGetCount(interfaces);
243  for (size_t i = 0; i != count; ++i) {
244  auto ifName = (CFStringRef)CFArrayGetValueAtIndex(interfaces, i);
245  ifNames.insert(convertToStdString(ifName));
246  }
247  return ifNames;
248 }
249 
250 void
251 NetworkMonitorImplOsx::addNewInterface(const std::string& ifName, const IfAddrs& ifaList)
252 {
253  shared_ptr<NetworkInterface> interface = makeNetworkInterface();
254  interface->setName(ifName);
255  interface->setState(getInterfaceState(*interface));
256  updateInterfaceInfo(*interface, ifaList);
257 
258  if (interface->getType() == InterfaceType::UNKNOWN) {
259  NDN_LOG_DEBUG("ignoring " << ifName << " due to unhandled interface type");
260  return;
261  }
262 
263  NDN_LOG_DEBUG("adding interface " << interface->getName());
264  m_interfaces[interface->getName()] = interface;
265  this->emitSignal(onInterfaceAdded, interface);
266 }
267 
269 NetworkMonitorImplOsx::getInterfaceState(const NetworkInterface& netif) const
270 {
271  CFReleaser<CFStringRef> linkName =
272  CFStringCreateWithCString(kCFAllocatorDefault,
273  ("State:/Network/Interface/" + netif.getName() + "/Link").data(),
274  kCFStringEncodingASCII);
275 
276  CFReleaser<CFDictionaryRef> dict =
277  (CFDictionaryRef)SCDynamicStoreCopyValue(m_scStore.get(), linkName.get());
278  if (dict.get() == nullptr) {
280  }
281 
282  CFBooleanRef isActive = (CFBooleanRef)CFDictionaryGetValue(dict.get(), CFSTR("Active"));
283  if (isActive == nullptr) {
285  }
286 
287  return CFBooleanGetValue(isActive) ? InterfaceState::RUNNING : InterfaceState::DOWN;
288 }
289 
290 size_t
291 NetworkMonitorImplOsx::getInterfaceMtu(const NetworkInterface& netif)
292 {
293  ifreq ifr{};
294  std::strncpy(ifr.ifr_name, netif.getName().data(), sizeof(ifr.ifr_name) - 1);
295 
296  if (::ioctl(m_ioctlSocket.native_handle(), SIOCGIFMTU, &ifr) == 0) {
297  return static_cast<size_t>(ifr.ifr_mtu);
298  }
299 
300  NDN_LOG_WARN("failed to get MTU of " << netif.getName() << ": " << std::strerror(errno));
301  return ethernet::MAX_DATA_LEN;
302 }
303 
304 template<typename AddressBytes>
305 static uint8_t
306 computePrefixLength(const AddressBytes& mask)
307 {
308  uint8_t prefixLength = 0;
309  for (auto byte : mask) {
310  while (byte != 0) {
311  ++prefixLength;
312  byte <<= 1;
313  }
314  }
315  return prefixLength;
316 }
317 
318 void
319 NetworkMonitorImplOsx::updateInterfaceInfo(NetworkInterface& netif, const IfAddrs& ifaList)
320 {
321  BOOST_ASSERT(!netif.getName().empty());
322 
323  netif.setMtu(getInterfaceMtu(netif));
324 
325  for (ifaddrs* ifa = ifaList.get(); ifa != nullptr; ifa = ifa->ifa_next) {
326  if (ifa->ifa_name != netif.getName())
327  continue;
328 
329  netif.setFlags(ifa->ifa_flags);
330 
331  if (ifa->ifa_addr == nullptr)
332  continue;
333 
334  namespace ip = boost::asio::ip;
336  ip::address ipAddr, broadcastAddr;
337  uint8_t prefixLength = 0;
338 
339  switch (ifa->ifa_addr->sa_family) {
340  case AF_INET: {
341  addrFamily = AddressFamily::V4;
342 
343  const sockaddr_in* sin = reinterpret_cast<sockaddr_in*>(ifa->ifa_addr);
344  ip::address_v4::bytes_type bytes;
345  std::copy_n(reinterpret_cast<const unsigned char*>(&sin->sin_addr), bytes.size(), bytes.begin());
346  ipAddr = ip::address_v4(bytes);
347 
348  const sockaddr_in* sinMask = reinterpret_cast<sockaddr_in*>(ifa->ifa_netmask);
349  std::copy_n(reinterpret_cast<const unsigned char*>(&sinMask->sin_addr), bytes.size(), bytes.begin());
350  prefixLength = computePrefixLength(bytes);
351  break;
352  }
353 
354  case AF_INET6: {
355  addrFamily = AddressFamily::V6;
356 
357  const sockaddr_in6* sin6 = reinterpret_cast<sockaddr_in6*>(ifa->ifa_addr);
358  ip::address_v6::bytes_type bytes;
359  std::copy_n(reinterpret_cast<const unsigned char*>(&sin6->sin6_addr), bytes.size(), bytes.begin());
360  ip::address_v6 v6Addr(bytes);
361  if (v6Addr.is_link_local())
362  v6Addr.scope_id(if_nametoindex(netif.getName().data()));
363  ipAddr = v6Addr;
364 
365  const sockaddr_in6* sinMask = reinterpret_cast<sockaddr_in6*>(ifa->ifa_netmask);
366  std::copy_n(reinterpret_cast<const unsigned char*>(&sinMask->sin6_addr), bytes.size(), bytes.begin());
367  prefixLength = computePrefixLength(bytes);
368  break;
369  }
370 
371  case AF_LINK: {
372  const sockaddr_dl* sdl = reinterpret_cast<sockaddr_dl*>(ifa->ifa_addr);
373  netif.setIndex(sdl->sdl_index);
374 
375  if (sdl->sdl_type == IFT_ETHER && sdl->sdl_alen == ethernet::ADDR_LEN) {
377  netif.setEthernetAddress(ethernet::Address(reinterpret_cast<uint8_t*>(LLADDR(sdl))));
378  NDN_LOG_TRACE(netif.getName() << " has Ethernet address " << netif.getEthernetAddress());
379  }
380  else if (sdl->sdl_type == IFT_LOOP) {
382  }
383  else {
385  }
386  break;
387  }
388  }
389 
390  if (netif.canBroadcast()) {
392 
393  if (addrFamily == AddressFamily::V4 && ifa->ifa_broadaddr != nullptr) {
394  const sockaddr_in* sin = reinterpret_cast<sockaddr_in*>(ifa->ifa_broadaddr);
395  ip::address_v4::bytes_type bytes;
396  std::copy_n(reinterpret_cast<const unsigned char*>(&sin->sin_addr), bytes.size(), bytes.begin());
397  broadcastAddr = ip::address_v4(bytes);
398  }
399  }
400 
401  if (addrFamily == AddressFamily::UNSPECIFIED)
402  continue;
403 
405  if (ipAddr.is_loopback()) {
406  scope = AddressScope::HOST;
407  }
408  else if ((ipAddr.is_v4() && (ipAddr.to_v4().to_ulong() & 0xFFFF0000) == 0xA9FE0000) ||
409  (ipAddr.is_v6() && ipAddr.to_v6().is_link_local())) {
410  scope = AddressScope::LINK;
411  }
412 
413  netif.addNetworkAddress(NetworkAddress(addrFamily, ipAddr, broadcastAddr, prefixLength, scope, 0));
414  }
415 }
416 
417 void
418 NetworkMonitorImplOsx::onConfigChanged(SCDynamicStoreRef m_scStore, CFArrayRef changedKeys, void* context)
419 {
420  static_cast<NetworkMonitorImplOsx*>(context)->onConfigChanged(changedKeys);
421 }
422 
423 void
424 NetworkMonitorImplOsx::onConfigChanged(CFArrayRef changedKeys)
425 {
426  IfAddrs ifaList;
427 
428  size_t count = CFArrayGetCount(changedKeys);
429  for (size_t i = 0; i != count; ++i) {
430  Name key(convertToStdString((CFStringRef)CFArrayGetValueAtIndex(changedKeys, i)));
431  std::string ifName = key.at(-2).toUri();
432 
433  auto ifIt = m_interfaces.find(ifName);
434  if (ifIt == m_interfaces.end()) {
435  addNewInterface(ifName, ifaList);
436  return;
437  }
438 
439  auto removeInterface = [&] {
440  NDN_LOG_DEBUG("removing interface " << ifName);
441  shared_ptr<NetworkInterface> removedNetif = ifIt->second;
442  m_interfaces.erase(ifIt);
443  this->emitSignal(onInterfaceRemoved, removedNetif);
444  };
445 
446  NetworkInterface& netif = *ifIt->second;
447  std::string changedItem = key.at(-1).toUri();
448  if (changedItem == "Link") {
449  auto newState = getInterfaceState(netif);
450  if (newState == InterfaceState::UNKNOWN) {
451  // check if it is really unknown or interface removed
452  if (getInterfaceNames().count(ifName) == 0) {
453  removeInterface();
454  return;
455  }
456  }
457  NDN_LOG_TRACE(ifName << " status changed from " << netif.getState() << " to " << newState);
458  netif.setState(newState);
459  }
460  else if (changedItem == "IPv4" || changedItem == "IPv6") {
461  auto updatedNetif = makeNetworkInterface();
462  updatedNetif->setName(ifName);
463  updateInterfaceInfo(*updatedNetif, ifaList);
464  if (updatedNetif->getType() == InterfaceType::UNKNOWN) {
465  NDN_LOG_DEBUG(ifName << " type changed to unknown");
466  removeInterface();
467  return;
468  }
469 
470  const auto& newAddrs = updatedNetif->getNetworkAddresses();
471  const auto& oldAddrs = netif.getNetworkAddresses();
472  std::set<NetworkAddress> added;
473  std::set<NetworkAddress> removed;
474  std::set_difference(newAddrs.begin(), newAddrs.end(),
475  oldAddrs.begin(), oldAddrs.end(), std::inserter(added, added.end()));
476  std::set_difference(oldAddrs.begin(), oldAddrs.end(),
477  newAddrs.begin(), newAddrs.end(), std::inserter(removed, removed.end()));
478 
479  for (const auto& addr : removed) {
480  netif.removeNetworkAddress(addr);
481  }
482  for (const auto& addr : added) {
483  netif.addNetworkAddress(addr);
484  }
485  }
486  }
487 }
488 
489 } // namespace net
490 } // namespace ndn
interface is administratively down
Copyright (c) 2011-2015 Regents of the University of California.
interface is in an unknown state
interface can be used to send and receive packets
void setState(InterfaceState state)
static shared_ptr< NetworkInterface > makeNetworkInterface()
const T & get() const
const size_t ADDR_LEN
Octets in one Ethernet address.
Definition: ethernet.hpp:41
NetworkMonitorImplOsx(boost::asio::io_service &io)
#define emitSignal(...)
(implementation detail)
Definition: emit.hpp:76
InterfaceState
Indicates the state of a network interface.
void setEthernetAddress(const ethernet::Address &address)
void setEthernetBroadcastAddress(const ethernet::Address &address)
util::Signal< NetworkMonitorImpl > onEnumerationCompleted
Represents one network interface attached to the host.
#define NDN_LOG_INIT(name)
declare a log module
Definition: logger.hpp:32
Stores one IP address supported by a network interface.
Address getBroadcastAddress()
Returns the Ethernet broadcast address (ff:ff:ff:ff:ff:ff)
Definition: ethernet.cpp:123
#define NDN_LOG_DEBUG(expression)
Definition: logger.hpp:35
std::vector< shared_ptr< const NetworkInterface > > listNetworkInterfaces() const final
bool removeNetworkAddress(const NetworkAddress &address)
util::Signal< NetworkMonitorImpl, shared_ptr< const NetworkInterface > > onInterfaceRemoved
static std::string convertToStdString(CFStringRef cfStr)
void toUri(std::ostream &os) const
Write *this to the output stream, escaping characters according to the NDN URI Scheme.
void setFlags(uint32_t flags)
Represents an absolute name.
Definition: name.hpp:42
std::string getName() const
Returns the name of the interface, unique on the system.
const std::set< NetworkAddress > & getNetworkAddresses() const
Returns a list of all network-layer addresses present on the interface.
util::Signal< NetworkMonitorImpl, shared_ptr< const NetworkInterface > > onInterfaceAdded
const Component & at(ssize_t i) const
Get the component at the given index.
Definition: name.cpp:185
bool addNetworkAddress(const NetworkAddress &address)
shared_ptr< const NetworkInterface > getNetworkInterface(const std::string &ifname) const final
represents an Ethernet hardware address
Definition: ethernet.hpp:52
ifaddrs * get() const noexcept
ethernet::Address getEthernetAddress() const
Returns the link-layer (Ethernet) address of the interface.
#define NDN_LOG_WARN(expression)
Definition: logger.hpp:37
util::Signal< NetworkMonitorImpl > onNetworkStateChanged
#define NDN_LOG_TRACE(expression)
Definition: logger.hpp:34
void setType(InterfaceType type)
InterfaceState getState() const
Returns the current state of the interface.
const size_t MAX_DATA_LEN
Max octets in Ethernet payload.
Definition: ethernet.hpp:46
bool canBroadcast() const
Returns true if the interface supports broadcast communication.
static uint8_t computePrefixLength(const AddressBytes &mask)