Merge pull request #1269 from alfred-bratterud/dev

IP4: experimental loopback / VIP, mock of NIC to unit test IP-stack

Author: alfreb

api/net/inet.hpp

@@ -19,6 +19,7 @@
 #define NET_INET_HPP
 
 #include <chrono>
+#include <unordered_set>
 
 #include <net/inet_common.hpp>
 #include <hw/mac_addr.hpp>
@@ -48,6 +49,7 @@ namespace net {
 
     template <typename IPv>
     using resolve_func = delegate<void(typename IPv::addr)>;
+    using Vip_list = std::unordered_set<typename IPV::addr>;
 
     ///
     /// NETWORK CONFIGURATION
@@ -85,19 +87,37 @@ namespace net {
     /** Use DHCP to configure this interface */
     virtual void negotiate_dhcp(double timeout = 10.0, dhcp_timeout_func = nullptr) = 0;
 
+    /** Get a list of virtual IP4 addresses assigned to this interface */
+    virtual const Vip_list virtual_ips() const = 0;
+
+    /** Check if an IP is a (possibly virtual) loopback address */
+    virtual bool is_loopback(typename IPV::addr a) const = 0;
+
+    /** Add an IP address as a virtual loopback IP */
+    virtual void add_vip(typename IPV::addr a) = 0;
+
+    /** Remove an IP address from the virtual loopback IP list */
+    virtual void remove_vip(typename IPV::addr a) = 0;
+
+    /** Determine the appropriate source address for a destination. */
+    virtual typename IPV::addr get_source_addr(typename IPV::addr dest) = 0;
+
+    /** Determine if an IP address is a valid source address for this stack */
+    virtual bool is_valid_source(typename IPV::addr) = 0;
+
 
     ///
     /// PROTOCOL OBJECTS
     ///
 
     /** Get the IP protocol object for this interface */
-    virtual IPV&       ip_obj() = 0;
+    virtual IPV& ip_obj() = 0;
 
     /** Get the TCP protocol object for this interface */
-    virtual TCP&       tcp()    = 0;
+    virtual TCP& tcp() = 0;
 
     /** Get the UDP protocol object for this interface */
-    virtual UDP&       udp()    = 0;
+    virtual UDP& udp() = 0;
 
     /** Get the ICMP protocol object for this interface */
     virtual ICMPv4&     icmp()    = 0;
@@ -122,13 +142,13 @@ namespace net {
     ///
 
     /** Get the network interface device */
-    virtual hw::Nic&           nic() = 0;
+    virtual hw::Nic& nic() = 0;
 
     /** Get interface name for this interface **/
-    virtual std::string        ifname() const = 0;
+    virtual std::string ifname() const = 0;
 
     /** Get linklayer address for this interface **/
-    virtual MAC::Addr       link_addr() = 0;
+    virtual MAC::Addr link_addr() = 0;
 
     /** Add cache entry to the link / IP address cache */
     virtual void cache_link_addr(typename IPV::addr, MAC::Addr) = 0;
@@ -137,7 +157,7 @@ namespace net {
     virtual void flush_link_cache() = 0;
 
     /** Set the regular interval for link address cache flushing */
-    virtual void set_link_cache_flush_interval(std::chrono::minutes);
+    virtual void set_link_cache_flush_interval(std::chrono::minutes) = 0;
 
 
     ///

api/net/inet4.hpp

@@ -18,14 +18,16 @@
 #ifndef NET_INET4_HPP
 #define NET_INET4_HPP
 
+#include <vector>
+#include <unordered_set>
+
 #include "inet.hpp"
 #include "ip4/arp.hpp"
 #include "ip4/ip4.hpp"
 #include "ip4/udp.hpp"
 #include "ip4/icmp4.hpp"
 #include "dns/client.hpp"
 #include "tcp/tcp.hpp"
-#include <vector>
 #include "super_stack.hpp"
 
 namespace net {
@@ -35,6 +37,9 @@ namespace net {
   /** A complete IP4 network stack */
   class Inet4 : public Inet<IP4>{
   public:
+
+    using Vip4_list = std::unordered_set<IP4::addr>;
+
     std::string ifname() const override
     { return nic_.device_name(); }
 
@@ -122,7 +127,6 @@ namespace net {
       return ip_packet;
     }
 
-
     IP_packet_factory ip_packet_factory() override
     { return IP_packet_factory{this, &Inet4::create_ip_packet}; }
 
@@ -243,10 +247,50 @@ namespace net {
       return stack<N>();
     }
 
-  private:
+    /** Add virtual IP4 address as loopback */
+    const Vip4_list virtual_ips() const noexcept override
+    { return vip4s_; }
+
+    /** Check if IP4 address is virtual loopback */
+    bool is_loopback(IP4::addr a) const override
+    {
+      return a.is_loopback()
+        or vip4s_.find(a) != vip4s_.end();
+    }
+
+    /** Add IP4 address as virtual loopback */
+    void add_vip(IP4::addr a) override
+    {
+      if (not is_loopback(a)) {
+        INFO("Inet4", "Adding virtual IP address %s", a.to_string().c_str());
+        vip4s_.emplace(a);
+      }
+    }
+
+    /** Add IP4 address as virtual loopback */
+    void remove_vip(IP4::addr a) override
+    { vip4s_.erase(a); }
+
+    IP4::addr get_source_addr(IP4::addr dest) override
+    {
+
+      if (dest.is_loopback())
+        return {127,0,0,1};
+
+      if (is_loopback(dest))
+        return dest;
+
+      return ip_addr();
+    }
+
+    bool is_valid_source(IP4::addr src) override
+    { return is_loopback(src) or src == ip_addr(); }
+
     /** Initialize with ANY_ADDR */
     Inet4(hw::Nic& nic);
 
+  private:
+
     void process_sendq(size_t);
     // delegates registered to get signalled about free packets
     std::vector<transmit_avail_delg> tqa;
@@ -256,6 +300,8 @@ namespace net {
     IP4::addr gateway_;
     IP4::addr dns_server;
 
+    Vip4_list vip4s_ = {{127,0,0,1}};
+
     // This is the actual stack
     hw::Nic& nic_;
     Arp    arp_;

api/net/ip4/addr.hpp

@@ -316,6 +316,23 @@ struct Addr {
   std::string to_string() const
   { return str(); }
 
+  /**
+   * RFC-1122 / IANA IP4 address space defines 127.* as loopback
+   **/
+  bool is_loopback() const noexcept
+  { return part(3) == 127; }
+
+  /**
+   * Determine if an address is a-priori illegal as source address in *all* cases.
+   *
+   * @note: The class E range 240/4 for "future use" is not illegal here
+   * @note: RFC-1122 prohibits 0.0.0.0 as source, but with exceptions
+   */
+  bool is_illegal_src() const noexcept {
+    return (part(3) >= 224 and part(3) < 240) // Multicast
+      or (part(0) == 255); // Limited and directed broadcast
+  }
+
   /* Data member */
   uint32_t whole;
 } __attribute__((packed)); //< struct Addr

api/net/ip4/ip4.hpp

@@ -30,12 +30,23 @@ namespace net {
   /** IP4 layer */
   class IP4 {
   public:
+
+    enum class Drop_reason
+    { None, Bad_source, Bad_destination, Wrong_version, Wrong_checksum,
+        Unknown_proto, TTL0 };
+
+    enum class Direction
+    { Upstream, Downstream };
+
+
     using Stack = Inet<IP4>;
     using addr = ip4::Addr;
     using header = ip4::Header;
     using IP_packet = PacketIP4;
     using IP_packet_ptr = std::unique_ptr<IP_packet>;
     using downstream_arp = delegate<void(Packet_ptr, IP4::addr)>;
+    using Packet_filter = delegate<IP_packet_ptr(IP_packet_ptr)>;
+    using drop_handler = delegate<void(IP_packet_ptr, Direction, Drop_reason)>;
 
     /** Initialize. Sets a dummy linklayer out. */
     explicit IP4(Stack&) noexcept;
@@ -69,14 +80,25 @@ namespace net {
     void set_tcp_handler(upstream s)
     { tcp_handler_ = s; }
 
+    /** Set packet dropped handler */
+    void set_drop_handler(drop_handler s)
+    { drop_handler_ = s; }
+
     /** Set handler for packets not addressed to this interface (upstream) */
     void set_packet_forwarding(Stack::Forward_delg fwd)
     { forward_packet_ = fwd; }
 
     /** Set linklayer out (downstream) */
     void set_linklayer_out(downstream_arp s)
-    { linklayer_out_ = s; };
+    { linklayer_out_ = s; }
 
+    /** Assign function to determine which upstream packets gets filtered */
+    void set_upstream_filter(Packet_filter f)
+    { upstream_filter_ = f; }
+
+    /** Assign function to determine which downstream packets gets filtered */
+    void set_downstream_filter(Packet_filter f)
+    { downstream_filter_ = f; }
 
     //
     // Delegate getters
@@ -120,6 +142,7 @@ namespace net {
       return stack_.ip_addr();
     }
 
+
     /**
      * Stats getters
      **/
@@ -132,6 +155,15 @@ namespace net {
     uint64_t get_packets_dropped()
     { return packets_dropped_; }
 
+    /**  Default upstream packet filter */
+    IP_packet_ptr filter_upstream(IP_packet_ptr packet);
+
+    /**  Default downstream packet filter */
+    IP_packet_ptr filter_downstream(IP_packet_ptr packet);
+
+
+
+
   private:
     /** Stats */
     uint64_t& packets_rx_;
@@ -151,9 +183,19 @@ namespace net {
     /** Packet forwarding  */
     Stack::Forward_delg forward_packet_;
 
-  }; //< class IP4
+    /** Packet filters */
+    Packet_filter upstream_filter_;
+    Packet_filter downstream_filter_;
 
 
+    /** All dropped packets go here */
+    drop_handler drop_handler_;
+
+    /** Drop a packet, calling drop handler if set */
+    IP_packet_ptr drop(IP_packet_ptr ptr, Direction direction, Drop_reason reason);
+
+  }; //< class IP4
+
 } //< namespace net
 
 #endif

api/net/ip4/packet_ip4.hpp

@@ -39,7 +39,10 @@ namespace net {
 
     /** Get IP protocol version field. Must be 4 (RFC 1122) */
     uint8_t ip_version() const noexcept
-    { return ip_header().version_ihl & 0x0f; }
+    { return (ip_header().version_ihl >> 4) & 0xf; }
+
+    bool is_ipv4() const noexcept
+    { return (ip_header().version_ihl & 0xf0) == 0x40; }
 
     /** Get IP header length field as-is. */
     uint8_t ip_ihl() const noexcept
@@ -71,7 +74,7 @@ namespace net {
 
     /** Get Fragment offset field */
     uint16_t ip_frag_offs() const noexcept
-    { return ntohs(ip_header().frag_off_flags) | 0xe; }
+    { return ntohs(ip_header().frag_off_flags) & 0xe; }
 
     /** Get Time-To-Live field */
     uint8_t ip_ttl() const noexcept
@@ -104,6 +107,9 @@ namespace net {
     uint16_t ip_capacity() const noexcept
     { return capacity() - ip_header_length(); }
 
+    /** Compute IP header checksum on header as-is */
+    uint16_t compute_checksum() noexcept
+    { return net::checksum(&ip_header(), ip_header_length()); };
 
 
     //
@@ -208,6 +214,8 @@ namespace net {
       hdr.frag_off_flags = 0;
       hdr.ttl            = DEFAULT_TTL;
       hdr.protocol       = static_cast<uint8_t>(proto);
+      hdr.check          = 0;
+      hdr.tot_len        = 0x1400; // Big-endian 20
       increment_data_end(sizeof(IP4::header));
     }
 
@@ -219,7 +227,6 @@ namespace net {
       return {ip_data_ptr(), ip_data_length()};
     }
 
-
   protected:
 
     /** Get pointer to IP data */