Adding force option to extract_json and extract_string, this allows developers to use these methods regardless of content type/mime type. This helps workaround or deal with rare or uncommon mime types that we don't expect or know about.

Author: stgates

Release/include/cpprest/http_msg.h

@@ -224,8 +224,8 @@ class http_msg_base
     _ASYNCRTIMP void set_body(concurrency::streams::istream instream, utility::string_t contentType);
     _ASYNCRTIMP void set_body(concurrency::streams::istream instream, utility::size64_t contentLength, utility::string_t contentType);
 
-    _ASYNCRTIMP utility::string_t _extract_string();
-    _ASYNCRTIMP json::value _extract_json();
+    _ASYNCRTIMP utility::string_t _extract_string(bool force = false);
+    _ASYNCRTIMP json::value _extract_json(bool force = false);
     _ASYNCRTIMP std::vector<unsigned char> _extract_vector();
 
     virtual _ASYNCRTIMP utility::string_t to_string() const;
@@ -445,22 +445,24 @@ class http_response
     /// Extracts the body of the response message as a string value, checking that the content type is a MIME text type.
     /// A body can only be extracted once because in some cases an optimization is made where the data is 'moved' out.
     /// </summary>
+    /// <param name="force">If true, ignores the Content-Type header and assumes UTF-8.</param>
     /// <returns>String containing body of the message.</returns>
-    pplx::task<utility::string_t> extract_string() const
+    pplx::task<utility::string_t> extract_string(bool force = false) const
     {
         auto impl = _m_impl;
-        return pplx::create_task(_m_impl->_get_data_available()).then([impl](utility::size64_t) { return impl->_extract_string(); });
+        return pplx::create_task(_m_impl->_get_data_available()).then([impl, force](utility::size64_t) { return impl->_extract_string(force); });
     }
 
     /// <summary>
     /// Extracts the body of the response message into a json value, checking that the content type is application\json.
     /// A body can only be extracted once because in some cases an optimization is made where the data is 'moved' out.
     /// </summary>
+    /// <param name="force">If true, ignores the Content-Type header and assumes UTF-8.</param>
     /// <returns>JSON value from the body of this message.</returns>
-    pplx::task<json::value> extract_json() const
+    pplx::task<json::value> extract_json(bool force = false) const
     {
         auto impl = _m_impl;
-        return pplx::create_task(_m_impl->_get_data_available()).then([impl](utility::size64_t) { return impl->_extract_json(); });
+        return pplx::create_task(_m_impl->_get_data_available()).then([impl, force](utility::size64_t) { return impl->_extract_json(force); });
     }
 
     /// <summary>
@@ -826,22 +828,24 @@ class http_request
     /// Extract the body of the request message as a string value, checking that the content type is a MIME text type.
     /// A body can only be extracted once because in some cases an optimization is made where the data is 'moved' out.
     /// </summary>
+    /// <param name="force">If true, ignores the Content-Type header and assumes UTF-8.</param>
     /// <returns>String containing body of the message.</returns>
-    pplx::task<utility::string_t> extract_string()
+    pplx::task<utility::string_t> extract_string(bool force = false)
     {
         auto impl = _m_impl;
-        return pplx::create_task(_m_impl->_get_data_available()).then([impl](utility::size64_t) { return impl->_extract_string(); });
+        return pplx::create_task(_m_impl->_get_data_available()).then([impl, force](utility::size64_t) { return impl->_extract_string(force); });
     }
 
     /// <summary>
     /// Extracts the body of the request message into a json value, checking that the content type is application\json.
     /// A body can only be extracted once because in some cases an optimization is made where the data is 'moved' out.
     /// </summary>
+    /// <param name="force">If true, ignores the Content-Type header and assumes UTF-8.</param>
     /// <returns>JSON value from the body of this message.</returns>
-    pplx::task<json::value> extract_json() const
+    pplx::task<json::value> extract_json(bool force = false) const
     {
         auto impl = _m_impl;
-        return pplx::create_task(_m_impl->_get_data_available()).then([impl](utility::size64_t) { return impl->_extract_json(); });
+        return pplx::create_task(_m_impl->_get_data_available()).then([impl, force](utility::size64_t) { return impl->_extract_json(force); });
     }
 
     /// <summary>

Release/src/http/common/http_msg.cpp

@@ -196,21 +196,24 @@ void http_msg_base::_complete(utility::size64_t body_size, std::exception_ptr ex
     }
 }
 
-utility::string_t details::http_msg_base::_extract_string()
+utility::string_t details::http_msg_base::_extract_string(bool force)
 {
-    utility::string_t content, charset;
-    parse_content_type_and_charset(headers().content_type(), content, charset);
-
-    // If no Content-Type then just return an empty string.
-    if(content.empty())
+    utility::string_t content, charset = charset_types::utf8;
+    if (!force)
     {
-        return utility::string_t();
-    }
+        parse_content_type_and_charset(headers().content_type(), content, charset);
 
-    // Content-Type must have textual type.
-    if(!is_content_type_textual(content))
-    {
-        throw http_exception(textual_content_type_missing);
+        // If no Content-Type then just return an empty string.
+        if (content.empty())
+        {
+            return utility::string_t();
+        }
+
+        // Content-Type must have textual type.
+        if (!is_content_type_textual(content))
+        {
+            throw http_exception(textual_content_type_missing);
+        }
     }
 
     if (!instream())
@@ -287,22 +290,25 @@ utility::string_t details::http_msg_base::_extract_string()
     }
 }
 
