common: support parsing cookies into a map

source/common/http/utility.cc

@@ -254,46 +254,69 @@ bool maybeAdjustForIpv6(absl::string_view absolute_url, uint64_t& offset, uint64
   return true;
 }
 
-absl::string_view parseCookie(absl::string_view cookie_value, absl::string_view key) {
-  // Split the cookie header into individual cookies.
-  for (const auto& s : StringUtil::splitToken(cookie_value, ";")) {
-    // Find the key part of the cookie (i.e. the name of the cookie).
-    size_t first_non_space = s.find_first_not_of(' ');
-    size_t equals_index = s.find('=');
-    if (equals_index == absl::string_view::npos) {
-      // The cookie is malformed if it does not have an `=`. Continue
-      // checking other cookies in this header.
-      continue;
-    }
-    absl::string_view k = s.substr(first_non_space, equals_index - first_non_space);
-    // If the key matches, parse the value from the rest of the cookie string.
-    if (k == key) {
+void forEachCookie(const HeaderMap& headers, const LowerCaseString& cookie_header,
+                   const std::function<bool (const absl::string_view&, const absl::string_view&)> cookie_consumer) {
+  const Http::HeaderMap::GetResult cookie_headers = headers.get(cookie_header);
+
+  for (size_t index = 0; index < cookie_headers.size(); index++) {
+    auto cookie_header_value = cookie_headers[index]->value().getStringView();
+
+    // Split the cookie header into individual cookies.
+    for (const auto& s : StringUtil::splitToken(cookie_header_value, ";")) {
+      // Find the key part of the cookie (i.e. the name of the cookie).
+      size_t first_non_space = s.find_first_not_of(' ');
+      size_t equals_index = s.find('=');
+      if (equals_index == absl::string_view::npos) {
+        // The cookie is malformed if it does not have an `=`. Continue
+        // checking other cookies in this header.
+        continue;
+      }
+      absl::string_view k = s.substr(first_non_space, equals_index - first_non_space);
       absl::string_view v = s.substr(equals_index + 1, s.size() - 1);
 
       // Cookie values may be wrapped in double quotes.
       // https://tools.ietf.org/html/rfc6265#section-4.1.1
       if (v.size() >= 2 && v.back() == '"' && v[0] == '"') {
         v = v.substr(1, v.size() - 2);
       }
-      return v;
+
+      bool continue_iteration = cookie_consumer(k, v);
+      if (!continue_iteration) {
+        return;
+      }
     }
   }
-  return EMPTY_STRING;
 }
 
 std::string parseCookie(const HeaderMap& headers, const std::string& key,
                         const LowerCaseString& cookie) {
-  const Http::HeaderMap::GetResult cookie_headers = headers.get(cookie);
+  std::string value;
 
-  for (size_t index = 0; index < cookie_headers.size(); index++) {
-    auto cookie_header_value = cookie_headers[index]->value().getStringView();
-    absl::string_view result = parseCookie(cookie_header_value, key);
-    if (!result.empty()) {
-      return std::string{result};
+  // Iterate over each cookie & return if its value is not empty.
+  forEachCookie(headers, cookie, [&key, &value] (const absl::string_view& k, const absl::string_view& v) -> bool {
+    if (key == k && !v.empty()) {
+      value = std::string{v};
+      return false;
     }
-  }
 
-  return EMPTY_STRING;
+    // continue iterating until a cookie that matches `key` is found.
+    return true;
+  });
+
+  return value;
+}
+
+std::map<std::string, std::string> Utility::parseCookies(const RequestHeaderMap& headers) {
+  std::map<std::string, std::string> cookies;
+
+  forEachCookie(headers, Http::Headers::get().Cookie, [&cookies] (const absl::string_view& k, const absl::string_view& v) -> bool {
+    cookies.emplace(std::string{k}, std::string{v});
+
+    // continue iterating until all cookies are processed.
+    return true;
+  });
+
+  return cookies;
 }
 
 bool Utility::Url::initialize(absl::string_view absolute_url, bool is_connect) {

source/common/http/utility.h

@@ -255,6 +255,13 @@ std::string stripQueryString(const HeaderString& path);
  **/
 std::string parseCookieValue(const HeaderMap& headers, const std::string& key);
 
+/**
+ * Parse cookies from header into a map.
+ * @param headers supplies the headers to get cookies from.
+ * @return std::map cookie map.
+ **/
+std::map<std::string, std::string> parseCookies(const RequestHeaderMap& headers);
+
 /**
  * Parse a particular value out of a set-cookie
  * @param headers supplies the headers to get the set-cookie from.

source/extensions/filters/http/oauth2/filter.cc

@@ -138,9 +138,17 @@ FilterStats FilterConfig::generateStats(const std::string& prefix, Stats::Scope&
 
 void OAuth2CookieValidator::setParams(const Http::RequestHeaderMap& headers,
                                       const std::string& secret) {
-  expires_ = Http::Utility::parseCookieValue(headers, "OauthExpires");
-  token_ = Http::Utility::parseCookieValue(headers, "BearerToken");
-  hmac_ = Http::Utility::parseCookieValue(headers, "OauthHMAC");
+  const auto& cookies = Http::Utility::parseCookies(headers);
+
+  const auto expires_it = cookies.find("OauthExpires");
+  expires_ = expires_it != cookies.end() ? expires_it->second : EMPTY_STRING;
+
+  const auto token_it = cookies.find("BearerToken");
+  token_ = token_it != cookies.end() ? token_it->second : EMPTY_STRING;
+
+  const auto hmac_it = cookies.find("OauthHMAC");
+  hmac_ = hmac_it != cookies.end() ? hmac_it->second : EMPTY_STRING;
+
   host_ = headers.Host()->value().getStringView();
 
   secret_.assign(secret.begin(), secret.end());

test/common/http/utility_test.cc

@@ -598,6 +598,21 @@ TEST(HttpUtility, TestParseCookieWithQuotes) {
   EXPECT_EQ(Utility::parseCookieValue(headers, "leadingdquote"), "\"foobar");
 }
 
+TEST(HttpUtility, TestParseCookies) {
+  TestRequestHeaderMapImpl headers{
+      {"someheader", "10.0.0.1"},
+      {"cookie", "dquote=\"; quoteddquote=\"\"\""},
+      {"cookie", "leadingdquote=\"foobar;"},
+      {"cookie", "abc=def; token=\"abc123\"; Expires=Wed, 09 Jun 2021 10:18:14 GMT"}};
+
+  const auto& cookies = Utility::parseCookies(headers);
+
+  EXPECT_EQ(cookies.at("token"), "abc123");
+  EXPECT_EQ(cookies.at("dquote"), "\"");
+  EXPECT_EQ(cookies.at("quoteddquote"), "\"");
+  EXPECT_EQ(cookies.at("leadingdquote"), "\"foobar");
+}
+
 TEST(HttpUtility, TestParseSetCookieWithQuotes) {
   TestRequestHeaderMapImpl headers{
       {"someheader", "10.0.0.1"},