Add support for HTTP/1.0 responses without 'Content-Lenght' header (#403)

Author: oleneveu

nanoFramework.System.Net.Http/Http/StreamContent.cs

@@ -96,21 +96,18 @@ protected override void SerializeToStream(Stream stream)
                 }
             }
 
-            while (totalRead < contentLength)
+            bool isDone = false;
+            while ((totalRead < contentLength) && !isDone)
             {
                 read = _content.Read(buffer, 0, buffer.Length);
+                isDone = (_content is IKnowWhenDone knowWhenDone && knowWhenDone.IsDone);
 
-                if (_content is IKnowWhenDone knowWhenDone && knowWhenDone.IsDone)
-                {
-                    //happens when a chunked response is at the end
-                    break;
-                }
-                else if (read == 0)
+                if (!isDone && (read == 0))
                 {
                     // need to let the native layer get more data
                     Thread.Sleep(10);
                 }
-                else
+                else if (read > 0)
                 {
                     totalRead += read;
                     stream.Write(buffer, 0, read);

nanoFramework.System.Net.Http/Http/System.Net._InputNetworkStreamWrapper.cs

@@ -323,7 +323,12 @@ public int ReadInternal(byte[] buffer, int offset, int size)
                 // then we read into internal buffer. 
                 if (size < read_buffer_size)
                 {
-                    if (0 == RefillInternalBuffer()) return 0;
+                    if (0 == RefillInternalBuffer())
+                    {
+                        // Handle the 'HTTP/1.0' case
+                        IsDone = IsHttp1_0Completed();
+                        return 0;
+                    }
 
                     dataBuffered = m_dataEnd - m_dataStart;
                     if (dataBuffered > 0)
@@ -341,7 +346,15 @@ public int ReadInternal(byte[] buffer, int offset, int size)
                 }
                 else // Do not replentish internal buffer. Read rest of data directly
                 {
-                    retVal += m_Stream.Read(buffer, offset, size);
+                    int bytesRead = m_Stream.Read(buffer, offset, size);
+                    retVal += bytesRead;
+
+                    // Handle the 'HTTP/1.0' case                    
+                    if ((bytesRead == 0) && IsHttp1_0Completed())
+                    {
+                        IsDone = true;
+                        return retVal;
+                    }
                 }
             }
 
@@ -357,6 +370,20 @@ public int ReadInternal(byte[] buffer, int offset, int size)
             return retVal;
         }
 
+        /// <summary>
+        /// Returns true if we are in 'HTTP/1.0' mode and the connection has been closed, which marks the end of the body.
+        /// </summary>
+        /// <remarks>
+        /// In 'HTTP/1.0' mode, where the content length is not transmitted in the response header and the server closes the connection to mark the end of the body.
+        /// (see: RFC9112, §6.3, point 8, https://www.rfc-editor.org/rfc/rfc9112#name-message-body-length)
+        /// </remarks>
+        private bool IsHttp1_0Completed()
+        {
+            return
+                (m_BytesLeftInResponse == -1) && !m_EnableChunkedDecoding &&                // We are in HTTP/1.0 mode
+                m_Socket.Poll(1, SelectMode.SelectRead) && (m_Socket.Available == 0);       // The socket is disconnected
+        }
+
         /// <summary>
         /// Impletments Write for the stream. 
         /// Since we do not have write buffering, all we do is delegate to the m_Stream.