Merge remote-tracking branch 'upstream/development' into cancellation

Author: Valtteri Heikkila

Release/include/cpprest/http_client.h

@@ -98,7 +98,7 @@ class http_client_config
     http_client_config() : 
         m_guarantee_order(false),
         m_timeout(utility::seconds(30)),
-        m_chunksize(64 * 1024)
+        m_chunksize(0)
 #if !defined(__cplusplus_winrt)
         , m_validate_certificates(true)
 #endif
@@ -227,7 +227,7 @@ class http_client_config
     /// <returns>The internal buffer size used by the http client when sending and receiving data from the network.</returns>
     size_t chunksize() const
     {
-        return m_chunksize;
+        return m_chunksize == 0 ? 64 * 1024 : m_chunksize;
     }
 
     /// <summary>
@@ -240,6 +240,16 @@ class http_client_config
         m_chunksize = size;
     }
 
+    /// <summary>
+    /// Returns true if the default chunk size is in use.
+    /// <remarks>If true, implementations are allowed to choose whatever size is best.</remarks>
+    /// </summary>
+    /// <returns>True if default, false if set by user.</returns>
+    bool is_default_chunksize() const
+    {
+        return m_chunksize == 0;
+    }
+
 #if !defined(__cplusplus_winrt)
     /// <summary>
     /// Gets the server certificate validation property.

Release/include/cpprest/http_client_impl.h

@@ -140,7 +140,7 @@ class request_context
     /// <summary>
     /// Completes this request, setting the underlying task completion event, and cleaning up the handles
     /// </summary>
