Merge pull request #1280 from AnnikaH/dev

Updates based on feedback on #1222 and more

Author: fwsGonzo

api/net/dns/client.hpp

@@ -77,7 +77,10 @@ namespace net
       }
 
       void finish()
-      { callback(request.getFirstIP4()); }
+      {
+        Error err;
+        callback(request.getFirstIP4(), err);
+      }
 
       void start_timeout(Timer::duration_t timeout)
       { timer.start(timeout); }

api/net/http/client.hpp

@@ -33,7 +33,7 @@ namespace http {
   class Client {
   public:
     using TCP                 = net::TCP;
-    using Host                = net::tcp::Socket;
+    using Host                = net::Socket;
 
     using Response_handler    = Client_connection::Response_handler;
     struct Options;
@@ -67,7 +67,7 @@ namespace http {
     };
 
   private:
-    using ResolveCallback    = delegate<void(net::ip4::Addr)>;
+    using ResolveCallback    = delegate<void(net::ip4::Addr, net::Error&)>;
 
   public:
     explicit Client(TCP& tcp, Request_handler on_send = nullptr);

api/net/http/connection.hpp

@@ -31,7 +31,7 @@ namespace http {
   public:
     using Stream        = net::tcp::Connection::Stream;
     using Stream_ptr    = std::unique_ptr<Stream>;
-    using Peer          = net::tcp::Socket;
+    using Peer          = net::Socket;
     using buffer_t      = net::tcp::buffer_t;
 
   public:

api/net/http/websocket.hpp

@@ -30,7 +30,7 @@ class WebSocket {
   // When a handshake is established and the WebSocket is created
   using Connect_handler = delegate<void(WebSocket_ptr)>;
   // Whether to accept the client or not before handshake
-  using Accept_handler  = delegate<bool(net::tcp::Socket, std::string)>;
+  using Accept_handler  = delegate<bool(net::Socket, std::string)>;
   // data read (data, length)
   typedef delegate<void(const char*, size_t)> read_func;
   // closed (status code)

api/net/http/ws_connector.hpp

@@ -44,7 +44,7 @@ class WS_connector {
  */
 class WS_server_connector : public WS_connector {
 public:
-  using AcceptCallback    = delegate<bool(net::tcp::Socket peer, const std::string& origin)>;
+  using AcceptCallback    = delegate<bool(net::Socket peer, const std::string& origin)>;
   using Request_handler   = delegate<void(Request_ptr, Response_writer_ptr)>;
 
   /**

api/net/inet.hpp

@@ -30,7 +30,7 @@ namespace net {
   class   TCP;
   class   UDP;
   class   DHClient;
-  struct  ICMPv4;
+  class   ICMPv4;
 
   /**
    * An abstract IP-stack interface.
@@ -44,28 +44,28 @@ namespace net {
     using Route_checker = delegate<bool(typename IPV::addr)>;
     using IP_packet_factory = delegate<typename IPV::IP_packet_ptr(Protocol)>;
 
-    using Error_type = icmp4::Type;
-    using Error_code = uint8_t;
-
     template <typename IPv>
-    using resolve_func = delegate<void(typename IPv::addr)>;
+    using resolve_func = delegate<void(typename IPv::addr, Error&)>;
     using Vip_list = std::unordered_set<typename IPV::addr>;
 
     ///
     /// NETWORK CONFIGURATION
     ///
 
     /** Get IP address of this interface **/
-    virtual typename IPV::addr ip_addr()  = 0;
+    virtual typename IPV::addr ip_addr()        = 0;
 
     /** Get netmask of this interface **/
-    virtual typename IPV::addr netmask()  = 0;
+    virtual typename IPV::addr netmask()        = 0;
 
     /** Get default gateway for this interface **/
-    virtual typename IPV::addr gateway()  = 0;
+    virtual typename IPV::addr gateway()        = 0;
 
     /** Get default dns for this interface **/
-    virtual typename IPV::addr dns()      = 0;
+    virtual typename IPV::addr dns_addr()       = 0;
+
+    /** Get broadcast address for this interface **/
+    virtual typename IPV::addr broadcast_addr() = 0;
 
    /** Set default gateway for this interface */
     virtual void set_gateway(typename IPV::addr server) = 0;
@@ -120,13 +120,15 @@ namespace net {
     virtual UDP& udp() = 0;
 
     /** Get the ICMP protocol object for this interface */
-    virtual ICMPv4&     icmp()    = 0;
+    virtual ICMPv4& icmp() = 0;
 
     /**
-     *  Error report in accordance with RFC 1122
+     *  Error reporting
+     *  Incl. ICMP error report in accordance with RFC 1122
      *  An ICMP error message has been received - forward to transport layer (UDP or TCP)
     */
-    virtual void error_report(Error_type type, Error_code code, Packet_ptr orig_pckt) = 0;
+    virtual void error_report(Error& err, Packet_ptr orig_pckt) = 0;
+
 
 
     ///
@@ -135,7 +137,7 @@ namespace net {
 
     /** DNS resolution */
     virtual void resolve(const std::string& hostname, resolve_func<IPV> func) = 0;
-
+    virtual void resolve(const std::string& hostname, typename IPV::addr server, resolve_func<IPV> func) = 0;
 
     ///
     /// LINK LAYER

api/net/inet4.hpp

@@ -58,8 +58,11 @@ namespace net {
     IP4::addr gateway() override
     { return gateway_; }
 
-    IP4::addr dns() override
-    { return dns_server; }
+    IP4::addr dns_addr() override
+    { return dns_server_; }
+
+    IP4::addr broadcast_addr() override
+    { return ip4_addr_ | ( ~ netmask_); }
 
     IP4& ip_obj() override
     { return ip4_; }
@@ -86,10 +89,11 @@ namespace net {
     auto dhclient() { return dhcp_;  }
 
     /**
-     *  Error report in accordance with RFC 1122
+     *  Error reporting
+     *  Incl. ICMP error report in accordance with RFC 1122
      *  An ICMP error message has been received - forward to transport layer (UDP or TCP)
     */
-    void error_report(Error_type type, Error_code code, Packet_ptr orig_pckt) override;
+    void error_report(Error& err, Packet_ptr orig_pckt) override;
 
     /**
      * Set the forwarding delegate used by this stack.
@@ -141,7 +145,14 @@ namespace net {
     void resolve(const std::string& hostname,
                  resolve_func<IP4>  func) override
     {
-      dns_.resolve(this->dns_server, hostname, func);
+      dns_.resolve(this->dns_server_, hostname, func);
+    }
+
+    void resolve(const std::string& hostname,
+                  IP4::addr         server,
+                  resolve_func<IP4> func) override
+    {
+      dns_.resolve(server, hostname, func);
     }
 
     void set_gateway(IP4::addr gateway) override
@@ -151,7 +162,7 @@ namespace net {
 
     void set_dns_server(IP4::addr server) override
     {
-      this->dns_server = server;
+      this->dns_server_ = server;
     }
 
     /**
@@ -181,12 +192,12 @@ namespace net {
       this->ip4_addr_  = addr;
       this->netmask_   = nmask;
       this->gateway_    = gateway;
-      this->dns_server = (dns == IP4::ADDR_ANY) ? gateway : dns;
+      this->dns_server_ = (dns == IP4::ADDR_ANY) ? gateway : dns;
       INFO("Inet4", "Network configured");
       INFO2("IP: \t\t%s", ip4_addr_.str().c_str());
       INFO2("Netmask: \t%s", netmask_.str().c_str());
       INFO2("Gateway: \t%s", gateway_.str().c_str());
-      INFO2("DNS Server: \t%s", dns_server.str().c_str());
+      INFO2("DNS Server: \t%s", dns_server_.str().c_str());
     }
 
     virtual void
@@ -298,7 +309,7 @@ namespace net {
     IP4::addr ip4_addr_;
     IP4::addr netmask_;
     IP4::addr gateway_;
-    IP4::addr dns_server;
+    IP4::addr dns_server_;
 
     Vip4_list vip4s_ = {{127,0,0,1}};
 

api/net/inet_common.hpp

@@ -59,45 +59,98 @@ namespace net {
     return std::static_pointer_cast<T>(packet);
   }
 
-
   template<typename Derived, typename Base>
   auto static_unique_ptr_cast( std::unique_ptr<Base>&& p )
   {
       auto* d = static_cast<Derived *>(p.release());
       return std::unique_ptr<Derived>(d);
   }
 
+  /**
+   *  General Error class for the OS
+   *  ICMP_error f.ex. inherits from this class
+   */
   class Error {
   public:
+
     enum class Type : uint8_t {
       no_error,
       general_IO,
       ifdown,
       ICMP
       // Add more as needed
-     };
-
-    virtual Type type()
-    { return t_;  }
-
-    virtual const char* what()
-    { return msg_; }
-
-    virtual ~Error() = default;
+    };
 
     Error() = default;
 
     Error(Type t, const char* msg)
       : t_{t}, msg_{msg}
-    {};
+    {}
 
-    operator bool()
+    virtual ~Error() = default;
+
+    Type type()
+    { return t_; }
+
+    operator bool() const noexcept
     { return t_ != Type::no_error; }
 
+    bool is_icmp() const noexcept
+    { return t_ == Type::ICMP; }
+
+    virtual const char* what() const noexcept
+    { return msg_; }
+
   private:
-    Type t_ = Type::no_error;
-    const char* msg_ = "No error";
-  };
+    Type t_{Type::no_error};
+    const char* msg_{"No error"};
+
+  };  // < class Error
+
+
+  /**
+   *  An object of this error class is sent to UDP and TCP (via Inet) when an ICMP error message
+   *  is received in ICMPv4::receive
+   */
+  class ICMP_error : public Error {
+
+  public:
+    using ICMP_type = icmp4::Type;
+    using ICMP_code = uint8_t;    // Codes in icmp4_common.hpp in namespace icmp4::code
+                                  // icmp4::code::Dest_unreachable::PORT f.ex.
+
+    ICMP_error()
+      : Error{}
+    {}
+
+    ICMP_error(ICMP_type icmp_type, ICMP_code icmp_code)
+      : Error{Error::Type::ICMP, "ICMP error message received"},
+        icmp_type_{icmp_type}, icmp_code_{icmp_code}
+    {}
+
+    ICMP_type icmp_type() const noexcept
+    { return icmp_type_; }
+
+    std::string icmp_type_str() const
+    { return icmp4::get_type_string(icmp_type_); }
+
+    void set_icmp_type(ICMP_type icmp_type)
+    { icmp_type_ = icmp_type; }
+
+    ICMP_code icmp_code() const noexcept
+    { return icmp_code_; }
+
+    std::string icmp_code_str() const
+    { return icmp4::get_code_string(icmp_type_, icmp_code_); }
+
+    void set_icmp_code(ICMP_code icmp_code)
+    { icmp_code_ = icmp_code; }
+
+  private:
+    ICMP_type icmp_type_{ICMP_type::NO_ERROR};
+    ICMP_code icmp_code_{0};
+
+  };  // < class ICMP_error
 
 
   /* RFC 6335 - IANA */

api/net/ip4/addr.hpp

@@ -323,15 +323,11 @@ struct Addr {
   { 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
+   * @note: The class E range 240/4 for "future use" is not included here
+   * RFC-5771 defining multicast address range from 224.0.0.0 to 239.255.255.255
    */
-  bool is_illegal_src() const noexcept {
-    return (part(3) >= 224 and part(3) < 240) // Multicast
-      or (part(0) == 255); // Limited and directed broadcast
-  }
+  bool is_multicast() const noexcept
+  { return part(3) >= 224 and part(3) < 240; }
 
   /* Data member */
   uint32_t whole;