create a blocking + cancellable Socket::readBytes method

ixwebsocket/IXHttpClient.cpp

@@ -231,19 +231,15 @@ namespace ix
 
             payload.reserve(contentLength);
 
-            // FIXME: very inefficient way to read bytes, but it works...
-            for (int i = 0; i < contentLength; ++i)
+            auto chunkResult = _socket->readBytes(contentLength, isCancellationRequested);
+            if (!chunkResult.first)
             {
-                char c;
-                if (!_socket->readByte(&c, isCancellationRequested))
-                {
-                    return std::make_tuple(code, HttpErrorCode_ReadError,
-                                           headers, payload, "Cannot read byte",
-                                           uploadSize, downloadSize);
-                }
-
-                payload += c;
+                errorMsg = "Cannot read chunk";
+                return std::make_tuple(code, HttpErrorCode_ChunkReadError,
+                                       headers, payload, errorMsg,
+                                       uploadSize, downloadSize);
             }
+            payload += chunkResult.second;
         }
         else if (headers.find("Transfer-Encoding") != headers.end() &&
                  headers["Transfer-Encoding"] == "chunked")
@@ -277,22 +273,18 @@ namespace ix
 
                 payload.reserve(payload.size() + chunkSize);
 
-                // Read another line
-
-                for (uint64_t i = 0; i < chunkSize; ++i)
+                // Read a chunk
+                auto chunkResult = _socket->readBytes(chunkSize, isCancellationRequested);
+                if (!chunkResult.first)
                 {
-                    char c;
-                    if (!_socket->readByte(&c, isCancellationRequested))
-                    {
-                        errorMsg = "Cannot read byte";
-                        return std::make_tuple(code, HttpErrorCode_ChunkReadError,
-                                               headers, payload, errorMsg,
-                                               uploadSize, downloadSize);
-                    }
-
-                    payload += c;
+                    errorMsg = "Cannot read chunk";
+                    return std::make_tuple(code, HttpErrorCode_ChunkReadError,
+                                           headers, payload, errorMsg,
+                                           uploadSize, downloadSize);
                 }
+                payload += chunkResult.second;
 
+                // Read the line that terminates the chunk (\r\n)
                 lineResult = _socket->readLine(isCancellationRequested);
 
                 if (!lineResult.first)

ixwebsocket/IXSocket.cpp

@@ -251,7 +251,8 @@ namespace ix
         {
             if (!readByte(&c, isCancellationRequested))
             {
-                return std::make_pair(false, std::string());
+                // Return what we were able to read
+                return std::make_pair(false, line);
             }
 
             line += c;
@@ -259,4 +260,26 @@ namespace ix
 
         return std::make_pair(true, line);
     }
+
+    std::pair<bool, std::string> Socket::readBytes(
+        size_t length,
+        const CancellationRequest& isCancellationRequested)
+    {
+        char c;
+        std::string buffer;
+        buffer.reserve(length);
+
+        for (size_t i = 0; i < length; ++i)
+        {
+            if (!readByte(&c, isCancellationRequested))
+            {
+                // Return what we were able to read
+                return std::make_pair(false, buffer);
+            }
+
+            buffer += c;
+        }
+
+        return std::make_pair(true, buffer);
+    }
 }

ixwebsocket/IXSocket.h

@@ -58,7 +58,12 @@ namespace ix
                       const CancellationRequest& isCancellationRequested);
         bool writeBytes(const std::string& str,
                         const CancellationRequest& isCancellationRequested);
-        std::pair<bool, std::string> readLine(const CancellationRequest& isCancellationRequested);
+
+        std::pair<bool, std::string> readLine(
+            const CancellationRequest& isCancellationRequested);
+        std::pair<bool, std::string> readBytes(
+            size_t length,
+            const CancellationRequest& isCancellationRequested);
 
         static int getErrno();
         static bool init(); // Required on Windows to initialize WinSocket