add configuration to preserve path seperator in URIs

src/aws-cpp-sdk-core/include/aws/core/Aws.h

@@ -105,6 +105,12 @@ namespace Aws
          * Disable legacy URL encoding that leaves `$&,:@=` unescaped for legacy purposes.
          */
         bool compliantRfc3986Encoding;
+        /**
+         * When construting Path sergements in a URI preserve path serperators instead of collapsing
+         * slashes. This is useful for aligning with other SDKs and tools on key path for S3 objects
+         * as currently the C++ SDK sanatizes the path.
+         */
+        bool preservePathSerperators  = false;
     };
 
     /**

src/aws-cpp-sdk-core/include/aws/core/http/URI.h

@@ -24,6 +24,9 @@ namespace Aws
         extern bool s_compliantRfc3986Encoding;
         AWS_CORE_API void SetCompliantRfc3986Encoding(bool compliant);
 
+        extern bool s_preservePathSeperators;
+        AWS_CORE_API void SetPreservePathSeperators(bool preservePathSerperators);
+
         //per https://tools.ietf.org/html/rfc3986#section-3.4 there is nothing preventing servers from allowing
         //multiple values for the same key. So use a multimap instead of a map.
         typedef Aws::MultiMap<Aws::String, Aws::String> QueryStringParameterCollection;
@@ -135,7 +138,10 @@ namespace Aws
                 Aws::StringStream ss;
                 ss << pathSegments;
                 Aws::String segments = ss.str();
-                for (const auto& segment : Aws::Utils::StringUtils::Split(segments, '/'))
+                const auto splitOption = s_preservePathSeperators
+                                           ? Utils::StringUtils::SplitOptions::PRESERVE_DELIMETERS
+                                           : Utils::StringUtils::SplitOptions::NOT_SET;
+                for (const auto& segment : Aws::Utils::StringUtils::Split(segments, '/', splitOption))
                 {
                     m_pathSegments.push_back(segment);
                 }

src/aws-cpp-sdk-core/include/aws/core/utils/StringUtils.h

@@ -81,7 +81,12 @@ namespace Aws
                 /**
                  * Includes empty entries in the vector returned by Split()
                  */
-                INCLUDE_EMPTY_ENTRIES
+                INCLUDE_EMPTY_ENTRIES,
+                /**
+                 * Include delimeter in vector returned, however removing leading and trailing
+                 * delimeters.
+                 */
+                PRESERVE_DELIMETERS,
             };
 
             /**
@@ -116,6 +121,14 @@ namespace Aws
              */
             static Aws::Vector<Aws::String> Split(const Aws::String& toSplit, char splitOn, size_t numOfTargetParts, SplitOptions option);
 
+            /**
+             * Splits a string on delimeter, keeping the delimeter in the vector returned.
+             * @param toSplit, the original string to split
+             * @param splitOn, the delimiter you want to use.
+             * @param numOfTargetParts, how many target parts you want to get, if it is 0, as many as possible.
+             */
+            static Aws::Vector<Aws::String> SplitWithDelimeters(const Aws::String& toSplit, char splitOn, size_t numOfTargetParts);
+
             /**
             * Splits a string on new line characters.
             */

src/aws-cpp-sdk-core/source/Aws.cpp

@@ -155,6 +155,7 @@ namespace Aws
         Aws::Http::SetInitCleanupCurlFlag(options.httpOptions.initAndCleanupCurl);
         Aws::Http::SetInstallSigPipeHandlerFlag(options.httpOptions.installSigPipeHandler);
         Aws::Http::SetCompliantRfc3986Encoding(options.httpOptions.compliantRfc3986Encoding);
+        Aws::Http::SetPreservePathSeperators(options.httpOptions.preservePathSerperators);
         Aws::Http::InitHttp();
         Aws::InitializeEnumOverflowContainer();
         cJSON_AS4CPP_Hooks hooks;

src/aws-cpp-sdk-core/source/http/URI.cpp

@@ -27,6 +27,9 @@ const char* SEPARATOR = "://";
 bool s_compliantRfc3986Encoding = false;
 void SetCompliantRfc3986Encoding(bool compliant) { s_compliantRfc3986Encoding = compliant; }
 
