network-interface.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013-2021 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 <davide.pesavento@lip6.fr>
 */

#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.hpp"

#include <set>

namespace ndn {
namespace 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 'const NetworkInterface'
  mutable util::Signal<NetworkInterface, InterfaceState /*old*/, InterfaceState /*new*/> onStateChanged;

  mutable util::Signal<NetworkInterface, uint32_t /*old*/, uint32_t /*new*/> onMtuChanged;

  mutable util::Signal<NetworkInterface, NetworkAddress> onAddressAdded;

  mutable util::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 information on this instance, but do not change netif 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;
  std::string m_name;
  InterfaceType m_type;
  uint32_t m_flags; // IFF_* in <net/if.h>
  InterfaceState m_state;
  uint32_t m_mtu;
  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 net
} // namespace ndn

#endif // NDN_CXX_NET_NETWORK_INTERFACE_HPP