-json::value details::http_msg_base::_extract_json()
+json::value details::http_msg_base::_extract_json(bool force)
 {
-    utility::string_t content, charset;
-    parse_content_type_and_charset(headers().content_type(), content, charset);
-
-    // If no Content-Type then just return a null json value.
-    if(content.empty())
+    utility::string_t content, charset = charset_types::utf8;
+    if (!force)
     {
-        return json::value();
-    }
+        parse_content_type_and_charset(headers().content_type(), content, charset);
 
-    // Content-Type must be "application/json" or one of the unofficial, but common JSON types.
-    if(!is_content_type_json(content))
-    {
-        const utility::string_t actualContentType = utility::conversions::to_string_t(content);
-        throw http_exception((_XPLATSTR("Content-Type must be JSON to extract (is: ") + actualContentType + _XPLATSTR(")")));
+        // If no Content-Type then just return a null json value.
+        if (content.empty())
+        {
+            return json::value();
+        }
+
+        // Content-Type must be "application/json" or one of the unofficial, but common JSON types.
+        if (!is_content_type_json(content))
+        {
+            const utility::string_t actualContentType = utility::conversions::to_string_t(content);
+            throw http_exception((_XPLATSTR("Content-Type must be JSON to extract (is: ") + actualContentType + _XPLATSTR(")")));
+        }
     }
 
     if (!instream())

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

@@ -153,6 +153,16 @@ TEST_FIXTURE(uri_address, extract_string)
 #endif
 }
 
+TEST_FIXTURE(uri_address, extract_string_force)
+{
+    test_http_server::scoped_server scoped(m_uri);
+    http_client client(m_uri);
+
+    std::string data("YOU KNOW ITITITITI");
+    http_response rsp = send_request_response(scoped.server(), &client, U("bad unknown charset"), data);
+    VERIFY_ARE_EQUAL(to_string_t(data), rsp.extract_string(true).get());
+}
+
 TEST_FIXTURE(uri_address, extract_string_incorrect)
 {
     test_http_server::scoped_server scoped(m_uri);
@@ -272,6 +282,16 @@ TEST_FIXTURE(uri_address, extract_json)
     VERIFY_ARE_EQUAL(data.serialize(), rsp.extract_json().get().serialize());
 }
 
+TEST_FIXTURE(uri_address, extract_json_force)
+{
+    test_http_server::scoped_server scoped(m_uri);
+    http_client client(m_uri);
+
+    json::value data = json::value::string(U("JSON string object"));
+    http_response rsp = send_request_response(scoped.server(), &client, U("bad charset"), to_utf8string(data.serialize()));
+    VERIFY_ARE_EQUAL(data.serialize(), rsp.extract_json(true).get().serialize());
+}
+
 TEST_FIXTURE(uri_address, extract_json_incorrect)
 {
     test_http_server::scoped_server scoped(m_uri);

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

@@ -52,6 +52,28 @@ TEST_FIXTURE(uri_address, extract_string)
     listener.close().wait();
 }
 
+TEST_FIXTURE(uri_address, extract_string_force)
+{
+    http_listener listener(m_uri);
+    listener.open().wait();
+    test_http_client::scoped_client client(m_uri);
+    test_http_client * p_client = client.client();
+    std::string data("HEHEHE");
+
+    listener.support([&](http_request request)
+    {
+        VERIFY_ARE_EQUAL(to_string_t(data), request.extract_string(true).get());
+        request.reply(status_codes::OK);
+    });
+    VERIFY_ARE_EQUAL(0, p_client->request(methods::PUT, U(""), U("unknown charset"), data));
+    p_client->next_response().then([](test_response *p_response)
+    {
+        http_asserts::assert_test_response_equals(p_response, status_codes::OK);
+    }).wait();
+
+    listener.close().wait();
+}
+
 TEST_FIXTURE(uri_address, extract_json)
 {
     http_listener listener(m_uri);
@@ -78,6 +100,30 @@ TEST_FIXTURE(uri_address, extract_json)
     listener.close().wait();
 }
 
+TEST_FIXTURE(uri_address, extract_json_force)
+{
+    http_listener listener(m_uri);
+    listener.open().wait();
+    test_http_client::scoped_client client(m_uri);
+    test_http_client * p_client = client.client();
+
+    json::value j(true);
+    listener.support([&](http_request request)
+    {
+        const json::value j_found = request.extract_json(true).get();
+        VERIFY_ARE_EQUAL(j.serialize(), j_found.serialize());
+        request.reply(status_codes::OK);
+    });
+    std::string data = to_utf8string(j.serialize());
+    VERIFY_ARE_EQUAL(0, p_client->request(methods::PUT, U(""), U("unknown charset"), data));
+    p_client->next_response().then([](test_response *p_response)
+    {
+        http_asserts::assert_test_response_equals(p_response, status_codes::OK);
+    }).wait();
+
+    listener.close().wait();
+}
+
 TEST_FIXTURE(uri_address, empty_vector)
 {
     http_listener listener(m_uri);