OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #ifndef NET_COOKIES_PARSED_COOKIE_H_ | |
6 #define NET_COOKIES_PARSED_COOKIE_H_ | |
7 | |
8 #include <string> | |
9 #include <vector> | |
10 | |
11 #include "base/basictypes.h" | |
12 #include "net/base/net_export.h" | |
13 #include "net/cookies/cookie_constants.h" | |
14 | |
15 namespace net { | |
16 | |
17 class NET_EXPORT ParsedCookie { | |
18 public: | |
19 typedef std::pair<std::string, std::string> TokenValuePair; | |
20 typedef std::vector<TokenValuePair> PairList; | |
21 | |
22 // The maximum length of a cookie string we will try to parse | |
23 static const size_t kMaxCookieSize = 4096; | |
24 // The maximum number of Token/Value pairs. Shouldn't have more than 8. | |
25 static const int kMaxPairs = 16; | |
26 | |
27 // Construct from a cookie string like "BLAH=1; path=/; domain=.google.com" | |
28 // Format is according to RFC 6265. Cookies with both name and value empty | |
29 // will be considered invalid. | |
30 ParsedCookie(const std::string& cookie_line); | |
31 ~ParsedCookie(); | |
32 | |
33 // You should not call any other methods except for SetName/SetValue on the | |
34 // class if !IsValid. | |
35 bool IsValid() const; | |
36 | |
37 const std::string& Name() const { return pairs_[0].first; } | |
38 const std::string& Token() const { return Name(); } | |
39 const std::string& Value() const { return pairs_[0].second; } | |
40 | |
41 bool HasPath() const { return path_index_ != 0; } | |
42 const std::string& Path() const { return pairs_[path_index_].second; } | |
43 bool HasDomain() const { return domain_index_ != 0; } | |
44 const std::string& Domain() const { return pairs_[domain_index_].second; } | |
45 bool HasExpires() const { return expires_index_ != 0; } | |
46 const std::string& Expires() const { return pairs_[expires_index_].second; } | |
47 bool HasMaxAge() const { return maxage_index_ != 0; } | |
48 const std::string& MaxAge() const { return pairs_[maxage_index_].second; } | |
49 bool IsSecure() const { return secure_index_ != 0; } | |
50 bool IsHttpOnly() const { return httponly_index_ != 0; } | |
51 CookiePriority Priority() const; | |
52 | |
53 // Returns the number of attributes, for example, returning 2 for: | |
54 // "BLAH=hah; path=/; domain=.google.com" | |
55 size_t NumberOfAttributes() const { return pairs_.size() - 1; } | |
56 | |
57 // These functions set the respective properties of the cookie. If the | |
58 // parameters are empty, the respective properties are cleared. | |
59 // The functions return false in case an error occurred. | |
60 // The cookie needs to be assigned a name/value before setting the other | |
61 // attributes. | |
62 bool SetName(const std::string& name); | |
63 bool SetValue(const std::string& value); | |
64 bool SetPath(const std::string& path); | |
65 bool SetDomain(const std::string& domain); | |
66 bool SetExpires(const std::string& expires); | |
67 bool SetMaxAge(const std::string& maxage); | |
68 bool SetIsSecure(bool is_secure); | |
69 bool SetIsHttpOnly(bool is_http_only); | |
70 bool SetPriority(const std::string& priority); | |
71 | |
72 // Returns the cookie description as it appears in a HTML response header. | |
73 std::string ToCookieLine() const; | |
74 | |
75 // Returns an iterator pointing to the first terminator character found in | |
76 // the given string. | |
77 static std::string::const_iterator FindFirstTerminator(const std::string& s); | |
78 | |
79 // Given iterators pointing to the beginning and end of a string segment, | |
80 // returns as output arguments token_start and token_end to the start and end | |
81 // positions of a cookie attribute token name parsed from the segment, and | |
82 // updates the segment iterator to point to the next segment to be parsed. | |
83 // If no token is found, the function returns false. | |
84 static bool ParseToken(std::string::const_iterator* it, | |
85 const std::string::const_iterator& end, | |
86 std::string::const_iterator* token_start, | |
87 std::string::const_iterator* token_end); | |
88 | |
89 // Given iterators pointing to the beginning and end of a string segment, | |
90 // returns as output arguments value_start and value_end to the start and end | |
91 // positions of a cookie attribute value parsed from the segment, and updates | |
92 // the segment iterator to point to the next segment to be parsed. | |
93 static void ParseValue(std::string::const_iterator* it, | |
94 const std::string::const_iterator& end, | |
95 std::string::const_iterator* value_start, | |
96 std::string::const_iterator* value_end); | |
97 | |
98 // Same as the above functions, except the input is assumed to contain the | |
99 // desired token/value and nothing else. | |
100 static std::string ParseTokenString(const std::string& token); | |
101 static std::string ParseValueString(const std::string& value); | |
102 | |
103 private: | |
104 void ParseTokenValuePairs(const std::string& cookie_line); | |
105 void SetupAttributes(); | |
106 | |
107 // Sets a key/value pair for a cookie. |index| has to point to one of the | |
108 // |*_index_| fields in ParsedCookie and is updated to the position where | |
109 // the key/value pair is set in |pairs_|. Accordingly, |key| has to correspond | |
110 // to the token matching |index|. If |value| contains invalid characters, the | |
111 // cookie parameter is not changed and the function returns false. | |
112 // If |value| is empty/false the key/value pair is removed. | |
113 bool SetString(size_t* index, | |
114 const std::string& key, | |
115 const std::string& value); | |
116 bool SetBool(size_t* index, | |
117 const std::string& key, | |
118 bool value); | |
119 | |
120 // Helper function for SetString and SetBool handling the case that the | |
121 // key/value pair shall not be removed. | |
122 bool SetAttributePair(size_t* index, | |
123 const std::string& key, | |
124 const std::string& value); | |
125 | |
126 // Removes the key/value pair from a cookie that is identified by |index|. | |
127 // |index| refers to a position in |pairs_|. | |
128 void ClearAttributePair(size_t index); | |
129 | |
130 PairList pairs_; | |
131 // These will default to 0, but that should never be valid since the | |
132 // 0th index is the user supplied token/value, not an attribute. | |
133 // We're really never going to have more than like 8 attributes, so we | |
134 // could fit these into 3 bits each if we're worried about size... | |
135 size_t path_index_; | |
136 size_t domain_index_; | |
137 size_t expires_index_; | |
138 size_t maxage_index_; | |
139 size_t secure_index_; | |
140 size_t httponly_index_; | |
141 size_t priority_index_; | |
142 | |
143 DISALLOW_COPY_AND_ASSIGN(ParsedCookie); | |
144 }; | |
145 | |
146 } // namespace net | |
147 | |
148 #endif // NET_COOKIES_COOKIE_MONSTER_H_ | |
OLD | NEW |