-    void complete_request(size_t body_size)
+    void complete_request(utility::size64_t body_size)
     {
         m_response._get_impl()->_complete(body_size);
 

Release/src/http/client/http_win7.cpp

@@ -589,7 +589,7 @@ class winhttp_client : public _http_client_communicator
             if(!WinHttpAddRequestHeaders(
                 winhttp_context->m_request_handle,
                 flattened_headers.c_str(),
-                (DWORD)flattened_headers.length(),
+                static_cast<DWORD>(flattened_headers.length()),
                 WINHTTP_ADDREQ_FLAG_ADD))
             {
                 request->report_error(GetLastError(), _XPLATSTR("Error adding request headers"));
@@ -704,6 +704,44 @@ class winhttp_client : public _http_client_communicator
         return has_proxy_credentials || has_server_credentials;
     }
 
+    // Helper function to query/read next part of response data from winhttp.
+    static void read_next_response_chunk(winhttp_request_context *pContext, DWORD bytesRead, bool firstRead=false)
+    {
+        const bool defaultChunkSize = pContext->m_http_client->client_config().is_default_chunksize();
+
+        // If user specified a chunk size then read in chunks instead of using query data avaliable.
+        if (defaultChunkSize)
+        {
+            if (!WinHttpQueryDataAvailable(pContext->m_request_handle, nullptr))
+            {
+                pContext->report_error(GetLastError(), _XPLATSTR("Error querying for http body data"));
+            }
+        }
+        else
+        {
+            // If bytes read is less than the chunksize this request is done.
+            const size_t chunkSize = pContext->m_http_client->client_config().chunksize();
+            if (bytesRead < chunkSize && !firstRead)
+            {
+                pContext->complete_request(pContext->m_downloaded);
+            }
+            else
+            {
+                auto writebuf = pContext->_get_writebuffer();
+                pContext->allocate_reply_space(writebuf.alloc(chunkSize), chunkSize);
+
+                if (!WinHttpReadData(
+                    pContext->m_request_handle,
+                    pContext->m_body_data.get(),
+                    static_cast<DWORD>(chunkSize),
+                    nullptr))
+                {
+                    pContext->report_error(GetLastError(), _XPLATSTR("Error receiving http response body chunk"));
+                }
+            }
+        }
+    }
+
     static void _transfer_encoding_chunked_write_data(_In_ winhttp_request_context * p_request_context)
     {
         const size_t chunk_size = p_request_context->m_http_client->client_config().chunksize();
@@ -751,7 +789,7 @@ class winhttp_client : public _http_client_communicator
             if (!WinHttpWriteData(
                 p_request_context->m_request_handle,
                 &p_request_context->m_body_data.get()[offset],
-                (DWORD) length,
+                static_cast<DWORD>(length),
                 nullptr))
             {
                 p_request_context->report_error(GetLastError(), _XPLATSTR("Error writing data"));
@@ -804,7 +842,7 @@ class winhttp_client : public _http_client_communicator
             if( !WinHttpWriteData(
                 p_request_context->m_request_handle,
                 p_request_context->m_body_data.get(),
-                (DWORD)to_write,
+                static_cast<DWORD>(to_write),
                 nullptr))
             {
                 p_request_context->report_error(GetLastError(), _XPLATSTR("Error writing data"));
@@ -846,7 +884,7 @@ class winhttp_client : public _http_client_communicator
                 if( !WinHttpWriteData(
                     p_request_context->m_request_handle,
                     p_request_context->m_body_data.get(),
-                    (DWORD)read,
+                    static_cast<DWORD>(read),
                     nullptr))
                 {
                     p_request_context->report_error(GetLastError(), _XPLATSTR("Error writing data"));
@@ -1072,7 +1110,7 @@ class winhttp_client : public _http_client_communicator
                         auto progress = p_request_context->m_request._get_impl()->_progress_handler();
                         if ( progress )
                         {
-                            p_request_context->m_uploaded += (size64_t)bytesWritten;
+                            p_request_context->m_uploaded += bytesWritten;
                             try { (*progress)(message_direction::upload, p_request_context->m_uploaded); } catch(...)
                             {
                                 p_request_context->report_exception(std::current_exception());
@@ -1157,11 +1195,7 @@ class winhttp_client : public _http_client_communicator
                     // If none of them is specified, the message length should be determined by the server closing the connection.
                     // http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.4
 
-                    // WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE callback determines whether this function was successful and the value of the parameters.
-                    if(!WinHttpQueryDataAvailable(hRequestHandle, nullptr))
-                    {
-                        p_request_context->report_error(GetLastError(), _XPLATSTR("Error querying for http body data"));
-                    }
+                    read_next_response_chunk(p_request_context, 0, true);
                     break;
                 }
             case WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE :
@@ -1172,16 +1206,13 @@ class winhttp_client : public _http_client_communicator
                     if(num_bytes > 0)
                     {
                         auto writebuf = p_request_context->_get_writebuffer();
-                        if ( !_check_streambuf(p_request_context, writebuf, _XPLATSTR("Output stream is not open")) )
-                            break;
-
                         p_request_context->allocate_reply_space(writebuf.alloc(num_bytes), num_bytes);
 
                         // Read in body all at once.
                         if(!WinHttpReadData(
                             hRequestHandle,
-                            (LPVOID)p_request_context->m_body_data.get(),
-                            (DWORD)num_bytes,
+                            p_request_context->m_body_data.get(),
+                            num_bytes,
                             nullptr))
                         {
                             p_request_context->report_error(GetLastError(), _XPLATSTR("Error receiving http body chunk"));
@@ -1201,75 +1232,65 @@ class winhttp_client : public _http_client_communicator
                             }
                         }
 
-                        p_request_context->complete_request((size_t)p_request_context->m_downloaded);
+                        p_request_context->complete_request(p_request_context->m_downloaded);
                     }
                     break;
                 }
             case WINHTTP_CALLBACK_STATUS_READ_COMPLETE :
                 {
                     // Status information length contains the number of bytes read.
-                    // WinHTTP will always fill the whole buffer or read nothing.
-                    // If number of bytes read is zero than we have reached the end.
+                    const DWORD bytesRead = statusInfoLength;
 
-                    if(statusInfoLength > 0)
+                    // Report progress about downloaded bytes.
+                    auto progress = p_request_context->m_request._get_impl()->_progress_handler();
+                    p_request_context->m_downloaded += statusInfoLength;
+                    if (progress)
                     {
-                        auto progress = p_request_context->m_request._get_impl()->_progress_handler();
-                        p_request_context->m_downloaded += (size64_t)statusInfoLength;
-                        if ( progress )
+                        try { (*progress)(message_direction::download, p_request_context->m_downloaded); }
+                        catch (...)
                         {
-                            try { (*progress)(message_direction::download, p_request_context->m_downloaded); } catch(...)
+                            p_request_context->report_exception(std::current_exception());
+                            return;
+                        }
+                    }
+
+                    // If no bytes have been read, then this is the end of the response.
+                    if (bytesRead == 0)
+                    {
+                        p_request_context->complete_request(p_request_context->m_downloaded);
+                        break;
+                    }
+
+                    // If the data was allocated directly from the buffer then commit, otherwise we still
+                    // need to write to the response stream buffer.
+                    auto writebuf = p_request_context->_get_writebuffer();
+                    if (p_request_context->is_externally_allocated())
+                    {
+                        writebuf.commit(bytesRead);
+                        read_next_response_chunk(p_request_context, bytesRead);
+                    }
+                    else
+                    {
+                        writebuf.putn(p_request_context->m_body_data.get(), bytesRead).then(
+                            [hRequestHandle, p_request_context, bytesRead] (pplx::task<size_t> op)
+                        {
+                            size_t written = 0;
+                            try { written = op.get(); }
+                            catch (...)
                             {
                                 p_request_context->report_exception(std::current_exception());
                                 return;
                             }
-                        }
-
-                        auto writebuf = p_request_context->_get_writebuffer();
-                        
-                        if ( p_request_context->is_externally_allocated() )
-                        {
-                            writebuf.commit(statusInfoLength);
 
-                            // Look for more data
-                            if (!WinHttpQueryDataAvailable(hRequestHandle, nullptr))
+                            // If we couldn't write everything, it's time to exit.
+                            if (written != bytesRead)
                             {
-                                p_request_context->report_error(GetLastError(), _XPLATSTR("Error querying for http body chunk"));
+                                p_request_context->report_exception(std::runtime_error("response stream unexpectedly failed to write the requested number of bytes"));
                                 return;
                             }
-                        }
-                        else 
-                        {
-                            writebuf.putn(p_request_context->m_body_data.get(), statusInfoLength).then(
-                                [hRequestHandle, p_request_context, statusInfoLength]
-                            (pplx::task<size_t> op)
-                            {
-                                size_t written = 0;
-                                try { written = op.get(); } catch(...)
-                                {
-                                    p_request_context->report_exception(std::current_exception());
-                                    return;
-                                }
-
-                                // If we couldn't write everything, it's time to exit.
-                                if ( written != statusInfoLength ) 
-                                {
-                                    p_request_context->report_exception(std::runtime_error("response stream unexpectedly failed to write the requested number of bytes"));
-                                    return;
-                                }
-
-                                // Look for more data
-                                if (!WinHttpQueryDataAvailable(hRequestHandle, nullptr))
-                                {
-                                    p_request_context->report_error(GetLastError(), _XPLATSTR("Error querying for http body chunk"));
-                                    return;
-                                }
-                            });
-                        }
-                    }
-                    else
-                    {
-                        // Done reading so set task completion event and close the request handle.
-                        p_request_context->complete_request((size_t)p_request_context->m_downloaded);
+
+                            read_next_response_chunk(p_request_context, bytesRead);
+                        });
                     }
                     break;
                 }

Release/src/http/client/http_win8.cpp

@@ -124,7 +124,7 @@ class HttpRequestCallback :
         if (m_request->m_exceptionPtr != nullptr)
             m_request->report_exception(m_request->m_exceptionPtr);
         else    
-            m_request->complete_request((size_t)m_request->m_downloaded);
+            m_request->complete_request(m_request->m_downloaded);
 
         // Break the circular reference loop.
         //     - winrt_request_context holds a reference to IXmlHttpRequest2

Release/src/json/json_parsing.cpp

@@ -18,7 +18,7 @@
 *
 * json_parsing.cpp
 *
-* HTTP Library: JSON parser and writer
+* HTTP Library: JSON parser
 *
 * For the latest on this and related APIs, please see http://casablanca.codeplex.com.
 *

Release/src/pplx/linux/pplxlinux.cpp

@@ -43,7 +43,7 @@ namespace details {
     {
         _PPLXIMP long GetCurrentThreadId()
         {
-            return static_cast<long>(pthread_self());
+            return reinterpret_cast<long>(reinterpret_cast<void*>(pthread_self()));
         }
 
         _PPLXIMP void YieldExecution()

Release/src/uri/uri_builder.cpp

@@ -80,7 +80,7 @@ uri_builder &uri_builder::append_query(const utility::string_t &query, bool is_e
         return *this;
     }
 
-    auto encoded_query = is_encode ? uri::encode_uri(query, uri::components::path) : query;
+    auto encoded_query = is_encode ? uri::encode_uri(query, uri::components::query) : query;
     auto thisQuery = this->query();
     if (thisQuery.empty())
     {