+bool s_preservePathSeperators = false;
+void SetPreservePathSeperators(bool preservePathSerperators) { s_preservePathSeperators = preservePathSerperators; }
+
 Aws::String urlEncodeSegment(const Aws::String& segment, bool rfcEncoded = false)
 {
     // consolidates legacy escaping logic into one local method
@@ -199,8 +202,18 @@ Aws::String URI::GetPath() const
 
     for (auto const& segment : m_pathSegments)
     {
-        path.push_back('/');
-        path.append(segment);
+        if((s_preservePathSeperators && segment == "/"))
+        {
+            path.push_back('/');
+        }
+        else
+        {
+            if (!s_preservePathSeperators)
+            {
+                path.push_back('/');
+            }
+            path.append(segment);
+        }
     }
 
     if (m_pathSegments.empty() || m_pathHasTrailingSlash)
@@ -217,7 +230,18 @@ Aws::String URI::GetURLEncodedPath() const
 
     for (auto const& segment : m_pathSegments)
     {
-        ss << '/' << StringUtils::URLEncode(segment.c_str());
+        if((s_preservePathSeperators && segment == "/"))
+        {
+            ss << "/";
+        }
+        else
+        {
+            if (!s_preservePathSeperators)
+            {
+                ss << "/";
+            }
+            ss << StringUtils::URLEncode(segment.c_str());
+        }
     }
 
     if (m_pathSegments.empty() || m_pathHasTrailingSlash)
@@ -237,7 +261,18 @@ Aws::String URI::GetURLEncodedPathRFC3986() const
     // (mostly; there is some non-standards legacy support that can be disabled)
     for (const auto& segment : m_pathSegments)
     {
-        ss << '/' << urlEncodeSegment(segment, m_useRfcEncoding);
+        if((s_preservePathSeperators && segment == "/"))
+        {
+            ss << "/";
+        }
+        else
+        {
+            if (!s_preservePathSeperators)
+            {
+                ss << "/";
+            }
+            ss << urlEncodeSegment(segment, m_useRfcEncoding);
+        }
     }
 
     if (m_pathSegments.empty() || m_pathHasTrailingSlash)

src/aws-cpp-sdk-core/source/utils/StringUtils.cpp

@@ -90,6 +90,11 @@ Aws::Vector<Aws::String> StringUtils::Split(const Aws::String& toSplit, char spl
 
 Aws::Vector<Aws::String> StringUtils::Split(const Aws::String& toSplit, char splitOn, size_t numOfTargetParts, SplitOptions option)
 {
+    if (option == SplitOptions::PRESERVE_DELIMETERS)
+    {
+        return StringUtils::SplitWithDelimeters(toSplit, splitOn, numOfTargetParts);
+    }
+
     Aws::Vector<Aws::String> returnValues;
     Aws::StringStream input(toSplit);
     Aws::String item;
@@ -128,6 +133,28 @@ Aws::Vector<Aws::String> StringUtils::Split(const Aws::String& toSplit, char spl
     return returnValues;
 }
 
+Aws::Vector<Aws::String> StringUtils::SplitWithDelimeters(const Aws::String& toSplit, char splitOn, size_t numOfTargetParts)
+{
+    Aws::Vector<Aws::String> returnValues;
+    size_t start = 0;
+    size_t found = toSplit.find_first_of(splitOn, start);
+
+    while (returnValues.size() < numOfTargetParts && found != std::string::npos) {
+        if (found > start) {
+            returnValues.push_back(toSplit.substr(start, found - start));
+        }
+        returnValues.push_back(toSplit.substr(found, 1));
+        start = found + 1;
+        found = toSplit.find_first_of(splitOn, start);
+    }
+
+    if (start < toSplit.length()) {
+        returnValues.push_back(toSplit.substr(start));
+    }
+
+    return returnValues;
+}
+
 Aws::Vector<Aws::String> StringUtils::SplitOnLine(const Aws::String& toSplit)
 {
     Aws::StringStream input(toSplit);