UDPSocket: sendto and bcast taking both a send callback and an error callback and updates in that regard elsewhere in the OS. UDP: Socket is now key into error_callbacks_ map. Socket: Added hash function so that this can be a key into a map

Author: AnnikaH

api/net/ip4/udp.hpp

@@ -44,24 +44,14 @@ namespace net {
     using Packet_ptr    = std::unique_ptr<PacketUDP, std::default_delete<net::Packet>>;
     using Stack         = IP4::Stack;
 
-    using Dest_tuple    = std::pair<addr_t, port_t>;
-
-    typedef delegate<void(Error&)> sendto_handler;
-
-    struct pair_hash {
-      template<class T1, class T2>
-      std::size_t operator () (const std::pair<T1, T2> &p) const {
-        auto h1 = std::hash<T1>{}(p.first);
-        auto h2 = std::hash<T2>{}(p.second);
-        return h1 ^ h2;
-      }
-    };
+    typedef delegate<void()> sendto_handler;
+    typedef delegate<void(Error&)> error_handler;
 
     // write buffer for sendq
     struct WriteBuffer
     {
       WriteBuffer(
-                  const uint8_t* data, size_t length, sendto_handler cb,
+                  const uint8_t* data, size_t length, sendto_handler cb, error_handler ecb,
                   UDP& udp, addr_t LA, port_t LP, addr_t DA, port_t DP);
 
       int remaining() const
@@ -78,7 +68,9 @@ namespace net {
       size_t len;
       size_t offset;
       // the callback for when this buffer is written
-      sendto_handler callback;
+      sendto_handler send_callback;
+      // the callback for when this receives an error
+      error_handler error_callback;
       // the UDP stack
       UDP& udp;
 
@@ -184,22 +176,22 @@ namespace net {
     /** Error entries are just error callbacks and timestamps */
     class Error_entry {
     public:
-      Error_entry(UDP::sendto_handler cb) noexcept
+      Error_entry(UDP::error_handler cb) noexcept
       : callback(std::move(cb)), timestamp(RTC::time_since_boot())
       {}
 
       bool expired() noexcept
       { return timestamp + exp_t_ < RTC::time_since_boot(); }
 
-      UDP::sendto_handler callback;
+      UDP::error_handler callback;
 
     private:
       RTC::timestamp_t timestamp;
 
     }; //< class Error_entry
 
     /** The error callbacks that the user has sent in via the UDPSockets' sendto and bcast methods */
-    std::unordered_map<Dest_tuple, Error_entry, pair_hash> error_callbacks_;
+    std::unordered_map<Socket, Error_entry, Socket::pair_hash> error_callbacks_;
 
     /** Timer that flushes expired error entries/callbacks (no errors have occurred) */
     Timer flush_timer_{{ *this, &UDP::flush_expired }};

api/net/ip4/udp_socket.hpp

@@ -33,6 +33,7 @@ namespace net
 
     typedef delegate<void(addr_t, port_t, const char*, size_t)> recvfrom_handler;
     typedef UDP::sendto_handler sendto_handler;
+    typedef UDP::error_handler error_handler;
 
     // constructors
     UDPSocket(UDP&, port_t port);
@@ -48,11 +49,13 @@ namespace net
 
     void sendto(addr_t destIP, port_t port,
                 const void* buffer, size_t length,
-                sendto_handler cb = nullptr);
+                sendto_handler cb = nullptr,
+                error_handler ecb = nullptr);
 
     void bcast(addr_t srcIP, port_t port,
                const void* buffer, size_t length,
-               sendto_handler cb = nullptr);
+               sendto_handler cb = nullptr,
+               error_handler ecb = nullptr);
 
     void close()
     { udp_.close(l_port); }

api/net/socket.hpp

@@ -32,6 +32,14 @@ class Socket {
   using Address = ip4::Addr;
   using port_t = uint16_t;
 
+  struct pair_hash {
+    std::size_t operator () (const Socket& s) const {
+      auto h1 = std::hash<Address>{}(s.address());
+      auto h2 = std::hash<port_t>{}(s.port());
+      return h1 ^ h2;
+    }
+  };
+
   /**
    * Constructor
    *

src/net/dns/client.cpp

@@ -36,7 +36,7 @@ namespace net
       std::forward_as_tuple(std::move(request), std::move(func)));
 
     // send request to DNS server
-    socket_.sendto(dns_server, DNS::DNS_SERVICE_PORT, buf.data(), len, [this, dns_server, key] (Error& err) {
+    socket_.sendto(dns_server, DNS::DNS_SERVICE_PORT, buf.data(), len, nullptr, [this, dns_server, key] (Error& err) {
       // If an error is not received, this will never execute (Error is just erased from the map
       // without calling the callback)
 

src/net/ip4/udp.cpp

@@ -68,7 +68,7 @@ namespace net {
     // Report to application layer that got an ICMP error message of type and code (reason and subreason)
 
     // Find callback with this destination address and port, and call it with the incoming err
-    auto it = error_callbacks_.find(std::make_pair(dest.address(), dest.port()));
+    auto it = error_callbacks_.find(Socket{dest.address(), dest.port()});
 
     if (it != error_callbacks_.end()) {
       it->second.callback(err);
@@ -143,10 +143,8 @@ namespace net {
     INFO("UDP", "Flushing expired error callbacks");
 
     for (auto& err : error_callbacks_) {
-      if (err.second.expired()) {
-        // error_callbacks_.second.callback(ICMP_error{});
+      if (err.second.expired())
         error_callbacks_.erase(err.first);
-      }
     }
 
     if (not error_callbacks_.empty())
@@ -164,10 +162,13 @@ namespace net {
       num--;
 
       if (buffer.done()) {
-        if (buffer.callback != nullptr) {
+        if (buffer.send_callback != nullptr)
+          buffer.send_callback();
+
+        if (buffer.error_callback != nullptr) {
           error_callbacks_.emplace(std::piecewise_construct,
-                              std::forward_as_tuple(std::make_pair(buffer.d_addr, buffer.d_port)),
-                              std::forward_as_tuple(Error_entry{buffer.callback}));
+                              std::forward_as_tuple(Socket{buffer.d_addr, buffer.d_port}),
+                              std::forward_as_tuple(Error_entry{buffer.error_callback}));
 
           if (UNLIKELY(not flush_timer_.is_running()))
             flush_timer_.start(flush_interval_);
@@ -194,9 +195,9 @@ namespace net {
     return P;
   }
 
-  UDP::WriteBuffer::WriteBuffer(const uint8_t* data, size_t length, sendto_handler cb,
+  UDP::WriteBuffer::WriteBuffer(const uint8_t* data, size_t length, sendto_handler cb, error_handler ecb,
                                 UDP& stack, addr_t LA, port_t LP, addr_t DA, port_t DP)
-    : len(length), offset(0), callback(cb), udp(stack),
+    : len(length), offset(0), send_callback(cb), error_callback(ecb), udp(stack),
       l_addr(LA), l_port(LP), d_port(DP), d_addr(DA)
   {
     // create a copy of the data,

src/net/ip4/udp_socket.cpp

@@ -43,35 +43,37 @@ namespace net
   void UDPSocket::internal_read(UDP::Packet_ptr udp)
   { on_read_handler(udp->ip_src(), udp->src_port(), (const char*) udp->data(), udp->data_length()); }
 
-  void UDPSocket::sendto (
+  void UDPSocket::sendto(
      addr_t destIP,
      port_t port,
      const void* buffer,
-     size_t len,
-     sendto_handler cb)
+     size_t length,
+     sendto_handler cb,
+     error_handler ecb)
   {
-    if (UNLIKELY(len == 0)) return;
+    if (UNLIKELY(length == 0)) return;
     udp_.sendq.emplace_back(
-       (const uint8_t*) buffer, len, cb, this->udp_,
+       (const uint8_t*) buffer, length, cb, ecb, this->udp_,
        local_addr(), this->l_port, destIP, port);
 
     // UDP packets are meant to be sent immediately, so try flushing
     udp_.flush();
   }
 
-  void UDPSocket::bcast (
-      addr_t srcIP,
-      port_t port,
-      const void* buffer,
-      size_t len,
-      sendto_handler cb)
+  void UDPSocket::bcast(
+    addr_t srcIP,
+    port_t port,
+    const void* buffer,
+    size_t length,
+    sendto_handler cb,
+    error_handler ecb)
   {
-    if (UNLIKELY(len == 0)) return;
+    if (UNLIKELY(length == 0)) return;
     udp_.sendq.emplace_back(
-         (const uint8_t*) buffer, len, cb, this->udp_,
+         (const uint8_t*) buffer, length, cb, ecb, this->udp_,
          srcIP, this->l_port, IP4::ADDR_BCAST, port);
 
     // UDP packets are meant to be sent immediately, so try flushing
     udp_.flush();
   }
-}
+} // < namespace net

src/posix/udp_fd.cpp

@@ -178,7 +178,7 @@ ssize_t UDP_FD::sendto(const void* message, size_t len, int,
   // Sending
   bool written = false;
   this->sock->sendto(ntohl(dest.sin_addr.s_addr), ntohs(dest.sin_port), message, len,
-    [&written](net::Error) { written = true; });
+    [&written]() { written = true; });
 
   while(!written)
     OS::block();