Fix bugs in network_socket_receive_from.

A few things are wrong with `network_socket_receive_from`:

- We claim `unclaimedBuffer` but don't unclaim it on error paths, thus
  leaking the buffer.
- The `check_pointer` for `port` is done on `address`, likely due to a
  copy/paste issue.
- The `if (received > 0)` before setting `buffer` is redundant as we
  already checked this a few lines earlier.
- We don't document that the UDP packet will be dropped if an error
  occurs in this function (timeout, permissions, etc.).
- The documentation of error codes is incomplete.

Address all these issues.

Signed-off-by: Hugo Lefeuvre <[email protected]>

Author: hlef

include/NetAPI.h

@@ -180,8 +180,13 @@ int __cheri_compartment("TCPIP")
  * The `bytesReceived` field of the result will be negative if an error
  * occurred.  The `buffer` field will be null if no data were received.
  *
+ * Note that errors occuring in this function (particularly timeout and invalid
+ * `address` or `port` pointers) may cause UDP packets to be dropped.
+ *
  * The negative values will be errno values:
  *
+ *  - `-ENOMEM`: The allocation quota is insufficient to hold the packet.
+ *  - `-EPERM`: The `address` and/or `port` pointers are invalid.
  *  - `-EINVAL`: The socket is not valid.
  *  - `-ETIMEDOUT`: The timeout was reached before data could be received.
  *  - `-ENOTCONN`: The socket is not connected.

lib/tcpip/network_wrapper.cc

@@ -667,23 +667,26 @@ NetworkReceiveResult network_socket_receive_from(Timeout *timeout,
 			                                                       FREERTOS_ZERO_COPY,
 			                                                       &remoteAddress,
 			                                                       &remoteAddressLength);
-            });
-		   if (received > 0)
+            } /* with_freertos_timeout */);
+          if (received > 0)
           {
-              ssize_t claimed = heap_claim(mallocCapability, unclaimedBuffer);
-              Debug::log(
-			     "Claimed {} bytes for {}-byte buffer", claimed, received);
+              Claim c{mallocCapability, unclaimedBuffer};
               FreeRTOS_ReleaseUDPPayloadBuffer(unclaimedBuffer);
-              if (claimed <= 0)
+              if (!c)
               {
+                  Debug::log("Failed to claim socket.");
                   return -ENOMEM;
               }
+
+              Debug::log("Claimed {}-byte buffer", received);
               Capability claimedBuffer{unclaimedBuffer};
               claimedBuffer.bounds() = received;
+
               if (heap_claim_fast(timeout, address, port) < 0)
               {
                   return -ETIMEDOUT;
               }
+
               if (address != nullptr)
               {
                   if (!check_pointer<PermissionSet{Permission::Store}>(address))
@@ -705,19 +708,18 @@ NetworkReceiveResult network_socket_receive_from(Timeout *timeout,
               }
               if (port != nullptr)
               {
-                  if (!check_pointer<PermissionSet{Permission::Store}>(address))
+                  if (!check_pointer<PermissionSet{Permission::Store}>(port))
                   {
                       return -EPERM;
                   }
                   *port = FreeRTOS_ntohs(remoteAddress.sin_port);
               }
-              if (received > 0)
-              {
-                  buffer = claimedBuffer;
-                  return received;
-              }
+
+              buffer = claimedBuffer;
+              c.release();
+              return received;
           }
-          else if (received < 0)
+          if (received < 0)
           {
               if (received == -pdFREERTOS_ERRNO_ENOTCONN)
               {
@@ -728,12 +730,13 @@ NetworkReceiveResult network_socket_receive_from(Timeout *timeout,
               {
                   return -ETIMEDOUT;
               }
+
               // Something went wrong?
               Debug::log("Receive failed with unexpected error: {}", received);
               return -EINVAL;
           }
-          return received;
-	   },
+          return received; // We had `received` == 0.
+	   } /* with_sealed_socket */,
 	   socket);
 	return {result, buffer};
 }