network-interface.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013-2024 Regents of the University of California.
 *
 * This file is part of ndn-cxx library (NDN C++ library with eXperimental eXtensions).
 *
 * ndn-cxx library is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later version.
 *
 * ndn-cxx library is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 * PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
 *
 * You should have received copies of the GNU General Public License and GNU Lesser
 * General Public License along with ndn-cxx, e.g., in COPYING.md file.  If not, see
 * <http://www.gnu.org/licenses/>.
 *
 * See AUTHORS.md for complete list of ndn-cxx authors and contributors.
 *
 * @author Davide Pesavento <[email protected]>
 */
 
#ifndef NDN_CXX_NET_NETWORK_INTERFACE_HPP
#define NDN_CXX_NET_NETWORK_INTERFACE_HPP
 
#include "ndn-cxx/net/ethernet.hpp"
#include "ndn-cxx/net/network-address.hpp"
#include "ndn-cxx/util/signal/signal.hpp"
 
#include <set>
 
namespace ndn::net {
 
enum class InterfaceType {
  UNKNOWN,
  LOOPBACK,
  ETHERNET,
  // we do not support anything else for now
};
 
std::ostream&
operator<<(std::ostream& os, InterfaceType type);
 
enum class InterfaceState {
  UNKNOWN,    
  DOWN,       
  NO_CARRIER, 
  DORMANT,    
  RUNNING,    
};
 
std::ostream&
operator<<(std::ostream& os, InterfaceState state);
 
class NetworkInterface
{
public: // signals, marked 'mutable' so they can be connected on a 'const NetworkInterface'
  mutable signal::Signal<NetworkInterface, InterfaceState /*old*/, InterfaceState /*new*/> onStateChanged;
 
  mutable signal::Signal<NetworkInterface, uint32_t /*old*/, uint32_t /*new*/> onMtuChanged;
 
  mutable signal::Signal<NetworkInterface, NetworkAddress> onAddressAdded;
 
  mutable signal::Signal<NetworkInterface, NetworkAddress> onAddressRemoved;
 
public: // getters
  int
  getIndex() const
  {
    return m_index;
  }
 
  std::string
  getName() const
  {
    return m_name;
  }
 
  InterfaceType
  getType() const
  {
    return m_type;
  }
 
  uint32_t
  getFlags() const
  {
    return m_flags;
  }
 
  InterfaceState
  getState() const
  {
    return m_state;
  }
 
  uint32_t
  getMtu() const
  {
    return m_mtu;
  }
 
  ethernet::Address
  getEthernetAddress() const
  {
    return m_etherAddress;
  }
 
  ethernet::Address
  getEthernetBroadcastAddress() const
  {
    return m_etherBrdAddress;
  }
 
  const std::set<NetworkAddress>&
  getNetworkAddresses() const
  {
    return m_netAddresses;
  }
 
  bool
  isLoopback() const
  {
    return (m_flags & IFF_LOOPBACK) != 0;
  }
 
  bool
  isPointToPoint() const
  {
    return (m_flags & IFF_POINTOPOINT) != 0;
  }
 
  bool
  canBroadcast() const
  {
    return (m_flags & IFF_BROADCAST) != 0;
  }
 
  bool
  canMulticast() const
  {
    return (m_flags & IFF_MULTICAST) != 0;
  }
 
  bool
  isUp() const
  {
    return (m_flags & IFF_UP) != 0;
  }
 
public: // modifiers: they update the info on this in-memory object, but do not modify the interface in the OS
  bool
  addNetworkAddress(const NetworkAddress& address);
 
  bool
  removeNetworkAddress(const NetworkAddress& address);
 
  void
  setIndex(int index);
 
  void
  setName(const std::string& name);
 
  void
  setType(InterfaceType type);
 
  void
  setFlags(uint32_t flags);
 
  void
  setState(InterfaceState state);
 
  void
  setMtu(uint32_t mtu);
 
  void
  setEthernetAddress(const ethernet::Address& address);
 
  void
  setEthernetBroadcastAddress(const ethernet::Address& address);
 
private: // constructor
  NetworkInterface(); // accessible through NetworkMonitorImpl::makeNetworkInterface
 
private:
  int m_index = 0;
  std::string m_name;
  InterfaceType m_type = InterfaceType::UNKNOWN;
  uint32_t m_flags = 0; // IFF_* in <net/if.h>
  InterfaceState m_state = InterfaceState::UNKNOWN;
  uint32_t m_mtu = 0;
  ethernet::Address m_etherAddress;
  ethernet::Address m_etherBrdAddress;
  std::set<NetworkAddress> m_netAddresses;
 
  friend class NetworkMonitorImpl;
};
 
std::ostream&
operator<<(std::ostream& os, const NetworkInterface& interface);
 
} // namespace ndn::net
 
#endif // NDN_CXX_NET_NETWORK_INTERFACE_HPP