Added an overload for websockets allowing length to be auto-determined

Author: ras0219-msft

Release/include/cpprest/ws_msg.h

@@ -139,7 +139,7 @@ class websocket_outgoing_message
     /// <summary>
     /// Sets a UTF-8 message as the message body.
     /// </summary>
-    /// <params>UTF-8 String containing body of the message.</returns>
+    /// <param name="data">UTF-8 String containing body of the message.</param>
     void set_utf8_message(std::string data)
     {
         this->_set_message(std::move(data), websocket_message_type::text_message);
@@ -148,7 +148,18 @@ class websocket_outgoing_message
     /// <summary>
     /// Sets a UTF-8 message as the message body.
     /// </summary>
-    /// <params>casablanca input stream representing the body of the message.</returns>
+    /// <param name="istream">casablanca input stream representing the body of the message.</param>
+    /// <remarks>Upon sending, the entire stream will be buffered to determine the length.</remarks>
+    void set_utf8_message(concurrency::streams::istream istream)
+    {
+        this->_set_message(istream, SIZE_MAX, websocket_message_type::text_message);
+    }
+
+    /// <summary>
+    /// Sets a UTF-8 message as the message body.
+    /// </summary>
+    /// <param name="istream">casablanca input stream representing the body of the message.</param>
+    /// <param name="len">number of bytes to send</param>
     void set_utf8_message(concurrency::streams::istream istream, size_t len)
     {
         this->_set_message(istream, len, websocket_message_type::text_message);
@@ -157,12 +168,23 @@ class websocket_outgoing_message
     /// <summary>
     /// Sets binary data as the message body.
     /// </summary>
-    /// <params>casablanca input stream representing the body of the message.</returns>
+    /// <param name="istream">casablanca input stream representing the body of the message.</param>
+    /// <param name="len">number of bytes to send</param>
     void set_binary_message(concurrency::streams::istream istream, size_t len)
     {
         this->_set_message(istream, len, websocket_message_type::binary_message);
     }
 
+    /// <summary>
+    /// Sets binary data as the message body.
+    /// </summary>
+    /// <param name="istream">casablanca input stream representing the body of the message.</param>
+    /// <remarks>Upon sending, the entire stream will be buffered to determine the length.</remarks>
+    void set_binary_message(concurrency::streams::istream istream)
+    {
+        this->_set_message(istream, SIZE_MAX, websocket_message_type::binary_message);
+    }
+
 private:
 
     friend class details::winrt_client;

Release/src/websockets/client/ws_client.cpp

@@ -341,9 +341,9 @@ class ws_desktop_client : public _websocket_client_impl, public std::enable_shar
             return pplx::task_from_exception<void>(websocket_exception("Cannot send empty message."));
         }
 
-        if (length > UINT_MAX)
+        if (length >= UINT_MAX && length != SIZE_MAX)
         {
-            return pplx::task_from_exception<void>(websocket_exception("Message size too large. Ensure message length is less than or equal to UINT_MAX."));
+            return pplx::task_from_exception<void>(websocket_exception("Message size too large. Ensure message length is less than UINT_MAX."));
         }
 
         {
@@ -395,6 +395,47 @@ class ws_desktop_client : public _websocket_client_impl, public std::enable_shar
         auto& is_buf = msg._m_impl->streambuf();
         auto length = msg._m_impl->length();
 
+        if (length == SIZE_MAX)
+        {
+            // This indicates we should determine the length automatically.
+            if (is_buf.has_size())
+            {
+                // The user's stream knows how large it is -- there's no need to buffer.
+                auto buf_sz = is_buf.size();
+                if (buf_sz >= SIZE_MAX)
+                {
+                    websocket_exception wx(_XPLATSTR("Cannot send messages larger than SIZE_MAX."));
+                    msg.m_send_tce.set_exception(std::make_exception_ptr(wx));
+                    return;
+                }
+                length = static_cast<size_t>(buf_sz);
+                // We have determined the length and can proceed normally.
+            }
+            else
+            {
+                // The stream needs to be buffered.
+                concurrency::streams::container_buffer<std::vector<uint8_t>> stbuf;
+                auto is_buf_istream = is_buf.create_istream();
+                msg._m_impl->set_streambuf(stbuf);
+                is_buf_istream.read_to_end(stbuf).then([this_client,msg](pplx::task<size_t> t)
+                {
+                    try
+                    {
+                        auto sz = t.get();
+                        msg._m_impl->set_length(sz);
+                        this_client->send_msg(msg);
+                    }
+                    catch (...)
+                    {
+                        auto eptr = std::current_exception();
+                        msg.m_send_tce.set_exception(eptr);
+                    }
+                });
+                // We have postponed the call to send_msg() until after the data is buffered.
+                return;
+            }
+        }
+
         // First try to acquire the data (Get a pointer to the next already allocated contiguous block of data)
         // If acquire succeeds, send the data over the socket connection, there is no copy of data from stream to temporary buffer.
         // If acquire fails, copy the data to a temporary buffer managed by sp_allocated and send it over the socket connection.

Release/tests/Functional/websockets/client/send_msg_tests.cpp

@@ -392,6 +392,59 @@ TEST_FIXTURE(uri_address, send_multi_byte_utf8_msg)
     client.close().wait();
 }
 
+// Send a streamed text message without specifying length
+TEST_FIXTURE(uri_address, send_stream_utf8_msg_no_length)
+{
+    test_websocket_server server;
+
+    std::string body = "\xC3\xA0\xC3\xB8";
+    std::vector<uint8_t> msgbuf(body.begin(), body.end());
+
+    auto is = streams::container_stream<std::vector<uint8_t>>::open_istream(std::move(msgbuf));
+
+    websocket_client client;
+    {
+        server.next_message([body](test_websocket_msg msg) // Handler to verify the message sent by the client.
+        {
+            websocket_asserts::assert_message_equals(msg, body, test_websocket_message_type::WEB_SOCKET_UTF8_MESSAGE_TYPE);
+        });
+
+        client.connect(m_uri).wait();
+
+        websocket_outgoing_message msg;
+        msg.set_utf8_message(is);
+        client.send(msg).wait();
+    }
+
+    client.close().wait();
+}
+
+// Send a streamed binary message without specifying length
+TEST_FIXTURE(uri_address, send_stream_binary_msg_no_length)
+{
+    test_websocket_server server;
+
+    std::vector<uint8_t> body = { { 0, 1, 2, 0 } };
+
+    auto is = streams::container_stream<std::vector<uint8_t>>::open_istream(body);
+
+    websocket_client client;
+    {
+        server.next_message([body](test_websocket_msg msg) // Handler to verify the message sent by the client.
+        {
+            websocket_asserts::assert_message_equals(msg, body, test_websocket_message_type::WEB_SOCKET_BINARY_MESSAGE_TYPE);
+        });
+
+        client.connect(m_uri).wait();
+
+        websocket_outgoing_message msg;
+        msg.set_binary_message(is);
+        client.send(msg).wait();
+    }
+
+    client.close().wait();
+}
+
 } // SUITE(send_msg_tests)
 
 }}}}