network-interface.hpp

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
#ifndef NDN_NET_NETWORK_INTERFACE_HPP
#define NDN_NET_NETWORK_INTERFACE_HPP

#include "ethernet.hpp"
#include "network-address.hpp"
#include "../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_NET_NETWORK_INTERFACE_HPP