Share link header parsing code between blink and content.

net/http/http_util.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_HTTP_HTTP_UTIL_H_
 #define NET_HTTP_HTTP_UTIL_H_
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
 
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/time/time.h"
 #include "net/base/net_export.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_version.h"
 #include "url/gurl.h"
 
 // This is a macro to support extending this string literal at compile time.
 // Please excuse me polluting your global namespace!
@@ skipping 93 matching lines @@
   // Whether the character is the start of a quotation mark.
   static bool IsQuote(char c);
 
   // Whether the string is a valid |token| as defined in RFC 2616 Sec 2.2.
   static bool IsToken(std::string::const_iterator begin,
                       std::string::const_iterator end);
   static bool IsToken(const std::string& str) {
     return IsToken(str.begin(), str.end());
   }
 
+  // Whether the string is a valid |parmname| as defined in RFC 5987 Sec 3.2.1.
+  static bool IsParmName(std::string::const_iterator begin,
+                         std::string::const_iterator end);
+  static bool IsParmName(const std::string& str) {
+    return IsParmName(str.begin(), str.end());
+  }
+
   // RFC 2616 Sec 2.2:
   // quoted-string = ( <"> *(qdtext | quoted-pair ) <"> )
   // Unquote() strips the surrounding quotemarks off a string, and unescapes
   // any quoted-pair to obtain the value contained by the quoted-string.
   // If the input is not quoted, then it works like the identity function.
   static std::string Unquote(std::string::const_iterator begin,
                              std::string::const_iterator end);
 
   // Same as above.
   static std::string Unquote(const std::string& str);
 
+  // Similar to Unquote(), but additionally validates that the string being
+  // unescaped actually is a valid quoted string. Returns false for an empty
+  // string, a string without quotes, a string with mismatched quotes, and
+  // a string with unescaped embeded quotes.
+  // In accordance with RFC 2616 this method only allows double quotes to
+  // enclose the string.
+  static bool StrictUnquote(std::string::const_iterator begin,
+                            std::string::const_iterator end,
+                            std::string* out) WARN_UNUSED_RESULT;
+
+  // Same as above.
+  static bool StrictUnquote(const std::string& str,
+                            std::string* out) WARN_UNUSED_RESULT;
+
   // The reverse of Unquote() -- escapes and surrounds with "
   static std::string Quote(const std::string& str);
 
   // Returns the start of the status line, or -1 if no status line was found.
   // This allows for 4 bytes of junk to precede the status line (which is what
   // mozilla does too).
   static int LocateStartOfStatusLine(const char* buf, int buf_len);
 
   // Returns index beyond the end-of-headers marker or -1 if not found.  RFC
   // 2616 defines the end-of-headers marker as a double CRLF; however, some
@@ skipping 149 matching lines @@
   // quoted string.
   //
   class NET_EXPORT_PRIVATE ValuesIterator {
    public:
     ValuesIterator(std::string::const_iterator values_begin,
                    std::string::const_iterator values_end,
                    char delimiter);
     ValuesIterator(const ValuesIterator& other);
     ~ValuesIterator();
 
+    // Set the characters to regard as quotes.  By default, this includes both
+    // single and double quotes.
+    void set_quote_chars(const char* quotes) {
+      values_.set_quote_chars(quotes);
+    }
+
     // Advances the iterator to the next value, if any.  Returns true if there
     // is a next value.  Use value* methods to access the resultant value.
     bool GetNext();
 
     std::string::const_iterator value_begin() const {
       return value_begin_;
     }
     std::string::const_iterator value_end() const {
       return value_end_;
     }
     std::string value() const {
       return std::string(value_begin_, value_end_);
     }
 
    private:
     base::StringTokenizer values_;
     std::string::const_iterator value_begin_;
     std::string::const_iterator value_end_;
   };
 
   // Iterates over a delimited sequence of name-value pairs in an HTTP header.
   // Each pair consists of a token (the name), an equals sign, and either a
   // token or quoted-string (the value). Arbitrary HTTP LWS is permitted outside
   // of and between names, values, and delimiters.
   //
   // String iterators returned from this class' methods may be invalidated upon
   // calls to GetNext() or after the NameValuePairsIterator is destroyed.
   class NET_EXPORT NameValuePairsIterator {
    public:
-    // Whether or not values are optional. VALUES_OPTIONAL allows
-    // e.g. name1=value1;name2;name3=value3, whereas VALUES_NOT_OPTIONAL
+    // Whether or not values are optional. Values::NOT_REQUIRED allows
+    // e.g. name1=value1;name2;name3=value3, whereas Vaues::REQUIRED
     // will treat it as a parse error because name2 does not have a
     // corresponding equals sign.
-    enum OptionalValues { VALUES_OPTIONAL, VALUES_NOT_OPTIONAL };
+    enum class Values { NOT_REQUIRED, REQUIRED };
+
+    // Whether or not unmatched quotes should be considered a failure. By
+    // default this class is pretty lenient and does a best effort to parse
+    // values with mismatched quotes. When set to STRICT_QUOTES a value with
+    // mismatched or otherwise invalid quotes is considered a parse error.
+    enum class Quotes { STRICT_QUOTES, NOT_STRICT };
 
     NameValuePairsIterator(std::string::const_iterator begin,
                            std::string::const_iterator end,
                            char delimiter,
-                           OptionalValues optional_values);
+                           Values optional_values,
+                           Quotes strict_quotes);
 
-    // Treats values as not optional by default (VALUES_NOT_OPTIONAL).
+    // Treats values as not optional by default (Values::REQUIRED) and
+    // treats quotes as not strict.
     NameValuePairsIterator(std::string::const_iterator begin,
                            std::string::const_iterator end,
                            char delimiter);
 
     NameValuePairsIterator(const NameValuePairsIterator& other);
 
     ~NameValuePairsIterator();
 
     // Advances the iterator to the next pair, if any.  Returns true if there
     // is a next pair.  Use name* and value* methods to access the resultant
@@ skipping 20 matching lines @@
                                                               value_end_);
     }
 
     bool value_is_quoted() const { return value_is_quoted_; }
 
     // The value before unquoting (if any).
     std::string raw_value() const { return std::string(value_begin_,
                                                        value_end_); }
 
    private:
+    bool IsQuote(char c) const;
+
     HttpUtil::ValuesIterator props_;
     bool valid_;
 
     std::string::const_iterator name_begin_;
     std::string::const_iterator name_end_;
 
     std::string::const_iterator value_begin_;
     std::string::const_iterator value_end_;
 
     // Do not store iterators into this string. The NameValuePairsIterator
     // is copyable/assignable, and if copied the copy's iterators would point
     // into the original's unquoted_value_ member.
     std::string unquoted_value_;
 
     bool value_is_quoted_;
 
     // True if values are required for each name/value pair; false if a
     // name is permitted to appear without a corresponding value.
     bool values_optional_;
+
+    // True if quotes values are required to be properly quoted; false if
+    // mismatched quotes and other problems with quoted values should be more
+    // or less gracefully treated as valid.
+    bool strict_quotes_;
   };
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_UTIL_H_