Sync to TFS

Author: ras0219-msft

Build/version.props

@@ -4,7 +4,7 @@
     <CppRestBaseFileName>cpprest</CppRestBaseFileName>
     <CppRestSDKVersionMajor>2</CppRestSDKVersionMajor>
     <CppRestSDKVersionMinor>0</CppRestSDKVersionMinor>
-    <CppRestSDKVersionRevision>0</CppRestSDKVersionRevision>
+    <CppRestSDKVersionRevision>1</CppRestSDKVersionRevision>
     <CppRestSDKVersionFileSuffix>$(CppRestSDKVersionMajor)_$(CppRestSDKVersionMinor)</CppRestSDKVersionFileSuffix>
     <CppRestSDKVersionString>$(CppRestSDKVersionMajor).$(CppRestSDKVersionMinor)</CppRestSDKVersionString>
   </PropertyGroup>

Release/include/cpprest/version.h

@@ -15,7 +15,7 @@
 *
 * ==--==
 */
-#define CPPREST_VERSION_REVISION 0
+#define CPPREST_VERSION_REVISION 1
 #define CPPREST_VERSION_MINOR 0
 #define CPPREST_VERSION_MAJOR 2
 

Release/nuget/cpprestsdk.autopkg

@@ -1,7 +1,7 @@
 nuget {
 	nuspec {
 		id = cpprestsdk;
-		version : 2.0.0;
+		version : 2.0.1;
 		title: C++ REST SDK;
 		authors: {casablancacore};
 		owners: {Microsoft, Visual C++};
@@ -11,7 +11,7 @@ nuget {
 		requireLicenseAcceptance: true;
 		summary: "The C++ REST SDK is a cross-platform, modern, and asynchronous library that enables developers to access and author connected applications";
 		description: "This library is a Microsoft effort to support cloud-based client-server communication in native code using a modern asynchronous C++ API design. The C++ REST SDK (codename "Casablanca") is a project to start exploring how to best support C++ developers who want to take advantage of the radical shift in software architecture that cloud computing represents.";
-		releaseNotes: "Release of C++ Rest SDK 2.0.0 libraries.";
+		releaseNotes: "Release of C++ Rest SDK 2.0.1 libraries.";
 		copyright: Copyright 2013;
 		tags: {REST, native, C++, JSON, Casablanca, Http, Uri};
 	};

Release/src/http/client/http_win7.cpp

@@ -1177,37 +1177,11 @@ class winhttp_client : public _http_client_communicator
                         return;
                     }
 
-                    size_t content_length = 0;
-                    utility::string_t transfer_encoding;
-
-                    bool has_cnt_length = response.headers().match(header_names::content_length, content_length);
-                    bool has_xfr_encode = response.headers().match(header_names::transfer_encoding, transfer_encoding);
-
-                    // Determine if there is a msg body that needs to be read
-                    bool hasMsgBody = (has_cnt_length && (content_length > 0)) || (has_xfr_encode);
-
-                    if (!hasMsgBody)
-                    {
-                        auto progress = p_request_context->m_request._get_impl()->_progress_handler();
-                        if ( progress )
-                        {
-                            try { (*progress)(message_direction::download, 0); } catch(...)
-                            {
-                                p_request_context->report_exception(std::current_exception());
-                                return;
-                            }
-                        }
-
-                        p_request_context->complete_request(0);
-                        return;
-                    }
-
                     // HTTP Specification states:
                     // If a message is received with both a Transfer-Encoding header field 
                     // and a Content-Length header field, the latter MUST be ignored.
-
-                    // At least one of them should be set
-                    _ASSERTE(has_xfr_encode || has_cnt_length);
+                    // 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))
@@ -1241,6 +1215,18 @@ class winhttp_client : public _http_client_communicator
                     }
                     else
                     {
+                        // No more data available, complete the request.
+                        auto progress = p_request_context->m_request._get_impl()->_progress_handler();
+                        if (progress)
+                        {
+                            try { (*progress)(message_direction::download, p_request_context->m_downloaded); }
+                            catch (...)
+                            {
+                                p_request_context->report_exception(std::current_exception());
+                                return;
+                            }
+                        }
+
                         p_request_context->complete_request((size_t)p_request_context->m_downloaded);
                     }
                     break;

Release/src/http/common/http_helpers.cpp

@@ -118,6 +118,11 @@ namespace details
             return;
         }
         charset = possible_charset.substr(equals_index + 1);
+        // Remove the redundant ';' at the end of charset.
+        while (charset.back() == ';')
+        {
+            charset.pop_back();
+        }
         trim_whitespace(charset);
         if (charset.front() == _XPLATSTR('"') && charset.back() == _XPLATSTR('"')) 
         {

Release/src/http/listener/http_windows_server.cpp

@@ -513,29 +513,31 @@ void windows_request_context::async_process_request(HTTP_REQUEST_ID request_id,
 void windows_request_context::read_headers_io_completion(DWORD error_code, DWORD)
 {
     if(error_code != NO_ERROR)
+    {
+        m_msg.reply(status_codes::InternalError);
+    }
+    else
+    {
+        // Parse headers.
+        // CookedUrl.pFullUrl contains the canonicalized URL and it is not encoded
+        // However, Query strings are opaque to http.sys and are passed as-is => CookedUrl.pFullUrl
+        // contains an already encoded version of query string.
+        uri_builder builder(uri::encode_uri(m_request->CookedUrl.pFullUrl));
+        if (m_request->CookedUrl.QueryStringLength != 0)
         {
-            m_msg.reply(status_codes::InternalError);
+            builder.set_query(uri::decode(builder.query()));
         }
-        else
-        {
-            // Parse headers.
-            // We have no way of getting at the full raw encoded URI that was sent across the wire
-            // so we have to access a already decoded version and re-encode it. But since we are dealing
-            // with a full URI we won't handle encoding all possible cases. I don't see any way around this
-            // right now.
-            // TFS # 392606
-            uri encoded_uri = uri::encode_uri(m_request->CookedUrl.pFullUrl);
-            m_msg.set_request_uri(encoded_uri);
-            m_msg.set_method(parse_request_method(m_request));
-            parse_http_headers(m_request->Headers, m_msg.headers());
-
-            // Start reading in body from the network.
-            m_msg._get_impl()->_prepare_to_receive_data();
-            read_request_body_chunk();
+        m_msg.set_request_uri(builder.to_uri());
+        m_msg.set_method(parse_request_method(m_request));
+        parse_http_headers(m_request->Headers, m_msg.headers());
 
-            // Dispatch request to the http_listener.
-            dispatch_request_to_listener(m_msg, (web::http::experimental::listener::details::http_listener_impl *)m_request->UrlContext);
-        }
+        // Start reading in body from the network.
+        m_msg._get_impl()->_prepare_to_receive_data();
+        read_request_body_chunk();
+
+        // Dispatch request to the http_listener.
+        dispatch_request_to_listener(m_msg, (web::http::experimental::listener::details::http_listener_impl *)m_request->UrlContext);
+    }
 }
 
 void windows_request_context::read_request_body_chunk()

Release/tests/Functional/http/client/connections_and_errors.cpp

@@ -379,6 +379,18 @@ TEST_FIXTURE(uri_address, cancel_while_downloading_data, "Ignore:Linux", "NYI",
 }
 #endif
 
+TEST_FIXTURE(uri_address, no_transfer_encoding_content_length, "Ignore", "Manual")
+{
+    http_client client(U("http://ws.audioscrobbler.com/2.0/?method=artist.gettoptracks&artist=cher&api_key=6fcd59047568e89b1615975081258990&format=json"));
+
+    client.request(methods::GET).then([](http_response response){
+        VERIFY_IS_FALSE(response.headers().has(header_names::content_length) 
+            && response.headers().has(header_names::transfer_encoding));
+        return response.extract_string();
+    }).then([](string_t result){
+        VERIFY_ARE_EQUAL(result.size(), 34686);  // hardcoded the content size here, need to check the correct number for manual test.
+    }).wait();
+}
 #pragma endregion
 
 } // SUITE(connections_and_errors)

Release/tests/Functional/http/client/header_tests.cpp

@@ -353,6 +353,37 @@ TEST_FIXTURE(uri_address, date_header)
     VERIFY_ARE_EQUAL(value.to_string(), foundValue);
 }
 
+
+TEST_FIXTURE(uri_address, parsing_content_type_redundantsemicolon_json)
+{
+    test_http_server::scoped_server scoped(m_uri);
+    web::json::value body = web::json::value::string(U("Json body"));
+
+    scoped.server()->next_request().then([&](test_request *p_request){
+        std::map<utility::string_t, utility::string_t> headers;
+        headers[header_names::content_type] = U("application/json; charset=utf-8;;;;");
+        p_request->reply(200, U("OK"), headers, utility::conversions::to_utf8string(body.serialize()));
+    });
+
+    http_client client(m_uri);
+    auto resp = client.request(methods::GET).get();
+    VERIFY_ARE_EQUAL(resp.extract_json().get().serialize(), body.serialize());
+}
+
+TEST_FIXTURE(uri_address, parsing_content_type_redundantsemicolon_string)
+{
+    test_http_server::scoped_server scoped(m_uri);
+    std::string body("Body");
+    scoped.server()->next_request().then([&](test_request *p_request){
+        std::map<utility::string_t, utility::string_t> headers;
+        headers[header_names::content_type] = U("text/plain; charset  =  UTF-8;;;; ");
+        p_request->reply(200, U("OK"), headers, body);
+    });
+
+    http_client client(m_uri);
+    auto resp = client.request(methods::GET).get();
+    VERIFY_ARE_EQUAL(resp.extract_string().get(), utility::conversions::to_string_t(body));
+}
 } // SUITE(header_tests)
 
 }}}}

Release/tests/Functional/http/listener/connections_and_errors.cpp

@@ -151,7 +151,7 @@ TEST_FIXTURE(uri_address, try_port_already_in_use, "Ignore:Linux", "Bug 879077",
     VERIFY_THROWS(listener.open().wait(), http_exception);
 }
 
-TEST_FIXTURE(uri_address, reply_after_starting_close, "TFS", "901808")
+TEST_FIXTURE(uri_address, reply_after_starting_close, "Ignore", "901808")
 {
     http_listener listener(m_uri);
     listener.open().wait();

Release/tests/Functional/http/listener/listener_construction_tests.cpp

@@ -111,11 +111,8 @@ TEST_FIXTURE(uri_address, various_uris)
 TEST_FIXTURE(uri_address, uri_routing)
 {
     http_listener listener1(web::http::uri_builder(m_uri).append_path(U("path1")).to_uri());
-    listener1.open().wait();
     http_listener listener2(web::http::uri_builder(m_uri).append_path(U("path2")).to_uri());
-    listener2.open().wait();
     http_listener listener3(web::http::uri_builder(m_uri).append_path(U("path1/path2")).to_uri());
-    listener3.open().wait();
 
     test_http_client::scoped_client client(m_uri);
     test_http_client * p_client = client.client();
@@ -125,14 +122,19 @@ TEST_FIXTURE(uri_address, uri_routing)
     {
         request.reply(status_codes::OK);
     });
+    listener1.open().wait();
+
     listener2.support([](http_request request)
     {
         request.reply(status_codes::Created);
     });
+    listener2.open().wait();
+
     listener3.support([](http_request request)
     {
         request.reply(status_codes::Accepted);
     });
+    listener3.open().wait();
 
     VERIFY_ARE_EQUAL(0, p_client->request(methods::GET, U("/path1/")));
     p_client->next_response().then([](test_response *p_response)
@@ -156,6 +158,10 @@ TEST_FIXTURE(uri_address, uri_routing)
     {
         http_asserts::assert_test_response_equals(p_response, status_codes::NotFound);
     }).wait();
+
+    listener1.close().wait();
+    listener2.close().wait();
+    listener3.close().wait();
 }
 
 TEST_FIXTURE(uri_address, uri_error_cases)